@voyantjs/distribution 0.1.0

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