@aion2hub/shared-schemas 1.1.8 → 1.1.10

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.
@@ -0,0 +1,2441 @@
1
+ /**
2
+ * Content Management Database Schema
3
+ * This file contains ONLY content-related tables for the aion2hub_content database
4
+ */
5
+ export declare const translationStatusEnum: import("drizzle-orm/pg-core").PgEnum<["PENDING", "PROCESSING", "COMPLETED", "FAILED", "REVIEWED", "REJECTED"]>;
6
+ export declare const contentStatusEnum: import("drizzle-orm/pg-core").PgEnum<["PENDING", "PROCESSING", "COMPLETED", "PUBLISHED", "FAILED", "REJECTED"]>;
7
+ export declare const jobStatusEnum: import("drizzle-orm/pg-core").PgEnum<["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED"]>;
8
+ export declare const scrapingTypeEnum: import("drizzle-orm/pg-core").PgEnum<["NEWS", "RSS", "YOUTUBE", "MANUAL", "BULK", "API"]>;
9
+ export declare const sourceTypeEnum: import("drizzle-orm/pg-core").PgEnum<["RSS_FEED", "NEWS_WEBSITE", "YOUTUBE_CHANNEL", "MANUAL_INPUT"]>;
10
+ export declare const filterMatchTypeEnum: import("drizzle-orm/pg-core").PgEnum<["exact", "partial", "regex", "fuzzy", "stemmed"]>;
11
+ export declare const filterContextScopeEnum: import("drizzle-orm/pg-core").PgEnum<["title", "content", "description", "any", "url"]>;
12
+ export declare const filterRuleTypeEnum: import("drizzle-orm/pg-core").PgEnum<["keyword", "regex", "domain", "category", "language", "date_range", "content_length", "quality_score"]>;
13
+ export declare const filterOperatorEnum: import("drizzle-orm/pg-core").PgEnum<["AND", "OR", "NOT"]>;
14
+ export declare const aiModels: import("drizzle-orm/pg-core").PgTableWithColumns<{
15
+ name: "AIModel";
16
+ schema: undefined;
17
+ columns: {
18
+ id: import("drizzle-orm/pg-core").PgColumn<{
19
+ name: "id";
20
+ tableName: "AIModel";
21
+ dataType: "string";
22
+ columnType: "PgText";
23
+ data: string;
24
+ driverParam: string;
25
+ notNull: true;
26
+ hasDefault: false;
27
+ isPrimaryKey: true;
28
+ isAutoincrement: false;
29
+ hasRuntimeDefault: false;
30
+ enumValues: [string, ...string[]];
31
+ baseColumn: never;
32
+ identity: undefined;
33
+ generated: undefined;
34
+ }, {}, {}>;
35
+ name: import("drizzle-orm/pg-core").PgColumn<{
36
+ name: "name";
37
+ tableName: "AIModel";
38
+ dataType: "string";
39
+ columnType: "PgText";
40
+ data: string;
41
+ driverParam: string;
42
+ notNull: true;
43
+ hasDefault: false;
44
+ isPrimaryKey: false;
45
+ isAutoincrement: false;
46
+ hasRuntimeDefault: false;
47
+ enumValues: [string, ...string[]];
48
+ baseColumn: never;
49
+ identity: undefined;
50
+ generated: undefined;
51
+ }, {}, {}>;
52
+ provider: import("drizzle-orm/pg-core").PgColumn<{
53
+ name: "provider";
54
+ tableName: "AIModel";
55
+ dataType: "string";
56
+ columnType: "PgText";
57
+ data: string;
58
+ driverParam: string;
59
+ notNull: true;
60
+ hasDefault: false;
61
+ isPrimaryKey: false;
62
+ isAutoincrement: false;
63
+ hasRuntimeDefault: false;
64
+ enumValues: [string, ...string[]];
65
+ baseColumn: never;
66
+ identity: undefined;
67
+ generated: undefined;
68
+ }, {}, {}>;
69
+ modelType: import("drizzle-orm/pg-core").PgColumn<{
70
+ name: "modelType";
71
+ tableName: "AIModel";
72
+ dataType: "string";
73
+ columnType: "PgText";
74
+ data: string;
75
+ driverParam: string;
76
+ notNull: true;
77
+ hasDefault: false;
78
+ isPrimaryKey: false;
79
+ isAutoincrement: false;
80
+ hasRuntimeDefault: false;
81
+ enumValues: [string, ...string[]];
82
+ baseColumn: never;
83
+ identity: undefined;
84
+ generated: undefined;
85
+ }, {}, {}>;
86
+ version: import("drizzle-orm/pg-core").PgColumn<{
87
+ name: "version";
88
+ tableName: "AIModel";
89
+ dataType: "string";
90
+ columnType: "PgText";
91
+ data: string;
92
+ driverParam: string;
93
+ notNull: true;
94
+ hasDefault: false;
95
+ isPrimaryKey: false;
96
+ isAutoincrement: false;
97
+ hasRuntimeDefault: false;
98
+ enumValues: [string, ...string[]];
99
+ baseColumn: never;
100
+ identity: undefined;
101
+ generated: undefined;
102
+ }, {}, {}>;
103
+ endpoint: import("drizzle-orm/pg-core").PgColumn<{
104
+ name: "endpoint";
105
+ tableName: "AIModel";
106
+ dataType: "string";
107
+ columnType: "PgText";
108
+ data: string;
109
+ driverParam: string;
110
+ notNull: false;
111
+ hasDefault: false;
112
+ isPrimaryKey: false;
113
+ isAutoincrement: false;
114
+ hasRuntimeDefault: false;
115
+ enumValues: [string, ...string[]];
116
+ baseColumn: never;
117
+ identity: undefined;
118
+ generated: undefined;
119
+ }, {}, {}>;
120
+ apiKey: import("drizzle-orm/pg-core").PgColumn<{
121
+ name: "apiKey";
122
+ tableName: "AIModel";
123
+ dataType: "string";
124
+ columnType: "PgText";
125
+ data: string;
126
+ driverParam: string;
127
+ notNull: false;
128
+ hasDefault: false;
129
+ isPrimaryKey: false;
130
+ isAutoincrement: false;
131
+ hasRuntimeDefault: false;
132
+ enumValues: [string, ...string[]];
133
+ baseColumn: never;
134
+ identity: undefined;
135
+ generated: undefined;
136
+ }, {}, {}>;
137
+ maxTokens: import("drizzle-orm/pg-core").PgColumn<{
138
+ name: "maxTokens";
139
+ tableName: "AIModel";
140
+ dataType: "number";
141
+ columnType: "PgInteger";
142
+ data: number;
143
+ driverParam: string | number;
144
+ notNull: false;
145
+ hasDefault: false;
146
+ isPrimaryKey: false;
147
+ isAutoincrement: false;
148
+ hasRuntimeDefault: false;
149
+ enumValues: undefined;
150
+ baseColumn: never;
151
+ identity: undefined;
152
+ generated: undefined;
153
+ }, {}, {}>;
154
+ temperature: import("drizzle-orm/pg-core").PgColumn<{
155
+ name: "temperature";
156
+ tableName: "AIModel";
157
+ dataType: "number";
158
+ columnType: "PgReal";
159
+ data: number;
160
+ driverParam: string | number;
161
+ notNull: false;
162
+ hasDefault: false;
163
+ isPrimaryKey: false;
164
+ isAutoincrement: false;
165
+ hasRuntimeDefault: false;
166
+ enumValues: undefined;
167
+ baseColumn: never;
168
+ identity: undefined;
169
+ generated: undefined;
170
+ }, {}, {}>;
171
+ supportsTranslation: import("drizzle-orm/pg-core").PgColumn<{
172
+ name: "supportsTranslation";
173
+ tableName: "AIModel";
174
+ dataType: "boolean";
175
+ columnType: "PgBoolean";
176
+ data: boolean;
177
+ driverParam: boolean;
178
+ notNull: true;
179
+ hasDefault: true;
180
+ isPrimaryKey: false;
181
+ isAutoincrement: false;
182
+ hasRuntimeDefault: false;
183
+ enumValues: undefined;
184
+ baseColumn: never;
185
+ identity: undefined;
186
+ generated: undefined;
187
+ }, {}, {}>;
188
+ supportsClassification: import("drizzle-orm/pg-core").PgColumn<{
189
+ name: "supportsClassification";
190
+ tableName: "AIModel";
191
+ dataType: "boolean";
192
+ columnType: "PgBoolean";
193
+ data: boolean;
194
+ driverParam: boolean;
195
+ notNull: true;
196
+ hasDefault: true;
197
+ isPrimaryKey: false;
198
+ isAutoincrement: false;
199
+ hasRuntimeDefault: false;
200
+ enumValues: undefined;
201
+ baseColumn: never;
202
+ identity: undefined;
203
+ generated: undefined;
204
+ }, {}, {}>;
205
+ supportedLanguages: import("drizzle-orm/pg-core").PgColumn<{
206
+ name: "supportedLanguages";
207
+ tableName: "AIModel";
208
+ dataType: "array";
209
+ columnType: "PgArray";
210
+ data: string[];
211
+ driverParam: string | string[];
212
+ notNull: false;
213
+ hasDefault: false;
214
+ isPrimaryKey: false;
215
+ isAutoincrement: false;
216
+ hasRuntimeDefault: false;
217
+ enumValues: [string, ...string[]];
218
+ baseColumn: import("drizzle-orm").Column<{
219
+ name: "supportedLanguages";
220
+ tableName: "AIModel";
221
+ dataType: "string";
222
+ columnType: "PgText";
223
+ data: string;
224
+ driverParam: string;
225
+ notNull: false;
226
+ hasDefault: false;
227
+ isPrimaryKey: false;
228
+ isAutoincrement: false;
229
+ hasRuntimeDefault: false;
230
+ enumValues: [string, ...string[]];
231
+ baseColumn: never;
232
+ identity: undefined;
233
+ generated: undefined;
234
+ }, {}, {}>;
235
+ identity: undefined;
236
+ generated: undefined;
237
+ }, {}, {
238
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
239
+ name: "supportedLanguages";
240
+ dataType: "string";
241
+ columnType: "PgText";
242
+ data: string;
243
+ enumValues: [string, ...string[]];
244
+ driverParam: string;
245
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
246
+ size: undefined;
247
+ }>;
248
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
249
+ name: "isActive";
250
+ tableName: "AIModel";
251
+ dataType: "boolean";
252
+ columnType: "PgBoolean";
253
+ data: boolean;
254
+ driverParam: boolean;
255
+ notNull: true;
256
+ hasDefault: true;
257
+ isPrimaryKey: false;
258
+ isAutoincrement: false;
259
+ hasRuntimeDefault: false;
260
+ enumValues: undefined;
261
+ baseColumn: never;
262
+ identity: undefined;
263
+ generated: undefined;
264
+ }, {}, {}>;
265
+ isDefault: import("drizzle-orm/pg-core").PgColumn<{
266
+ name: "isDefault";
267
+ tableName: "AIModel";
268
+ dataType: "boolean";
269
+ columnType: "PgBoolean";
270
+ data: boolean;
271
+ driverParam: boolean;
272
+ notNull: true;
273
+ hasDefault: true;
274
+ isPrimaryKey: false;
275
+ isAutoincrement: false;
276
+ hasRuntimeDefault: false;
277
+ enumValues: undefined;
278
+ baseColumn: never;
279
+ identity: undefined;
280
+ generated: undefined;
281
+ }, {}, {}>;
282
+ priority: import("drizzle-orm/pg-core").PgColumn<{
283
+ name: "priority";
284
+ tableName: "AIModel";
285
+ dataType: "number";
286
+ columnType: "PgInteger";
287
+ data: number;
288
+ driverParam: string | number;
289
+ notNull: true;
290
+ hasDefault: true;
291
+ isPrimaryKey: false;
292
+ isAutoincrement: false;
293
+ hasRuntimeDefault: false;
294
+ enumValues: undefined;
295
+ baseColumn: never;
296
+ identity: undefined;
297
+ generated: undefined;
298
+ }, {}, {}>;
299
+ avgResponseTime: import("drizzle-orm/pg-core").PgColumn<{
300
+ name: "avgResponseTime";
301
+ tableName: "AIModel";
302
+ dataType: "string";
303
+ columnType: "PgNumeric";
304
+ data: string;
305
+ driverParam: string;
306
+ notNull: false;
307
+ hasDefault: false;
308
+ isPrimaryKey: false;
309
+ isAutoincrement: false;
310
+ hasRuntimeDefault: false;
311
+ enumValues: undefined;
312
+ baseColumn: never;
313
+ identity: undefined;
314
+ generated: undefined;
315
+ }, {}, {}>;
316
+ successRate: import("drizzle-orm/pg-core").PgColumn<{
317
+ name: "successRate";
318
+ tableName: "AIModel";
319
+ dataType: "string";
320
+ columnType: "PgNumeric";
321
+ data: string;
322
+ driverParam: string;
323
+ notNull: false;
324
+ hasDefault: false;
325
+ isPrimaryKey: false;
326
+ isAutoincrement: false;
327
+ hasRuntimeDefault: false;
328
+ enumValues: undefined;
329
+ baseColumn: never;
330
+ identity: undefined;
331
+ generated: undefined;
332
+ }, {}, {}>;
333
+ lastUsed: import("drizzle-orm/pg-core").PgColumn<{
334
+ name: "lastUsed";
335
+ tableName: "AIModel";
336
+ dataType: "date";
337
+ columnType: "PgTimestamp";
338
+ data: Date;
339
+ driverParam: string;
340
+ notNull: false;
341
+ hasDefault: false;
342
+ isPrimaryKey: false;
343
+ isAutoincrement: false;
344
+ hasRuntimeDefault: false;
345
+ enumValues: undefined;
346
+ baseColumn: never;
347
+ identity: undefined;
348
+ generated: undefined;
349
+ }, {}, {}>;
350
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
351
+ name: "createdAt";
352
+ tableName: "AIModel";
353
+ dataType: "date";
354
+ columnType: "PgTimestamp";
355
+ data: Date;
356
+ driverParam: string;
357
+ notNull: true;
358
+ hasDefault: true;
359
+ isPrimaryKey: false;
360
+ isAutoincrement: false;
361
+ hasRuntimeDefault: false;
362
+ enumValues: undefined;
363
+ baseColumn: never;
364
+ identity: undefined;
365
+ generated: undefined;
366
+ }, {}, {}>;
367
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
368
+ name: "updatedAt";
369
+ tableName: "AIModel";
370
+ dataType: "date";
371
+ columnType: "PgTimestamp";
372
+ data: Date;
373
+ driverParam: string;
374
+ notNull: true;
375
+ hasDefault: true;
376
+ isPrimaryKey: false;
377
+ isAutoincrement: false;
378
+ hasRuntimeDefault: false;
379
+ enumValues: undefined;
380
+ baseColumn: never;
381
+ identity: undefined;
382
+ generated: undefined;
383
+ }, {}, {}>;
384
+ };
385
+ dialect: "pg";
386
+ }>;
387
+ export declare const contentTranslations: import("drizzle-orm/pg-core").PgTableWithColumns<{
388
+ name: "ContentTranslation";
389
+ schema: undefined;
390
+ columns: {
391
+ id: import("drizzle-orm/pg-core").PgColumn<{
392
+ name: "id";
393
+ tableName: "ContentTranslation";
394
+ dataType: "string";
395
+ columnType: "PgText";
396
+ data: string;
397
+ driverParam: string;
398
+ notNull: true;
399
+ hasDefault: false;
400
+ isPrimaryKey: true;
401
+ isAutoincrement: false;
402
+ hasRuntimeDefault: false;
403
+ enumValues: [string, ...string[]];
404
+ baseColumn: never;
405
+ identity: undefined;
406
+ generated: undefined;
407
+ }, {}, {}>;
408
+ contentType: import("drizzle-orm/pg-core").PgColumn<{
409
+ name: "contentType";
410
+ tableName: "ContentTranslation";
411
+ dataType: "string";
412
+ columnType: "PgText";
413
+ data: string;
414
+ driverParam: string;
415
+ notNull: true;
416
+ hasDefault: false;
417
+ isPrimaryKey: false;
418
+ isAutoincrement: false;
419
+ hasRuntimeDefault: false;
420
+ enumValues: [string, ...string[]];
421
+ baseColumn: never;
422
+ identity: undefined;
423
+ generated: undefined;
424
+ }, {}, {}>;
425
+ contentId: import("drizzle-orm/pg-core").PgColumn<{
426
+ name: "contentId";
427
+ tableName: "ContentTranslation";
428
+ dataType: "string";
429
+ columnType: "PgText";
430
+ data: string;
431
+ driverParam: string;
432
+ notNull: true;
433
+ hasDefault: false;
434
+ isPrimaryKey: false;
435
+ isAutoincrement: false;
436
+ hasRuntimeDefault: false;
437
+ enumValues: [string, ...string[]];
438
+ baseColumn: never;
439
+ identity: undefined;
440
+ generated: undefined;
441
+ }, {}, {}>;
442
+ fieldName: import("drizzle-orm/pg-core").PgColumn<{
443
+ name: "fieldName";
444
+ tableName: "ContentTranslation";
445
+ dataType: "string";
446
+ columnType: "PgText";
447
+ data: string;
448
+ driverParam: string;
449
+ notNull: true;
450
+ hasDefault: false;
451
+ isPrimaryKey: false;
452
+ isAutoincrement: false;
453
+ hasRuntimeDefault: false;
454
+ enumValues: [string, ...string[]];
455
+ baseColumn: never;
456
+ identity: undefined;
457
+ generated: undefined;
458
+ }, {}, {}>;
459
+ originalText: import("drizzle-orm/pg-core").PgColumn<{
460
+ name: "originalText";
461
+ tableName: "ContentTranslation";
462
+ dataType: "string";
463
+ columnType: "PgText";
464
+ data: string;
465
+ driverParam: string;
466
+ notNull: true;
467
+ hasDefault: false;
468
+ isPrimaryKey: false;
469
+ isAutoincrement: false;
470
+ hasRuntimeDefault: false;
471
+ enumValues: [string, ...string[]];
472
+ baseColumn: never;
473
+ identity: undefined;
474
+ generated: undefined;
475
+ }, {}, {}>;
476
+ originalLanguage: import("drizzle-orm/pg-core").PgColumn<{
477
+ name: "originalLanguage";
478
+ tableName: "ContentTranslation";
479
+ dataType: "string";
480
+ columnType: "PgText";
481
+ data: string;
482
+ driverParam: string;
483
+ notNull: true;
484
+ hasDefault: true;
485
+ isPrimaryKey: false;
486
+ isAutoincrement: false;
487
+ hasRuntimeDefault: false;
488
+ enumValues: [string, ...string[]];
489
+ baseColumn: never;
490
+ identity: undefined;
491
+ generated: undefined;
492
+ }, {}, {}>;
493
+ translatedText: import("drizzle-orm/pg-core").PgColumn<{
494
+ name: "translatedText";
495
+ tableName: "ContentTranslation";
496
+ dataType: "string";
497
+ columnType: "PgText";
498
+ data: string;
499
+ driverParam: string;
500
+ notNull: true;
501
+ hasDefault: false;
502
+ isPrimaryKey: false;
503
+ isAutoincrement: false;
504
+ hasRuntimeDefault: false;
505
+ enumValues: [string, ...string[]];
506
+ baseColumn: never;
507
+ identity: undefined;
508
+ generated: undefined;
509
+ }, {}, {}>;
510
+ targetLanguage: import("drizzle-orm/pg-core").PgColumn<{
511
+ name: "targetLanguage";
512
+ tableName: "ContentTranslation";
513
+ dataType: "string";
514
+ columnType: "PgText";
515
+ data: string;
516
+ driverParam: string;
517
+ notNull: true;
518
+ hasDefault: true;
519
+ isPrimaryKey: false;
520
+ isAutoincrement: false;
521
+ hasRuntimeDefault: false;
522
+ enumValues: [string, ...string[]];
523
+ baseColumn: never;
524
+ identity: undefined;
525
+ generated: undefined;
526
+ }, {}, {}>;
527
+ modelId: import("drizzle-orm/pg-core").PgColumn<{
528
+ name: "modelId";
529
+ tableName: "ContentTranslation";
530
+ dataType: "string";
531
+ columnType: "PgText";
532
+ data: string;
533
+ driverParam: string;
534
+ notNull: true;
535
+ hasDefault: false;
536
+ isPrimaryKey: false;
537
+ isAutoincrement: false;
538
+ hasRuntimeDefault: false;
539
+ enumValues: [string, ...string[]];
540
+ baseColumn: never;
541
+ identity: undefined;
542
+ generated: undefined;
543
+ }, {}, {}>;
544
+ confidence: import("drizzle-orm/pg-core").PgColumn<{
545
+ name: "confidence";
546
+ tableName: "ContentTranslation";
547
+ dataType: "string";
548
+ columnType: "PgNumeric";
549
+ data: string;
550
+ driverParam: string;
551
+ notNull: false;
552
+ hasDefault: false;
553
+ isPrimaryKey: false;
554
+ isAutoincrement: false;
555
+ hasRuntimeDefault: false;
556
+ enumValues: undefined;
557
+ baseColumn: never;
558
+ identity: undefined;
559
+ generated: undefined;
560
+ }, {}, {}>;
561
+ qualityScore: import("drizzle-orm/pg-core").PgColumn<{
562
+ name: "qualityScore";
563
+ tableName: "ContentTranslation";
564
+ dataType: "string";
565
+ columnType: "PgNumeric";
566
+ data: string;
567
+ driverParam: string;
568
+ notNull: false;
569
+ hasDefault: false;
570
+ isPrimaryKey: false;
571
+ isAutoincrement: false;
572
+ hasRuntimeDefault: false;
573
+ enumValues: undefined;
574
+ baseColumn: never;
575
+ identity: undefined;
576
+ generated: undefined;
577
+ }, {}, {}>;
578
+ translationTime: import("drizzle-orm/pg-core").PgColumn<{
579
+ name: "translationTime";
580
+ tableName: "ContentTranslation";
581
+ dataType: "number";
582
+ columnType: "PgInteger";
583
+ data: number;
584
+ driverParam: string | number;
585
+ notNull: false;
586
+ hasDefault: false;
587
+ isPrimaryKey: false;
588
+ isAutoincrement: false;
589
+ hasRuntimeDefault: false;
590
+ enumValues: undefined;
591
+ baseColumn: never;
592
+ identity: undefined;
593
+ generated: undefined;
594
+ }, {}, {}>;
595
+ tokenCount: import("drizzle-orm/pg-core").PgColumn<{
596
+ name: "tokenCount";
597
+ tableName: "ContentTranslation";
598
+ dataType: "number";
599
+ columnType: "PgInteger";
600
+ data: number;
601
+ driverParam: string | number;
602
+ notNull: false;
603
+ hasDefault: false;
604
+ isPrimaryKey: false;
605
+ isAutoincrement: false;
606
+ hasRuntimeDefault: false;
607
+ enumValues: undefined;
608
+ baseColumn: never;
609
+ identity: undefined;
610
+ generated: undefined;
611
+ }, {}, {}>;
612
+ status: import("drizzle-orm/pg-core").PgColumn<{
613
+ name: "status";
614
+ tableName: "ContentTranslation";
615
+ dataType: "string";
616
+ columnType: "PgEnumColumn";
617
+ data: "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED" | "REVIEWED" | "REJECTED";
618
+ driverParam: string;
619
+ notNull: true;
620
+ hasDefault: true;
621
+ isPrimaryKey: false;
622
+ isAutoincrement: false;
623
+ hasRuntimeDefault: false;
624
+ enumValues: ["PENDING", "PROCESSING", "COMPLETED", "FAILED", "REVIEWED", "REJECTED"];
625
+ baseColumn: never;
626
+ identity: undefined;
627
+ generated: undefined;
628
+ }, {}, {}>;
629
+ isManuallyEdited: import("drizzle-orm/pg-core").PgColumn<{
630
+ name: "isManuallyEdited";
631
+ tableName: "ContentTranslation";
632
+ dataType: "boolean";
633
+ columnType: "PgBoolean";
634
+ data: boolean;
635
+ driverParam: boolean;
636
+ notNull: true;
637
+ hasDefault: true;
638
+ isPrimaryKey: false;
639
+ isAutoincrement: false;
640
+ hasRuntimeDefault: false;
641
+ enumValues: undefined;
642
+ baseColumn: never;
643
+ identity: undefined;
644
+ generated: undefined;
645
+ }, {}, {}>;
646
+ editedBy: import("drizzle-orm/pg-core").PgColumn<{
647
+ name: "editedBy";
648
+ tableName: "ContentTranslation";
649
+ dataType: "string";
650
+ columnType: "PgText";
651
+ data: string;
652
+ driverParam: string;
653
+ notNull: false;
654
+ hasDefault: false;
655
+ isPrimaryKey: false;
656
+ isAutoincrement: false;
657
+ hasRuntimeDefault: false;
658
+ enumValues: [string, ...string[]];
659
+ baseColumn: never;
660
+ identity: undefined;
661
+ generated: undefined;
662
+ }, {}, {}>;
663
+ editNotes: import("drizzle-orm/pg-core").PgColumn<{
664
+ name: "editNotes";
665
+ tableName: "ContentTranslation";
666
+ dataType: "string";
667
+ columnType: "PgText";
668
+ data: string;
669
+ driverParam: string;
670
+ notNull: false;
671
+ hasDefault: false;
672
+ isPrimaryKey: false;
673
+ isAutoincrement: false;
674
+ hasRuntimeDefault: false;
675
+ enumValues: [string, ...string[]];
676
+ baseColumn: never;
677
+ identity: undefined;
678
+ generated: undefined;
679
+ }, {}, {}>;
680
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
681
+ name: "createdAt";
682
+ tableName: "ContentTranslation";
683
+ dataType: "date";
684
+ columnType: "PgTimestamp";
685
+ data: Date;
686
+ driverParam: string;
687
+ notNull: true;
688
+ hasDefault: true;
689
+ isPrimaryKey: false;
690
+ isAutoincrement: false;
691
+ hasRuntimeDefault: false;
692
+ enumValues: undefined;
693
+ baseColumn: never;
694
+ identity: undefined;
695
+ generated: undefined;
696
+ }, {}, {}>;
697
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
698
+ name: "updatedAt";
699
+ tableName: "ContentTranslation";
700
+ dataType: "date";
701
+ columnType: "PgTimestamp";
702
+ data: Date;
703
+ driverParam: string;
704
+ notNull: true;
705
+ hasDefault: true;
706
+ isPrimaryKey: false;
707
+ isAutoincrement: false;
708
+ hasRuntimeDefault: false;
709
+ enumValues: undefined;
710
+ baseColumn: never;
711
+ identity: undefined;
712
+ generated: undefined;
713
+ }, {}, {}>;
714
+ translatedAt: import("drizzle-orm/pg-core").PgColumn<{
715
+ name: "translatedAt";
716
+ tableName: "ContentTranslation";
717
+ dataType: "date";
718
+ columnType: "PgTimestamp";
719
+ data: Date;
720
+ driverParam: string;
721
+ notNull: true;
722
+ hasDefault: true;
723
+ isPrimaryKey: false;
724
+ isAutoincrement: false;
725
+ hasRuntimeDefault: false;
726
+ enumValues: undefined;
727
+ baseColumn: never;
728
+ identity: undefined;
729
+ generated: undefined;
730
+ }, {}, {}>;
731
+ };
732
+ dialect: "pg";
733
+ }>;
734
+ export declare const newsArticles: import("drizzle-orm/pg-core").PgTableWithColumns<{
735
+ name: "news_articles";
736
+ schema: undefined;
737
+ columns: {
738
+ id: import("drizzle-orm/pg-core").PgColumn<{
739
+ name: "id";
740
+ tableName: "news_articles";
741
+ dataType: "string";
742
+ columnType: "PgText";
743
+ data: string;
744
+ driverParam: string;
745
+ notNull: true;
746
+ hasDefault: false;
747
+ isPrimaryKey: true;
748
+ isAutoincrement: false;
749
+ hasRuntimeDefault: false;
750
+ enumValues: [string, ...string[]];
751
+ baseColumn: never;
752
+ identity: undefined;
753
+ generated: undefined;
754
+ }, {}, {}>;
755
+ title: import("drizzle-orm/pg-core").PgColumn<{
756
+ name: "title";
757
+ tableName: "news_articles";
758
+ dataType: "string";
759
+ columnType: "PgText";
760
+ data: string;
761
+ driverParam: string;
762
+ notNull: true;
763
+ hasDefault: false;
764
+ isPrimaryKey: false;
765
+ isAutoincrement: false;
766
+ hasRuntimeDefault: false;
767
+ enumValues: [string, ...string[]];
768
+ baseColumn: never;
769
+ identity: undefined;
770
+ generated: undefined;
771
+ }, {}, {}>;
772
+ content: import("drizzle-orm/pg-core").PgColumn<{
773
+ name: "content";
774
+ tableName: "news_articles";
775
+ dataType: "string";
776
+ columnType: "PgText";
777
+ data: string;
778
+ driverParam: string;
779
+ notNull: false;
780
+ hasDefault: false;
781
+ isPrimaryKey: false;
782
+ isAutoincrement: false;
783
+ hasRuntimeDefault: false;
784
+ enumValues: [string, ...string[]];
785
+ baseColumn: never;
786
+ identity: undefined;
787
+ generated: undefined;
788
+ }, {}, {}>;
789
+ summary: import("drizzle-orm/pg-core").PgColumn<{
790
+ name: "summary";
791
+ tableName: "news_articles";
792
+ dataType: "string";
793
+ columnType: "PgText";
794
+ data: string;
795
+ driverParam: string;
796
+ notNull: false;
797
+ hasDefault: false;
798
+ isPrimaryKey: false;
799
+ isAutoincrement: false;
800
+ hasRuntimeDefault: false;
801
+ enumValues: [string, ...string[]];
802
+ baseColumn: never;
803
+ identity: undefined;
804
+ generated: undefined;
805
+ }, {}, {}>;
806
+ url: import("drizzle-orm/pg-core").PgColumn<{
807
+ name: "url";
808
+ tableName: "news_articles";
809
+ dataType: "string";
810
+ columnType: "PgText";
811
+ data: string;
812
+ driverParam: string;
813
+ notNull: true;
814
+ hasDefault: false;
815
+ isPrimaryKey: false;
816
+ isAutoincrement: false;
817
+ hasRuntimeDefault: false;
818
+ enumValues: [string, ...string[]];
819
+ baseColumn: never;
820
+ identity: undefined;
821
+ generated: undefined;
822
+ }, {}, {}>;
823
+ imageUrl: import("drizzle-orm/pg-core").PgColumn<{
824
+ name: "image_url";
825
+ tableName: "news_articles";
826
+ dataType: "string";
827
+ columnType: "PgText";
828
+ data: string;
829
+ driverParam: string;
830
+ notNull: false;
831
+ hasDefault: false;
832
+ isPrimaryKey: false;
833
+ isAutoincrement: false;
834
+ hasRuntimeDefault: false;
835
+ enumValues: [string, ...string[]];
836
+ baseColumn: never;
837
+ identity: undefined;
838
+ generated: undefined;
839
+ }, {}, {}>;
840
+ publishedAt: import("drizzle-orm/pg-core").PgColumn<{
841
+ name: "published_at";
842
+ tableName: "news_articles";
843
+ dataType: "date";
844
+ columnType: "PgTimestamp";
845
+ data: Date;
846
+ driverParam: string;
847
+ notNull: true;
848
+ hasDefault: false;
849
+ isPrimaryKey: false;
850
+ isAutoincrement: false;
851
+ hasRuntimeDefault: false;
852
+ enumValues: undefined;
853
+ baseColumn: never;
854
+ identity: undefined;
855
+ generated: undefined;
856
+ }, {}, {}>;
857
+ scrapedAt: import("drizzle-orm/pg-core").PgColumn<{
858
+ name: "scraped_at";
859
+ tableName: "news_articles";
860
+ dataType: "date";
861
+ columnType: "PgTimestamp";
862
+ data: Date;
863
+ driverParam: string;
864
+ notNull: true;
865
+ hasDefault: true;
866
+ isPrimaryKey: false;
867
+ isAutoincrement: false;
868
+ hasRuntimeDefault: false;
869
+ enumValues: undefined;
870
+ baseColumn: never;
871
+ identity: undefined;
872
+ generated: undefined;
873
+ }, {}, {}>;
874
+ sourceName: import("drizzle-orm/pg-core").PgColumn<{
875
+ name: "source_name";
876
+ tableName: "news_articles";
877
+ dataType: "string";
878
+ columnType: "PgText";
879
+ data: string;
880
+ driverParam: string;
881
+ notNull: false;
882
+ hasDefault: false;
883
+ isPrimaryKey: false;
884
+ isAutoincrement: false;
885
+ hasRuntimeDefault: false;
886
+ enumValues: [string, ...string[]];
887
+ baseColumn: never;
888
+ identity: undefined;
889
+ generated: undefined;
890
+ }, {}, {}>;
891
+ sourceUrl: import("drizzle-orm/pg-core").PgColumn<{
892
+ name: "source_url";
893
+ tableName: "news_articles";
894
+ dataType: "string";
895
+ columnType: "PgText";
896
+ data: string;
897
+ driverParam: string;
898
+ notNull: false;
899
+ hasDefault: false;
900
+ isPrimaryKey: false;
901
+ isAutoincrement: false;
902
+ hasRuntimeDefault: false;
903
+ enumValues: [string, ...string[]];
904
+ baseColumn: never;
905
+ identity: undefined;
906
+ generated: undefined;
907
+ }, {}, {}>;
908
+ author: import("drizzle-orm/pg-core").PgColumn<{
909
+ name: "author";
910
+ tableName: "news_articles";
911
+ dataType: "string";
912
+ columnType: "PgText";
913
+ data: string;
914
+ driverParam: string;
915
+ notNull: false;
916
+ hasDefault: false;
917
+ isPrimaryKey: false;
918
+ isAutoincrement: false;
919
+ hasRuntimeDefault: false;
920
+ enumValues: [string, ...string[]];
921
+ baseColumn: never;
922
+ identity: undefined;
923
+ generated: undefined;
924
+ }, {}, {}>;
925
+ category: import("drizzle-orm/pg-core").PgColumn<{
926
+ name: "category";
927
+ tableName: "news_articles";
928
+ dataType: "string";
929
+ columnType: "PgText";
930
+ data: string;
931
+ driverParam: string;
932
+ notNull: false;
933
+ hasDefault: false;
934
+ isPrimaryKey: false;
935
+ isAutoincrement: false;
936
+ hasRuntimeDefault: false;
937
+ enumValues: [string, ...string[]];
938
+ baseColumn: never;
939
+ identity: undefined;
940
+ generated: undefined;
941
+ }, {}, {}>;
942
+ tags: import("drizzle-orm/pg-core").PgColumn<{
943
+ name: "tags";
944
+ tableName: "news_articles";
945
+ dataType: "array";
946
+ columnType: "PgArray";
947
+ data: string[];
948
+ driverParam: string | string[];
949
+ notNull: true;
950
+ hasDefault: true;
951
+ isPrimaryKey: false;
952
+ isAutoincrement: false;
953
+ hasRuntimeDefault: false;
954
+ enumValues: [string, ...string[]];
955
+ baseColumn: import("drizzle-orm").Column<{
956
+ name: "tags";
957
+ tableName: "news_articles";
958
+ dataType: "string";
959
+ columnType: "PgText";
960
+ data: string;
961
+ driverParam: string;
962
+ notNull: false;
963
+ hasDefault: false;
964
+ isPrimaryKey: false;
965
+ isAutoincrement: false;
966
+ hasRuntimeDefault: false;
967
+ enumValues: [string, ...string[]];
968
+ baseColumn: never;
969
+ identity: undefined;
970
+ generated: undefined;
971
+ }, {}, {}>;
972
+ identity: undefined;
973
+ generated: undefined;
974
+ }, {}, {
975
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
976
+ name: "tags";
977
+ dataType: "string";
978
+ columnType: "PgText";
979
+ data: string;
980
+ enumValues: [string, ...string[]];
981
+ driverParam: string;
982
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
983
+ size: undefined;
984
+ }>;
985
+ language: import("drizzle-orm/pg-core").PgColumn<{
986
+ name: "language";
987
+ tableName: "news_articles";
988
+ dataType: "string";
989
+ columnType: "PgText";
990
+ data: string;
991
+ driverParam: string;
992
+ notNull: true;
993
+ hasDefault: true;
994
+ isPrimaryKey: false;
995
+ isAutoincrement: false;
996
+ hasRuntimeDefault: false;
997
+ enumValues: [string, ...string[]];
998
+ baseColumn: never;
999
+ identity: undefined;
1000
+ generated: undefined;
1001
+ }, {}, {}>;
1002
+ relevanceScore: import("drizzle-orm/pg-core").PgColumn<{
1003
+ name: "relevance_score";
1004
+ tableName: "news_articles";
1005
+ dataType: "string";
1006
+ columnType: "PgNumeric";
1007
+ data: string;
1008
+ driverParam: string;
1009
+ notNull: false;
1010
+ hasDefault: false;
1011
+ isPrimaryKey: false;
1012
+ isAutoincrement: false;
1013
+ hasRuntimeDefault: false;
1014
+ enumValues: undefined;
1015
+ baseColumn: never;
1016
+ identity: undefined;
1017
+ generated: undefined;
1018
+ }, {}, {}>;
1019
+ qualityScore: import("drizzle-orm/pg-core").PgColumn<{
1020
+ name: "quality_score";
1021
+ tableName: "news_articles";
1022
+ dataType: "string";
1023
+ columnType: "PgNumeric";
1024
+ data: string;
1025
+ driverParam: string;
1026
+ notNull: false;
1027
+ hasDefault: false;
1028
+ isPrimaryKey: false;
1029
+ isAutoincrement: false;
1030
+ hasRuntimeDefault: false;
1031
+ enumValues: undefined;
1032
+ baseColumn: never;
1033
+ identity: undefined;
1034
+ generated: undefined;
1035
+ }, {}, {}>;
1036
+ status: import("drizzle-orm/pg-core").PgColumn<{
1037
+ name: "status";
1038
+ tableName: "news_articles";
1039
+ dataType: "string";
1040
+ columnType: "PgEnumColumn";
1041
+ data: "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED" | "REJECTED" | "PUBLISHED";
1042
+ driverParam: string;
1043
+ notNull: true;
1044
+ hasDefault: true;
1045
+ isPrimaryKey: false;
1046
+ isAutoincrement: false;
1047
+ hasRuntimeDefault: false;
1048
+ enumValues: ["PENDING", "PROCESSING", "COMPLETED", "PUBLISHED", "FAILED", "REJECTED"];
1049
+ baseColumn: never;
1050
+ identity: undefined;
1051
+ generated: undefined;
1052
+ }, {}, {}>;
1053
+ featured: import("drizzle-orm/pg-core").PgColumn<{
1054
+ name: "featured";
1055
+ tableName: "news_articles";
1056
+ dataType: "boolean";
1057
+ columnType: "PgBoolean";
1058
+ data: boolean;
1059
+ driverParam: boolean;
1060
+ notNull: true;
1061
+ hasDefault: true;
1062
+ isPrimaryKey: false;
1063
+ isAutoincrement: false;
1064
+ hasRuntimeDefault: false;
1065
+ enumValues: undefined;
1066
+ baseColumn: never;
1067
+ identity: undefined;
1068
+ generated: undefined;
1069
+ }, {}, {}>;
1070
+ processingNotes: import("drizzle-orm/pg-core").PgColumn<{
1071
+ name: "processing_notes";
1072
+ tableName: "news_articles";
1073
+ dataType: "string";
1074
+ columnType: "PgText";
1075
+ data: string;
1076
+ driverParam: string;
1077
+ notNull: false;
1078
+ hasDefault: false;
1079
+ isPrimaryKey: false;
1080
+ isAutoincrement: false;
1081
+ hasRuntimeDefault: false;
1082
+ enumValues: [string, ...string[]];
1083
+ baseColumn: never;
1084
+ identity: undefined;
1085
+ generated: undefined;
1086
+ }, {}, {}>;
1087
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1088
+ name: "created_at";
1089
+ tableName: "news_articles";
1090
+ dataType: "date";
1091
+ columnType: "PgTimestamp";
1092
+ data: Date;
1093
+ driverParam: string;
1094
+ notNull: true;
1095
+ hasDefault: true;
1096
+ isPrimaryKey: false;
1097
+ isAutoincrement: false;
1098
+ hasRuntimeDefault: false;
1099
+ enumValues: undefined;
1100
+ baseColumn: never;
1101
+ identity: undefined;
1102
+ generated: undefined;
1103
+ }, {}, {}>;
1104
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1105
+ name: "updated_at";
1106
+ tableName: "news_articles";
1107
+ dataType: "date";
1108
+ columnType: "PgTimestamp";
1109
+ data: Date;
1110
+ driverParam: string;
1111
+ notNull: true;
1112
+ hasDefault: true;
1113
+ isPrimaryKey: false;
1114
+ isAutoincrement: false;
1115
+ hasRuntimeDefault: false;
1116
+ enumValues: undefined;
1117
+ baseColumn: never;
1118
+ identity: undefined;
1119
+ generated: undefined;
1120
+ }, {}, {}>;
1121
+ };
1122
+ dialect: "pg";
1123
+ }>;
1124
+ export declare const rssFeeds: import("drizzle-orm/pg-core").PgTableWithColumns<{
1125
+ name: "rss_feeds";
1126
+ schema: undefined;
1127
+ columns: {
1128
+ id: import("drizzle-orm/pg-core").PgColumn<{
1129
+ name: "id";
1130
+ tableName: "rss_feeds";
1131
+ dataType: "string";
1132
+ columnType: "PgText";
1133
+ data: string;
1134
+ driverParam: string;
1135
+ notNull: true;
1136
+ hasDefault: false;
1137
+ isPrimaryKey: true;
1138
+ isAutoincrement: false;
1139
+ hasRuntimeDefault: false;
1140
+ enumValues: [string, ...string[]];
1141
+ baseColumn: never;
1142
+ identity: undefined;
1143
+ generated: undefined;
1144
+ }, {}, {}>;
1145
+ name: import("drizzle-orm/pg-core").PgColumn<{
1146
+ name: "name";
1147
+ tableName: "rss_feeds";
1148
+ dataType: "string";
1149
+ columnType: "PgText";
1150
+ data: string;
1151
+ driverParam: string;
1152
+ notNull: true;
1153
+ hasDefault: false;
1154
+ isPrimaryKey: false;
1155
+ isAutoincrement: false;
1156
+ hasRuntimeDefault: false;
1157
+ enumValues: [string, ...string[]];
1158
+ baseColumn: never;
1159
+ identity: undefined;
1160
+ generated: undefined;
1161
+ }, {}, {}>;
1162
+ url: import("drizzle-orm/pg-core").PgColumn<{
1163
+ name: "url";
1164
+ tableName: "rss_feeds";
1165
+ dataType: "string";
1166
+ columnType: "PgText";
1167
+ data: string;
1168
+ driverParam: string;
1169
+ notNull: true;
1170
+ hasDefault: false;
1171
+ isPrimaryKey: false;
1172
+ isAutoincrement: false;
1173
+ hasRuntimeDefault: false;
1174
+ enumValues: [string, ...string[]];
1175
+ baseColumn: never;
1176
+ identity: undefined;
1177
+ generated: undefined;
1178
+ }, {}, {}>;
1179
+ description: import("drizzle-orm/pg-core").PgColumn<{
1180
+ name: "description";
1181
+ tableName: "rss_feeds";
1182
+ dataType: "string";
1183
+ columnType: "PgText";
1184
+ data: string;
1185
+ driverParam: string;
1186
+ notNull: false;
1187
+ hasDefault: false;
1188
+ isPrimaryKey: false;
1189
+ isAutoincrement: false;
1190
+ hasRuntimeDefault: false;
1191
+ enumValues: [string, ...string[]];
1192
+ baseColumn: never;
1193
+ identity: undefined;
1194
+ generated: undefined;
1195
+ }, {}, {}>;
1196
+ category: import("drizzle-orm/pg-core").PgColumn<{
1197
+ name: "category";
1198
+ tableName: "rss_feeds";
1199
+ dataType: "string";
1200
+ columnType: "PgText";
1201
+ data: string;
1202
+ driverParam: string;
1203
+ notNull: true;
1204
+ hasDefault: true;
1205
+ isPrimaryKey: false;
1206
+ isAutoincrement: false;
1207
+ hasRuntimeDefault: false;
1208
+ enumValues: [string, ...string[]];
1209
+ baseColumn: never;
1210
+ identity: undefined;
1211
+ generated: undefined;
1212
+ }, {}, {}>;
1213
+ language: import("drizzle-orm/pg-core").PgColumn<{
1214
+ name: "language";
1215
+ tableName: "rss_feeds";
1216
+ dataType: "string";
1217
+ columnType: "PgText";
1218
+ data: string;
1219
+ driverParam: string;
1220
+ notNull: true;
1221
+ hasDefault: true;
1222
+ isPrimaryKey: false;
1223
+ isAutoincrement: false;
1224
+ hasRuntimeDefault: false;
1225
+ enumValues: [string, ...string[]];
1226
+ baseColumn: never;
1227
+ identity: undefined;
1228
+ generated: undefined;
1229
+ }, {}, {}>;
1230
+ isActive: import("drizzle-orm/pg-core").PgColumn<{
1231
+ name: "is_active";
1232
+ tableName: "rss_feeds";
1233
+ dataType: "boolean";
1234
+ columnType: "PgBoolean";
1235
+ data: boolean;
1236
+ driverParam: boolean;
1237
+ notNull: true;
1238
+ hasDefault: true;
1239
+ isPrimaryKey: false;
1240
+ isAutoincrement: false;
1241
+ hasRuntimeDefault: false;
1242
+ enumValues: undefined;
1243
+ baseColumn: never;
1244
+ identity: undefined;
1245
+ generated: undefined;
1246
+ }, {}, {}>;
1247
+ isPaused: import("drizzle-orm/pg-core").PgColumn<{
1248
+ name: "is_paused";
1249
+ tableName: "rss_feeds";
1250
+ dataType: "boolean";
1251
+ columnType: "PgBoolean";
1252
+ data: boolean;
1253
+ driverParam: boolean;
1254
+ notNull: true;
1255
+ hasDefault: true;
1256
+ isPrimaryKey: false;
1257
+ isAutoincrement: false;
1258
+ hasRuntimeDefault: false;
1259
+ enumValues: undefined;
1260
+ baseColumn: never;
1261
+ identity: undefined;
1262
+ generated: undefined;
1263
+ }, {}, {}>;
1264
+ schedulingEnabled: import("drizzle-orm/pg-core").PgColumn<{
1265
+ name: "scheduling_enabled";
1266
+ tableName: "rss_feeds";
1267
+ dataType: "boolean";
1268
+ columnType: "PgBoolean";
1269
+ data: boolean;
1270
+ driverParam: boolean;
1271
+ notNull: true;
1272
+ hasDefault: true;
1273
+ isPrimaryKey: false;
1274
+ isAutoincrement: false;
1275
+ hasRuntimeDefault: false;
1276
+ enumValues: undefined;
1277
+ baseColumn: never;
1278
+ identity: undefined;
1279
+ generated: undefined;
1280
+ }, {}, {}>;
1281
+ checkFrequencyMinutes: import("drizzle-orm/pg-core").PgColumn<{
1282
+ name: "check_frequency_minutes";
1283
+ tableName: "rss_feeds";
1284
+ dataType: "number";
1285
+ columnType: "PgInteger";
1286
+ data: number;
1287
+ driverParam: string | number;
1288
+ notNull: true;
1289
+ hasDefault: true;
1290
+ isPrimaryKey: false;
1291
+ isAutoincrement: false;
1292
+ hasRuntimeDefault: false;
1293
+ enumValues: undefined;
1294
+ baseColumn: never;
1295
+ identity: undefined;
1296
+ generated: undefined;
1297
+ }, {}, {}>;
1298
+ scrapeInterval: import("drizzle-orm/pg-core").PgColumn<{
1299
+ name: "scrape_interval";
1300
+ tableName: "rss_feeds";
1301
+ dataType: "number";
1302
+ columnType: "PgInteger";
1303
+ data: number;
1304
+ driverParam: string | number;
1305
+ notNull: true;
1306
+ hasDefault: true;
1307
+ isPrimaryKey: false;
1308
+ isAutoincrement: false;
1309
+ hasRuntimeDefault: false;
1310
+ enumValues: undefined;
1311
+ baseColumn: never;
1312
+ identity: undefined;
1313
+ generated: undefined;
1314
+ }, {}, {}>;
1315
+ maxItems: import("drizzle-orm/pg-core").PgColumn<{
1316
+ name: "max_items";
1317
+ tableName: "rss_feeds";
1318
+ dataType: "number";
1319
+ columnType: "PgInteger";
1320
+ data: number;
1321
+ driverParam: string | number;
1322
+ notNull: true;
1323
+ hasDefault: true;
1324
+ isPrimaryKey: false;
1325
+ isAutoincrement: false;
1326
+ hasRuntimeDefault: false;
1327
+ enumValues: undefined;
1328
+ baseColumn: never;
1329
+ identity: undefined;
1330
+ generated: undefined;
1331
+ }, {}, {}>;
1332
+ lastChecked: import("drizzle-orm/pg-core").PgColumn<{
1333
+ name: "last_checked";
1334
+ tableName: "rss_feeds";
1335
+ dataType: "date";
1336
+ columnType: "PgTimestamp";
1337
+ data: Date;
1338
+ driverParam: string;
1339
+ notNull: false;
1340
+ hasDefault: false;
1341
+ isPrimaryKey: false;
1342
+ isAutoincrement: false;
1343
+ hasRuntimeDefault: false;
1344
+ enumValues: undefined;
1345
+ baseColumn: never;
1346
+ identity: undefined;
1347
+ generated: undefined;
1348
+ }, {}, {}>;
1349
+ lastSuccessfulCheck: import("drizzle-orm/pg-core").PgColumn<{
1350
+ name: "last_successful_check";
1351
+ tableName: "rss_feeds";
1352
+ dataType: "date";
1353
+ columnType: "PgTimestamp";
1354
+ data: Date;
1355
+ driverParam: string;
1356
+ notNull: false;
1357
+ hasDefault: false;
1358
+ isPrimaryKey: false;
1359
+ isAutoincrement: false;
1360
+ hasRuntimeDefault: false;
1361
+ enumValues: undefined;
1362
+ baseColumn: never;
1363
+ identity: undefined;
1364
+ generated: undefined;
1365
+ }, {}, {}>;
1366
+ lastError: import("drizzle-orm/pg-core").PgColumn<{
1367
+ name: "last_error";
1368
+ tableName: "rss_feeds";
1369
+ dataType: "string";
1370
+ columnType: "PgText";
1371
+ data: string;
1372
+ driverParam: string;
1373
+ notNull: false;
1374
+ hasDefault: false;
1375
+ isPrimaryKey: false;
1376
+ isAutoincrement: false;
1377
+ hasRuntimeDefault: false;
1378
+ enumValues: [string, ...string[]];
1379
+ baseColumn: never;
1380
+ identity: undefined;
1381
+ generated: undefined;
1382
+ }, {}, {}>;
1383
+ errorCount: import("drizzle-orm/pg-core").PgColumn<{
1384
+ name: "error_count";
1385
+ tableName: "rss_feeds";
1386
+ dataType: "number";
1387
+ columnType: "PgInteger";
1388
+ data: number;
1389
+ driverParam: string | number;
1390
+ notNull: true;
1391
+ hasDefault: true;
1392
+ isPrimaryKey: false;
1393
+ isAutoincrement: false;
1394
+ hasRuntimeDefault: false;
1395
+ enumValues: undefined;
1396
+ baseColumn: never;
1397
+ identity: undefined;
1398
+ generated: undefined;
1399
+ }, {}, {}>;
1400
+ totalArticles: import("drizzle-orm/pg-core").PgColumn<{
1401
+ name: "total_articles";
1402
+ tableName: "rss_feeds";
1403
+ dataType: "number";
1404
+ columnType: "PgInteger";
1405
+ data: number;
1406
+ driverParam: string | number;
1407
+ notNull: true;
1408
+ hasDefault: true;
1409
+ isPrimaryKey: false;
1410
+ isAutoincrement: false;
1411
+ hasRuntimeDefault: false;
1412
+ enumValues: undefined;
1413
+ baseColumn: never;
1414
+ identity: undefined;
1415
+ generated: undefined;
1416
+ }, {}, {}>;
1417
+ lastRunDuration: import("drizzle-orm/pg-core").PgColumn<{
1418
+ name: "last_run_duration";
1419
+ tableName: "rss_feeds";
1420
+ dataType: "number";
1421
+ columnType: "PgInteger";
1422
+ data: number;
1423
+ driverParam: string | number;
1424
+ notNull: false;
1425
+ hasDefault: false;
1426
+ isPrimaryKey: false;
1427
+ isAutoincrement: false;
1428
+ hasRuntimeDefault: false;
1429
+ enumValues: undefined;
1430
+ baseColumn: never;
1431
+ identity: undefined;
1432
+ generated: undefined;
1433
+ }, {}, {}>;
1434
+ averageRunDuration: import("drizzle-orm/pg-core").PgColumn<{
1435
+ name: "average_run_duration";
1436
+ tableName: "rss_feeds";
1437
+ dataType: "number";
1438
+ columnType: "PgInteger";
1439
+ data: number;
1440
+ driverParam: string | number;
1441
+ notNull: false;
1442
+ hasDefault: false;
1443
+ isPrimaryKey: false;
1444
+ isAutoincrement: false;
1445
+ hasRuntimeDefault: false;
1446
+ enumValues: undefined;
1447
+ baseColumn: never;
1448
+ identity: undefined;
1449
+ generated: undefined;
1450
+ }, {}, {}>;
1451
+ lastRunStartedAt: import("drizzle-orm/pg-core").PgColumn<{
1452
+ name: "last_run_started_at";
1453
+ tableName: "rss_feeds";
1454
+ dataType: "date";
1455
+ columnType: "PgTimestamp";
1456
+ data: Date;
1457
+ driverParam: string;
1458
+ notNull: false;
1459
+ hasDefault: false;
1460
+ isPrimaryKey: false;
1461
+ isAutoincrement: false;
1462
+ hasRuntimeDefault: false;
1463
+ enumValues: undefined;
1464
+ baseColumn: never;
1465
+ identity: undefined;
1466
+ generated: undefined;
1467
+ }, {}, {}>;
1468
+ lastRunCompletedAt: import("drizzle-orm/pg-core").PgColumn<{
1469
+ name: "last_run_completed_at";
1470
+ tableName: "rss_feeds";
1471
+ dataType: "date";
1472
+ columnType: "PgTimestamp";
1473
+ data: Date;
1474
+ driverParam: string;
1475
+ notNull: false;
1476
+ hasDefault: false;
1477
+ isPrimaryKey: false;
1478
+ isAutoincrement: false;
1479
+ hasRuntimeDefault: false;
1480
+ enumValues: undefined;
1481
+ baseColumn: never;
1482
+ identity: undefined;
1483
+ generated: undefined;
1484
+ }, {}, {}>;
1485
+ tags: import("drizzle-orm/pg-core").PgColumn<{
1486
+ name: "tags";
1487
+ tableName: "rss_feeds";
1488
+ dataType: "array";
1489
+ columnType: "PgArray";
1490
+ data: string[];
1491
+ driverParam: string | string[];
1492
+ notNull: true;
1493
+ hasDefault: true;
1494
+ isPrimaryKey: false;
1495
+ isAutoincrement: false;
1496
+ hasRuntimeDefault: false;
1497
+ enumValues: [string, ...string[]];
1498
+ baseColumn: import("drizzle-orm").Column<{
1499
+ name: "tags";
1500
+ tableName: "rss_feeds";
1501
+ dataType: "string";
1502
+ columnType: "PgText";
1503
+ data: string;
1504
+ driverParam: string;
1505
+ notNull: false;
1506
+ hasDefault: false;
1507
+ isPrimaryKey: false;
1508
+ isAutoincrement: false;
1509
+ hasRuntimeDefault: false;
1510
+ enumValues: [string, ...string[]];
1511
+ baseColumn: never;
1512
+ identity: undefined;
1513
+ generated: undefined;
1514
+ }, {}, {}>;
1515
+ identity: undefined;
1516
+ generated: undefined;
1517
+ }, {}, {
1518
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1519
+ name: "tags";
1520
+ dataType: "string";
1521
+ columnType: "PgText";
1522
+ data: string;
1523
+ enumValues: [string, ...string[]];
1524
+ driverParam: string;
1525
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1526
+ size: undefined;
1527
+ }>;
1528
+ priority: import("drizzle-orm/pg-core").PgColumn<{
1529
+ name: "priority";
1530
+ tableName: "rss_feeds";
1531
+ dataType: "number";
1532
+ columnType: "PgInteger";
1533
+ data: number;
1534
+ driverParam: string | number;
1535
+ notNull: true;
1536
+ hasDefault: true;
1537
+ isPrimaryKey: false;
1538
+ isAutoincrement: false;
1539
+ hasRuntimeDefault: false;
1540
+ enumValues: undefined;
1541
+ baseColumn: never;
1542
+ identity: undefined;
1543
+ generated: undefined;
1544
+ }, {}, {}>;
1545
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
1546
+ name: "user_agent";
1547
+ tableName: "rss_feeds";
1548
+ dataType: "string";
1549
+ columnType: "PgText";
1550
+ data: string;
1551
+ driverParam: string;
1552
+ notNull: false;
1553
+ hasDefault: false;
1554
+ isPrimaryKey: false;
1555
+ isAutoincrement: false;
1556
+ hasRuntimeDefault: false;
1557
+ enumValues: [string, ...string[]];
1558
+ baseColumn: never;
1559
+ identity: undefined;
1560
+ generated: undefined;
1561
+ }, {}, {}>;
1562
+ headers: import("drizzle-orm/pg-core").PgColumn<{
1563
+ name: "headers";
1564
+ tableName: "rss_feeds";
1565
+ dataType: "string";
1566
+ columnType: "PgText";
1567
+ data: string;
1568
+ driverParam: string;
1569
+ notNull: false;
1570
+ hasDefault: false;
1571
+ isPrimaryKey: false;
1572
+ isAutoincrement: false;
1573
+ hasRuntimeDefault: false;
1574
+ enumValues: [string, ...string[]];
1575
+ baseColumn: never;
1576
+ identity: undefined;
1577
+ generated: undefined;
1578
+ }, {}, {}>;
1579
+ timeout: import("drizzle-orm/pg-core").PgColumn<{
1580
+ name: "timeout";
1581
+ tableName: "rss_feeds";
1582
+ dataType: "number";
1583
+ columnType: "PgInteger";
1584
+ data: number;
1585
+ driverParam: string | number;
1586
+ notNull: true;
1587
+ hasDefault: true;
1588
+ isPrimaryKey: false;
1589
+ isAutoincrement: false;
1590
+ hasRuntimeDefault: false;
1591
+ enumValues: undefined;
1592
+ baseColumn: never;
1593
+ identity: undefined;
1594
+ generated: undefined;
1595
+ }, {}, {}>;
1596
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
1597
+ name: "created_by";
1598
+ tableName: "rss_feeds";
1599
+ dataType: "string";
1600
+ columnType: "PgText";
1601
+ data: string;
1602
+ driverParam: string;
1603
+ notNull: true;
1604
+ hasDefault: true;
1605
+ isPrimaryKey: false;
1606
+ isAutoincrement: false;
1607
+ hasRuntimeDefault: false;
1608
+ enumValues: [string, ...string[]];
1609
+ baseColumn: never;
1610
+ identity: undefined;
1611
+ generated: undefined;
1612
+ }, {}, {}>;
1613
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1614
+ name: "created_at";
1615
+ tableName: "rss_feeds";
1616
+ dataType: "date";
1617
+ columnType: "PgTimestamp";
1618
+ data: Date;
1619
+ driverParam: string;
1620
+ notNull: true;
1621
+ hasDefault: true;
1622
+ isPrimaryKey: false;
1623
+ isAutoincrement: false;
1624
+ hasRuntimeDefault: false;
1625
+ enumValues: undefined;
1626
+ baseColumn: never;
1627
+ identity: undefined;
1628
+ generated: undefined;
1629
+ }, {}, {}>;
1630
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1631
+ name: "updated_at";
1632
+ tableName: "rss_feeds";
1633
+ dataType: "date";
1634
+ columnType: "PgTimestamp";
1635
+ data: Date;
1636
+ driverParam: string;
1637
+ notNull: true;
1638
+ hasDefault: true;
1639
+ isPrimaryKey: false;
1640
+ isAutoincrement: false;
1641
+ hasRuntimeDefault: false;
1642
+ enumValues: undefined;
1643
+ baseColumn: never;
1644
+ identity: undefined;
1645
+ generated: undefined;
1646
+ }, {}, {}>;
1647
+ };
1648
+ dialect: "pg";
1649
+ }>;
1650
+ export declare const rssArticles: import("drizzle-orm/pg-core").PgTableWithColumns<{
1651
+ name: "rss_articles";
1652
+ schema: undefined;
1653
+ columns: {
1654
+ id: import("drizzle-orm/pg-core").PgColumn<{
1655
+ name: "id";
1656
+ tableName: "rss_articles";
1657
+ dataType: "string";
1658
+ columnType: "PgText";
1659
+ data: string;
1660
+ driverParam: string;
1661
+ notNull: true;
1662
+ hasDefault: false;
1663
+ isPrimaryKey: true;
1664
+ isAutoincrement: false;
1665
+ hasRuntimeDefault: false;
1666
+ enumValues: [string, ...string[]];
1667
+ baseColumn: never;
1668
+ identity: undefined;
1669
+ generated: undefined;
1670
+ }, {}, {}>;
1671
+ feedId: import("drizzle-orm/pg-core").PgColumn<{
1672
+ name: "feed_id";
1673
+ tableName: "rss_articles";
1674
+ dataType: "string";
1675
+ columnType: "PgText";
1676
+ data: string;
1677
+ driverParam: string;
1678
+ notNull: true;
1679
+ hasDefault: false;
1680
+ isPrimaryKey: false;
1681
+ isAutoincrement: false;
1682
+ hasRuntimeDefault: false;
1683
+ enumValues: [string, ...string[]];
1684
+ baseColumn: never;
1685
+ identity: undefined;
1686
+ generated: undefined;
1687
+ }, {}, {}>;
1688
+ title: import("drizzle-orm/pg-core").PgColumn<{
1689
+ name: "title";
1690
+ tableName: "rss_articles";
1691
+ dataType: "string";
1692
+ columnType: "PgText";
1693
+ data: string;
1694
+ driverParam: string;
1695
+ notNull: true;
1696
+ hasDefault: false;
1697
+ isPrimaryKey: false;
1698
+ isAutoincrement: false;
1699
+ hasRuntimeDefault: false;
1700
+ enumValues: [string, ...string[]];
1701
+ baseColumn: never;
1702
+ identity: undefined;
1703
+ generated: undefined;
1704
+ }, {}, {}>;
1705
+ content: import("drizzle-orm/pg-core").PgColumn<{
1706
+ name: "content";
1707
+ tableName: "rss_articles";
1708
+ dataType: "string";
1709
+ columnType: "PgText";
1710
+ data: string;
1711
+ driverParam: string;
1712
+ notNull: false;
1713
+ hasDefault: false;
1714
+ isPrimaryKey: false;
1715
+ isAutoincrement: false;
1716
+ hasRuntimeDefault: false;
1717
+ enumValues: [string, ...string[]];
1718
+ baseColumn: never;
1719
+ identity: undefined;
1720
+ generated: undefined;
1721
+ }, {}, {}>;
1722
+ description: import("drizzle-orm/pg-core").PgColumn<{
1723
+ name: "description";
1724
+ tableName: "rss_articles";
1725
+ dataType: "string";
1726
+ columnType: "PgText";
1727
+ data: string;
1728
+ driverParam: string;
1729
+ notNull: false;
1730
+ hasDefault: false;
1731
+ isPrimaryKey: false;
1732
+ isAutoincrement: false;
1733
+ hasRuntimeDefault: false;
1734
+ enumValues: [string, ...string[]];
1735
+ baseColumn: never;
1736
+ identity: undefined;
1737
+ generated: undefined;
1738
+ }, {}, {}>;
1739
+ url: import("drizzle-orm/pg-core").PgColumn<{
1740
+ name: "url";
1741
+ tableName: "rss_articles";
1742
+ dataType: "string";
1743
+ columnType: "PgText";
1744
+ data: string;
1745
+ driverParam: string;
1746
+ notNull: true;
1747
+ hasDefault: false;
1748
+ isPrimaryKey: false;
1749
+ isAutoincrement: false;
1750
+ hasRuntimeDefault: false;
1751
+ enumValues: [string, ...string[]];
1752
+ baseColumn: never;
1753
+ identity: undefined;
1754
+ generated: undefined;
1755
+ }, {}, {}>;
1756
+ link: import("drizzle-orm/pg-core").PgColumn<{
1757
+ name: "link";
1758
+ tableName: "rss_articles";
1759
+ dataType: "string";
1760
+ columnType: "PgText";
1761
+ data: string;
1762
+ driverParam: string;
1763
+ notNull: false;
1764
+ hasDefault: false;
1765
+ isPrimaryKey: false;
1766
+ isAutoincrement: false;
1767
+ hasRuntimeDefault: false;
1768
+ enumValues: [string, ...string[]];
1769
+ baseColumn: never;
1770
+ identity: undefined;
1771
+ generated: undefined;
1772
+ }, {}, {}>;
1773
+ author: import("drizzle-orm/pg-core").PgColumn<{
1774
+ name: "author";
1775
+ tableName: "rss_articles";
1776
+ dataType: "string";
1777
+ columnType: "PgText";
1778
+ data: string;
1779
+ driverParam: string;
1780
+ notNull: false;
1781
+ hasDefault: false;
1782
+ isPrimaryKey: false;
1783
+ isAutoincrement: false;
1784
+ hasRuntimeDefault: false;
1785
+ enumValues: [string, ...string[]];
1786
+ baseColumn: never;
1787
+ identity: undefined;
1788
+ generated: undefined;
1789
+ }, {}, {}>;
1790
+ publishedAt: import("drizzle-orm/pg-core").PgColumn<{
1791
+ name: "published_at";
1792
+ tableName: "rss_articles";
1793
+ dataType: "date";
1794
+ columnType: "PgTimestamp";
1795
+ data: Date;
1796
+ driverParam: string;
1797
+ notNull: true;
1798
+ hasDefault: false;
1799
+ isPrimaryKey: false;
1800
+ isAutoincrement: false;
1801
+ hasRuntimeDefault: false;
1802
+ enumValues: undefined;
1803
+ baseColumn: never;
1804
+ identity: undefined;
1805
+ generated: undefined;
1806
+ }, {}, {}>;
1807
+ scrapedAt: import("drizzle-orm/pg-core").PgColumn<{
1808
+ name: "scraped_at";
1809
+ tableName: "rss_articles";
1810
+ dataType: "date";
1811
+ columnType: "PgTimestamp";
1812
+ data: Date;
1813
+ driverParam: string;
1814
+ notNull: true;
1815
+ hasDefault: true;
1816
+ isPrimaryKey: false;
1817
+ isAutoincrement: false;
1818
+ hasRuntimeDefault: false;
1819
+ enumValues: undefined;
1820
+ baseColumn: never;
1821
+ identity: undefined;
1822
+ generated: undefined;
1823
+ }, {}, {}>;
1824
+ categories: import("drizzle-orm/pg-core").PgColumn<{
1825
+ name: "categories";
1826
+ tableName: "rss_articles";
1827
+ dataType: "array";
1828
+ columnType: "PgArray";
1829
+ data: string[];
1830
+ driverParam: string | string[];
1831
+ notNull: false;
1832
+ hasDefault: true;
1833
+ isPrimaryKey: false;
1834
+ isAutoincrement: false;
1835
+ hasRuntimeDefault: false;
1836
+ enumValues: [string, ...string[]];
1837
+ baseColumn: import("drizzle-orm").Column<{
1838
+ name: "categories";
1839
+ tableName: "rss_articles";
1840
+ dataType: "string";
1841
+ columnType: "PgText";
1842
+ data: string;
1843
+ driverParam: string;
1844
+ notNull: false;
1845
+ hasDefault: false;
1846
+ isPrimaryKey: false;
1847
+ isAutoincrement: false;
1848
+ hasRuntimeDefault: false;
1849
+ enumValues: [string, ...string[]];
1850
+ baseColumn: never;
1851
+ identity: undefined;
1852
+ generated: undefined;
1853
+ }, {}, {}>;
1854
+ identity: undefined;
1855
+ generated: undefined;
1856
+ }, {}, {
1857
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1858
+ name: "categories";
1859
+ dataType: "string";
1860
+ columnType: "PgText";
1861
+ data: string;
1862
+ enumValues: [string, ...string[]];
1863
+ driverParam: string;
1864
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1865
+ size: undefined;
1866
+ }>;
1867
+ tags: import("drizzle-orm/pg-core").PgColumn<{
1868
+ name: "tags";
1869
+ tableName: "rss_articles";
1870
+ dataType: "array";
1871
+ columnType: "PgArray";
1872
+ data: string[];
1873
+ driverParam: string | string[];
1874
+ notNull: false;
1875
+ hasDefault: true;
1876
+ isPrimaryKey: false;
1877
+ isAutoincrement: false;
1878
+ hasRuntimeDefault: false;
1879
+ enumValues: [string, ...string[]];
1880
+ baseColumn: import("drizzle-orm").Column<{
1881
+ name: "tags";
1882
+ tableName: "rss_articles";
1883
+ dataType: "string";
1884
+ columnType: "PgText";
1885
+ data: string;
1886
+ driverParam: string;
1887
+ notNull: false;
1888
+ hasDefault: false;
1889
+ isPrimaryKey: false;
1890
+ isAutoincrement: false;
1891
+ hasRuntimeDefault: false;
1892
+ enumValues: [string, ...string[]];
1893
+ baseColumn: never;
1894
+ identity: undefined;
1895
+ generated: undefined;
1896
+ }, {}, {}>;
1897
+ identity: undefined;
1898
+ generated: undefined;
1899
+ }, {}, {
1900
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1901
+ name: "tags";
1902
+ dataType: "string";
1903
+ columnType: "PgText";
1904
+ data: string;
1905
+ enumValues: [string, ...string[]];
1906
+ driverParam: string;
1907
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1908
+ size: undefined;
1909
+ }>;
1910
+ language: import("drizzle-orm/pg-core").PgColumn<{
1911
+ name: "language";
1912
+ tableName: "rss_articles";
1913
+ dataType: "string";
1914
+ columnType: "PgText";
1915
+ data: string;
1916
+ driverParam: string;
1917
+ notNull: false;
1918
+ hasDefault: true;
1919
+ isPrimaryKey: false;
1920
+ isAutoincrement: false;
1921
+ hasRuntimeDefault: false;
1922
+ enumValues: [string, ...string[]];
1923
+ baseColumn: never;
1924
+ identity: undefined;
1925
+ generated: undefined;
1926
+ }, {}, {}>;
1927
+ relevanceScore: import("drizzle-orm/pg-core").PgColumn<{
1928
+ name: "relevance_score";
1929
+ tableName: "rss_articles";
1930
+ dataType: "string";
1931
+ columnType: "PgNumeric";
1932
+ data: string;
1933
+ driverParam: string;
1934
+ notNull: false;
1935
+ hasDefault: false;
1936
+ isPrimaryKey: false;
1937
+ isAutoincrement: false;
1938
+ hasRuntimeDefault: false;
1939
+ enumValues: undefined;
1940
+ baseColumn: never;
1941
+ identity: undefined;
1942
+ generated: undefined;
1943
+ }, {}, {}>;
1944
+ qualityScore: import("drizzle-orm/pg-core").PgColumn<{
1945
+ name: "quality_score";
1946
+ tableName: "rss_articles";
1947
+ dataType: "string";
1948
+ columnType: "PgNumeric";
1949
+ data: string;
1950
+ driverParam: string;
1951
+ notNull: false;
1952
+ hasDefault: false;
1953
+ isPrimaryKey: false;
1954
+ isAutoincrement: false;
1955
+ hasRuntimeDefault: false;
1956
+ enumValues: undefined;
1957
+ baseColumn: never;
1958
+ identity: undefined;
1959
+ generated: undefined;
1960
+ }, {}, {}>;
1961
+ aiClassified: import("drizzle-orm/pg-core").PgColumn<{
1962
+ name: "ai_classified";
1963
+ tableName: "rss_articles";
1964
+ dataType: "boolean";
1965
+ columnType: "PgBoolean";
1966
+ data: boolean;
1967
+ driverParam: boolean;
1968
+ notNull: true;
1969
+ hasDefault: true;
1970
+ isPrimaryKey: false;
1971
+ isAutoincrement: false;
1972
+ hasRuntimeDefault: false;
1973
+ enumValues: undefined;
1974
+ baseColumn: never;
1975
+ identity: undefined;
1976
+ generated: undefined;
1977
+ }, {}, {}>;
1978
+ aiConfidence: import("drizzle-orm/pg-core").PgColumn<{
1979
+ name: "ai_confidence";
1980
+ tableName: "rss_articles";
1981
+ dataType: "string";
1982
+ columnType: "PgNumeric";
1983
+ data: string;
1984
+ driverParam: string;
1985
+ notNull: false;
1986
+ hasDefault: false;
1987
+ isPrimaryKey: false;
1988
+ isAutoincrement: false;
1989
+ hasRuntimeDefault: false;
1990
+ enumValues: undefined;
1991
+ baseColumn: never;
1992
+ identity: undefined;
1993
+ generated: undefined;
1994
+ }, {}, {}>;
1995
+ aiReason: import("drizzle-orm/pg-core").PgColumn<{
1996
+ name: "ai_reason";
1997
+ tableName: "rss_articles";
1998
+ dataType: "string";
1999
+ columnType: "PgText";
2000
+ data: string;
2001
+ driverParam: string;
2002
+ notNull: false;
2003
+ hasDefault: false;
2004
+ isPrimaryKey: false;
2005
+ isAutoincrement: false;
2006
+ hasRuntimeDefault: false;
2007
+ enumValues: [string, ...string[]];
2008
+ baseColumn: never;
2009
+ identity: undefined;
2010
+ generated: undefined;
2011
+ }, {}, {}>;
2012
+ isAion2Related: import("drizzle-orm/pg-core").PgColumn<{
2013
+ name: "is_aion2_related";
2014
+ tableName: "rss_articles";
2015
+ dataType: "boolean";
2016
+ columnType: "PgBoolean";
2017
+ data: boolean;
2018
+ driverParam: boolean;
2019
+ notNull: true;
2020
+ hasDefault: true;
2021
+ isPrimaryKey: false;
2022
+ isAutoincrement: false;
2023
+ hasRuntimeDefault: false;
2024
+ enumValues: undefined;
2025
+ baseColumn: never;
2026
+ identity: undefined;
2027
+ generated: undefined;
2028
+ }, {}, {}>;
2029
+ featured: import("drizzle-orm/pg-core").PgColumn<{
2030
+ name: "featured";
2031
+ tableName: "rss_articles";
2032
+ dataType: "boolean";
2033
+ columnType: "PgBoolean";
2034
+ data: boolean;
2035
+ driverParam: boolean;
2036
+ notNull: true;
2037
+ hasDefault: true;
2038
+ isPrimaryKey: false;
2039
+ isAutoincrement: false;
2040
+ hasRuntimeDefault: false;
2041
+ enumValues: undefined;
2042
+ baseColumn: never;
2043
+ identity: undefined;
2044
+ generated: undefined;
2045
+ }, {}, {}>;
2046
+ featuredUntil: import("drizzle-orm/pg-core").PgColumn<{
2047
+ name: "featured_until";
2048
+ tableName: "rss_articles";
2049
+ dataType: "date";
2050
+ columnType: "PgTimestamp";
2051
+ data: Date;
2052
+ driverParam: string;
2053
+ notNull: false;
2054
+ hasDefault: false;
2055
+ isPrimaryKey: false;
2056
+ isAutoincrement: false;
2057
+ hasRuntimeDefault: false;
2058
+ enumValues: undefined;
2059
+ baseColumn: never;
2060
+ identity: undefined;
2061
+ generated: undefined;
2062
+ }, {}, {}>;
2063
+ classificationFilters: import("drizzle-orm/pg-core").PgColumn<{
2064
+ name: "classification_filters";
2065
+ tableName: "rss_articles";
2066
+ dataType: "array";
2067
+ columnType: "PgArray";
2068
+ data: string[];
2069
+ driverParam: string | string[];
2070
+ notNull: false;
2071
+ hasDefault: true;
2072
+ isPrimaryKey: false;
2073
+ isAutoincrement: false;
2074
+ hasRuntimeDefault: false;
2075
+ enumValues: [string, ...string[]];
2076
+ baseColumn: import("drizzle-orm").Column<{
2077
+ name: "classification_filters";
2078
+ tableName: "rss_articles";
2079
+ dataType: "string";
2080
+ columnType: "PgText";
2081
+ data: string;
2082
+ driverParam: string;
2083
+ notNull: false;
2084
+ hasDefault: false;
2085
+ isPrimaryKey: false;
2086
+ isAutoincrement: false;
2087
+ hasRuntimeDefault: false;
2088
+ enumValues: [string, ...string[]];
2089
+ baseColumn: never;
2090
+ identity: undefined;
2091
+ generated: undefined;
2092
+ }, {}, {}>;
2093
+ identity: undefined;
2094
+ generated: undefined;
2095
+ }, {}, {
2096
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2097
+ name: "classification_filters";
2098
+ dataType: "string";
2099
+ columnType: "PgText";
2100
+ data: string;
2101
+ enumValues: [string, ...string[]];
2102
+ driverParam: string;
2103
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2104
+ size: undefined;
2105
+ }>;
2106
+ filterMatchDetails: import("drizzle-orm/pg-core").PgColumn<{
2107
+ name: "filter_match_details";
2108
+ tableName: "rss_articles";
2109
+ dataType: "json";
2110
+ columnType: "PgJsonb";
2111
+ data: unknown;
2112
+ driverParam: unknown;
2113
+ notNull: false;
2114
+ hasDefault: false;
2115
+ isPrimaryKey: false;
2116
+ isAutoincrement: false;
2117
+ hasRuntimeDefault: false;
2118
+ enumValues: undefined;
2119
+ baseColumn: never;
2120
+ identity: undefined;
2121
+ generated: undefined;
2122
+ }, {}, {}>;
2123
+ classificationVersion: import("drizzle-orm/pg-core").PgColumn<{
2124
+ name: "classification_version";
2125
+ tableName: "rss_articles";
2126
+ dataType: "string";
2127
+ columnType: "PgText";
2128
+ data: string;
2129
+ driverParam: string;
2130
+ notNull: false;
2131
+ hasDefault: true;
2132
+ isPrimaryKey: false;
2133
+ isAutoincrement: false;
2134
+ hasRuntimeDefault: false;
2135
+ enumValues: [string, ...string[]];
2136
+ baseColumn: never;
2137
+ identity: undefined;
2138
+ generated: undefined;
2139
+ }, {}, {}>;
2140
+ classificationKeywords: import("drizzle-orm/pg-core").PgColumn<{
2141
+ name: "classification_keywords";
2142
+ tableName: "rss_articles";
2143
+ dataType: "array";
2144
+ columnType: "PgArray";
2145
+ data: string[];
2146
+ driverParam: string | string[];
2147
+ notNull: false;
2148
+ hasDefault: true;
2149
+ isPrimaryKey: false;
2150
+ isAutoincrement: false;
2151
+ hasRuntimeDefault: false;
2152
+ enumValues: [string, ...string[]];
2153
+ baseColumn: import("drizzle-orm").Column<{
2154
+ name: "classification_keywords";
2155
+ tableName: "rss_articles";
2156
+ dataType: "string";
2157
+ columnType: "PgText";
2158
+ data: string;
2159
+ driverParam: string;
2160
+ notNull: false;
2161
+ hasDefault: false;
2162
+ isPrimaryKey: false;
2163
+ isAutoincrement: false;
2164
+ hasRuntimeDefault: false;
2165
+ enumValues: [string, ...string[]];
2166
+ baseColumn: never;
2167
+ identity: undefined;
2168
+ generated: undefined;
2169
+ }, {}, {}>;
2170
+ identity: undefined;
2171
+ generated: undefined;
2172
+ }, {}, {
2173
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2174
+ name: "classification_keywords";
2175
+ dataType: "string";
2176
+ columnType: "PgText";
2177
+ data: string;
2178
+ enumValues: [string, ...string[]];
2179
+ driverParam: string;
2180
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2181
+ size: undefined;
2182
+ }>;
2183
+ titleTranslated: import("drizzle-orm/pg-core").PgColumn<{
2184
+ name: "title_translated";
2185
+ tableName: "rss_articles";
2186
+ dataType: "string";
2187
+ columnType: "PgText";
2188
+ data: string;
2189
+ driverParam: string;
2190
+ notNull: false;
2191
+ hasDefault: false;
2192
+ isPrimaryKey: false;
2193
+ isAutoincrement: false;
2194
+ hasRuntimeDefault: false;
2195
+ enumValues: [string, ...string[]];
2196
+ baseColumn: never;
2197
+ identity: undefined;
2198
+ generated: undefined;
2199
+ }, {}, {}>;
2200
+ descriptionTranslated: import("drizzle-orm/pg-core").PgColumn<{
2201
+ name: "description_translated";
2202
+ tableName: "rss_articles";
2203
+ dataType: "string";
2204
+ columnType: "PgText";
2205
+ data: string;
2206
+ driverParam: string;
2207
+ notNull: false;
2208
+ hasDefault: false;
2209
+ isPrimaryKey: false;
2210
+ isAutoincrement: false;
2211
+ hasRuntimeDefault: false;
2212
+ enumValues: [string, ...string[]];
2213
+ baseColumn: never;
2214
+ identity: undefined;
2215
+ generated: undefined;
2216
+ }, {}, {}>;
2217
+ contentTranslated: import("drizzle-orm/pg-core").PgColumn<{
2218
+ name: "content_translated";
2219
+ tableName: "rss_articles";
2220
+ dataType: "string";
2221
+ columnType: "PgText";
2222
+ data: string;
2223
+ driverParam: string;
2224
+ notNull: false;
2225
+ hasDefault: false;
2226
+ isPrimaryKey: false;
2227
+ isAutoincrement: false;
2228
+ hasRuntimeDefault: false;
2229
+ enumValues: [string, ...string[]];
2230
+ baseColumn: never;
2231
+ identity: undefined;
2232
+ generated: undefined;
2233
+ }, {}, {}>;
2234
+ translatedAt: import("drizzle-orm/pg-core").PgColumn<{
2235
+ name: "translated_at";
2236
+ tableName: "rss_articles";
2237
+ dataType: "date";
2238
+ columnType: "PgTimestamp";
2239
+ data: Date;
2240
+ driverParam: string;
2241
+ notNull: false;
2242
+ hasDefault: false;
2243
+ isPrimaryKey: false;
2244
+ isAutoincrement: false;
2245
+ hasRuntimeDefault: false;
2246
+ enumValues: undefined;
2247
+ baseColumn: never;
2248
+ identity: undefined;
2249
+ generated: undefined;
2250
+ }, {}, {}>;
2251
+ translationConfidence: import("drizzle-orm/pg-core").PgColumn<{
2252
+ name: "translation_confidence";
2253
+ tableName: "rss_articles";
2254
+ dataType: "string";
2255
+ columnType: "PgNumeric";
2256
+ data: string;
2257
+ driverParam: string;
2258
+ notNull: false;
2259
+ hasDefault: false;
2260
+ isPrimaryKey: false;
2261
+ isAutoincrement: false;
2262
+ hasRuntimeDefault: false;
2263
+ enumValues: undefined;
2264
+ baseColumn: never;
2265
+ identity: undefined;
2266
+ generated: undefined;
2267
+ }, {}, {}>;
2268
+ isTranslated: import("drizzle-orm/pg-core").PgColumn<{
2269
+ name: "is_translated";
2270
+ tableName: "rss_articles";
2271
+ dataType: "boolean";
2272
+ columnType: "PgBoolean";
2273
+ data: boolean;
2274
+ driverParam: boolean;
2275
+ notNull: true;
2276
+ hasDefault: true;
2277
+ isPrimaryKey: false;
2278
+ isAutoincrement: false;
2279
+ hasRuntimeDefault: false;
2280
+ enumValues: undefined;
2281
+ baseColumn: never;
2282
+ identity: undefined;
2283
+ generated: undefined;
2284
+ }, {}, {}>;
2285
+ imageUrl: import("drizzle-orm/pg-core").PgColumn<{
2286
+ name: "image_url";
2287
+ tableName: "rss_articles";
2288
+ dataType: "string";
2289
+ columnType: "PgText";
2290
+ data: string;
2291
+ driverParam: string;
2292
+ notNull: false;
2293
+ hasDefault: false;
2294
+ isPrimaryKey: false;
2295
+ isAutoincrement: false;
2296
+ hasRuntimeDefault: false;
2297
+ enumValues: [string, ...string[]];
2298
+ baseColumn: never;
2299
+ identity: undefined;
2300
+ generated: undefined;
2301
+ }, {}, {}>;
2302
+ images: import("drizzle-orm/pg-core").PgColumn<{
2303
+ name: "images";
2304
+ tableName: "rss_articles";
2305
+ dataType: "string";
2306
+ columnType: "PgText";
2307
+ data: string;
2308
+ driverParam: string;
2309
+ notNull: false;
2310
+ hasDefault: false;
2311
+ isPrimaryKey: false;
2312
+ isAutoincrement: false;
2313
+ hasRuntimeDefault: false;
2314
+ enumValues: [string, ...string[]];
2315
+ baseColumn: never;
2316
+ identity: undefined;
2317
+ generated: undefined;
2318
+ }, {}, {}>;
2319
+ views: import("drizzle-orm/pg-core").PgColumn<{
2320
+ name: "views";
2321
+ tableName: "rss_articles";
2322
+ dataType: "number";
2323
+ columnType: "PgInteger";
2324
+ data: number;
2325
+ driverParam: string | number;
2326
+ notNull: false;
2327
+ hasDefault: true;
2328
+ isPrimaryKey: false;
2329
+ isAutoincrement: false;
2330
+ hasRuntimeDefault: false;
2331
+ enumValues: undefined;
2332
+ baseColumn: never;
2333
+ identity: undefined;
2334
+ generated: undefined;
2335
+ }, {}, {}>;
2336
+ likes: import("drizzle-orm/pg-core").PgColumn<{
2337
+ name: "likes";
2338
+ tableName: "rss_articles";
2339
+ dataType: "number";
2340
+ columnType: "PgInteger";
2341
+ data: number;
2342
+ driverParam: string | number;
2343
+ notNull: false;
2344
+ hasDefault: true;
2345
+ isPrimaryKey: false;
2346
+ isAutoincrement: false;
2347
+ hasRuntimeDefault: false;
2348
+ enumValues: undefined;
2349
+ baseColumn: never;
2350
+ identity: undefined;
2351
+ generated: undefined;
2352
+ }, {}, {}>;
2353
+ shares: import("drizzle-orm/pg-core").PgColumn<{
2354
+ name: "shares";
2355
+ tableName: "rss_articles";
2356
+ dataType: "number";
2357
+ columnType: "PgInteger";
2358
+ data: number;
2359
+ driverParam: string | number;
2360
+ notNull: false;
2361
+ hasDefault: true;
2362
+ isPrimaryKey: false;
2363
+ isAutoincrement: false;
2364
+ hasRuntimeDefault: false;
2365
+ enumValues: undefined;
2366
+ baseColumn: never;
2367
+ identity: undefined;
2368
+ generated: undefined;
2369
+ }, {}, {}>;
2370
+ status: import("drizzle-orm/pg-core").PgColumn<{
2371
+ name: "status";
2372
+ tableName: "rss_articles";
2373
+ dataType: "string";
2374
+ columnType: "PgEnumColumn";
2375
+ data: "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED" | "REJECTED" | "PUBLISHED";
2376
+ driverParam: string;
2377
+ notNull: true;
2378
+ hasDefault: true;
2379
+ isPrimaryKey: false;
2380
+ isAutoincrement: false;
2381
+ hasRuntimeDefault: false;
2382
+ enumValues: ["PENDING", "PROCESSING", "COMPLETED", "PUBLISHED", "FAILED", "REJECTED"];
2383
+ baseColumn: never;
2384
+ identity: undefined;
2385
+ generated: undefined;
2386
+ }, {}, {}>;
2387
+ processingNotes: import("drizzle-orm/pg-core").PgColumn<{
2388
+ name: "processing_notes";
2389
+ tableName: "rss_articles";
2390
+ dataType: "string";
2391
+ columnType: "PgText";
2392
+ data: string;
2393
+ driverParam: string;
2394
+ notNull: false;
2395
+ hasDefault: false;
2396
+ isPrimaryKey: false;
2397
+ isAutoincrement: false;
2398
+ hasRuntimeDefault: false;
2399
+ enumValues: [string, ...string[]];
2400
+ baseColumn: never;
2401
+ identity: undefined;
2402
+ generated: undefined;
2403
+ }, {}, {}>;
2404
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2405
+ name: "created_at";
2406
+ tableName: "rss_articles";
2407
+ dataType: "date";
2408
+ columnType: "PgTimestamp";
2409
+ data: Date;
2410
+ driverParam: string;
2411
+ notNull: true;
2412
+ hasDefault: true;
2413
+ isPrimaryKey: false;
2414
+ isAutoincrement: false;
2415
+ hasRuntimeDefault: false;
2416
+ enumValues: undefined;
2417
+ baseColumn: never;
2418
+ identity: undefined;
2419
+ generated: undefined;
2420
+ }, {}, {}>;
2421
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2422
+ name: "updated_at";
2423
+ tableName: "rss_articles";
2424
+ dataType: "date";
2425
+ columnType: "PgTimestamp";
2426
+ data: Date;
2427
+ driverParam: string;
2428
+ notNull: true;
2429
+ hasDefault: true;
2430
+ isPrimaryKey: false;
2431
+ isAutoincrement: false;
2432
+ hasRuntimeDefault: false;
2433
+ enumValues: undefined;
2434
+ baseColumn: never;
2435
+ identity: undefined;
2436
+ generated: undefined;
2437
+ }, {}, {}>;
2438
+ };
2439
+ dialect: "pg";
2440
+ }>;
2441
+ //# sourceMappingURL=content-schema.d.ts.map