@pipeline-builder/pipeline-data 0.0.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 (48) hide show
  1. package/LICENSE +202 -0
  2. package/README.md +61 -0
  3. package/drizzle.config.ts +17 -0
  4. package/lib/api/access-control-builder.d.ts +148 -0
  5. package/lib/api/access-control-builder.js +199 -0
  6. package/lib/api/crud-service.d.ts +343 -0
  7. package/lib/api/crud-service.js +849 -0
  8. package/lib/api/query-builders.d.ts +82 -0
  9. package/lib/api/query-builders.js +460 -0
  10. package/lib/api/reporting-service.d.ts +685 -0
  11. package/lib/api/reporting-service.js +1564 -0
  12. package/lib/api/soft-delete-sweep.d.ts +65 -0
  13. package/lib/api/soft-delete-sweep.js +124 -0
  14. package/lib/api/viewer-context.d.ts +29 -0
  15. package/lib/api/viewer-context.js +63 -0
  16. package/lib/core/query-filters.d.ts +263 -0
  17. package/lib/core/query-filters.js +4 -0
  18. package/lib/database/drizzle-schema.d.ts +7357 -0
  19. package/lib/database/drizzle-schema.js +66 -0
  20. package/lib/database/index.d.ts +5 -0
  21. package/lib/database/index.js +8 -0
  22. package/lib/database/migrator.d.ts +20 -0
  23. package/lib/database/migrator.js +80 -0
  24. package/lib/database/postgres-connection.d.ts +201 -0
  25. package/lib/database/postgres-connection.js +413 -0
  26. package/lib/database/retry-strategy.d.ts +68 -0
  27. package/lib/database/retry-strategy.js +122 -0
  28. package/lib/database/schema/alert.d.ts +588 -0
  29. package/lib/database/schema/alert.js +130 -0
  30. package/lib/database/schema/compliance.d.ts +3319 -0
  31. package/lib/database/schema/compliance.js +377 -0
  32. package/lib/database/schema/dashboard.d.ts +474 -0
  33. package/lib/database/schema/dashboard.js +129 -0
  34. package/lib/database/schema/message-attachment.d.ts +183 -0
  35. package/lib/database/schema/message-attachment.js +40 -0
  36. package/lib/database/schema/message.d.ts +411 -0
  37. package/lib/database/schema/message.js +114 -0
  38. package/lib/database/schema/pipeline-template.d.ts +466 -0
  39. package/lib/database/schema/pipeline-template.js +80 -0
  40. package/lib/database/schema/pipeline.d.ts +1613 -0
  41. package/lib/database/schema/pipeline.js +332 -0
  42. package/lib/database/schema/plugin.d.ts +749 -0
  43. package/lib/database/schema/plugin.js +166 -0
  44. package/lib/database/tenancy.d.ts +103 -0
  45. package/lib/database/tenancy.js +167 -0
  46. package/lib/index.d.ts +32 -0
  47. package/lib/index.js +38 -0
  48. package/package.json +161 -0
