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