package/lib/database/schema/compliance.d.ts ADDED
@@ -0,0 +1,3319 @@
1
+ /**
2
+ * Compliance rule severity levels.
3
+ */
4
+ export type RuleSeverity = 'warning' | 'error' | 'critical';
5
+ /**
6
+ * Compliance rule target entity types.
7
+ */
8
+ export type RuleTarget = 'plugin' | 'pipeline';
9
+ /**
10
+ * Compliance rule operators for field evaluation.
11
+ */
12
+ export type RuleOperator = 'eq' | 'neq' | 'contains' | 'notContains' | 'regex' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'exists' | 'notExists' | 'notEmpty' | 'countGt' | 'countLt' | 'lengthGt' | 'lengthLt';
13
+ /**
14
+ * Cross-field condition mode for multi-condition rules.
15
+ */
16
+ export type RuleConditionMode = 'all' | 'any';
17
+ /**
18
+ * Rule scope org-level or published (system org only, opt-in via subscription).
19
+ */
20
+ export type RuleScope = 'org' | 'published';
21
+ /**
22
+ * A single condition in a cross-field rule.
23
+ */
24
+ export interface RuleCondition {
25
+ field?: string;
26
+ operator?: RuleOperator;
27
+ value?: unknown;
28
+ dependsOnRule?: string;
29
+ }
30
+ /**
31
+ * Compliance policies group rules into named sets that can be enabled/disabled together.
32
+ *
33
+ * @table compliance_policies
34
+ */
35
+ export declare const compliancePolicy: import("drizzle-orm/pg-core").PgTableWithColumns<{
36
+ name: "compliance_policies";
37
+ schema: undefined;
38
+ columns: {
39
+ id: import("drizzle-orm/pg-core").PgColumn<{
40
+ name: "id";
41
+ tableName: "compliance_policies";
42
+ dataType: "string";
43
+ columnType: "PgUUID";
44
+ data: string;
45
+ driverParam: string;
46
+ notNull: true;
47
+ hasDefault: true;
48
+ isPrimaryKey: true;
49
+ isAutoincrement: false;
50
+ hasRuntimeDefault: false;
51
+ enumValues: undefined;
52
+ baseColumn: never;
53
+ identity: undefined;
54
+ generated: undefined;
55
+ }, {}, {}>;
56
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
57
+ name: "org_id";
58
+ tableName: "compliance_policies";
59
+ dataType: "string";
60
+ columnType: "PgVarchar";
61
+ data: string;
62
+ driverParam: string;
63
+ notNull: true;
64
+ hasDefault: true;
65
+ isPrimaryKey: false;
66
+ isAutoincrement: false;
67
+ hasRuntimeDefault: false;
68
+ enumValues: [string, ...string[]];
69
+ baseColumn: never;
70
+ identity: undefined;
71
+ generated: undefined;
72
+ }, {}, {
73
+ length: 255;
74
+ }>;
75
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
76
+ name: "created_by";
77
+ tableName: "compliance_policies";
78
+ dataType: "string";
79
+ columnType: "PgText";
80
+ data: string;
81
+ driverParam: string;
82
+ notNull: true;
83
+ hasDefault: true;
84
+ isPrimaryKey: false;
85
+ isAutoincrement: false;
86
+ hasRuntimeDefault: false;
87
+ enumValues: [string, ...string[]];
88
+ baseColumn: never;
89
+ identity: undefined;
90
+ generated: undefined;
91
+ }, {}, {}>;
92
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
93
+ name: "created_at";
94
+ tableName: "compliance_policies";
95
+ dataType: "date";
96
+ columnType: "PgTimestamp";
97
+ data: Date;
98
+ driverParam: string;
99
+ notNull: true;
100
+ hasDefault: true;
101
+ isPrimaryKey: false;
102
+ isAutoincrement: false;
103
+ hasRuntimeDefault: false;
104
+ enumValues: undefined;
105
+ baseColumn: never;
106
+ identity: undefined;
107
+ generated: undefined;
108
+ }, {}, {}>;
109
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
110
+ name: "updated_by";
111
+ tableName: "compliance_policies";
112
+ dataType: "string";
113
+ columnType: "PgText";
114
+ data: string;
115
+ driverParam: string;
116
+ notNull: true;
117
+ hasDefault: true;
118
+ isPrimaryKey: false;
119
+ isAutoincrement: false;
120
+ hasRuntimeDefault: false;
121
+ enumValues: [string, ...string[]];
122
+ baseColumn: never;
123
+ identity: undefined;
124
+ generated: undefined;
125
+ }, {}, {}>;
126
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
127
+ name: "updated_at";
128
+ tableName: "compliance_policies";
129
+ dataType: "date";
130
+ columnType: "PgTimestamp";
131
+ data: Date;
132
+ driverParam: string;
133
+ notNull: true;
134
+ hasDefault: true;
135
+ isPrimaryKey: false;
136
+ isAutoincrement: false;
137
+ hasRuntimeDefault: false;
138
+ enumValues: undefined;
139
+ baseColumn: never;
140
+ identity: undefined;
141
+ generated: undefined;
142
+ }, {}, {}>;
143
+ name: import("drizzle-orm/pg-core").PgColumn<{
144
+ name: "name";
145
+ tableName: "compliance_policies";
146
+ dataType: "string";
147
+ columnType: "PgVarchar";
148
+ data: string;
149
+ driverParam: string;
150
+ notNull: true;
151
+ hasDefault: false;
152
+ isPrimaryKey: false;
153
+ isAutoincrement: false;
154
+ hasRuntimeDefault: false;
155
+ enumValues: [string, ...string[]];
156
+ baseColumn: never;
157
+ identity: undefined;
158
+ generated: undefined;
159
+ }, {}, {
160
+ length: 255;
161
+ }>;
162
+ description: import("drizzle-orm/pg-core").PgColumn<{
163
+ name: "description";
164
+ tableName: "compliance_policies";
165
+ dataType: "string";
166
+ columnType: "PgText";
167
+ data: string;
168
+ driverParam: string;
169
+ notNull: false;
170
+ hasDefault: false;
171
+ isPrimaryKey: false;
172
+ isAutoincrement: false;
173
+ hasRuntimeDefault: false;
174
+ enumValues: [string, ...string[]];
175
+ baseColumn: never;
176
+ identity: undefined;
177
+ generated: undefined;
178
+ }, {}, {}>;
179
+ version: import("drizzle-orm/pg-core").PgColumn<{
180
+ name: "version";
181
+ tableName: "compliance_policies";
182
+ dataType: "string";
183
+ columnType: "PgVarchar";
184
+ data: string;
185
+ driverParam: string;
186
+ notNull: true;
187
+ hasDefault: true;
188
+ isPrimaryKey: false;
189
+ isAutoincrement: false;
190
+ hasRuntimeDefault: false;
191
+ enumValues: [string, ...string[]];
192
+ baseColumn: never;
193
+ identity: undefined;
194
+ generated: undefined;
195
+ }, {}, {
196
+ length: 50;
197
+ }>;
198
+ isTemplate: import("drizzle-orm/pg-core").PgColumn<{
199
+ name: "is_template";
200
+ tableName: "compliance_policies";
201
+ dataType: "boolean";
202
+ columnType: "PgBoolean";
203
+ data: boolean;
204
+ driverParam: boolean;
205
+ notNull: true;
206
+ hasDefault: true;
207
+ isPrimaryKey: false;
208
+ isAutoincrement: false;
209
+ hasRuntimeDefault: false;
210
+ enumValues: undefined;
211
+ baseColumn: never;
212
+ identity: undefined;
213
+ generated: undefined;
214
+ }, {}, {}>;
215
+ isDefault: import("drizzle-orm/pg-core").PgColumn<{
216
+ name: "is_default";
217
+ tableName: "compliance_policies";
218
+ dataType: "boolean";
219
+ columnType: "PgBoolean";
220
+ data: boolean;
221
+ driverParam: boolean;
222
+ notNull: true;
223
+ hasDefault: true;
224
+ isPrimaryKey: false;
225
+ isAutoincrement: false;
226
+ hasRuntimeDefault: false;
227
+ enumValues: undefined;
228
+ baseColumn: never;
229
+ identity: undefined;
230
+ generated: undefined;
231
+ }, {}, {}>;
232
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
233
+ name: "is_active";
234
+ tableName: "compliance_policies";
235
+ dataType: "boolean";
236
+ columnType: "PgBoolean";
237
+ data: boolean;
238
+ driverParam: boolean;
239
+ notNull: true;
240
+ hasDefault: true;
241
+ isPrimaryKey: false;
242
+ isAutoincrement: false;
243
+ hasRuntimeDefault: false;
244
+ enumValues: undefined;
245
+ baseColumn: never;
246
+ identity: undefined;
247
+ generated: undefined;
248
+ }, {}, {}>;
249
+ deletedAt: import("drizzle-orm/pg-core").PgColumn<{
250
+ name: "deleted_at";
251
+ tableName: "compliance_policies";
252
+ dataType: "date";
253
+ columnType: "PgTimestamp";
254
+ data: Date;
255
+ driverParam: string;
256
+ notNull: false;
257
+ hasDefault: false;
258
+ isPrimaryKey: false;
259
+ isAutoincrement: false;
260
+ hasRuntimeDefault: false;
261
+ enumValues: undefined;
262
+ baseColumn: never;
263
+ identity: undefined;
264
+ generated: undefined;
265
+ }, {}, {}>;
266
+ deletedBy: import("drizzle-orm/pg-core").PgColumn<{
267
+ name: "deleted_by";
268
+ tableName: "compliance_policies";
269
+ dataType: "string";
270
+ columnType: "PgText";
271
+ data: string;
272
+ driverParam: string;
273
+ notNull: false;
274
+ hasDefault: false;
275
+ isPrimaryKey: false;
276
+ isAutoincrement: false;
277
+ hasRuntimeDefault: false;
278
+ enumValues: [string, ...string[]];
279
+ baseColumn: never;
280
+ identity: undefined;
281
+ generated: undefined;
282
+ }, {}, {}>;
283
+ purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
284
+ name: "purge_after";
285
+ tableName: "compliance_policies";
286
+ dataType: "date";
287
+ columnType: "PgTimestamp";
288
+ data: Date;
289
+ driverParam: string;
290
+ notNull: false;
291
+ hasDefault: false;
292
+ isPrimaryKey: false;
293
+ isAutoincrement: false;
294
+ hasRuntimeDefault: false;
295
+ enumValues: undefined;
296
+ baseColumn: never;
297
+ identity: undefined;
298
+ generated: undefined;
299
+ }, {}, {}>;
300
+ };
301
+ dialect: 'pg';
302
+ }>;
303
+ /**
304
+ * Compliance rules define individual checks against plugin/pipeline attributes.
305
+ *
306
+ * @table compliance_rules
307
+ */
308
+ export declare const complianceRule: import("drizzle-orm/pg-core").PgTableWithColumns<{
309
+ name: "compliance_rules";
310
+ schema: undefined;
311
+ columns: {
312
+ id: import("drizzle-orm/pg-core").PgColumn<{
313
+ name: "id";
314
+ tableName: "compliance_rules";
315
+ dataType: "string";
316
+ columnType: "PgUUID";
317
+ data: string;
318
+ driverParam: string;
319
+ notNull: true;
320
+ hasDefault: true;
321
+ isPrimaryKey: true;
322
+ isAutoincrement: false;
323
+ hasRuntimeDefault: false;
324
+ enumValues: undefined;
325
+ baseColumn: never;
326
+ identity: undefined;
327
+ generated: undefined;
328
+ }, {}, {}>;
329
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
330
+ name: "org_id";
331
+ tableName: "compliance_rules";
332
+ dataType: "string";
333
+ columnType: "PgVarchar";
334
+ data: string;
335
+ driverParam: string;
336
+ notNull: true;
337
+ hasDefault: true;
338
+ isPrimaryKey: false;
339
+ isAutoincrement: false;
340
+ hasRuntimeDefault: false;
341
+ enumValues: [string, ...string[]];
342
+ baseColumn: never;
343
+ identity: undefined;
344
+ generated: undefined;
345
+ }, {}, {
346
+ length: 255;
347
+ }>;
348
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
349
+ name: "created_by";
350
+ tableName: "compliance_rules";
351
+ dataType: "string";
352
+ columnType: "PgText";
353
+ data: string;
354
+ driverParam: string;
355
+ notNull: true;
356
+ hasDefault: true;
357
+ isPrimaryKey: false;
358
+ isAutoincrement: false;
359
+ hasRuntimeDefault: false;
360
+ enumValues: [string, ...string[]];
361
+ baseColumn: never;
362
+ identity: undefined;
363
+ generated: undefined;
364
+ }, {}, {}>;
365
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
366
+ name: "created_at";
367
+ tableName: "compliance_rules";
368
+ dataType: "date";
369
+ columnType: "PgTimestamp";
370
+ data: Date;
371
+ driverParam: string;
372
+ notNull: true;
373
+ hasDefault: true;
374
+ isPrimaryKey: false;
375
+ isAutoincrement: false;
376
+ hasRuntimeDefault: false;
377
+ enumValues: undefined;
378
+ baseColumn: never;
379
+ identity: undefined;
380
+ generated: undefined;
381
+ }, {}, {}>;
382
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
383
+ name: "updated_by";
384
+ tableName: "compliance_rules";
385
+ dataType: "string";
386
+ columnType: "PgText";
387
+ data: string;
388
+ driverParam: string;
389
+ notNull: true;
390
+ hasDefault: true;
391
+ isPrimaryKey: false;
392
+ isAutoincrement: false;
393
+ hasRuntimeDefault: false;
394
+ enumValues: [string, ...string[]];
395
+ baseColumn: never;
396
+ identity: undefined;
397
+ generated: undefined;
398
+ }, {}, {}>;
399
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
400
+ name: "updated_at";
401
+ tableName: "compliance_rules";
402
+ dataType: "date";
403
+ columnType: "PgTimestamp";
404
+ data: Date;
405
+ driverParam: string;
406
+ notNull: true;
407
+ hasDefault: true;
408
+ isPrimaryKey: false;
409
+ isAutoincrement: false;
410
+ hasRuntimeDefault: false;
411
+ enumValues: undefined;
412
+ baseColumn: never;
413
+ identity: undefined;
414
+ generated: undefined;
415
+ }, {}, {}>;
416
+ name: import("drizzle-orm/pg-core").PgColumn<{
417
+ name: "name";
418
+ tableName: "compliance_rules";
419
+ dataType: "string";
420
+ columnType: "PgVarchar";
421
+ data: string;
422
+ driverParam: string;
423
+ notNull: true;
424
+ hasDefault: false;
425
+ isPrimaryKey: false;
426
+ isAutoincrement: false;
427
+ hasRuntimeDefault: false;
428
+ enumValues: [string, ...string[]];
429
+ baseColumn: never;
430
+ identity: undefined;
431
+ generated: undefined;
432
+ }, {}, {
433
+ length: 255;
434
+ }>;
435
+ description: import("drizzle-orm/pg-core").PgColumn<{
436
+ name: "description";
437
+ tableName: "compliance_rules";
438
+ dataType: "string";
439
+ columnType: "PgText";
440
+ data: string;
441
+ driverParam: string;
442
+ notNull: false;
443
+ hasDefault: false;
444
+ isPrimaryKey: false;
445
+ isAutoincrement: false;
446
+ hasRuntimeDefault: false;
447
+ enumValues: [string, ...string[]];
448
+ baseColumn: never;
449
+ identity: undefined;
450
+ generated: undefined;
451
+ }, {}, {}>;
452
+ policyId: import("drizzle-orm/pg-core").PgColumn<{
453
+ name: "policy_id";
454
+ tableName: "compliance_rules";
455
+ dataType: "string";
456
+ columnType: "PgUUID";
457
+ data: string;
458
+ driverParam: string;
459
+ notNull: false;
460
+ hasDefault: false;
461
+ isPrimaryKey: false;
462
+ isAutoincrement: false;
463
+ hasRuntimeDefault: false;
464
+ enumValues: undefined;
465
+ baseColumn: never;
466
+ identity: undefined;
467
+ generated: undefined;
468
+ }, {}, {}>;
469
+ priority: import("drizzle-orm/pg-core").PgColumn<{
470
+ name: "priority";
471
+ tableName: "compliance_rules";
472
+ dataType: "number";
473
+ columnType: "PgInteger";
474
+ data: number;
475
+ driverParam: string | number;
476
+ notNull: true;
477
+ hasDefault: true;
478
+ isPrimaryKey: false;
479
+ isAutoincrement: false;
480
+ hasRuntimeDefault: false;
481
+ enumValues: undefined;
482
+ baseColumn: never;
483
+ identity: undefined;
484
+ generated: undefined;
485
+ }, {}, {}>;
486
+ target: import("drizzle-orm/pg-core").PgColumn<{
487
+ name: "target";
488
+ tableName: "compliance_rules";
489
+ dataType: "string";
490
+ columnType: "PgVarchar";
491
+ data: RuleTarget;
492
+ driverParam: string;
493
+ notNull: true;
494
+ hasDefault: false;
495
+ isPrimaryKey: false;
496
+ isAutoincrement: false;
497
+ hasRuntimeDefault: false;
498
+ enumValues: [string, ...string[]];
499
+ baseColumn: never;
500
+ identity: undefined;
501
+ generated: undefined;
502
+ }, {}, {
503
+ length: 20;
504
+ $type: RuleTarget;
505
+ }>;
506
+ severity: import("drizzle-orm/pg-core").PgColumn<{
507
+ name: "severity";
508
+ tableName: "compliance_rules";
509
+ dataType: "string";
510
+ columnType: "PgVarchar";
511
+ data: RuleSeverity;
512
+ driverParam: string;
513
+ notNull: true;
514
+ hasDefault: true;
515
+ isPrimaryKey: false;
516
+ isAutoincrement: false;
517
+ hasRuntimeDefault: false;
518
+ enumValues: [string, ...string[]];
519
+ baseColumn: never;
520
+ identity: undefined;
521
+ generated: undefined;
522
+ }, {}, {
523
+ length: 10;
524
+ $type: RuleSeverity;
525
+ }>;
526
+ tags: import("drizzle-orm/pg-core").PgColumn<{
527
+ name: "tags";
528
+ tableName: "compliance_rules";
529
+ dataType: "json";
530
+ columnType: "PgJsonb";
531
+ data: string[];
532
+ driverParam: unknown;
533
+ notNull: true;
534
+ hasDefault: true;
535
+ isPrimaryKey: false;
536
+ isAutoincrement: false;
537
+ hasRuntimeDefault: false;
538
+ enumValues: undefined;
539
+ baseColumn: never;
540
+ identity: undefined;
541
+ generated: undefined;
542
+ }, {}, {
543
+ $type: string[];
544
+ }>;
545
+ effectiveFrom: import("drizzle-orm/pg-core").PgColumn<{
546
+ name: "effective_from";
547
+ tableName: "compliance_rules";
548
+ dataType: "date";
549
+ columnType: "PgTimestamp";
550
+ data: Date;
551
+ driverParam: string;
552
+ notNull: false;
553
+ hasDefault: false;
554
+ isPrimaryKey: false;
555
+ isAutoincrement: false;
556
+ hasRuntimeDefault: false;
557
+ enumValues: undefined;
558
+ baseColumn: never;
559
+ identity: undefined;
560
+ generated: undefined;
561
+ }, {}, {}>;
562
+ effectiveUntil: import("drizzle-orm/pg-core").PgColumn<{
563
+ name: "effective_until";
564
+ tableName: "compliance_rules";
565
+ dataType: "date";
566
+ columnType: "PgTimestamp";
567
+ data: Date;
568
+ driverParam: string;
569
+ notNull: false;
570
+ hasDefault: false;
571
+ isPrimaryKey: false;
572
+ isAutoincrement: false;
573
+ hasRuntimeDefault: false;
574
+ enumValues: undefined;
575
+ baseColumn: never;
576
+ identity: undefined;
577
+ generated: undefined;
578
+ }, {}, {}>;
579
+ scope: import("drizzle-orm/pg-core").PgColumn<{
580
+ name: "scope";
581
+ tableName: "compliance_rules";
582
+ dataType: "string";
583
+ columnType: "PgVarchar";
584
+ data: RuleScope;
585
+ driverParam: string;
586
+ notNull: true;
587
+ hasDefault: true;
588
+ isPrimaryKey: false;
589
+ isAutoincrement: false;
590
+ hasRuntimeDefault: false;
591
+ enumValues: [string, ...string[]];
592
+ baseColumn: never;
593
+ identity: undefined;
594
+ generated: undefined;
595
+ }, {}, {
596
+ length: 10;
597
+ $type: RuleScope;
598
+ }>;
599
+ forkedFromRuleId: import("drizzle-orm/pg-core").PgColumn<{
600
+ name: "forked_from_rule_id";
601
+ tableName: "compliance_rules";
602
+ dataType: "string";
603
+ columnType: "PgUUID";
604
+ data: string;
605
+ driverParam: string;
606
+ notNull: false;
607
+ hasDefault: false;
608
+ isPrimaryKey: false;
609
+ isAutoincrement: false;
610
+ hasRuntimeDefault: false;
611
+ enumValues: undefined;
612
+ baseColumn: never;
613
+ identity: undefined;
614
+ generated: undefined;
615
+ }, {}, {}>;
616
+ suppressNotification: import("drizzle-orm/pg-core").PgColumn<{
617
+ name: "suppress_notification";
618
+ tableName: "compliance_rules";
619
+ dataType: "boolean";
620
+ columnType: "PgBoolean";
621
+ data: boolean;
622
+ driverParam: boolean;
623
+ notNull: true;
624
+ hasDefault: true;
625
+ isPrimaryKey: false;
626
+ isAutoincrement: false;
627
+ hasRuntimeDefault: false;
628
+ enumValues: undefined;
629
+ baseColumn: never;
630
+ identity: undefined;
631
+ generated: undefined;
632
+ }, {}, {}>;
633
+ propagateToChildren: import("drizzle-orm/pg-core").PgColumn<{
634
+ name: "propagate_to_children";
635
+ tableName: "compliance_rules";
636
+ dataType: "boolean";
637
+ columnType: "PgBoolean";
638
+ data: boolean;
639
+ driverParam: boolean;
640
+ notNull: true;
641
+ hasDefault: true;
642
+ isPrimaryKey: false;
643
+ isAutoincrement: false;
644
+ hasRuntimeDefault: false;
645
+ enumValues: undefined;
646
+ baseColumn: never;
647
+ identity: undefined;
648
+ generated: undefined;
649
+ }, {}, {}>;
650
+ field: import("drizzle-orm/pg-core").PgColumn<{
651
+ name: "field";
652
+ tableName: "compliance_rules";
653
+ dataType: "string";
654
+ columnType: "PgVarchar";
655
+ data: string;
656
+ driverParam: string;
657
+ notNull: false;
658
+ hasDefault: false;
659
+ isPrimaryKey: false;
660
+ isAutoincrement: false;
661
+ hasRuntimeDefault: false;
662
+ enumValues: [string, ...string[]];
663
+ baseColumn: never;
664
+ identity: undefined;
665
+ generated: undefined;
666
+ }, {}, {
667
+ length: 100;
668
+ }>;
669
+ operator: import("drizzle-orm/pg-core").PgColumn<{
670
+ name: "operator";
671
+ tableName: "compliance_rules";
672
+ dataType: "string";
673
+ columnType: "PgVarchar";
674
+ data: RuleOperator;
675
+ driverParam: string;
676
+ notNull: false;
677
+ hasDefault: false;
678
+ isPrimaryKey: false;
679
+ isAutoincrement: false;
680
+ hasRuntimeDefault: false;
681
+ enumValues: [string, ...string[]];
682
+ baseColumn: never;
683
+ identity: undefined;
684
+ generated: undefined;
685
+ }, {}, {
686
+ length: 20;
687
+ $type: RuleOperator;
688
+ }>;
689
+ value: import("drizzle-orm/pg-core").PgColumn<{
690
+ name: "value";
691
+ tableName: "compliance_rules";
692
+ dataType: "json";
693
+ columnType: "PgJsonb";
694
+ data: unknown;
695
+ driverParam: unknown;
696
+ notNull: false;
697
+ hasDefault: false;
698
+ isPrimaryKey: false;
699
+ isAutoincrement: false;
700
+ hasRuntimeDefault: false;
701
+ enumValues: undefined;
702
+ baseColumn: never;
703
+ identity: undefined;
704
+ generated: undefined;
705
+ }, {}, {}>;
706
+ conditions: import("drizzle-orm/pg-core").PgColumn<{
707
+ name: "conditions";
708
+ tableName: "compliance_rules";
709
+ dataType: "json";
710
+ columnType: "PgJsonb";
711
+ data: RuleCondition[];
712
+ driverParam: unknown;
713
+ notNull: false;
714
+ hasDefault: false;
715
+ isPrimaryKey: false;
716
+ isAutoincrement: false;
717
+ hasRuntimeDefault: false;
718
+ enumValues: undefined;
719
+ baseColumn: never;
720
+ identity: undefined;
721
+ generated: undefined;
722
+ }, {}, {
723
+ $type: RuleCondition[];
724
+ }>;
725
+ conditionMode: import("drizzle-orm/pg-core").PgColumn<{
726
+ name: "condition_mode";
727
+ tableName: "compliance_rules";
728
+ dataType: "string";
729
+ columnType: "PgVarchar";
730
+ data: RuleConditionMode;
731
+ driverParam: string;
732
+ notNull: false;
733
+ hasDefault: true;
734
+ isPrimaryKey: false;
735
+ isAutoincrement: false;
736
+ hasRuntimeDefault: false;
737
+ enumValues: [string, ...string[]];
738
+ baseColumn: never;
739
+ identity: undefined;
740
+ generated: undefined;
741
+ }, {}, {
742
+ length: 5;
743
+ $type: RuleConditionMode;
744
+ }>;
745
+ isDefault: import("drizzle-orm/pg-core").PgColumn<{
746
+ name: "is_default";
747
+ tableName: "compliance_rules";
748
+ dataType: "boolean";
749
+ columnType: "PgBoolean";
750
+ data: boolean;
751
+ driverParam: boolean;
752
+ notNull: true;
753
+ hasDefault: true;
754
+ isPrimaryKey: false;
755
+ isAutoincrement: false;
756
+ hasRuntimeDefault: false;
757
+ enumValues: undefined;
758
+ baseColumn: never;
759
+ identity: undefined;
760
+ generated: undefined;
761
+ }, {}, {}>;
762
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
763
+ name: "is_active";
764
+ tableName: "compliance_rules";
765
+ dataType: "boolean";
766
+ columnType: "PgBoolean";
767
+ data: boolean;
768
+ driverParam: boolean;
769
+ notNull: true;
770
+ hasDefault: true;
771
+ isPrimaryKey: false;
772
+ isAutoincrement: false;
773
+ hasRuntimeDefault: false;
774
+ enumValues: undefined;
775
+ baseColumn: never;
776
+ identity: undefined;
777
+ generated: undefined;
778
+ }, {}, {}>;
779
+ deletedAt: import("drizzle-orm/pg-core").PgColumn<{
780
+ name: "deleted_at";
781
+ tableName: "compliance_rules";
782
+ dataType: "date";
783
+ columnType: "PgTimestamp";
784
+ data: Date;
785
+ driverParam: string;
786
+ notNull: false;
787
+ hasDefault: false;
788
+ isPrimaryKey: false;
789
+ isAutoincrement: false;
790
+ hasRuntimeDefault: false;
791
+ enumValues: undefined;
792
+ baseColumn: never;
793
+ identity: undefined;
794
+ generated: undefined;
795
+ }, {}, {}>;
796
+ deletedBy: import("drizzle-orm/pg-core").PgColumn<{
797
+ name: "deleted_by";
798
+ tableName: "compliance_rules";
799
+ dataType: "string";
800
+ columnType: "PgText";
801
+ data: string;
802
+ driverParam: string;
803
+ notNull: false;
804
+ hasDefault: false;
805
+ isPrimaryKey: false;
806
+ isAutoincrement: false;
807
+ hasRuntimeDefault: false;
808
+ enumValues: [string, ...string[]];
809
+ baseColumn: never;
810
+ identity: undefined;
811
+ generated: undefined;
812
+ }, {}, {}>;
813
+ purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
814
+ name: "purge_after";
815
+ tableName: "compliance_rules";
816
+ dataType: "date";
817
+ columnType: "PgTimestamp";
818
+ data: Date;
819
+ driverParam: string;
820
+ notNull: false;
821
+ hasDefault: false;
822
+ isPrimaryKey: false;
823
+ isAutoincrement: false;
824
+ hasRuntimeDefault: false;
825
+ enumValues: undefined;
826
+ baseColumn: never;
827
+ identity: undefined;
828
+ generated: undefined;
829
+ }, {}, {}>;
830
+ };
831
+ dialect: 'pg';
832
+ }>;
833
+ /**
834
+ * Tracks every change to compliance rules for versioning and rollback.
835
+ *
836
+ * @table compliance_rule_history
837
+ */
838
+ export declare const complianceRuleHistory: import("drizzle-orm/pg-core").PgTableWithColumns<{
839
+ name: "compliance_rule_history";
840
+ schema: undefined;
841
+ columns: {
842
+ id: import("drizzle-orm/pg-core").PgColumn<{
843
+ name: "id";
844
+ tableName: "compliance_rule_history";
845
+ dataType: "string";
846
+ columnType: "PgUUID";
847
+ data: string;
848
+ driverParam: string;
849
+ notNull: true;
850
+ hasDefault: true;
851
+ isPrimaryKey: true;
852
+ isAutoincrement: false;
853
+ hasRuntimeDefault: false;
854
+ enumValues: undefined;
855
+ baseColumn: never;
856
+ identity: undefined;
857
+ generated: undefined;
858
+ }, {}, {}>;
859
+ ruleId: import("drizzle-orm/pg-core").PgColumn<{
860
+ name: "rule_id";
861
+ tableName: "compliance_rule_history";
862
+ dataType: "string";
863
+ columnType: "PgUUID";
864
+ data: string;
865
+ driverParam: string;
866
+ notNull: true;
867
+ hasDefault: false;
868
+ isPrimaryKey: false;
869
+ isAutoincrement: false;
870
+ hasRuntimeDefault: false;
871
+ enumValues: undefined;
872
+ baseColumn: never;
873
+ identity: undefined;
874
+ generated: undefined;
875
+ }, {}, {}>;
876
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
877
+ name: "org_id";
878
+ tableName: "compliance_rule_history";
879
+ dataType: "string";
880
+ columnType: "PgVarchar";
881
+ data: string;
882
+ driverParam: string;
883
+ notNull: true;
884
+ hasDefault: false;
885
+ isPrimaryKey: false;
886
+ isAutoincrement: false;
887
+ hasRuntimeDefault: false;
888
+ enumValues: [string, ...string[]];
889
+ baseColumn: never;
890
+ identity: undefined;
891
+ generated: undefined;
892
+ }, {}, {
893
+ length: 255;
894
+ }>;
895
+ changeType: import("drizzle-orm/pg-core").PgColumn<{
896
+ name: "change_type";
897
+ tableName: "compliance_rule_history";
898
+ dataType: "string";
899
+ columnType: "PgVarchar";
900
+ data: string;
901
+ driverParam: string;
902
+ notNull: true;
903
+ hasDefault: false;
904
+ isPrimaryKey: false;
905
+ isAutoincrement: false;
906
+ hasRuntimeDefault: false;
907
+ enumValues: [string, ...string[]];
908
+ baseColumn: never;
909
+ identity: undefined;
910
+ generated: undefined;
911
+ }, {}, {
912
+ length: 20;
913
+ }>;
914
+ previousState: import("drizzle-orm/pg-core").PgColumn<{
915
+ name: "previous_state";
916
+ tableName: "compliance_rule_history";
917
+ dataType: "json";
918
+ columnType: "PgJsonb";
919
+ data: unknown;
920
+ driverParam: unknown;
921
+ notNull: false;
922
+ hasDefault: false;
923
+ isPrimaryKey: false;
924
+ isAutoincrement: false;
925
+ hasRuntimeDefault: false;
926
+ enumValues: undefined;
927
+ baseColumn: never;
928
+ identity: undefined;
929
+ generated: undefined;
930
+ }, {}, {}>;
931
+ changedBy: import("drizzle-orm/pg-core").PgColumn<{
932
+ name: "changed_by";
933
+ tableName: "compliance_rule_history";
934
+ dataType: "string";
935
+ columnType: "PgText";
936
+ data: string;
937
+ driverParam: string;
938
+ notNull: true;
939
+ hasDefault: false;
940
+ isPrimaryKey: false;
941
+ isAutoincrement: false;
942
+ hasRuntimeDefault: false;
943
+ enumValues: [string, ...string[]];
944
+ baseColumn: never;
945
+ identity: undefined;
946
+ generated: undefined;
947
+ }, {}, {}>;
948
+ changedAt: import("drizzle-orm/pg-core").PgColumn<{
949
+ name: "changed_at";
950
+ tableName: "compliance_rule_history";
951
+ dataType: "date";
952
+ columnType: "PgTimestamp";
953
+ data: Date;
954
+ driverParam: string;
955
+ notNull: true;
956
+ hasDefault: true;
957
+ isPrimaryKey: false;
958
+ isAutoincrement: false;
959
+ hasRuntimeDefault: false;
960
+ enumValues: undefined;
961
+ baseColumn: never;
962
+ identity: undefined;
963
+ generated: undefined;
964
+ }, {}, {}>;
965
+ };
966
+ dialect: 'pg';
967
+ }>;
968
+ /**
969
+ * Compliance audit log stores every compliance check result.
970
+ *
971
+ * @table compliance_audit_log
972
+ */
973
+ export declare const complianceAuditLog: import("drizzle-orm/pg-core").PgTableWithColumns<{
974
+ name: "compliance_audit_log";
975
+ schema: undefined;
976
+ columns: {
977
+ id: import("drizzle-orm/pg-core").PgColumn<{
978
+ name: "id";
979
+ tableName: "compliance_audit_log";
980
+ dataType: "string";
981
+ columnType: "PgUUID";
982
+ data: string;
983
+ driverParam: string;
984
+ notNull: true;
985
+ hasDefault: true;
986
+ isPrimaryKey: true;
987
+ isAutoincrement: false;
988
+ hasRuntimeDefault: false;
989
+ enumValues: undefined;
990
+ baseColumn: never;
991
+ identity: undefined;
992
+ generated: undefined;
993
+ }, {}, {}>;
994
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
995
+ name: "org_id";
996
+ tableName: "compliance_audit_log";
997
+ dataType: "string";
998
+ columnType: "PgVarchar";
999
+ data: string;
1000
+ driverParam: string;
1001
+ notNull: true;
1002
+ hasDefault: false;
1003
+ isPrimaryKey: false;
1004
+ isAutoincrement: false;
1005
+ hasRuntimeDefault: false;
1006
+ enumValues: [string, ...string[]];
1007
+ baseColumn: never;
1008
+ identity: undefined;
1009
+ generated: undefined;
1010
+ }, {}, {
1011
+ length: 255;
1012
+ }>;
1013
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1014
+ name: "user_id";
1015
+ tableName: "compliance_audit_log";
1016
+ dataType: "string";
1017
+ columnType: "PgText";
1018
+ data: string;
1019
+ driverParam: string;
1020
+ notNull: true;
1021
+ hasDefault: false;
1022
+ isPrimaryKey: false;
1023
+ isAutoincrement: false;
1024
+ hasRuntimeDefault: false;
1025
+ enumValues: [string, ...string[]];
1026
+ baseColumn: never;
1027
+ identity: undefined;
1028
+ generated: undefined;
1029
+ }, {}, {}>;
1030
+ target: import("drizzle-orm/pg-core").PgColumn<{
1031
+ name: "target";
1032
+ tableName: "compliance_audit_log";
1033
+ dataType: "string";
1034
+ columnType: "PgVarchar";
1035
+ data: RuleTarget;
1036
+ driverParam: string;
1037
+ notNull: true;
1038
+ hasDefault: false;
1039
+ isPrimaryKey: false;
1040
+ isAutoincrement: false;
1041
+ hasRuntimeDefault: false;
1042
+ enumValues: [string, ...string[]];
1043
+ baseColumn: never;
1044
+ identity: undefined;
1045
+ generated: undefined;
1046
+ }, {}, {
1047
+ length: 20;
1048
+ $type: RuleTarget;
1049
+ }>;
1050
+ action: import("drizzle-orm/pg-core").PgColumn<{
1051
+ name: "action";
1052
+ tableName: "compliance_audit_log";
1053
+ dataType: "string";
1054
+ columnType: "PgVarchar";
1055
+ data: string;
1056
+ driverParam: string;
1057
+ notNull: true;
1058
+ hasDefault: false;
1059
+ isPrimaryKey: false;
1060
+ isAutoincrement: false;
1061
+ hasRuntimeDefault: false;
1062
+ enumValues: [string, ...string[]];
1063
+ baseColumn: never;
1064
+ identity: undefined;
1065
+ generated: undefined;
1066
+ }, {}, {
1067
+ length: 20;
1068
+ }>;
1069
+ entityId: import("drizzle-orm/pg-core").PgColumn<{
1070
+ name: "entity_id";
1071
+ tableName: "compliance_audit_log";
1072
+ dataType: "string";
1073
+ columnType: "PgVarchar";
1074
+ data: string;
1075
+ driverParam: string;
1076
+ notNull: false;
1077
+ hasDefault: false;
1078
+ isPrimaryKey: false;
1079
+ isAutoincrement: false;
1080
+ hasRuntimeDefault: false;
1081
+ enumValues: [string, ...string[]];
1082
+ baseColumn: never;
1083
+ identity: undefined;
1084
+ generated: undefined;
1085
+ }, {}, {
1086
+ length: 255;
1087
+ }>;
1088
+ entityName: import("drizzle-orm/pg-core").PgColumn<{
1089
+ name: "entity_name";
1090
+ tableName: "compliance_audit_log";
1091
+ dataType: "string";
1092
+ columnType: "PgVarchar";
1093
+ data: string;
1094
+ driverParam: string;
1095
+ notNull: false;
1096
+ hasDefault: false;
1097
+ isPrimaryKey: false;
1098
+ isAutoincrement: false;
1099
+ hasRuntimeDefault: false;
1100
+ enumValues: [string, ...string[]];
1101
+ baseColumn: never;
1102
+ identity: undefined;
1103
+ generated: undefined;
1104
+ }, {}, {
1105
+ length: 255;
1106
+ }>;
1107
+ result: import("drizzle-orm/pg-core").PgColumn<{
1108
+ name: "result";
1109
+ tableName: "compliance_audit_log";
1110
+ dataType: "string";
1111
+ columnType: "PgVarchar";
1112
+ data: string;
1113
+ driverParam: string;
1114
+ notNull: true;
1115
+ hasDefault: false;
1116
+ isPrimaryKey: false;
1117
+ isAutoincrement: false;
1118
+ hasRuntimeDefault: false;
1119
+ enumValues: [string, ...string[]];
1120
+ baseColumn: never;
1121
+ identity: undefined;
1122
+ generated: undefined;
1123
+ }, {}, {
1124
+ length: 10;
1125
+ }>;
1126
+ violations: import("drizzle-orm/pg-core").PgColumn<{
1127
+ name: "violations";
1128
+ tableName: "compliance_audit_log";
1129
+ dataType: "json";
1130
+ columnType: "PgJsonb";
1131
+ data: Record<string, unknown>[];
1132
+ driverParam: unknown;
1133
+ notNull: false;
1134
+ hasDefault: true;
1135
+ isPrimaryKey: false;
1136
+ isAutoincrement: false;
1137
+ hasRuntimeDefault: false;
1138
+ enumValues: undefined;
1139
+ baseColumn: never;
1140
+ identity: undefined;
1141
+ generated: undefined;
1142
+ }, {}, {
1143
+ $type: Record<string, unknown>[];
1144
+ }>;
1145
+ ruleCount: import("drizzle-orm/pg-core").PgColumn<{
1146
+ name: "rule_count";
1147
+ tableName: "compliance_audit_log";
1148
+ dataType: "number";
1149
+ columnType: "PgInteger";
1150
+ data: number;
1151
+ driverParam: string | number;
1152
+ notNull: true;
1153
+ hasDefault: false;
1154
+ isPrimaryKey: false;
1155
+ isAutoincrement: false;
1156
+ hasRuntimeDefault: false;
1157
+ enumValues: undefined;
1158
+ baseColumn: never;
1159
+ identity: undefined;
1160
+ generated: undefined;
1161
+ }, {}, {}>;
1162
+ scanId: import("drizzle-orm/pg-core").PgColumn<{
1163
+ name: "scan_id";
1164
+ tableName: "compliance_audit_log";
1165
+ dataType: "string";
1166
+ columnType: "PgUUID";
1167
+ data: string;
1168
+ driverParam: string;
1169
+ notNull: false;
1170
+ hasDefault: false;
1171
+ isPrimaryKey: false;
1172
+ isAutoincrement: false;
1173
+ hasRuntimeDefault: false;
1174
+ enumValues: undefined;
1175
+ baseColumn: never;
1176
+ identity: undefined;
1177
+ generated: undefined;
1178
+ }, {}, {}>;
1179
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1180
+ name: "created_at";
1181
+ tableName: "compliance_audit_log";
1182
+ dataType: "date";
1183
+ columnType: "PgTimestamp";
1184
+ data: Date;
1185
+ driverParam: string;
1186
+ notNull: true;
1187
+ hasDefault: true;
1188
+ isPrimaryKey: false;
1189
+ isAutoincrement: false;
1190
+ hasRuntimeDefault: false;
1191
+ enumValues: undefined;
1192
+ baseColumn: never;
1193
+ identity: undefined;
1194
+ generated: undefined;
1195
+ }, {}, {}>;
1196
+ };
1197
+ dialect: 'pg';
1198
+ }>;
1199
+ /**
1200
+ * Per-entity exemptions from specific compliance rules.
1201
+ *
1202
+ * @table compliance_exemptions
1203
+ */
1204
+ export declare const complianceExemption: import("drizzle-orm/pg-core").PgTableWithColumns<{
1205
+ name: "compliance_exemptions";
1206
+ schema: undefined;
1207
+ columns: {
1208
+ id: import("drizzle-orm/pg-core").PgColumn<{
1209
+ name: "id";
1210
+ tableName: "compliance_exemptions";
1211
+ dataType: "string";
1212
+ columnType: "PgUUID";
1213
+ data: string;
1214
+ driverParam: string;
1215
+ notNull: true;
1216
+ hasDefault: true;
1217
+ isPrimaryKey: true;
1218
+ isAutoincrement: false;
1219
+ hasRuntimeDefault: false;
1220
+ enumValues: undefined;
1221
+ baseColumn: never;
1222
+ identity: undefined;
1223
+ generated: undefined;
1224
+ }, {}, {}>;
1225
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
1226
+ name: "org_id";
1227
+ tableName: "compliance_exemptions";
1228
+ dataType: "string";
1229
+ columnType: "PgVarchar";
1230
+ data: string;
1231
+ driverParam: string;
1232
+ notNull: true;
1233
+ hasDefault: false;
1234
+ isPrimaryKey: false;
1235
+ isAutoincrement: false;
1236
+ hasRuntimeDefault: false;
1237
+ enumValues: [string, ...string[]];
1238
+ baseColumn: never;
1239
+ identity: undefined;
1240
+ generated: undefined;
1241
+ }, {}, {
1242
+ length: 255;
1243
+ }>;
1244
+ ruleId: import("drizzle-orm/pg-core").PgColumn<{
1245
+ name: "rule_id";
1246
+ tableName: "compliance_exemptions";
1247
+ dataType: "string";
1248
+ columnType: "PgUUID";
1249
+ data: string;
1250
+ driverParam: string;
1251
+ notNull: true;
1252
+ hasDefault: false;
1253
+ isPrimaryKey: false;
1254
+ isAutoincrement: false;
1255
+ hasRuntimeDefault: false;
1256
+ enumValues: undefined;
1257
+ baseColumn: never;
1258
+ identity: undefined;
1259
+ generated: undefined;
1260
+ }, {}, {}>;
1261
+ entityType: import("drizzle-orm/pg-core").PgColumn<{
1262
+ name: "entity_type";
1263
+ tableName: "compliance_exemptions";
1264
+ dataType: "string";
1265
+ columnType: "PgVarchar";
1266
+ data: RuleTarget;
1267
+ driverParam: string;
1268
+ notNull: true;
1269
+ hasDefault: false;
1270
+ isPrimaryKey: false;
1271
+ isAutoincrement: false;
1272
+ hasRuntimeDefault: false;
1273
+ enumValues: [string, ...string[]];
1274
+ baseColumn: never;
1275
+ identity: undefined;
1276
+ generated: undefined;
1277
+ }, {}, {
1278
+ length: 20;
1279
+ $type: RuleTarget;
1280
+ }>;
1281
+ entityId: import("drizzle-orm/pg-core").PgColumn<{
1282
+ name: "entity_id";
1283
+ tableName: "compliance_exemptions";
1284
+ dataType: "string";
1285
+ columnType: "PgUUID";
1286
+ data: string;
1287
+ driverParam: string;
1288
+ notNull: true;
1289
+ hasDefault: false;
1290
+ isPrimaryKey: false;
1291
+ isAutoincrement: false;
1292
+ hasRuntimeDefault: false;
1293
+ enumValues: undefined;
1294
+ baseColumn: never;
1295
+ identity: undefined;
1296
+ generated: undefined;
1297
+ }, {}, {}>;
1298
+ entityName: import("drizzle-orm/pg-core").PgColumn<{
1299
+ name: "entity_name";
1300
+ tableName: "compliance_exemptions";
1301
+ dataType: "string";
1302
+ columnType: "PgVarchar";
1303
+ data: string;
1304
+ driverParam: string;
1305
+ notNull: false;
1306
+ hasDefault: false;
1307
+ isPrimaryKey: false;
1308
+ isAutoincrement: false;
1309
+ hasRuntimeDefault: false;
1310
+ enumValues: [string, ...string[]];
1311
+ baseColumn: never;
1312
+ identity: undefined;
1313
+ generated: undefined;
1314
+ }, {}, {
1315
+ length: 255;
1316
+ }>;
1317
+ reason: import("drizzle-orm/pg-core").PgColumn<{
1318
+ name: "reason";
1319
+ tableName: "compliance_exemptions";
1320
+ dataType: "string";
1321
+ columnType: "PgText";
1322
+ data: string;
1323
+ driverParam: string;
1324
+ notNull: true;
1325
+ hasDefault: false;
1326
+ isPrimaryKey: false;
1327
+ isAutoincrement: false;
1328
+ hasRuntimeDefault: false;
1329
+ enumValues: [string, ...string[]];
1330
+ baseColumn: never;
1331
+ identity: undefined;
1332
+ generated: undefined;
1333
+ }, {}, {}>;
1334
+ approvedBy: import("drizzle-orm/pg-core").PgColumn<{
1335
+ name: "approved_by";
1336
+ tableName: "compliance_exemptions";
1337
+ dataType: "string";
1338
+ columnType: "PgText";
1339
+ data: string;
1340
+ driverParam: string;
1341
+ notNull: false;
1342
+ hasDefault: false;
1343
+ isPrimaryKey: false;
1344
+ isAutoincrement: false;
1345
+ hasRuntimeDefault: false;
1346
+ enumValues: [string, ...string[]];
1347
+ baseColumn: never;
1348
+ identity: undefined;
1349
+ generated: undefined;
1350
+ }, {}, {}>;
1351
+ rejectionReason: import("drizzle-orm/pg-core").PgColumn<{
1352
+ name: "rejection_reason";
1353
+ tableName: "compliance_exemptions";
1354
+ dataType: "string";
1355
+ columnType: "PgText";
1356
+ data: string;
1357
+ driverParam: string;
1358
+ notNull: false;
1359
+ hasDefault: false;
1360
+ isPrimaryKey: false;
1361
+ isAutoincrement: false;
1362
+ hasRuntimeDefault: false;
1363
+ enumValues: [string, ...string[]];
1364
+ baseColumn: never;
1365
+ identity: undefined;
1366
+ generated: undefined;
1367
+ }, {}, {}>;
1368
+ status: import("drizzle-orm/pg-core").PgColumn<{
1369
+ name: "status";
1370
+ tableName: "compliance_exemptions";
1371
+ dataType: "string";
1372
+ columnType: "PgVarchar";
1373
+ data: string;
1374
+ driverParam: string;
1375
+ notNull: true;
1376
+ hasDefault: true;
1377
+ isPrimaryKey: false;
1378
+ isAutoincrement: false;
1379
+ hasRuntimeDefault: false;
1380
+ enumValues: [string, ...string[]];
1381
+ baseColumn: never;
1382
+ identity: undefined;
1383
+ generated: undefined;
1384
+ }, {}, {
1385
+ length: 20;
1386
+ }>;
1387
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1388
+ name: "expires_at";
1389
+ tableName: "compliance_exemptions";
1390
+ dataType: "date";
1391
+ columnType: "PgTimestamp";
1392
+ data: Date;
1393
+ driverParam: string;
1394
+ notNull: false;
1395
+ hasDefault: false;
1396
+ isPrimaryKey: false;
1397
+ isAutoincrement: false;
1398
+ hasRuntimeDefault: false;
1399
+ enumValues: undefined;
1400
+ baseColumn: never;
1401
+ identity: undefined;
1402
+ generated: undefined;
1403
+ }, {}, {}>;
1404
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
1405
+ name: "created_by";
1406
+ tableName: "compliance_exemptions";
1407
+ dataType: "string";
1408
+ columnType: "PgText";
1409
+ data: string;
1410
+ driverParam: string;
1411
+ notNull: true;
1412
+ hasDefault: false;
1413
+ isPrimaryKey: false;
1414
+ isAutoincrement: false;
1415
+ hasRuntimeDefault: false;
1416
+ enumValues: [string, ...string[]];
1417
+ baseColumn: never;
1418
+ identity: undefined;
1419
+ generated: undefined;
1420
+ }, {}, {}>;
1421
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1422
+ name: "created_at";
1423
+ tableName: "compliance_exemptions";
1424
+ dataType: "date";
1425
+ columnType: "PgTimestamp";
1426
+ data: Date;
1427
+ driverParam: string;
1428
+ notNull: true;
1429
+ hasDefault: true;
1430
+ isPrimaryKey: false;
1431
+ isAutoincrement: false;
1432
+ hasRuntimeDefault: false;
1433
+ enumValues: undefined;
1434
+ baseColumn: never;
1435
+ identity: undefined;
1436
+ generated: undefined;
1437
+ }, {}, {}>;
1438
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
1439
+ name: "updated_by";
1440
+ tableName: "compliance_exemptions";
1441
+ dataType: "string";
1442
+ columnType: "PgText";
1443
+ data: string;
1444
+ driverParam: string;
1445
+ notNull: true;
1446
+ hasDefault: false;
1447
+ isPrimaryKey: false;
1448
+ isAutoincrement: false;
1449
+ hasRuntimeDefault: false;
1450
+ enumValues: [string, ...string[]];
1451
+ baseColumn: never;
1452
+ identity: undefined;
1453
+ generated: undefined;
1454
+ }, {}, {}>;
1455
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1456
+ name: "updated_at";
1457
+ tableName: "compliance_exemptions";
1458
+ dataType: "date";
1459
+ columnType: "PgTimestamp";
1460
+ data: Date;
1461
+ driverParam: string;
1462
+ notNull: true;
1463
+ hasDefault: true;
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
+ /**
1476
+ * Tracks which orgs have opted into system-org published compliance rules.
1477
+ *
1478
+ * @table compliance_rule_subscriptions
1479
+ */
1480
+ export declare const complianceRuleSubscription: import("drizzle-orm/pg-core").PgTableWithColumns<{
1481
+ name: "compliance_rule_subscriptions";
1482
+ schema: undefined;
1483
+ columns: {
1484
+ id: import("drizzle-orm/pg-core").PgColumn<{
1485
+ name: "id";
1486
+ tableName: "compliance_rule_subscriptions";
1487
+ dataType: "string";
1488
+ columnType: "PgUUID";
1489
+ data: string;
1490
+ driverParam: string;
1491
+ notNull: true;
1492
+ hasDefault: true;
1493
+ isPrimaryKey: true;
1494
+ isAutoincrement: false;
1495
+ hasRuntimeDefault: false;
1496
+ enumValues: undefined;
1497
+ baseColumn: never;
1498
+ identity: undefined;
1499
+ generated: undefined;
1500
+ }, {}, {}>;
1501
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
1502
+ name: "org_id";
1503
+ tableName: "compliance_rule_subscriptions";
1504
+ dataType: "string";
1505
+ columnType: "PgVarchar";
1506
+ data: string;
1507
+ driverParam: string;
1508
+ notNull: true;
1509
+ hasDefault: false;
1510
+ isPrimaryKey: false;
1511
+ isAutoincrement: false;
1512
+ hasRuntimeDefault: false;
1513
+ enumValues: [string, ...string[]];
1514
+ baseColumn: never;
1515
+ identity: undefined;
1516
+ generated: undefined;
1517
+ }, {}, {
1518
+ length: 255;
1519
+ }>;
1520
+ ruleId: import("drizzle-orm/pg-core").PgColumn<{
1521
+ name: "rule_id";
1522
+ tableName: "compliance_rule_subscriptions";
1523
+ dataType: "string";
1524
+ columnType: "PgUUID";
1525
+ data: string;
1526
+ driverParam: string;
1527
+ notNull: true;
1528
+ hasDefault: false;
1529
+ isPrimaryKey: false;
1530
+ isAutoincrement: false;
1531
+ hasRuntimeDefault: false;
1532
+ enumValues: undefined;
1533
+ baseColumn: never;
1534
+ identity: undefined;
1535
+ generated: undefined;
1536
+ }, {}, {}>;
1537
+ subscribedBy: import("drizzle-orm/pg-core").PgColumn<{
1538
+ name: "subscribed_by";
1539
+ tableName: "compliance_rule_subscriptions";
1540
+ dataType: "string";
1541
+ columnType: "PgText";
1542
+ data: string;
1543
+ driverParam: string;
1544
+ notNull: true;
1545
+ hasDefault: false;
1546
+ isPrimaryKey: false;
1547
+ isAutoincrement: false;
1548
+ hasRuntimeDefault: false;
1549
+ enumValues: [string, ...string[]];
1550
+ baseColumn: never;
1551
+ identity: undefined;
1552
+ generated: undefined;
1553
+ }, {}, {}>;
1554
+ subscribedAt: import("drizzle-orm/pg-core").PgColumn<{
1555
+ name: "subscribed_at";
1556
+ tableName: "compliance_rule_subscriptions";
1557
+ dataType: "date";
1558
+ columnType: "PgTimestamp";
1559
+ data: Date;
1560
+ driverParam: string;
1561
+ notNull: true;
1562
+ hasDefault: true;
1563
+ isPrimaryKey: false;
1564
+ isAutoincrement: false;
1565
+ hasRuntimeDefault: false;
1566
+ enumValues: undefined;
1567
+ baseColumn: never;
1568
+ identity: undefined;
1569
+ generated: undefined;
1570
+ }, {}, {}>;
1571
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
1572
+ name: "is_active";
1573
+ tableName: "compliance_rule_subscriptions";
1574
+ dataType: "boolean";
1575
+ columnType: "PgBoolean";
1576
+ data: boolean;
1577
+ driverParam: boolean;
1578
+ notNull: true;
1579
+ hasDefault: true;
1580
+ isPrimaryKey: false;
1581
+ isAutoincrement: false;
1582
+ hasRuntimeDefault: false;
1583
+ enumValues: undefined;
1584
+ baseColumn: never;
1585
+ identity: undefined;
1586
+ generated: undefined;
1587
+ }, {}, {}>;
1588
+ pinnedVersion: import("drizzle-orm/pg-core").PgColumn<{
1589
+ name: "pinned_version";
1590
+ tableName: "compliance_rule_subscriptions";
1591
+ dataType: "json";
1592
+ columnType: "PgJsonb";
1593
+ data: Record<string, unknown>;
1594
+ driverParam: unknown;
1595
+ notNull: false;
1596
+ hasDefault: false;
1597
+ isPrimaryKey: false;
1598
+ isAutoincrement: false;
1599
+ hasRuntimeDefault: false;
1600
+ enumValues: undefined;
1601
+ baseColumn: never;
1602
+ identity: undefined;
1603
+ generated: undefined;
1604
+ }, {}, {
1605
+ $type: Record<string, unknown>;
1606
+ }>;
1607
+ unsubscribedAt: import("drizzle-orm/pg-core").PgColumn<{
1608
+ name: "unsubscribed_at";
1609
+ tableName: "compliance_rule_subscriptions";
1610
+ dataType: "date";
1611
+ columnType: "PgTimestamp";
1612
+ data: Date;
1613
+ driverParam: string;
1614
+ notNull: false;
1615
+ hasDefault: false;
1616
+ isPrimaryKey: false;
1617
+ isAutoincrement: false;
1618
+ hasRuntimeDefault: false;
1619
+ enumValues: undefined;
1620
+ baseColumn: never;
1621
+ identity: undefined;
1622
+ generated: undefined;
1623
+ }, {}, {}>;
1624
+ unsubscribedBy: import("drizzle-orm/pg-core").PgColumn<{
1625
+ name: "unsubscribed_by";
1626
+ tableName: "compliance_rule_subscriptions";
1627
+ dataType: "string";
1628
+ columnType: "PgText";
1629
+ data: string;
1630
+ driverParam: string;
1631
+ notNull: false;
1632
+ hasDefault: false;
1633
+ isPrimaryKey: false;
1634
+ isAutoincrement: false;
1635
+ hasRuntimeDefault: false;
1636
+ enumValues: [string, ...string[]];
1637
+ baseColumn: never;
1638
+ identity: undefined;
1639
+ generated: undefined;
1640
+ }, {}, {}>;
1641
+ };
1642
+ dialect: 'pg';
1643
+ }>;
1644
+ /**
1645
+ * Bulk compliance scans tracks scheduled and on-demand scans.
1646
+ *
1647
+ * @table compliance_scans
1648
+ */
1649
+ export declare const complianceScan: import("drizzle-orm/pg-core").PgTableWithColumns<{
1650
+ name: "compliance_scans";
1651
+ schema: undefined;
1652
+ columns: {
1653
+ id: import("drizzle-orm/pg-core").PgColumn<{
1654
+ name: "id";
1655
+ tableName: "compliance_scans";
1656
+ dataType: "string";
1657
+ columnType: "PgUUID";
1658
+ data: string;
1659
+ driverParam: string;
1660
+ notNull: true;
1661
+ hasDefault: true;
1662
+ isPrimaryKey: true;
1663
+ isAutoincrement: false;
1664
+ hasRuntimeDefault: false;
1665
+ enumValues: undefined;
1666
+ baseColumn: never;
1667
+ identity: undefined;
1668
+ generated: undefined;
1669
+ }, {}, {}>;
1670
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
1671
+ name: "org_id";
1672
+ tableName: "compliance_scans";
1673
+ dataType: "string";
1674
+ columnType: "PgVarchar";
1675
+ data: string;
1676
+ driverParam: string;
1677
+ notNull: true;
1678
+ hasDefault: false;
1679
+ isPrimaryKey: false;
1680
+ isAutoincrement: false;
1681
+ hasRuntimeDefault: false;
1682
+ enumValues: [string, ...string[]];
1683
+ baseColumn: never;
1684
+ identity: undefined;
1685
+ generated: undefined;
1686
+ }, {}, {
1687
+ length: 255;
1688
+ }>;
1689
+ target: import("drizzle-orm/pg-core").PgColumn<{
1690
+ name: "target";
1691
+ tableName: "compliance_scans";
1692
+ dataType: "string";
1693
+ columnType: "PgVarchar";
1694
+ data: string;
1695
+ driverParam: string;
1696
+ notNull: true;
1697
+ hasDefault: false;
1698
+ isPrimaryKey: false;
1699
+ isAutoincrement: false;
1700
+ hasRuntimeDefault: false;
1701
+ enumValues: [string, ...string[]];
1702
+ baseColumn: never;
1703
+ identity: undefined;
1704
+ generated: undefined;
1705
+ }, {}, {
1706
+ length: 20;
1707
+ }>;
1708
+ filter: import("drizzle-orm/pg-core").PgColumn<{
1709
+ name: "filter";
1710
+ tableName: "compliance_scans";
1711
+ dataType: "json";
1712
+ columnType: "PgJsonb";
1713
+ data: unknown;
1714
+ driverParam: unknown;
1715
+ notNull: false;
1716
+ hasDefault: false;
1717
+ isPrimaryKey: false;
1718
+ isAutoincrement: false;
1719
+ hasRuntimeDefault: false;
1720
+ enumValues: undefined;
1721
+ baseColumn: never;
1722
+ identity: undefined;
1723
+ generated: undefined;
1724
+ }, {}, {}>;
1725
+ status: import("drizzle-orm/pg-core").PgColumn<{
1726
+ name: "status";
1727
+ tableName: "compliance_scans";
1728
+ dataType: "string";
1729
+ columnType: "PgVarchar";
1730
+ data: string;
1731
+ driverParam: string;
1732
+ notNull: true;
1733
+ hasDefault: true;
1734
+ isPrimaryKey: false;
1735
+ isAutoincrement: false;
1736
+ hasRuntimeDefault: false;
1737
+ enumValues: [string, ...string[]];
1738
+ baseColumn: never;
1739
+ identity: undefined;
1740
+ generated: undefined;
1741
+ }, {}, {
1742
+ length: 20;
1743
+ }>;
1744
+ triggeredBy: import("drizzle-orm/pg-core").PgColumn<{
1745
+ name: "triggered_by";
1746
+ tableName: "compliance_scans";
1747
+ dataType: "string";
1748
+ columnType: "PgVarchar";
1749
+ data: string;
1750
+ driverParam: string;
1751
+ notNull: true;
1752
+ hasDefault: false;
1753
+ isPrimaryKey: false;
1754
+ isAutoincrement: false;
1755
+ hasRuntimeDefault: false;
1756
+ enumValues: [string, ...string[]];
1757
+ baseColumn: never;
1758
+ identity: undefined;
1759
+ generated: undefined;
1760
+ }, {}, {
1761
+ length: 20;
1762
+ }>;
1763
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1764
+ name: "user_id";
1765
+ tableName: "compliance_scans";
1766
+ dataType: "string";
1767
+ columnType: "PgText";
1768
+ data: string;
1769
+ driverParam: string;
1770
+ notNull: true;
1771
+ hasDefault: false;
1772
+ isPrimaryKey: false;
1773
+ isAutoincrement: false;
1774
+ hasRuntimeDefault: false;
1775
+ enumValues: [string, ...string[]];
1776
+ baseColumn: never;
1777
+ identity: undefined;
1778
+ generated: undefined;
1779
+ }, {}, {}>;
1780
+ totalEntities: import("drizzle-orm/pg-core").PgColumn<{
1781
+ name: "total_entities";
1782
+ tableName: "compliance_scans";
1783
+ dataType: "number";
1784
+ columnType: "PgInteger";
1785
+ data: number;
1786
+ driverParam: string | number;
1787
+ notNull: true;
1788
+ hasDefault: true;
1789
+ isPrimaryKey: false;
1790
+ isAutoincrement: false;
1791
+ hasRuntimeDefault: false;
1792
+ enumValues: undefined;
1793
+ baseColumn: never;
1794
+ identity: undefined;
1795
+ generated: undefined;
1796
+ }, {}, {}>;
1797
+ processedEntities: import("drizzle-orm/pg-core").PgColumn<{
1798
+ name: "processed_entities";
1799
+ tableName: "compliance_scans";
1800
+ dataType: "number";
1801
+ columnType: "PgInteger";
1802
+ data: number;
1803
+ driverParam: string | number;
1804
+ notNull: true;
1805
+ hasDefault: true;
1806
+ isPrimaryKey: false;
1807
+ isAutoincrement: false;
1808
+ hasRuntimeDefault: false;
1809
+ enumValues: undefined;
1810
+ baseColumn: never;
1811
+ identity: undefined;
1812
+ generated: undefined;
1813
+ }, {}, {}>;
1814
+ passCount: import("drizzle-orm/pg-core").PgColumn<{
1815
+ name: "pass_count";
1816
+ tableName: "compliance_scans";
1817
+ dataType: "number";
1818
+ columnType: "PgInteger";
1819
+ data: number;
1820
+ driverParam: string | number;
1821
+ notNull: true;
1822
+ hasDefault: true;
1823
+ isPrimaryKey: false;
1824
+ isAutoincrement: false;
1825
+ hasRuntimeDefault: false;
1826
+ enumValues: undefined;
1827
+ baseColumn: never;
1828
+ identity: undefined;
1829
+ generated: undefined;
1830
+ }, {}, {}>;
1831
+ warnCount: import("drizzle-orm/pg-core").PgColumn<{
1832
+ name: "warn_count";
1833
+ tableName: "compliance_scans";
1834
+ dataType: "number";
1835
+ columnType: "PgInteger";
1836
+ data: number;
1837
+ driverParam: string | number;
1838
+ notNull: true;
1839
+ hasDefault: true;
1840
+ isPrimaryKey: false;
1841
+ isAutoincrement: false;
1842
+ hasRuntimeDefault: false;
1843
+ enumValues: undefined;
1844
+ baseColumn: never;
1845
+ identity: undefined;
1846
+ generated: undefined;
1847
+ }, {}, {}>;
1848
+ blockCount: import("drizzle-orm/pg-core").PgColumn<{
1849
+ name: "block_count";
1850
+ tableName: "compliance_scans";
1851
+ dataType: "number";
1852
+ columnType: "PgInteger";
1853
+ data: number;
1854
+ driverParam: string | number;
1855
+ notNull: true;
1856
+ hasDefault: true;
1857
+ isPrimaryKey: false;
1858
+ isAutoincrement: false;
1859
+ hasRuntimeDefault: false;
1860
+ enumValues: undefined;
1861
+ baseColumn: never;
1862
+ identity: undefined;
1863
+ generated: undefined;
1864
+ }, {}, {}>;
1865
+ truncated: import("drizzle-orm/pg-core").PgColumn<{
1866
+ name: "truncated";
1867
+ tableName: "compliance_scans";
1868
+ dataType: "boolean";
1869
+ columnType: "PgBoolean";
1870
+ data: boolean;
1871
+ driverParam: boolean;
1872
+ notNull: true;
1873
+ hasDefault: true;
1874
+ isPrimaryKey: false;
1875
+ isAutoincrement: false;
1876
+ hasRuntimeDefault: false;
1877
+ enumValues: undefined;
1878
+ baseColumn: never;
1879
+ identity: undefined;
1880
+ generated: undefined;
1881
+ }, {}, {}>;
1882
+ startedAt: import("drizzle-orm/pg-core").PgColumn<{
1883
+ name: "started_at";
1884
+ tableName: "compliance_scans";
1885
+ dataType: "date";
1886
+ columnType: "PgTimestamp";
1887
+ data: Date;
1888
+ driverParam: string;
1889
+ notNull: false;
1890
+ hasDefault: false;
1891
+ isPrimaryKey: false;
1892
+ isAutoincrement: false;
1893
+ hasRuntimeDefault: false;
1894
+ enumValues: undefined;
1895
+ baseColumn: never;
1896
+ identity: undefined;
1897
+ generated: undefined;
1898
+ }, {}, {}>;
1899
+ completedAt: import("drizzle-orm/pg-core").PgColumn<{
1900
+ name: "completed_at";
1901
+ tableName: "compliance_scans";
1902
+ dataType: "date";
1903
+ columnType: "PgTimestamp";
1904
+ data: Date;
1905
+ driverParam: string;
1906
+ notNull: false;
1907
+ hasDefault: false;
1908
+ isPrimaryKey: false;
1909
+ isAutoincrement: false;
1910
+ hasRuntimeDefault: false;
1911
+ enumValues: undefined;
1912
+ baseColumn: never;
1913
+ identity: undefined;
1914
+ generated: undefined;
1915
+ }, {}, {}>;
1916
+ cancelledAt: import("drizzle-orm/pg-core").PgColumn<{
1917
+ name: "cancelled_at";
1918
+ tableName: "compliance_scans";
1919
+ dataType: "date";
1920
+ columnType: "PgTimestamp";
1921
+ data: Date;
1922
+ driverParam: string;
1923
+ notNull: false;
1924
+ hasDefault: false;
1925
+ isPrimaryKey: false;
1926
+ isAutoincrement: false;
1927
+ hasRuntimeDefault: false;
1928
+ enumValues: undefined;
1929
+ baseColumn: never;
1930
+ identity: undefined;
1931
+ generated: undefined;
1932
+ }, {}, {}>;
1933
+ cancelledBy: import("drizzle-orm/pg-core").PgColumn<{
1934
+ name: "cancelled_by";
1935
+ tableName: "compliance_scans";
1936
+ dataType: "string";
1937
+ columnType: "PgText";
1938
+ data: string;
1939
+ driverParam: string;
1940
+ notNull: false;
1941
+ hasDefault: false;
1942
+ isPrimaryKey: false;
1943
+ isAutoincrement: false;
1944
+ hasRuntimeDefault: false;
1945
+ enumValues: [string, ...string[]];
1946
+ baseColumn: never;
1947
+ identity: undefined;
1948
+ generated: undefined;
1949
+ }, {}, {}>;
1950
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1951
+ name: "created_at";
1952
+ tableName: "compliance_scans";
1953
+ dataType: "date";
1954
+ columnType: "PgTimestamp";
1955
+ data: Date;
1956
+ driverParam: string;
1957
+ notNull: true;
1958
+ hasDefault: true;
1959
+ isPrimaryKey: false;
1960
+ isAutoincrement: false;
1961
+ hasRuntimeDefault: false;
1962
+ enumValues: undefined;
1963
+ baseColumn: never;
1964
+ identity: undefined;
1965
+ generated: undefined;
1966
+ }, {}, {}>;
1967
+ };
1968
+ dialect: 'pg';
1969
+ }>;
1970
+ /**
1971
+ * Cron-based recurring scan schedules.
1972
+ *
1973
+ * @table compliance_scan_schedules
1974
+ */
1975
+ export declare const complianceScanSchedule: import("drizzle-orm/pg-core").PgTableWithColumns<{
1976
+ name: "compliance_scan_schedules";
1977
+ schema: undefined;
1978
+ columns: {
1979
+ id: import("drizzle-orm/pg-core").PgColumn<{
1980
+ name: "id";
1981
+ tableName: "compliance_scan_schedules";
1982
+ dataType: "string";
1983
+ columnType: "PgUUID";
1984
+ data: string;
1985
+ driverParam: string;
1986
+ notNull: true;
1987
+ hasDefault: true;
1988
+ isPrimaryKey: true;
1989
+ isAutoincrement: false;
1990
+ hasRuntimeDefault: false;
1991
+ enumValues: undefined;
1992
+ baseColumn: never;
1993
+ identity: undefined;
1994
+ generated: undefined;
1995
+ }, {}, {}>;
1996
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
1997
+ name: "org_id";
1998
+ tableName: "compliance_scan_schedules";
1999
+ dataType: "string";
2000
+ columnType: "PgVarchar";
2001
+ data: string;
2002
+ driverParam: string;
2003
+ notNull: true;
2004
+ hasDefault: false;
2005
+ isPrimaryKey: false;
2006
+ isAutoincrement: false;
2007
+ hasRuntimeDefault: false;
2008
+ enumValues: [string, ...string[]];
2009
+ baseColumn: never;
2010
+ identity: undefined;
2011
+ generated: undefined;
2012
+ }, {}, {
2013
+ length: 255;
2014
+ }>;
2015
+ target: import("drizzle-orm/pg-core").PgColumn<{
2016
+ name: "target";
2017
+ tableName: "compliance_scan_schedules";
2018
+ dataType: "string";
2019
+ columnType: "PgVarchar";
2020
+ data: string;
2021
+ driverParam: string;
2022
+ notNull: true;
2023
+ hasDefault: false;
2024
+ isPrimaryKey: false;
2025
+ isAutoincrement: false;
2026
+ hasRuntimeDefault: false;
2027
+ enumValues: [string, ...string[]];
2028
+ baseColumn: never;
2029
+ identity: undefined;
2030
+ generated: undefined;
2031
+ }, {}, {
2032
+ length: 20;
2033
+ }>;
2034
+ cronExpression: import("drizzle-orm/pg-core").PgColumn<{
2035
+ name: "cron_expression";
2036
+ tableName: "compliance_scan_schedules";
2037
+ dataType: "string";
2038
+ columnType: "PgVarchar";
2039
+ data: string;
2040
+ driverParam: string;
2041
+ notNull: true;
2042
+ hasDefault: false;
2043
+ isPrimaryKey: false;
2044
+ isAutoincrement: false;
2045
+ hasRuntimeDefault: false;
2046
+ enumValues: [string, ...string[]];
2047
+ baseColumn: never;
2048
+ identity: undefined;
2049
+ generated: undefined;
2050
+ }, {}, {
2051
+ length: 100;
2052
+ }>;
2053
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
2054
+ name: "is_active";
2055
+ tableName: "compliance_scan_schedules";
2056
+ dataType: "boolean";
2057
+ columnType: "PgBoolean";
2058
+ data: boolean;
2059
+ driverParam: boolean;
2060
+ notNull: true;
2061
+ hasDefault: true;
2062
+ isPrimaryKey: false;
2063
+ isAutoincrement: false;
2064
+ hasRuntimeDefault: false;
2065
+ enumValues: undefined;
2066
+ baseColumn: never;
2067
+ identity: undefined;
2068
+ generated: undefined;
2069
+ }, {}, {}>;
2070
+ lastRunAt: import("drizzle-orm/pg-core").PgColumn<{
2071
+ name: "last_run_at";
2072
+ tableName: "compliance_scan_schedules";
2073
+ dataType: "date";
2074
+ columnType: "PgTimestamp";
2075
+ data: Date;
2076
+ driverParam: string;
2077
+ notNull: false;
2078
+ hasDefault: false;
2079
+ isPrimaryKey: false;
2080
+ isAutoincrement: false;
2081
+ hasRuntimeDefault: false;
2082
+ enumValues: undefined;
2083
+ baseColumn: never;
2084
+ identity: undefined;
2085
+ generated: undefined;
2086
+ }, {}, {}>;
2087
+ nextRunAt: import("drizzle-orm/pg-core").PgColumn<{
2088
+ name: "next_run_at";
2089
+ tableName: "compliance_scan_schedules";
2090
+ dataType: "date";
2091
+ columnType: "PgTimestamp";
2092
+ data: Date;
2093
+ driverParam: string;
2094
+ notNull: false;
2095
+ hasDefault: false;
2096
+ isPrimaryKey: false;
2097
+ isAutoincrement: false;
2098
+ hasRuntimeDefault: false;
2099
+ enumValues: undefined;
2100
+ baseColumn: never;
2101
+ identity: undefined;
2102
+ generated: undefined;
2103
+ }, {}, {}>;
2104
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
2105
+ name: "created_by";
2106
+ tableName: "compliance_scan_schedules";
2107
+ dataType: "string";
2108
+ columnType: "PgText";
2109
+ data: string;
2110
+ driverParam: string;
2111
+ notNull: true;
2112
+ hasDefault: false;
2113
+ isPrimaryKey: false;
2114
+ isAutoincrement: false;
2115
+ hasRuntimeDefault: false;
2116
+ enumValues: [string, ...string[]];
2117
+ baseColumn: never;
2118
+ identity: undefined;
2119
+ generated: undefined;
2120
+ }, {}, {}>;
2121
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2122
+ name: "created_at";
2123
+ tableName: "compliance_scan_schedules";
2124
+ dataType: "date";
2125
+ columnType: "PgTimestamp";
2126
+ data: Date;
2127
+ driverParam: string;
2128
+ notNull: true;
2129
+ hasDefault: true;
2130
+ isPrimaryKey: false;
2131
+ isAutoincrement: false;
2132
+ hasRuntimeDefault: false;
2133
+ enumValues: undefined;
2134
+ baseColumn: never;
2135
+ identity: undefined;
2136
+ generated: undefined;
2137
+ }, {}, {}>;
2138
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
2139
+ name: "updated_by";
2140
+ tableName: "compliance_scan_schedules";
2141
+ dataType: "string";
2142
+ columnType: "PgText";
2143
+ data: string;
2144
+ driverParam: string;
2145
+ notNull: true;
2146
+ hasDefault: false;
2147
+ isPrimaryKey: false;
2148
+ isAutoincrement: false;
2149
+ hasRuntimeDefault: false;
2150
+ enumValues: [string, ...string[]];
2151
+ baseColumn: never;
2152
+ identity: undefined;
2153
+ generated: undefined;
2154
+ }, {}, {}>;
2155
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2156
+ name: "updated_at";
2157
+ tableName: "compliance_scan_schedules";
2158
+ dataType: "date";
2159
+ columnType: "PgTimestamp";
2160
+ data: Date;
2161
+ driverParam: string;
2162
+ notNull: true;
2163
+ hasDefault: true;
2164
+ isPrimaryKey: false;
2165
+ isAutoincrement: false;
2166
+ hasRuntimeDefault: false;
2167
+ enumValues: undefined;
2168
+ baseColumn: never;
2169
+ identity: undefined;
2170
+ generated: undefined;
2171
+ }, {}, {}>;
2172
+ };
2173
+ dialect: 'pg';
2174
+ }>;
2175
+ /**
2176
+ * Per-org notification settings for compliance events.
2177
+ *
2178
+ * @table compliance_notification_preferences
2179
+ */
2180
+ export declare const complianceNotificationPreference: import("drizzle-orm/pg-core").PgTableWithColumns<{
2181
+ name: "compliance_notification_preferences";
2182
+ schema: undefined;
2183
+ columns: {
2184
+ id: import("drizzle-orm/pg-core").PgColumn<{
2185
+ name: "id";
2186
+ tableName: "compliance_notification_preferences";
2187
+ dataType: "string";
2188
+ columnType: "PgUUID";
2189
+ data: string;
2190
+ driverParam: string;
2191
+ notNull: true;
2192
+ hasDefault: true;
2193
+ isPrimaryKey: true;
2194
+ isAutoincrement: false;
2195
+ hasRuntimeDefault: false;
2196
+ enumValues: undefined;
2197
+ baseColumn: never;
2198
+ identity: undefined;
2199
+ generated: undefined;
2200
+ }, {}, {}>;
2201
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
2202
+ name: "org_id";
2203
+ tableName: "compliance_notification_preferences";
2204
+ dataType: "string";
2205
+ columnType: "PgVarchar";
2206
+ data: string;
2207
+ driverParam: string;
2208
+ notNull: true;
2209
+ hasDefault: false;
2210
+ isPrimaryKey: false;
2211
+ isAutoincrement: false;
2212
+ hasRuntimeDefault: false;
2213
+ enumValues: [string, ...string[]];
2214
+ baseColumn: never;
2215
+ identity: undefined;
2216
+ generated: undefined;
2217
+ }, {}, {
2218
+ length: 255;
2219
+ }>;
2220
+ notifyOnBlock: import("drizzle-orm/pg-core").PgColumn<{
2221
+ name: "notify_on_block";
2222
+ tableName: "compliance_notification_preferences";
2223
+ dataType: "boolean";
2224
+ columnType: "PgBoolean";
2225
+ data: boolean;
2226
+ driverParam: boolean;
2227
+ notNull: true;
2228
+ hasDefault: true;
2229
+ isPrimaryKey: false;
2230
+ isAutoincrement: false;
2231
+ hasRuntimeDefault: false;
2232
+ enumValues: undefined;
2233
+ baseColumn: never;
2234
+ identity: undefined;
2235
+ generated: undefined;
2236
+ }, {}, {}>;
2237
+ notifyOnWarning: import("drizzle-orm/pg-core").PgColumn<{
2238
+ name: "notify_on_warning";
2239
+ tableName: "compliance_notification_preferences";
2240
+ dataType: "boolean";
2241
+ columnType: "PgBoolean";
2242
+ data: boolean;
2243
+ driverParam: boolean;
2244
+ notNull: true;
2245
+ hasDefault: true;
2246
+ isPrimaryKey: false;
2247
+ isAutoincrement: false;
2248
+ hasRuntimeDefault: false;
2249
+ enumValues: undefined;
2250
+ baseColumn: never;
2251
+ identity: undefined;
2252
+ generated: undefined;
2253
+ }, {}, {}>;
2254
+ emailEnabled: import("drizzle-orm/pg-core").PgColumn<{
2255
+ name: "email_enabled";
2256
+ tableName: "compliance_notification_preferences";
2257
+ dataType: "boolean";
2258
+ columnType: "PgBoolean";
2259
+ data: boolean;
2260
+ driverParam: boolean;
2261
+ notNull: true;
2262
+ hasDefault: true;
2263
+ isPrimaryKey: false;
2264
+ isAutoincrement: false;
2265
+ hasRuntimeDefault: false;
2266
+ enumValues: undefined;
2267
+ baseColumn: never;
2268
+ identity: undefined;
2269
+ generated: undefined;
2270
+ }, {}, {}>;
2271
+ digestMode: import("drizzle-orm/pg-core").PgColumn<{
2272
+ name: "digest_mode";
2273
+ tableName: "compliance_notification_preferences";
2274
+ dataType: "string";
2275
+ columnType: "PgVarchar";
2276
+ data: string;
2277
+ driverParam: string;
2278
+ notNull: true;
2279
+ hasDefault: true;
2280
+ isPrimaryKey: false;
2281
+ isAutoincrement: false;
2282
+ hasRuntimeDefault: false;
2283
+ enumValues: [string, ...string[]];
2284
+ baseColumn: never;
2285
+ identity: undefined;
2286
+ generated: undefined;
2287
+ }, {}, {
2288
+ length: 20;
2289
+ }>;
2290
+ digestSchedule: import("drizzle-orm/pg-core").PgColumn<{
2291
+ name: "digest_schedule";
2292
+ tableName: "compliance_notification_preferences";
2293
+ dataType: "string";
2294
+ columnType: "PgVarchar";
2295
+ data: string;
2296
+ driverParam: string;
2297
+ notNull: false;
2298
+ hasDefault: false;
2299
+ isPrimaryKey: false;
2300
+ isAutoincrement: false;
2301
+ hasRuntimeDefault: false;
2302
+ enumValues: [string, ...string[]];
2303
+ baseColumn: never;
2304
+ identity: undefined;
2305
+ generated: undefined;
2306
+ }, {}, {
2307
+ length: 100;
2308
+ }>;
2309
+ lastDigestAt: import("drizzle-orm/pg-core").PgColumn<{
2310
+ name: "last_digest_at";
2311
+ tableName: "compliance_notification_preferences";
2312
+ dataType: "date";
2313
+ columnType: "PgTimestamp";
2314
+ data: Date;
2315
+ driverParam: string;
2316
+ notNull: false;
2317
+ hasDefault: false;
2318
+ isPrimaryKey: false;
2319
+ isAutoincrement: false;
2320
+ hasRuntimeDefault: false;
2321
+ enumValues: undefined;
2322
+ baseColumn: never;
2323
+ identity: undefined;
2324
+ generated: undefined;
2325
+ }, {}, {}>;
2326
+ targetUsers: import("drizzle-orm/pg-core").PgColumn<{
2327
+ name: "target_users";
2328
+ tableName: "compliance_notification_preferences";
2329
+ dataType: "json";
2330
+ columnType: "PgJsonb";
2331
+ data: string[];
2332
+ driverParam: unknown;
2333
+ notNull: false;
2334
+ hasDefault: false;
2335
+ isPrimaryKey: false;
2336
+ isAutoincrement: false;
2337
+ hasRuntimeDefault: false;
2338
+ enumValues: undefined;
2339
+ baseColumn: never;
2340
+ identity: undefined;
2341
+ generated: undefined;
2342
+ }, {}, {
2343
+ $type: string[];
2344
+ }>;
2345
+ webhookUrl: import("drizzle-orm/pg-core").PgColumn<{
2346
+ name: "webhook_url";
2347
+ tableName: "compliance_notification_preferences";
2348
+ dataType: "string";
2349
+ columnType: "PgVarchar";
2350
+ data: string;
2351
+ driverParam: string;
2352
+ notNull: false;
2353
+ hasDefault: false;
2354
+ isPrimaryKey: false;
2355
+ isAutoincrement: false;
2356
+ hasRuntimeDefault: false;
2357
+ enumValues: [string, ...string[]];
2358
+ baseColumn: never;
2359
+ identity: undefined;
2360
+ generated: undefined;
2361
+ }, {}, {
2362
+ length: 500;
2363
+ }>;
2364
+ webhookSecret: import("drizzle-orm/pg-core").PgColumn<{
2365
+ name: "webhook_secret";
2366
+ tableName: "compliance_notification_preferences";
2367
+ dataType: "string";
2368
+ columnType: "PgVarchar";
2369
+ data: string;
2370
+ driverParam: string;
2371
+ notNull: false;
2372
+ hasDefault: false;
2373
+ isPrimaryKey: false;
2374
+ isAutoincrement: false;
2375
+ hasRuntimeDefault: false;
2376
+ enumValues: [string, ...string[]];
2377
+ baseColumn: never;
2378
+ identity: undefined;
2379
+ generated: undefined;
2380
+ }, {}, {
2381
+ length: 255;
2382
+ }>;
2383
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2384
+ name: "created_at";
2385
+ tableName: "compliance_notification_preferences";
2386
+ dataType: "date";
2387
+ columnType: "PgTimestamp";
2388
+ data: Date;
2389
+ driverParam: string;
2390
+ notNull: true;
2391
+ hasDefault: true;
2392
+ isPrimaryKey: false;
2393
+ isAutoincrement: false;
2394
+ hasRuntimeDefault: false;
2395
+ enumValues: undefined;
2396
+ baseColumn: never;
2397
+ identity: undefined;
2398
+ generated: undefined;
2399
+ }, {}, {}>;
2400
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2401
+ name: "updated_at";
2402
+ tableName: "compliance_notification_preferences";
2403
+ dataType: "date";
2404
+ columnType: "PgTimestamp";
2405
+ data: Date;
2406
+ driverParam: string;
2407
+ notNull: true;
2408
+ hasDefault: true;
2409
+ isPrimaryKey: false;
2410
+ isAutoincrement: false;
2411
+ hasRuntimeDefault: false;
2412
+ enumValues: undefined;
2413
+ baseColumn: never;
2414
+ identity: undefined;
2415
+ generated: undefined;
2416
+ }, {}, {}>;
2417
+ };
2418
+ dialect: 'pg';
2419
+ }>;
2420
+ /**
2421
+ * Log of all compliance notifications sent.
2422
+ *
2423
+ * @table compliance_notification_log
2424
+ */
2425
+ export declare const complianceNotificationLog: import("drizzle-orm/pg-core").PgTableWithColumns<{
2426
+ name: "compliance_notification_log";
2427
+ schema: undefined;
2428
+ columns: {
2429
+ id: import("drizzle-orm/pg-core").PgColumn<{
2430
+ name: "id";
2431
+ tableName: "compliance_notification_log";
2432
+ dataType: "string";
2433
+ columnType: "PgUUID";
2434
+ data: string;
2435
+ driverParam: string;
2436
+ notNull: true;
2437
+ hasDefault: true;
2438
+ isPrimaryKey: true;
2439
+ isAutoincrement: false;
2440
+ hasRuntimeDefault: false;
2441
+ enumValues: undefined;
2442
+ baseColumn: never;
2443
+ identity: undefined;
2444
+ generated: undefined;
2445
+ }, {}, {}>;
2446
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
2447
+ name: "org_id";
2448
+ tableName: "compliance_notification_log";
2449
+ dataType: "string";
2450
+ columnType: "PgVarchar";
2451
+ data: string;
2452
+ driverParam: string;
2453
+ notNull: true;
2454
+ hasDefault: false;
2455
+ isPrimaryKey: false;
2456
+ isAutoincrement: false;
2457
+ hasRuntimeDefault: false;
2458
+ enumValues: [string, ...string[]];
2459
+ baseColumn: never;
2460
+ identity: undefined;
2461
+ generated: undefined;
2462
+ }, {}, {
2463
+ length: 255;
2464
+ }>;
2465
+ channel: import("drizzle-orm/pg-core").PgColumn<{
2466
+ name: "channel";
2467
+ tableName: "compliance_notification_log";
2468
+ dataType: "string";
2469
+ columnType: "PgVarchar";
2470
+ data: string;
2471
+ driverParam: string;
2472
+ notNull: true;
2473
+ hasDefault: false;
2474
+ isPrimaryKey: false;
2475
+ isAutoincrement: false;
2476
+ hasRuntimeDefault: false;
2477
+ enumValues: [string, ...string[]];
2478
+ baseColumn: never;
2479
+ identity: undefined;
2480
+ generated: undefined;
2481
+ }, {}, {
2482
+ length: 20;
2483
+ }>;
2484
+ status: import("drizzle-orm/pg-core").PgColumn<{
2485
+ name: "status";
2486
+ tableName: "compliance_notification_log";
2487
+ dataType: "string";
2488
+ columnType: "PgVarchar";
2489
+ data: string;
2490
+ driverParam: string;
2491
+ notNull: true;
2492
+ hasDefault: false;
2493
+ isPrimaryKey: false;
2494
+ isAutoincrement: false;
2495
+ hasRuntimeDefault: false;
2496
+ enumValues: [string, ...string[]];
2497
+ baseColumn: never;
2498
+ identity: undefined;
2499
+ generated: undefined;
2500
+ }, {}, {
2501
+ length: 20;
2502
+ }>;
2503
+ payload: import("drizzle-orm/pg-core").PgColumn<{
2504
+ name: "payload";
2505
+ tableName: "compliance_notification_log";
2506
+ dataType: "json";
2507
+ columnType: "PgJsonb";
2508
+ data: Record<string, unknown>;
2509
+ driverParam: unknown;
2510
+ notNull: true;
2511
+ hasDefault: false;
2512
+ isPrimaryKey: false;
2513
+ isAutoincrement: false;
2514
+ hasRuntimeDefault: false;
2515
+ enumValues: undefined;
2516
+ baseColumn: never;
2517
+ identity: undefined;
2518
+ generated: undefined;
2519
+ }, {}, {
2520
+ $type: Record<string, unknown>;
2521
+ }>;
2522
+ webhookResponseCode: import("drizzle-orm/pg-core").PgColumn<{
2523
+ name: "webhook_response_code";
2524
+ tableName: "compliance_notification_log";
2525
+ dataType: "number";
2526
+ columnType: "PgInteger";
2527
+ data: number;
2528
+ driverParam: string | number;
2529
+ notNull: false;
2530
+ hasDefault: false;
2531
+ isPrimaryKey: false;
2532
+ isAutoincrement: false;
2533
+ hasRuntimeDefault: false;
2534
+ enumValues: undefined;
2535
+ baseColumn: never;
2536
+ identity: undefined;
2537
+ generated: undefined;
2538
+ }, {}, {}>;
2539
+ webhookError: import("drizzle-orm/pg-core").PgColumn<{
2540
+ name: "webhook_error";
2541
+ tableName: "compliance_notification_log";
2542
+ dataType: "string";
2543
+ columnType: "PgText";
2544
+ data: string;
2545
+ driverParam: string;
2546
+ notNull: false;
2547
+ hasDefault: false;
2548
+ isPrimaryKey: false;
2549
+ isAutoincrement: false;
2550
+ hasRuntimeDefault: false;
2551
+ enumValues: [string, ...string[]];
2552
+ baseColumn: never;
2553
+ identity: undefined;
2554
+ generated: undefined;
2555
+ }, {}, {}>;
2556
+ retryCount: import("drizzle-orm/pg-core").PgColumn<{
2557
+ name: "retry_count";
2558
+ tableName: "compliance_notification_log";
2559
+ dataType: "number";
2560
+ columnType: "PgInteger";
2561
+ data: number;
2562
+ driverParam: string | number;
2563
+ notNull: true;
2564
+ hasDefault: true;
2565
+ isPrimaryKey: false;
2566
+ isAutoincrement: false;
2567
+ hasRuntimeDefault: false;
2568
+ enumValues: undefined;
2569
+ baseColumn: never;
2570
+ identity: undefined;
2571
+ generated: undefined;
2572
+ }, {}, {}>;
2573
+ nextRetryAt: import("drizzle-orm/pg-core").PgColumn<{
2574
+ name: "next_retry_at";
2575
+ tableName: "compliance_notification_log";
2576
+ dataType: "date";
2577
+ columnType: "PgTimestamp";
2578
+ data: Date;
2579
+ driverParam: string;
2580
+ notNull: false;
2581
+ hasDefault: false;
2582
+ isPrimaryKey: false;
2583
+ isAutoincrement: false;
2584
+ hasRuntimeDefault: false;
2585
+ enumValues: undefined;
2586
+ baseColumn: never;
2587
+ identity: undefined;
2588
+ generated: undefined;
2589
+ }, {}, {}>;
2590
+ relatedAuditId: import("drizzle-orm/pg-core").PgColumn<{
2591
+ name: "related_audit_id";
2592
+ tableName: "compliance_notification_log";
2593
+ dataType: "string";
2594
+ columnType: "PgUUID";
2595
+ data: string;
2596
+ driverParam: string;
2597
+ notNull: false;
2598
+ hasDefault: false;
2599
+ isPrimaryKey: false;
2600
+ isAutoincrement: false;
2601
+ hasRuntimeDefault: false;
2602
+ enumValues: undefined;
2603
+ baseColumn: never;
2604
+ identity: undefined;
2605
+ generated: undefined;
2606
+ }, {}, {}>;
2607
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2608
+ name: "created_at";
2609
+ tableName: "compliance_notification_log";
2610
+ dataType: "date";
2611
+ columnType: "PgTimestamp";
2612
+ data: Date;
2613
+ driverParam: string;
2614
+ notNull: true;
2615
+ hasDefault: true;
2616
+ isPrimaryKey: false;
2617
+ isAutoincrement: false;
2618
+ hasRuntimeDefault: false;
2619
+ enumValues: undefined;
2620
+ baseColumn: never;
2621
+ identity: undefined;
2622
+ generated: undefined;
2623
+ }, {}, {}>;
2624
+ };
2625
+ dialect: 'pg';
2626
+ }>;
2627
+ /**
2628
+ * Compliance-specific RBAC roles.
2629
+ *
2630
+ * @table compliance_roles
2631
+ */
2632
+ export type ComplianceRoleType = 'compliance-viewer' | 'compliance-editor' | 'compliance-admin';
2633
+ export declare const complianceRole: import("drizzle-orm/pg-core").PgTableWithColumns<{
2634
+ name: "compliance_roles";
2635
+ schema: undefined;
2636
+ columns: {
2637
+ id: import("drizzle-orm/pg-core").PgColumn<{
2638
+ name: "id";
2639
+ tableName: "compliance_roles";
2640
+ dataType: "string";
2641
+ columnType: "PgUUID";
2642
+ data: string;
2643
+ driverParam: string;
2644
+ notNull: true;
2645
+ hasDefault: true;
2646
+ isPrimaryKey: true;
2647
+ isAutoincrement: false;
2648
+ hasRuntimeDefault: false;
2649
+ enumValues: undefined;
2650
+ baseColumn: never;
2651
+ identity: undefined;
2652
+ generated: undefined;
2653
+ }, {}, {}>;
2654
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
2655
+ name: "org_id";
2656
+ tableName: "compliance_roles";
2657
+ dataType: "string";
2658
+ columnType: "PgVarchar";
2659
+ data: string;
2660
+ driverParam: string;
2661
+ notNull: true;
2662
+ hasDefault: false;
2663
+ isPrimaryKey: false;
2664
+ isAutoincrement: false;
2665
+ hasRuntimeDefault: false;
2666
+ enumValues: [string, ...string[]];
2667
+ baseColumn: never;
2668
+ identity: undefined;
2669
+ generated: undefined;
2670
+ }, {}, {
2671
+ length: 255;
2672
+ }>;
2673
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2674
+ name: "user_id";
2675
+ tableName: "compliance_roles";
2676
+ dataType: "string";
2677
+ columnType: "PgText";
2678
+ data: string;
2679
+ driverParam: string;
2680
+ notNull: true;
2681
+ hasDefault: false;
2682
+ isPrimaryKey: false;
2683
+ isAutoincrement: false;
2684
+ hasRuntimeDefault: false;
2685
+ enumValues: [string, ...string[]];
2686
+ baseColumn: never;
2687
+ identity: undefined;
2688
+ generated: undefined;
2689
+ }, {}, {}>;
2690
+ role: import("drizzle-orm/pg-core").PgColumn<{
2691
+ name: "role";
2692
+ tableName: "compliance_roles";
2693
+ dataType: "string";
2694
+ columnType: "PgVarchar";
2695
+ data: ComplianceRoleType;
2696
+ driverParam: string;
2697
+ notNull: true;
2698
+ hasDefault: false;
2699
+ isPrimaryKey: false;
2700
+ isAutoincrement: false;
2701
+ hasRuntimeDefault: false;
2702
+ enumValues: [string, ...string[]];
2703
+ baseColumn: never;
2704
+ identity: undefined;
2705
+ generated: undefined;
2706
+ }, {}, {
2707
+ length: 30;
2708
+ $type: ComplianceRoleType;
2709
+ }>;
2710
+ grantedBy: import("drizzle-orm/pg-core").PgColumn<{
2711
+ name: "granted_by";
2712
+ tableName: "compliance_roles";
2713
+ dataType: "string";
2714
+ columnType: "PgText";
2715
+ data: string;
2716
+ driverParam: string;
2717
+ notNull: true;
2718
+ hasDefault: false;
2719
+ isPrimaryKey: false;
2720
+ isAutoincrement: false;
2721
+ hasRuntimeDefault: false;
2722
+ enumValues: [string, ...string[]];
2723
+ baseColumn: never;
2724
+ identity: undefined;
2725
+ generated: undefined;
2726
+ }, {}, {}>;
2727
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2728
+ name: "created_at";
2729
+ tableName: "compliance_roles";
2730
+ dataType: "date";
2731
+ columnType: "PgTimestamp";
2732
+ data: Date;
2733
+ driverParam: string;
2734
+ notNull: true;
2735
+ hasDefault: true;
2736
+ isPrimaryKey: false;
2737
+ isAutoincrement: false;
2738
+ hasRuntimeDefault: false;
2739
+ enumValues: undefined;
2740
+ baseColumn: never;
2741
+ identity: undefined;
2742
+ generated: undefined;
2743
+ }, {}, {}>;
2744
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2745
+ name: "updated_at";
2746
+ tableName: "compliance_roles";
2747
+ dataType: "date";
2748
+ columnType: "PgTimestamp";
2749
+ data: Date;
2750
+ driverParam: string;
2751
+ notNull: true;
2752
+ hasDefault: true;
2753
+ isPrimaryKey: false;
2754
+ isAutoincrement: false;
2755
+ hasRuntimeDefault: false;
2756
+ enumValues: undefined;
2757
+ baseColumn: never;
2758
+ identity: undefined;
2759
+ generated: undefined;
2760
+ }, {}, {}>;
2761
+ };
2762
+ dialect: 'pg';
2763
+ }>;
2764
+ /**
2765
+ * Generated compliance reports.
2766
+ *
2767
+ * @table compliance_reports
2768
+ */
2769
+ export declare const complianceReport: import("drizzle-orm/pg-core").PgTableWithColumns<{
2770
+ name: "compliance_reports";
2771
+ schema: undefined;
2772
+ columns: {
2773
+ id: import("drizzle-orm/pg-core").PgColumn<{
2774
+ name: "id";
2775
+ tableName: "compliance_reports";
2776
+ dataType: "string";
2777
+ columnType: "PgUUID";
2778
+ data: string;
2779
+ driverParam: string;
2780
+ notNull: true;
2781
+ hasDefault: true;
2782
+ isPrimaryKey: true;
2783
+ isAutoincrement: false;
2784
+ hasRuntimeDefault: false;
2785
+ enumValues: undefined;
2786
+ baseColumn: never;
2787
+ identity: undefined;
2788
+ generated: undefined;
2789
+ }, {}, {}>;
2790
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
2791
+ name: "org_id";
2792
+ tableName: "compliance_reports";
2793
+ dataType: "string";
2794
+ columnType: "PgVarchar";
2795
+ data: string;
2796
+ driverParam: string;
2797
+ notNull: true;
2798
+ hasDefault: false;
2799
+ isPrimaryKey: false;
2800
+ isAutoincrement: false;
2801
+ hasRuntimeDefault: false;
2802
+ enumValues: [string, ...string[]];
2803
+ baseColumn: never;
2804
+ identity: undefined;
2805
+ generated: undefined;
2806
+ }, {}, {
2807
+ length: 255;
2808
+ }>;
2809
+ reportType: import("drizzle-orm/pg-core").PgColumn<{
2810
+ name: "report_type";
2811
+ tableName: "compliance_reports";
2812
+ dataType: "string";
2813
+ columnType: "PgVarchar";
2814
+ data: string;
2815
+ driverParam: string;
2816
+ notNull: true;
2817
+ hasDefault: false;
2818
+ isPrimaryKey: false;
2819
+ isAutoincrement: false;
2820
+ hasRuntimeDefault: false;
2821
+ enumValues: [string, ...string[]];
2822
+ baseColumn: never;
2823
+ identity: undefined;
2824
+ generated: undefined;
2825
+ }, {}, {
2826
+ length: 30;
2827
+ }>;
2828
+ target: import("drizzle-orm/pg-core").PgColumn<{
2829
+ name: "target";
2830
+ tableName: "compliance_reports";
2831
+ dataType: "string";
2832
+ columnType: "PgVarchar";
2833
+ data: string;
2834
+ driverParam: string;
2835
+ notNull: true;
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
+ length: 20;
2846
+ }>;
2847
+ dateFrom: import("drizzle-orm/pg-core").PgColumn<{
2848
+ name: "date_from";
2849
+ tableName: "compliance_reports";
2850
+ dataType: "date";
2851
+ columnType: "PgTimestamp";
2852
+ data: Date;
2853
+ driverParam: string;
2854
+ notNull: false;
2855
+ hasDefault: false;
2856
+ isPrimaryKey: false;
2857
+ isAutoincrement: false;
2858
+ hasRuntimeDefault: false;
2859
+ enumValues: undefined;
2860
+ baseColumn: never;
2861
+ identity: undefined;
2862
+ generated: undefined;
2863
+ }, {}, {}>;
2864
+ dateTo: import("drizzle-orm/pg-core").PgColumn<{
2865
+ name: "date_to";
2866
+ tableName: "compliance_reports";
2867
+ dataType: "date";
2868
+ columnType: "PgTimestamp";
2869
+ data: Date;
2870
+ driverParam: string;
2871
+ notNull: false;
2872
+ hasDefault: false;
2873
+ isPrimaryKey: false;
2874
+ isAutoincrement: false;
2875
+ hasRuntimeDefault: false;
2876
+ enumValues: undefined;
2877
+ baseColumn: never;
2878
+ identity: undefined;
2879
+ generated: undefined;
2880
+ }, {}, {}>;
2881
+ compareFrom: import("drizzle-orm/pg-core").PgColumn<{
2882
+ name: "compare_from";
2883
+ tableName: "compliance_reports";
2884
+ dataType: "date";
2885
+ columnType: "PgTimestamp";
2886
+ data: Date;
2887
+ driverParam: string;
2888
+ notNull: false;
2889
+ hasDefault: false;
2890
+ isPrimaryKey: false;
2891
+ isAutoincrement: false;
2892
+ hasRuntimeDefault: false;
2893
+ enumValues: undefined;
2894
+ baseColumn: never;
2895
+ identity: undefined;
2896
+ generated: undefined;
2897
+ }, {}, {}>;
2898
+ compareTo: import("drizzle-orm/pg-core").PgColumn<{
2899
+ name: "compare_to";
2900
+ tableName: "compliance_reports";
2901
+ dataType: "date";
2902
+ columnType: "PgTimestamp";
2903
+ data: Date;
2904
+ driverParam: string;
2905
+ notNull: false;
2906
+ hasDefault: false;
2907
+ isPrimaryKey: false;
2908
+ isAutoincrement: false;
2909
+ hasRuntimeDefault: false;
2910
+ enumValues: undefined;
2911
+ baseColumn: never;
2912
+ identity: undefined;
2913
+ generated: undefined;
2914
+ }, {}, {}>;
2915
+ data: import("drizzle-orm/pg-core").PgColumn<{
2916
+ name: "data";
2917
+ tableName: "compliance_reports";
2918
+ dataType: "json";
2919
+ columnType: "PgJsonb";
2920
+ data: Record<string, unknown>;
2921
+ driverParam: unknown;
2922
+ notNull: true;
2923
+ hasDefault: false;
2924
+ isPrimaryKey: false;
2925
+ isAutoincrement: false;
2926
+ hasRuntimeDefault: false;
2927
+ enumValues: undefined;
2928
+ baseColumn: never;
2929
+ identity: undefined;
2930
+ generated: undefined;
2931
+ }, {}, {
2932
+ $type: Record<string, unknown>;
2933
+ }>;
2934
+ format: import("drizzle-orm/pg-core").PgColumn<{
2935
+ name: "format";
2936
+ tableName: "compliance_reports";
2937
+ dataType: "string";
2938
+ columnType: "PgVarchar";
2939
+ data: string;
2940
+ driverParam: string;
2941
+ notNull: true;
2942
+ hasDefault: true;
2943
+ isPrimaryKey: false;
2944
+ isAutoincrement: false;
2945
+ hasRuntimeDefault: false;
2946
+ enumValues: [string, ...string[]];
2947
+ baseColumn: never;
2948
+ identity: undefined;
2949
+ generated: undefined;
2950
+ }, {}, {
2951
+ length: 10;
2952
+ }>;
2953
+ generatedBy: import("drizzle-orm/pg-core").PgColumn<{
2954
+ name: "generated_by";
2955
+ tableName: "compliance_reports";
2956
+ dataType: "string";
2957
+ columnType: "PgText";
2958
+ data: string;
2959
+ driverParam: string;
2960
+ notNull: true;
2961
+ hasDefault: false;
2962
+ isPrimaryKey: false;
2963
+ isAutoincrement: false;
2964
+ hasRuntimeDefault: false;
2965
+ enumValues: [string, ...string[]];
2966
+ baseColumn: never;
2967
+ identity: undefined;
2968
+ generated: undefined;
2969
+ }, {}, {}>;
2970
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2971
+ name: "created_at";
2972
+ tableName: "compliance_reports";
2973
+ dataType: "date";
2974
+ columnType: "PgTimestamp";
2975
+ data: Date;
2976
+ driverParam: string;
2977
+ notNull: true;
2978
+ hasDefault: true;
2979
+ isPrimaryKey: false;
2980
+ isAutoincrement: false;
2981
+ hasRuntimeDefault: false;
2982
+ enumValues: undefined;
2983
+ baseColumn: never;
2984
+ identity: undefined;
2985
+ generated: undefined;
2986
+ }, {}, {}>;
2987
+ };
2988
+ dialect: 'pg';
2989
+ }>;
2990
+ /**
2991
+ * Cron-based recurring report generation schedules.
2992
+ *
2993
+ * @table compliance_report_schedules
2994
+ */
2995
+ export declare const complianceReportSchedule: import("drizzle-orm/pg-core").PgTableWithColumns<{
2996
+ name: "compliance_report_schedules";
2997
+ schema: undefined;
2998
+ columns: {
2999
+ id: import("drizzle-orm/pg-core").PgColumn<{
3000
+ name: "id";
3001
+ tableName: "compliance_report_schedules";
3002
+ dataType: "string";
3003
+ columnType: "PgUUID";
3004
+ data: string;
3005
+ driverParam: string;
3006
+ notNull: true;
3007
+ hasDefault: true;
3008
+ isPrimaryKey: true;
3009
+ isAutoincrement: false;
3010
+ hasRuntimeDefault: false;
3011
+ enumValues: undefined;
3012
+ baseColumn: never;
3013
+ identity: undefined;
3014
+ generated: undefined;
3015
+ }, {}, {}>;
3016
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
3017
+ name: "org_id";
3018
+ tableName: "compliance_report_schedules";
3019
+ dataType: "string";
3020
+ columnType: "PgVarchar";
3021
+ data: string;
3022
+ driverParam: string;
3023
+ notNull: true;
3024
+ hasDefault: false;
3025
+ isPrimaryKey: false;
3026
+ isAutoincrement: false;
3027
+ hasRuntimeDefault: false;
3028
+ enumValues: [string, ...string[]];
3029
+ baseColumn: never;
3030
+ identity: undefined;
3031
+ generated: undefined;
3032
+ }, {}, {
3033
+ length: 255;
3034
+ }>;
3035
+ reportType: import("drizzle-orm/pg-core").PgColumn<{
3036
+ name: "report_type";
3037
+ tableName: "compliance_report_schedules";
3038
+ dataType: "string";
3039
+ columnType: "PgVarchar";
3040
+ data: string;
3041
+ driverParam: string;
3042
+ notNull: true;
3043
+ hasDefault: false;
3044
+ isPrimaryKey: false;
3045
+ isAutoincrement: false;
3046
+ hasRuntimeDefault: false;
3047
+ enumValues: [string, ...string[]];
3048
+ baseColumn: never;
3049
+ identity: undefined;
3050
+ generated: undefined;
3051
+ }, {}, {
3052
+ length: 30;
3053
+ }>;
3054
+ target: import("drizzle-orm/pg-core").PgColumn<{
3055
+ name: "target";
3056
+ tableName: "compliance_report_schedules";
3057
+ dataType: "string";
3058
+ columnType: "PgVarchar";
3059
+ data: string;
3060
+ driverParam: string;
3061
+ notNull: true;
3062
+ hasDefault: false;
3063
+ isPrimaryKey: false;
3064
+ isAutoincrement: false;
3065
+ hasRuntimeDefault: false;
3066
+ enumValues: [string, ...string[]];
3067
+ baseColumn: never;
3068
+ identity: undefined;
3069
+ generated: undefined;
3070
+ }, {}, {
3071
+ length: 20;
3072
+ }>;
3073
+ format: import("drizzle-orm/pg-core").PgColumn<{
3074
+ name: "format";
3075
+ tableName: "compliance_report_schedules";
3076
+ dataType: "string";
3077
+ columnType: "PgVarchar";
3078
+ data: string;
3079
+ driverParam: string;
3080
+ notNull: true;
3081
+ hasDefault: true;
3082
+ isPrimaryKey: false;
3083
+ isAutoincrement: false;
3084
+ hasRuntimeDefault: false;
3085
+ enumValues: [string, ...string[]];
3086
+ baseColumn: never;
3087
+ identity: undefined;
3088
+ generated: undefined;
3089
+ }, {}, {
3090
+ length: 10;
3091
+ }>;
3092
+ cronExpression: import("drizzle-orm/pg-core").PgColumn<{
3093
+ name: "cron_expression";
3094
+ tableName: "compliance_report_schedules";
3095
+ dataType: "string";
3096
+ columnType: "PgVarchar";
3097
+ data: string;
3098
+ driverParam: string;
3099
+ notNull: true;
3100
+ hasDefault: false;
3101
+ isPrimaryKey: false;
3102
+ isAutoincrement: false;
3103
+ hasRuntimeDefault: false;
3104
+ enumValues: [string, ...string[]];
3105
+ baseColumn: never;
3106
+ identity: undefined;
3107
+ generated: undefined;
3108
+ }, {}, {
3109
+ length: 100;
3110
+ }>;
3111
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
3112
+ name: "is_active";
3113
+ tableName: "compliance_report_schedules";
3114
+ dataType: "boolean";
3115
+ columnType: "PgBoolean";
3116
+ data: boolean;
3117
+ driverParam: boolean;
3118
+ notNull: true;
3119
+ hasDefault: true;
3120
+ isPrimaryKey: false;
3121
+ isAutoincrement: false;
3122
+ hasRuntimeDefault: false;
3123
+ enumValues: undefined;
3124
+ baseColumn: never;
3125
+ identity: undefined;
3126
+ generated: undefined;
3127
+ }, {}, {}>;
3128
+ lastRunAt: import("drizzle-orm/pg-core").PgColumn<{
3129
+ name: "last_run_at";
3130
+ tableName: "compliance_report_schedules";
3131
+ dataType: "date";
3132
+ columnType: "PgTimestamp";
3133
+ data: Date;
3134
+ driverParam: string;
3135
+ notNull: false;
3136
+ hasDefault: false;
3137
+ isPrimaryKey: false;
3138
+ isAutoincrement: false;
3139
+ hasRuntimeDefault: false;
3140
+ enumValues: undefined;
3141
+ baseColumn: never;
3142
+ identity: undefined;
3143
+ generated: undefined;
3144
+ }, {}, {}>;
3145
+ nextRunAt: import("drizzle-orm/pg-core").PgColumn<{
3146
+ name: "next_run_at";
3147
+ tableName: "compliance_report_schedules";
3148
+ dataType: "date";
3149
+ columnType: "PgTimestamp";
3150
+ data: Date;
3151
+ driverParam: string;
3152
+ notNull: false;
3153
+ hasDefault: false;
3154
+ isPrimaryKey: false;
3155
+ isAutoincrement: false;
3156
+ hasRuntimeDefault: false;
3157
+ enumValues: undefined;
3158
+ baseColumn: never;
3159
+ identity: undefined;
3160
+ generated: undefined;
3161
+ }, {}, {}>;
3162
+ deliverTo: import("drizzle-orm/pg-core").PgColumn<{
3163
+ name: "deliver_to";
3164
+ tableName: "compliance_report_schedules";
3165
+ dataType: "json";
3166
+ columnType: "PgJsonb";
3167
+ data: string[];
3168
+ driverParam: unknown;
3169
+ notNull: true;
3170
+ hasDefault: true;
3171
+ isPrimaryKey: false;
3172
+ isAutoincrement: false;
3173
+ hasRuntimeDefault: false;
3174
+ enumValues: undefined;
3175
+ baseColumn: never;
3176
+ identity: undefined;
3177
+ generated: undefined;
3178
+ }, {}, {
3179
+ $type: string[];
3180
+ }>;
3181
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
3182
+ name: "created_by";
3183
+ tableName: "compliance_report_schedules";
3184
+ dataType: "string";
3185
+ columnType: "PgText";
3186
+ data: string;
3187
+ driverParam: string;
3188
+ notNull: true;
3189
+ hasDefault: false;
3190
+ isPrimaryKey: false;
3191
+ isAutoincrement: false;
3192
+ hasRuntimeDefault: false;
3193
+ enumValues: [string, ...string[]];
3194
+ baseColumn: never;
3195
+ identity: undefined;
3196
+ generated: undefined;
3197
+ }, {}, {}>;
3198
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3199
+ name: "created_at";
3200
+ tableName: "compliance_report_schedules";
3201
+ dataType: "date";
3202
+ columnType: "PgTimestamp";
3203
+ data: Date;
3204
+ driverParam: string;
3205
+ notNull: true;
3206
+ hasDefault: true;
3207
+ isPrimaryKey: false;
3208
+ isAutoincrement: false;
3209
+ hasRuntimeDefault: false;
3210
+ enumValues: undefined;
3211
+ baseColumn: never;
3212
+ identity: undefined;
3213
+ generated: undefined;
3214
+ }, {}, {}>;
3215
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
3216
+ name: "updated_by";
3217
+ tableName: "compliance_report_schedules";
3218
+ dataType: "string";
3219
+ columnType: "PgText";
3220
+ data: string;
3221
+ driverParam: string;
3222
+ notNull: true;
3223
+ hasDefault: false;
3224
+ isPrimaryKey: false;
3225
+ isAutoincrement: false;
3226
+ hasRuntimeDefault: false;
3227
+ enumValues: [string, ...string[]];
3228
+ baseColumn: never;
3229
+ identity: undefined;
3230
+ generated: undefined;
3231
+ }, {}, {}>;
3232
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3233
+ name: "updated_at";
3234
+ tableName: "compliance_report_schedules";
3235
+ dataType: "date";
3236
+ columnType: "PgTimestamp";
3237
+ data: Date;
3238
+ driverParam: string;
3239
+ notNull: true;
3240
+ hasDefault: true;
3241
+ isPrimaryKey: false;
3242
+ isAutoincrement: false;
3243
+ hasRuntimeDefault: false;
3244
+ enumValues: undefined;
3245
+ baseColumn: never;
3246
+ identity: undefined;
3247
+ generated: undefined;
3248
+ }, {}, {}>;
3249
+ };
3250
+ dialect: 'pg';
3251
+ }>;
3252
+ export declare const complianceEntitlementWatermark: import("drizzle-orm/pg-core").PgTableWithColumns<{
3253
+ name: "compliance_entitlement_watermark";
3254
+ schema: undefined;
3255
+ columns: {
3256
+ orgId: import("drizzle-orm/pg-core").PgColumn<{
3257
+ name: "org_id";
3258
+ tableName: "compliance_entitlement_watermark";
3259
+ dataType: "string";
3260
+ columnType: "PgText";
3261
+ data: string;
3262
+ driverParam: string;
3263
+ notNull: true;
3264
+ hasDefault: false;
3265
+ isPrimaryKey: true;
3266
+ isAutoincrement: false;
3267
+ hasRuntimeDefault: false;
3268
+ enumValues: [string, ...string[]];
3269
+ baseColumn: never;
3270
+ identity: undefined;
3271
+ generated: undefined;
3272
+ }, {}, {}>;
3273
+ lastOccurredAt: import("drizzle-orm/pg-core").PgColumn<{
3274
+ name: "last_occurred_at";
3275
+ tableName: "compliance_entitlement_watermark";
3276
+ dataType: "date";
3277
+ columnType: "PgTimestamp";
3278
+ data: Date;
3279
+ driverParam: string;
3280
+ notNull: true;
3281
+ hasDefault: false;
3282
+ isPrimaryKey: false;
3283
+ isAutoincrement: false;
3284
+ hasRuntimeDefault: false;
3285
+ enumValues: undefined;
3286
+ baseColumn: never;
3287
+ identity: undefined;
3288
+ generated: undefined;
3289
+ }, {}, {}>;
3290
+ };
3291
+ dialect: 'pg';
3292
+ }>;
3293
+ export type ComplianceEntitlementWatermark = typeof complianceEntitlementWatermark.$inferSelect;
3294
+ export type CompliancePolicy = typeof compliancePolicy.$inferSelect;
3295
+ export type CompliancePolicyInsert = typeof compliancePolicy.$inferInsert;
3296
+ export type ComplianceRule = typeof complianceRule.$inferSelect;
3297
+ export type ComplianceRuleInsert = typeof complianceRule.$inferInsert;
3298
+ export type ComplianceRuleHistory = typeof complianceRuleHistory.$inferSelect;
3299
+ export type ComplianceRuleHistoryInsert = typeof complianceRuleHistory.$inferInsert;
3300
+ export type ComplianceAuditLog = typeof complianceAuditLog.$inferSelect;
3301
+ export type ComplianceAuditLogInsert = typeof complianceAuditLog.$inferInsert;
3302
+ export type ComplianceExemption = typeof complianceExemption.$inferSelect;
3303
+ export type ComplianceExemptionInsert = typeof complianceExemption.$inferInsert;
3304
+ export type ComplianceRuleSubscription = typeof complianceRuleSubscription.$inferSelect;
3305
+ export type ComplianceRuleSubscriptionInsert = typeof complianceRuleSubscription.$inferInsert;
3306
+ export type ComplianceScan = typeof complianceScan.$inferSelect;
3307
+ export type ComplianceScanInsert = typeof complianceScan.$inferInsert;
3308
+ export type ComplianceScanSchedule = typeof complianceScanSchedule.$inferSelect;
3309
+ export type ComplianceScanScheduleInsert = typeof complianceScanSchedule.$inferInsert;
3310
+ export type ComplianceNotificationPreference = typeof complianceNotificationPreference.$inferSelect;
3311
+ export type ComplianceNotificationPreferenceInsert = typeof complianceNotificationPreference.$inferInsert;
3312
+ export type ComplianceNotificationLog = typeof complianceNotificationLog.$inferSelect;
3313
+ export type ComplianceNotificationLogInsert = typeof complianceNotificationLog.$inferInsert;
3314
+ export type ComplianceRole = typeof complianceRole.$inferSelect;
3315
+ export type ComplianceRoleInsert = typeof complianceRole.$inferInsert;
3316
+ export type ComplianceReport = typeof complianceReport.$inferSelect;
3317
+ export type ComplianceReportInsert = typeof complianceReport.$inferInsert;
3318
+ export type ComplianceReportSchedule = typeof complianceReportSchedule.$inferSelect;
3319
+ export type ComplianceReportScheduleInsert = typeof complianceReportSchedule.$inferInsert;