@voyantjs/markets 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 (18) hide show
  1. package/LICENSE +109 -0
  2. package/README.md +34 -0
  3. package/dist/index.d.ts +11 -0
  4. package/dist/index.d.ts.map +1 -0
  5. package/dist/index.js +12 -0
  6. package/dist/routes.d.ts +1182 -0
  7. package/dist/routes.d.ts.map +1 -0
  8. package/dist/routes.js +208 -0
  9. package/dist/schema.d.ts +1527 -0
  10. package/dist/schema.d.ts.map +1 -0
  11. package/dist/schema.js +231 -0
  12. package/dist/service.d.ts +459 -0
  13. package/dist/service.d.ts.map +1 -0
  14. package/dist/service.js +403 -0
  15. package/dist/validation.d.ts +451 -0
  16. package/dist/validation.d.ts.map +1 -0
  17. package/dist/validation.js +160 -0
  18. package/package.json +51 -0
package/dist/schema.d.ts ADDED
@@ -0,0 +1,1527 @@
1
+ export declare const marketStatusEnum: import("drizzle-orm/pg-core").PgEnum<["active", "inactive", "archived"]>;
2
+ export declare const marketVisibilityEnum: import("drizzle-orm/pg-core").PgEnum<["public", "private", "hidden"]>;
3
+ export declare const marketSellabilityEnum: import("drizzle-orm/pg-core").PgEnum<["sellable", "on_request", "unavailable"]>;
4
+ export declare const marketChannelScopeEnum: import("drizzle-orm/pg-core").PgEnum<["all", "b2c", "b2b", "internal"]>;
5
+ export declare const fxRateSourceEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "ecb", "custom", "channel", "supplier", "other"]>;
6
+ export declare const markets: import("drizzle-orm/pg-core").PgTableWithColumns<{
7
+ name: "markets";
8
+ schema: undefined;
9
+ columns: {
10
+ id: import("drizzle-orm/pg-core").PgColumn<{
11
+ name: string;
12
+ tableName: "markets";
13
+ dataType: "string";
14
+ columnType: "PgText";
15
+ data: string;
16
+ driverParam: string;
17
+ notNull: true;
18
+ hasDefault: true;
19
+ isPrimaryKey: true;
20
+ isAutoincrement: false;
21
+ hasRuntimeDefault: true;
22
+ enumValues: [string, ...string[]];
23
+ baseColumn: never;
24
+ identity: undefined;
25
+ generated: undefined;
26
+ }, {}, {}>;
27
+ code: import("drizzle-orm/pg-core").PgColumn<{
28
+ name: "code";
29
+ tableName: "markets";
30
+ dataType: "string";
31
+ columnType: "PgText";
32
+ data: string;
33
+ driverParam: string;
34
+ notNull: true;
35
+ hasDefault: false;
36
+ isPrimaryKey: false;
37
+ isAutoincrement: false;
38
+ hasRuntimeDefault: false;
39
+ enumValues: [string, ...string[]];
40
+ baseColumn: never;
41
+ identity: undefined;
42
+ generated: undefined;
43
+ }, {}, {}>;
44
+ name: import("drizzle-orm/pg-core").PgColumn<{
45
+ name: "name";
46
+ tableName: "markets";
47
+ dataType: "string";
48
+ columnType: "PgText";
49
+ data: string;
50
+ driverParam: string;
51
+ notNull: true;
52
+ hasDefault: false;
53
+ isPrimaryKey: false;
54
+ isAutoincrement: false;
55
+ hasRuntimeDefault: false;
56
+ enumValues: [string, ...string[]];
57
+ baseColumn: never;
58
+ identity: undefined;
59
+ generated: undefined;
60
+ }, {}, {}>;
61
+ status: import("drizzle-orm/pg-core").PgColumn<{
62
+ name: "status";
63
+ tableName: "markets";
64
+ dataType: "string";
65
+ columnType: "PgEnumColumn";
66
+ data: "active" | "inactive" | "archived";
67
+ driverParam: string;
68
+ notNull: true;
69
+ hasDefault: true;
70
+ isPrimaryKey: false;
71
+ isAutoincrement: false;
72
+ hasRuntimeDefault: false;
73
+ enumValues: ["active", "inactive", "archived"];
74
+ baseColumn: never;
75
+ identity: undefined;
76
+ generated: undefined;
77
+ }, {}, {}>;
78
+ regionCode: import("drizzle-orm/pg-core").PgColumn<{
79
+ name: "region_code";
80
+ tableName: "markets";
81
+ dataType: "string";
82
+ columnType: "PgText";
83
+ data: string;
84
+ driverParam: string;
85
+ notNull: false;
86
+ hasDefault: false;
87
+ isPrimaryKey: false;
88
+ isAutoincrement: false;
89
+ hasRuntimeDefault: false;
90
+ enumValues: [string, ...string[]];
91
+ baseColumn: never;
92
+ identity: undefined;
93
+ generated: undefined;
94
+ }, {}, {}>;
95
+ countryCode: import("drizzle-orm/pg-core").PgColumn<{
96
+ name: "country_code";
97
+ tableName: "markets";
98
+ dataType: "string";
99
+ columnType: "PgText";
100
+ data: string;
101
+ driverParam: string;
102
+ notNull: false;
103
+ hasDefault: false;
104
+ isPrimaryKey: false;
105
+ isAutoincrement: false;
106
+ hasRuntimeDefault: false;
107
+ enumValues: [string, ...string[]];
108
+ baseColumn: never;
109
+ identity: undefined;
110
+ generated: undefined;
111
+ }, {}, {}>;
112
+ defaultLanguageTag: import("drizzle-orm/pg-core").PgColumn<{
113
+ name: "default_language_tag";
114
+ tableName: "markets";
115
+ dataType: "string";
116
+ columnType: "PgText";
117
+ data: string;
118
+ driverParam: string;
119
+ notNull: true;
120
+ hasDefault: false;
121
+ isPrimaryKey: false;
122
+ isAutoincrement: false;
123
+ hasRuntimeDefault: false;
124
+ enumValues: [string, ...string[]];
125
+ baseColumn: never;
126
+ identity: undefined;
127
+ generated: undefined;
128
+ }, {}, {}>;
129
+ defaultCurrency: import("drizzle-orm/pg-core").PgColumn<{
130
+ name: "default_currency";
131
+ tableName: "markets";
132
+ dataType: "string";
133
+ columnType: "PgText";
134
+ data: string;
135
+ driverParam: string;
136
+ notNull: true;
137
+ hasDefault: false;
138
+ isPrimaryKey: false;
139
+ isAutoincrement: false;
140
+ hasRuntimeDefault: false;
141
+ enumValues: [string, ...string[]];
142
+ baseColumn: never;
143
+ identity: undefined;
144
+ generated: undefined;
145
+ }, {}, {}>;
146
+ timezone: import("drizzle-orm/pg-core").PgColumn<{
147
+ name: "timezone";
148
+ tableName: "markets";
149
+ dataType: "string";
150
+ columnType: "PgText";
151
+ data: string;
152
+ driverParam: string;
153
+ notNull: false;
154
+ hasDefault: false;
155
+ isPrimaryKey: false;
156
+ isAutoincrement: false;
157
+ hasRuntimeDefault: false;
158
+ enumValues: [string, ...string[]];
159
+ baseColumn: never;
160
+ identity: undefined;
161
+ generated: undefined;
162
+ }, {}, {}>;
163
+ taxContext: import("drizzle-orm/pg-core").PgColumn<{
164
+ name: "tax_context";
165
+ tableName: "markets";
166
+ dataType: "string";
167
+ columnType: "PgText";
168
+ data: string;
169
+ driverParam: string;
170
+ notNull: false;
171
+ hasDefault: false;
172
+ isPrimaryKey: false;
173
+ isAutoincrement: false;
174
+ hasRuntimeDefault: false;
175
+ enumValues: [string, ...string[]];
176
+ baseColumn: never;
177
+ identity: undefined;
178
+ generated: undefined;
179
+ }, {}, {}>;
180
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
181
+ name: "metadata";
182
+ tableName: "markets";
183
+ dataType: "json";
184
+ columnType: "PgJsonb";
185
+ data: Record<string, unknown>;
186
+ driverParam: unknown;
187
+ notNull: false;
188
+ hasDefault: false;
189
+ isPrimaryKey: false;
190
+ isAutoincrement: false;
191
+ hasRuntimeDefault: false;
192
+ enumValues: undefined;
193
+ baseColumn: never;
194
+ identity: undefined;
195
+ generated: undefined;
196
+ }, {}, {
197
+ $type: Record<string, unknown>;
198
+ }>;
199
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
200
+ name: "created_at";
201
+ tableName: "markets";
202
+ dataType: "date";
203
+ columnType: "PgTimestamp";
204
+ data: Date;
205
+ driverParam: string;
206
+ notNull: true;
207
+ hasDefault: true;
208
+ isPrimaryKey: false;
209
+ isAutoincrement: false;
210
+ hasRuntimeDefault: false;
211
+ enumValues: undefined;
212
+ baseColumn: never;
213
+ identity: undefined;
214
+ generated: undefined;
215
+ }, {}, {}>;
216
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
217
+ name: "updated_at";
218
+ tableName: "markets";
219
+ dataType: "date";
220
+ columnType: "PgTimestamp";
221
+ data: Date;
222
+ driverParam: string;
223
+ notNull: true;
224
+ hasDefault: true;
225
+ isPrimaryKey: false;
226
+ isAutoincrement: false;
227
+ hasRuntimeDefault: false;
228
+ enumValues: undefined;
229
+ baseColumn: never;
230
+ identity: undefined;
231
+ generated: undefined;
232
+ }, {}, {}>;
233
+ };
234
+ dialect: "pg";
235
+ }>;
236
+ export declare const marketLocales: import("drizzle-orm/pg-core").PgTableWithColumns<{
237
+ name: "market_locales";
238
+ schema: undefined;
239
+ columns: {
240
+ id: import("drizzle-orm/pg-core").PgColumn<{
241
+ name: string;
242
+ tableName: "market_locales";
243
+ dataType: "string";
244
+ columnType: "PgText";
245
+ data: string;
246
+ driverParam: string;
247
+ notNull: true;
248
+ hasDefault: true;
249
+ isPrimaryKey: true;
250
+ isAutoincrement: false;
251
+ hasRuntimeDefault: true;
252
+ enumValues: [string, ...string[]];
253
+ baseColumn: never;
254
+ identity: undefined;
255
+ generated: undefined;
256
+ }, {}, {}>;
257
+ marketId: import("drizzle-orm/pg-core").PgColumn<{
258
+ name: string;
259
+ tableName: "market_locales";
260
+ dataType: "string";
261
+ columnType: "PgText";
262
+ data: string;
263
+ driverParam: string;
264
+ notNull: true;
265
+ hasDefault: false;
266
+ isPrimaryKey: false;
267
+ isAutoincrement: false;
268
+ hasRuntimeDefault: false;
269
+ enumValues: [string, ...string[]];
270
+ baseColumn: never;
271
+ identity: undefined;
272
+ generated: undefined;
273
+ }, {}, {}>;
274
+ languageTag: import("drizzle-orm/pg-core").PgColumn<{
275
+ name: "language_tag";
276
+ tableName: "market_locales";
277
+ dataType: "string";
278
+ columnType: "PgText";
279
+ data: string;
280
+ driverParam: string;
281
+ notNull: true;
282
+ hasDefault: false;
283
+ isPrimaryKey: false;
284
+ isAutoincrement: false;
285
+ hasRuntimeDefault: false;
286
+ enumValues: [string, ...string[]];
287
+ baseColumn: never;
288
+ identity: undefined;
289
+ generated: undefined;
290
+ }, {}, {}>;
291
+ isDefault: import("drizzle-orm/pg-core").PgColumn<{
292
+ name: "is_default";
293
+ tableName: "market_locales";
294
+ dataType: "boolean";
295
+ columnType: "PgBoolean";
296
+ data: boolean;
297
+ driverParam: boolean;
298
+ notNull: true;
299
+ hasDefault: true;
300
+ isPrimaryKey: false;
301
+ isAutoincrement: false;
302
+ hasRuntimeDefault: false;
303
+ enumValues: undefined;
304
+ baseColumn: never;
305
+ identity: undefined;
306
+ generated: undefined;
307
+ }, {}, {}>;
308
+ sortOrder: import("drizzle-orm/pg-core").PgColumn<{
309
+ name: "sort_order";
310
+ tableName: "market_locales";
311
+ dataType: "number";
312
+ columnType: "PgInteger";
313
+ data: number;
314
+ driverParam: string | number;
315
+ notNull: true;
316
+ hasDefault: true;
317
+ isPrimaryKey: false;
318
+ isAutoincrement: false;
319
+ hasRuntimeDefault: false;
320
+ enumValues: undefined;
321
+ baseColumn: never;
322
+ identity: undefined;
323
+ generated: undefined;
324
+ }, {}, {}>;
325
+ active: import("drizzle-orm/pg-core").PgColumn<{
326
+ name: "active";
327
+ tableName: "market_locales";
328
+ dataType: "boolean";
329
+ columnType: "PgBoolean";
330
+ data: boolean;
331
+ driverParam: boolean;
332
+ notNull: true;
333
+ hasDefault: true;
334
+ isPrimaryKey: false;
335
+ isAutoincrement: false;
336
+ hasRuntimeDefault: false;
337
+ enumValues: undefined;
338
+ baseColumn: never;
339
+ identity: undefined;
340
+ generated: undefined;
341
+ }, {}, {}>;
342
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
343
+ name: "created_at";
344
+ tableName: "market_locales";
345
+ dataType: "date";
346
+ columnType: "PgTimestamp";
347
+ data: Date;
348
+ driverParam: string;
349
+ notNull: true;
350
+ hasDefault: true;
351
+ isPrimaryKey: false;
352
+ isAutoincrement: false;
353
+ hasRuntimeDefault: false;
354
+ enumValues: undefined;
355
+ baseColumn: never;
356
+ identity: undefined;
357
+ generated: undefined;
358
+ }, {}, {}>;
359
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
360
+ name: "updated_at";
361
+ tableName: "market_locales";
362
+ dataType: "date";
363
+ columnType: "PgTimestamp";
364
+ data: Date;
365
+ driverParam: string;
366
+ notNull: true;
367
+ hasDefault: true;
368
+ isPrimaryKey: false;
369
+ isAutoincrement: false;
370
+ hasRuntimeDefault: false;
371
+ enumValues: undefined;
372
+ baseColumn: never;
373
+ identity: undefined;
374
+ generated: undefined;
375
+ }, {}, {}>;
376
+ };
377
+ dialect: "pg";
378
+ }>;
379
+ export declare const marketCurrencies: import("drizzle-orm/pg-core").PgTableWithColumns<{
380
+ name: "market_currencies";
381
+ schema: undefined;
382
+ columns: {
383
+ id: import("drizzle-orm/pg-core").PgColumn<{
384
+ name: string;
385
+ tableName: "market_currencies";
386
+ dataType: "string";
387
+ columnType: "PgText";
388
+ data: string;
389
+ driverParam: string;
390
+ notNull: true;
391
+ hasDefault: true;
392
+ isPrimaryKey: true;
393
+ isAutoincrement: false;
394
+ hasRuntimeDefault: true;
395
+ enumValues: [string, ...string[]];
396
+ baseColumn: never;
397
+ identity: undefined;
398
+ generated: undefined;
399
+ }, {}, {}>;
400
+ marketId: import("drizzle-orm/pg-core").PgColumn<{
401
+ name: string;
402
+ tableName: "market_currencies";
403
+ dataType: "string";
404
+ columnType: "PgText";
405
+ data: string;
406
+ driverParam: string;
407
+ notNull: true;
408
+ hasDefault: false;
409
+ isPrimaryKey: false;
410
+ isAutoincrement: false;
411
+ hasRuntimeDefault: false;
412
+ enumValues: [string, ...string[]];
413
+ baseColumn: never;
414
+ identity: undefined;
415
+ generated: undefined;
416
+ }, {}, {}>;
417
+ currencyCode: import("drizzle-orm/pg-core").PgColumn<{
418
+ name: "currency_code";
419
+ tableName: "market_currencies";
420
+ dataType: "string";
421
+ columnType: "PgText";
422
+ data: string;
423
+ driverParam: string;
424
+ notNull: true;
425
+ hasDefault: false;
426
+ isPrimaryKey: false;
427
+ isAutoincrement: false;
428
+ hasRuntimeDefault: false;
429
+ enumValues: [string, ...string[]];
430
+ baseColumn: never;
431
+ identity: undefined;
432
+ generated: undefined;
433
+ }, {}, {}>;
434
+ isDefault: import("drizzle-orm/pg-core").PgColumn<{
435
+ name: "is_default";
436
+ tableName: "market_currencies";
437
+ dataType: "boolean";
438
+ columnType: "PgBoolean";
439
+ data: boolean;
440
+ driverParam: boolean;
441
+ notNull: true;
442
+ hasDefault: true;
443
+ isPrimaryKey: false;
444
+ isAutoincrement: false;
445
+ hasRuntimeDefault: false;
446
+ enumValues: undefined;
447
+ baseColumn: never;
448
+ identity: undefined;
449
+ generated: undefined;
450
+ }, {}, {}>;
451
+ isSettlement: import("drizzle-orm/pg-core").PgColumn<{
452
+ name: "is_settlement";
453
+ tableName: "market_currencies";
454
+ dataType: "boolean";
455
+ columnType: "PgBoolean";
456
+ data: boolean;
457
+ driverParam: boolean;
458
+ notNull: true;
459
+ hasDefault: true;
460
+ isPrimaryKey: false;
461
+ isAutoincrement: false;
462
+ hasRuntimeDefault: false;
463
+ enumValues: undefined;
464
+ baseColumn: never;
465
+ identity: undefined;
466
+ generated: undefined;
467
+ }, {}, {}>;
468
+ isReporting: import("drizzle-orm/pg-core").PgColumn<{
469
+ name: "is_reporting";
470
+ tableName: "market_currencies";
471
+ dataType: "boolean";
472
+ columnType: "PgBoolean";
473
+ data: boolean;
474
+ driverParam: boolean;
475
+ notNull: true;
476
+ hasDefault: true;
477
+ isPrimaryKey: false;
478
+ isAutoincrement: false;
479
+ hasRuntimeDefault: false;
480
+ enumValues: undefined;
481
+ baseColumn: never;
482
+ identity: undefined;
483
+ generated: undefined;
484
+ }, {}, {}>;
485
+ sortOrder: import("drizzle-orm/pg-core").PgColumn<{
486
+ name: "sort_order";
487
+ tableName: "market_currencies";
488
+ dataType: "number";
489
+ columnType: "PgInteger";
490
+ data: number;
491
+ driverParam: string | number;
492
+ notNull: true;
493
+ hasDefault: true;
494
+ isPrimaryKey: false;
495
+ isAutoincrement: false;
496
+ hasRuntimeDefault: false;
497
+ enumValues: undefined;
498
+ baseColumn: never;
499
+ identity: undefined;
500
+ generated: undefined;
501
+ }, {}, {}>;
502
+ active: import("drizzle-orm/pg-core").PgColumn<{
503
+ name: "active";
504
+ tableName: "market_currencies";
505
+ dataType: "boolean";
506
+ columnType: "PgBoolean";
507
+ data: boolean;
508
+ driverParam: boolean;
509
+ notNull: true;
510
+ hasDefault: true;
511
+ isPrimaryKey: false;
512
+ isAutoincrement: false;
513
+ hasRuntimeDefault: false;
514
+ enumValues: undefined;
515
+ baseColumn: never;
516
+ identity: undefined;
517
+ generated: undefined;
518
+ }, {}, {}>;
519
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
520
+ name: "created_at";
521
+ tableName: "market_currencies";
522
+ dataType: "date";
523
+ columnType: "PgTimestamp";
524
+ data: Date;
525
+ driverParam: string;
526
+ notNull: true;
527
+ hasDefault: true;
528
+ isPrimaryKey: false;
529
+ isAutoincrement: false;
530
+ hasRuntimeDefault: false;
531
+ enumValues: undefined;
532
+ baseColumn: never;
533
+ identity: undefined;
534
+ generated: undefined;
535
+ }, {}, {}>;
536
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
537
+ name: "updated_at";
538
+ tableName: "market_currencies";
539
+ dataType: "date";
540
+ columnType: "PgTimestamp";
541
+ data: Date;
542
+ driverParam: string;
543
+ notNull: true;
544
+ hasDefault: true;
545
+ isPrimaryKey: false;
546
+ isAutoincrement: false;
547
+ hasRuntimeDefault: false;
548
+ enumValues: undefined;
549
+ baseColumn: never;
550
+ identity: undefined;
551
+ generated: undefined;
552
+ }, {}, {}>;
553
+ };
554
+ dialect: "pg";
555
+ }>;
556
+ export declare const fxRateSets: import("drizzle-orm/pg-core").PgTableWithColumns<{
557
+ name: "fx_rate_sets";
558
+ schema: undefined;
559
+ columns: {
560
+ id: import("drizzle-orm/pg-core").PgColumn<{
561
+ name: string;
562
+ tableName: "fx_rate_sets";
563
+ dataType: "string";
564
+ columnType: "PgText";
565
+ data: string;
566
+ driverParam: string;
567
+ notNull: true;
568
+ hasDefault: true;
569
+ isPrimaryKey: true;
570
+ isAutoincrement: false;
571
+ hasRuntimeDefault: true;
572
+ enumValues: [string, ...string[]];
573
+ baseColumn: never;
574
+ identity: undefined;
575
+ generated: undefined;
576
+ }, {}, {}>;
577
+ source: import("drizzle-orm/pg-core").PgColumn<{
578
+ name: "source";
579
+ tableName: "fx_rate_sets";
580
+ dataType: "string";
581
+ columnType: "PgEnumColumn";
582
+ data: "supplier" | "manual" | "ecb" | "custom" | "channel" | "other";
583
+ driverParam: string;
584
+ notNull: true;
585
+ hasDefault: true;
586
+ isPrimaryKey: false;
587
+ isAutoincrement: false;
588
+ hasRuntimeDefault: false;
589
+ enumValues: ["manual", "ecb", "custom", "channel", "supplier", "other"];
590
+ baseColumn: never;
591
+ identity: undefined;
592
+ generated: undefined;
593
+ }, {}, {}>;
594
+ baseCurrency: import("drizzle-orm/pg-core").PgColumn<{
595
+ name: "base_currency";
596
+ tableName: "fx_rate_sets";
597
+ dataType: "string";
598
+ columnType: "PgText";
599
+ data: string;
600
+ driverParam: string;
601
+ notNull: true;
602
+ hasDefault: false;
603
+ isPrimaryKey: false;
604
+ isAutoincrement: false;
605
+ hasRuntimeDefault: false;
606
+ enumValues: [string, ...string[]];
607
+ baseColumn: never;
608
+ identity: undefined;
609
+ generated: undefined;
610
+ }, {}, {}>;
611
+ effectiveAt: import("drizzle-orm/pg-core").PgColumn<{
612
+ name: "effective_at";
613
+ tableName: "fx_rate_sets";
614
+ dataType: "date";
615
+ columnType: "PgTimestamp";
616
+ data: Date;
617
+ driverParam: string;
618
+ notNull: true;
619
+ hasDefault: false;
620
+ isPrimaryKey: false;
621
+ isAutoincrement: false;
622
+ hasRuntimeDefault: false;
623
+ enumValues: undefined;
624
+ baseColumn: never;
625
+ identity: undefined;
626
+ generated: undefined;
627
+ }, {}, {}>;
628
+ observedAt: import("drizzle-orm/pg-core").PgColumn<{
629
+ name: "observed_at";
630
+ tableName: "fx_rate_sets";
631
+ dataType: "date";
632
+ columnType: "PgTimestamp";
633
+ data: Date;
634
+ driverParam: string;
635
+ notNull: false;
636
+ hasDefault: false;
637
+ isPrimaryKey: false;
638
+ isAutoincrement: false;
639
+ hasRuntimeDefault: false;
640
+ enumValues: undefined;
641
+ baseColumn: never;
642
+ identity: undefined;
643
+ generated: undefined;
644
+ }, {}, {}>;
645
+ sourceReference: import("drizzle-orm/pg-core").PgColumn<{
646
+ name: "source_reference";
647
+ tableName: "fx_rate_sets";
648
+ dataType: "string";
649
+ columnType: "PgText";
650
+ data: string;
651
+ driverParam: string;
652
+ notNull: false;
653
+ hasDefault: false;
654
+ isPrimaryKey: false;
655
+ isAutoincrement: false;
656
+ hasRuntimeDefault: false;
657
+ enumValues: [string, ...string[]];
658
+ baseColumn: never;
659
+ identity: undefined;
660
+ generated: undefined;
661
+ }, {}, {}>;
662
+ notes: import("drizzle-orm/pg-core").PgColumn<{
663
+ name: "notes";
664
+ tableName: "fx_rate_sets";
665
+ dataType: "string";
666
+ columnType: "PgText";
667
+ data: string;
668
+ driverParam: string;
669
+ notNull: false;
670
+ hasDefault: false;
671
+ isPrimaryKey: false;
672
+ isAutoincrement: false;
673
+ hasRuntimeDefault: false;
674
+ enumValues: [string, ...string[]];
675
+ baseColumn: never;
676
+ identity: undefined;
677
+ generated: undefined;
678
+ }, {}, {}>;
679
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
680
+ name: "metadata";
681
+ tableName: "fx_rate_sets";
682
+ dataType: "json";
683
+ columnType: "PgJsonb";
684
+ data: Record<string, unknown>;
685
+ driverParam: unknown;
686
+ notNull: false;
687
+ hasDefault: false;
688
+ isPrimaryKey: false;
689
+ isAutoincrement: false;
690
+ hasRuntimeDefault: false;
691
+ enumValues: undefined;
692
+ baseColumn: never;
693
+ identity: undefined;
694
+ generated: undefined;
695
+ }, {}, {
696
+ $type: Record<string, unknown>;
697
+ }>;
698
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
699
+ name: "created_at";
700
+ tableName: "fx_rate_sets";
701
+ dataType: "date";
702
+ columnType: "PgTimestamp";
703
+ data: Date;
704
+ driverParam: string;
705
+ notNull: true;
706
+ hasDefault: true;
707
+ isPrimaryKey: false;
708
+ isAutoincrement: false;
709
+ hasRuntimeDefault: false;
710
+ enumValues: undefined;
711
+ baseColumn: never;
712
+ identity: undefined;
713
+ generated: undefined;
714
+ }, {}, {}>;
715
+ };
716
+ dialect: "pg";
717
+ }>;
718
+ export declare const exchangeRates: import("drizzle-orm/pg-core").PgTableWithColumns<{
719
+ name: "exchange_rates";
720
+ schema: undefined;
721
+ columns: {
722
+ id: import("drizzle-orm/pg-core").PgColumn<{
723
+ name: string;
724
+ tableName: "exchange_rates";
725
+ dataType: "string";
726
+ columnType: "PgText";
727
+ data: string;
728
+ driverParam: string;
729
+ notNull: true;
730
+ hasDefault: true;
731
+ isPrimaryKey: true;
732
+ isAutoincrement: false;
733
+ hasRuntimeDefault: true;
734
+ enumValues: [string, ...string[]];
735
+ baseColumn: never;
736
+ identity: undefined;
737
+ generated: undefined;
738
+ }, {}, {}>;
739
+ fxRateSetId: import("drizzle-orm/pg-core").PgColumn<{
740
+ name: string;
741
+ tableName: "exchange_rates";
742
+ dataType: "string";
743
+ columnType: "PgText";
744
+ data: string;
745
+ driverParam: string;
746
+ notNull: true;
747
+ hasDefault: false;
748
+ isPrimaryKey: false;
749
+ isAutoincrement: false;
750
+ hasRuntimeDefault: false;
751
+ enumValues: [string, ...string[]];
752
+ baseColumn: never;
753
+ identity: undefined;
754
+ generated: undefined;
755
+ }, {}, {}>;
756
+ baseCurrency: import("drizzle-orm/pg-core").PgColumn<{
757
+ name: "base_currency";
758
+ tableName: "exchange_rates";
759
+ dataType: "string";
760
+ columnType: "PgText";
761
+ data: string;
762
+ driverParam: string;
763
+ notNull: true;
764
+ hasDefault: false;
765
+ isPrimaryKey: false;
766
+ isAutoincrement: false;
767
+ hasRuntimeDefault: false;
768
+ enumValues: [string, ...string[]];
769
+ baseColumn: never;
770
+ identity: undefined;
771
+ generated: undefined;
772
+ }, {}, {}>;
773
+ quoteCurrency: import("drizzle-orm/pg-core").PgColumn<{
774
+ name: "quote_currency";
775
+ tableName: "exchange_rates";
776
+ dataType: "string";
777
+ columnType: "PgText";
778
+ data: string;
779
+ driverParam: string;
780
+ notNull: true;
781
+ hasDefault: false;
782
+ isPrimaryKey: false;
783
+ isAutoincrement: false;
784
+ hasRuntimeDefault: false;
785
+ enumValues: [string, ...string[]];
786
+ baseColumn: never;
787
+ identity: undefined;
788
+ generated: undefined;
789
+ }, {}, {}>;
790
+ rateDecimal: import("drizzle-orm/pg-core").PgColumn<{
791
+ name: "rate_decimal";
792
+ tableName: "exchange_rates";
793
+ dataType: "string";
794
+ columnType: "PgNumeric";
795
+ data: string;
796
+ driverParam: string;
797
+ notNull: true;
798
+ hasDefault: false;
799
+ isPrimaryKey: false;
800
+ isAutoincrement: false;
801
+ hasRuntimeDefault: false;
802
+ enumValues: undefined;
803
+ baseColumn: never;
804
+ identity: undefined;
805
+ generated: undefined;
806
+ }, {}, {}>;
807
+ inverseRateDecimal: import("drizzle-orm/pg-core").PgColumn<{
808
+ name: "inverse_rate_decimal";
809
+ tableName: "exchange_rates";
810
+ dataType: "string";
811
+ columnType: "PgNumeric";
812
+ data: string;
813
+ driverParam: string;
814
+ notNull: false;
815
+ hasDefault: false;
816
+ isPrimaryKey: false;
817
+ isAutoincrement: false;
818
+ hasRuntimeDefault: false;
819
+ enumValues: undefined;
820
+ baseColumn: never;
821
+ identity: undefined;
822
+ generated: undefined;
823
+ }, {}, {}>;
824
+ observedAt: import("drizzle-orm/pg-core").PgColumn<{
825
+ name: "observed_at";
826
+ tableName: "exchange_rates";
827
+ dataType: "date";
828
+ columnType: "PgTimestamp";
829
+ data: Date;
830
+ driverParam: string;
831
+ notNull: false;
832
+ hasDefault: false;
833
+ isPrimaryKey: false;
834
+ isAutoincrement: false;
835
+ hasRuntimeDefault: false;
836
+ enumValues: undefined;
837
+ baseColumn: never;
838
+ identity: undefined;
839
+ generated: undefined;
840
+ }, {}, {}>;
841
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
842
+ name: "created_at";
843
+ tableName: "exchange_rates";
844
+ dataType: "date";
845
+ columnType: "PgTimestamp";
846
+ data: Date;
847
+ driverParam: string;
848
+ notNull: true;
849
+ hasDefault: true;
850
+ isPrimaryKey: false;
851
+ isAutoincrement: false;
852
+ hasRuntimeDefault: false;
853
+ enumValues: undefined;
854
+ baseColumn: never;
855
+ identity: undefined;
856
+ generated: undefined;
857
+ }, {}, {}>;
858
+ };
859
+ dialect: "pg";
860
+ }>;
861
+ export declare const marketPriceCatalogs: import("drizzle-orm/pg-core").PgTableWithColumns<{
862
+ name: "market_price_catalogs";
863
+ schema: undefined;
864
+ columns: {
865
+ id: import("drizzle-orm/pg-core").PgColumn<{
866
+ name: string;
867
+ tableName: "market_price_catalogs";
868
+ dataType: "string";
869
+ columnType: "PgText";
870
+ data: string;
871
+ driverParam: string;
872
+ notNull: true;
873
+ hasDefault: true;
874
+ isPrimaryKey: true;
875
+ isAutoincrement: false;
876
+ hasRuntimeDefault: true;
877
+ enumValues: [string, ...string[]];
878
+ baseColumn: never;
879
+ identity: undefined;
880
+ generated: undefined;
881
+ }, {}, {}>;
882
+ marketId: import("drizzle-orm/pg-core").PgColumn<{
883
+ name: string;
884
+ tableName: "market_price_catalogs";
885
+ dataType: "string";
886
+ columnType: "PgText";
887
+ data: string;
888
+ driverParam: string;
889
+ notNull: true;
890
+ hasDefault: false;
891
+ isPrimaryKey: false;
892
+ isAutoincrement: false;
893
+ hasRuntimeDefault: false;
894
+ enumValues: [string, ...string[]];
895
+ baseColumn: never;
896
+ identity: undefined;
897
+ generated: undefined;
898
+ }, {}, {}>;
899
+ priceCatalogId: import("drizzle-orm/pg-core").PgColumn<{
900
+ name: string;
901
+ tableName: "market_price_catalogs";
902
+ dataType: "string";
903
+ columnType: "PgText";
904
+ data: string;
905
+ driverParam: string;
906
+ notNull: true;
907
+ hasDefault: false;
908
+ isPrimaryKey: false;
909
+ isAutoincrement: false;
910
+ hasRuntimeDefault: false;
911
+ enumValues: [string, ...string[]];
912
+ baseColumn: never;
913
+ identity: undefined;
914
+ generated: undefined;
915
+ }, {}, {}>;
916
+ isDefault: import("drizzle-orm/pg-core").PgColumn<{
917
+ name: "is_default";
918
+ tableName: "market_price_catalogs";
919
+ dataType: "boolean";
920
+ columnType: "PgBoolean";
921
+ data: boolean;
922
+ driverParam: boolean;
923
+ notNull: true;
924
+ hasDefault: true;
925
+ isPrimaryKey: false;
926
+ isAutoincrement: false;
927
+ hasRuntimeDefault: false;
928
+ enumValues: undefined;
929
+ baseColumn: never;
930
+ identity: undefined;
931
+ generated: undefined;
932
+ }, {}, {}>;
933
+ priority: import("drizzle-orm/pg-core").PgColumn<{
934
+ name: "priority";
935
+ tableName: "market_price_catalogs";
936
+ dataType: "number";
937
+ columnType: "PgInteger";
938
+ data: number;
939
+ driverParam: string | number;
940
+ notNull: true;
941
+ hasDefault: true;
942
+ isPrimaryKey: false;
943
+ isAutoincrement: false;
944
+ hasRuntimeDefault: false;
945
+ enumValues: undefined;
946
+ baseColumn: never;
947
+ identity: undefined;
948
+ generated: undefined;
949
+ }, {}, {}>;
950
+ active: import("drizzle-orm/pg-core").PgColumn<{
951
+ name: "active";
952
+ tableName: "market_price_catalogs";
953
+ dataType: "boolean";
954
+ columnType: "PgBoolean";
955
+ data: boolean;
956
+ driverParam: boolean;
957
+ notNull: true;
958
+ hasDefault: true;
959
+ isPrimaryKey: false;
960
+ isAutoincrement: false;
961
+ hasRuntimeDefault: false;
962
+ enumValues: undefined;
963
+ baseColumn: never;
964
+ identity: undefined;
965
+ generated: undefined;
966
+ }, {}, {}>;
967
+ notes: import("drizzle-orm/pg-core").PgColumn<{
968
+ name: "notes";
969
+ tableName: "market_price_catalogs";
970
+ dataType: "string";
971
+ columnType: "PgText";
972
+ data: string;
973
+ driverParam: string;
974
+ notNull: false;
975
+ hasDefault: false;
976
+ isPrimaryKey: false;
977
+ isAutoincrement: false;
978
+ hasRuntimeDefault: false;
979
+ enumValues: [string, ...string[]];
980
+ baseColumn: never;
981
+ identity: undefined;
982
+ generated: undefined;
983
+ }, {}, {}>;
984
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
985
+ name: "metadata";
986
+ tableName: "market_price_catalogs";
987
+ dataType: "json";
988
+ columnType: "PgJsonb";
989
+ data: Record<string, unknown>;
990
+ driverParam: unknown;
991
+ notNull: false;
992
+ hasDefault: false;
993
+ isPrimaryKey: false;
994
+ isAutoincrement: false;
995
+ hasRuntimeDefault: false;
996
+ enumValues: undefined;
997
+ baseColumn: never;
998
+ identity: undefined;
999
+ generated: undefined;
1000
+ }, {}, {
1001
+ $type: Record<string, unknown>;
1002
+ }>;
1003
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1004
+ name: "created_at";
1005
+ tableName: "market_price_catalogs";
1006
+ dataType: "date";
1007
+ columnType: "PgTimestamp";
1008
+ data: Date;
1009
+ driverParam: string;
1010
+ notNull: true;
1011
+ hasDefault: true;
1012
+ isPrimaryKey: false;
1013
+ isAutoincrement: false;
1014
+ hasRuntimeDefault: false;
1015
+ enumValues: undefined;
1016
+ baseColumn: never;
1017
+ identity: undefined;
1018
+ generated: undefined;
1019
+ }, {}, {}>;
1020
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1021
+ name: "updated_at";
1022
+ tableName: "market_price_catalogs";
1023
+ dataType: "date";
1024
+ columnType: "PgTimestamp";
1025
+ data: Date;
1026
+ driverParam: string;
1027
+ notNull: true;
1028
+ hasDefault: true;
1029
+ isPrimaryKey: false;
1030
+ isAutoincrement: false;
1031
+ hasRuntimeDefault: false;
1032
+ enumValues: undefined;
1033
+ baseColumn: never;
1034
+ identity: undefined;
1035
+ generated: undefined;
1036
+ }, {}, {}>;
1037
+ };
1038
+ dialect: "pg";
1039
+ }>;
1040
+ export declare const marketProductRules: import("drizzle-orm/pg-core").PgTableWithColumns<{
1041
+ name: "market_product_rules";
1042
+ schema: undefined;
1043
+ columns: {
1044
+ id: import("drizzle-orm/pg-core").PgColumn<{
1045
+ name: string;
1046
+ tableName: "market_product_rules";
1047
+ dataType: "string";
1048
+ columnType: "PgText";
1049
+ data: string;
1050
+ driverParam: string;
1051
+ notNull: true;
1052
+ hasDefault: true;
1053
+ isPrimaryKey: true;
1054
+ isAutoincrement: false;
1055
+ hasRuntimeDefault: true;
1056
+ enumValues: [string, ...string[]];
1057
+ baseColumn: never;
1058
+ identity: undefined;
1059
+ generated: undefined;
1060
+ }, {}, {}>;
1061
+ marketId: import("drizzle-orm/pg-core").PgColumn<{
1062
+ name: string;
1063
+ tableName: "market_product_rules";
1064
+ dataType: "string";
1065
+ columnType: "PgText";
1066
+ data: string;
1067
+ driverParam: string;
1068
+ notNull: true;
1069
+ hasDefault: false;
1070
+ isPrimaryKey: false;
1071
+ isAutoincrement: false;
1072
+ hasRuntimeDefault: false;
1073
+ enumValues: [string, ...string[]];
1074
+ baseColumn: never;
1075
+ identity: undefined;
1076
+ generated: undefined;
1077
+ }, {}, {}>;
1078
+ productId: import("drizzle-orm/pg-core").PgColumn<{
1079
+ name: "product_id";
1080
+ tableName: "market_product_rules";
1081
+ dataType: "string";
1082
+ columnType: "PgText";
1083
+ data: string;
1084
+ driverParam: string;
1085
+ notNull: true;
1086
+ hasDefault: false;
1087
+ isPrimaryKey: false;
1088
+ isAutoincrement: false;
1089
+ hasRuntimeDefault: false;
1090
+ enumValues: [string, ...string[]];
1091
+ baseColumn: never;
1092
+ identity: undefined;
1093
+ generated: undefined;
1094
+ }, {}, {}>;
1095
+ optionId: import("drizzle-orm/pg-core").PgColumn<{
1096
+ name: "option_id";
1097
+ tableName: "market_product_rules";
1098
+ dataType: "string";
1099
+ columnType: "PgText";
1100
+ data: string;
1101
+ driverParam: string;
1102
+ notNull: false;
1103
+ hasDefault: false;
1104
+ isPrimaryKey: false;
1105
+ isAutoincrement: false;
1106
+ hasRuntimeDefault: false;
1107
+ enumValues: [string, ...string[]];
1108
+ baseColumn: never;
1109
+ identity: undefined;
1110
+ generated: undefined;
1111
+ }, {}, {}>;
1112
+ priceCatalogId: import("drizzle-orm/pg-core").PgColumn<{
1113
+ name: string;
1114
+ tableName: "market_product_rules";
1115
+ dataType: "string";
1116
+ columnType: "PgText";
1117
+ data: string;
1118
+ driverParam: string;
1119
+ notNull: false;
1120
+ hasDefault: false;
1121
+ isPrimaryKey: false;
1122
+ isAutoincrement: false;
1123
+ hasRuntimeDefault: false;
1124
+ enumValues: [string, ...string[]];
1125
+ baseColumn: never;
1126
+ identity: undefined;
1127
+ generated: undefined;
1128
+ }, {}, {}>;
1129
+ visibility: import("drizzle-orm/pg-core").PgColumn<{
1130
+ name: "visibility";
1131
+ tableName: "market_product_rules";
1132
+ dataType: "string";
1133
+ columnType: "PgEnumColumn";
1134
+ data: "public" | "private" | "hidden";
1135
+ driverParam: string;
1136
+ notNull: true;
1137
+ hasDefault: true;
1138
+ isPrimaryKey: false;
1139
+ isAutoincrement: false;
1140
+ hasRuntimeDefault: false;
1141
+ enumValues: ["public", "private", "hidden"];
1142
+ baseColumn: never;
1143
+ identity: undefined;
1144
+ generated: undefined;
1145
+ }, {}, {}>;
1146
+ sellability: import("drizzle-orm/pg-core").PgColumn<{
1147
+ name: "sellability";
1148
+ tableName: "market_product_rules";
1149
+ dataType: "string";
1150
+ columnType: "PgEnumColumn";
1151
+ data: "sellable" | "on_request" | "unavailable";
1152
+ driverParam: string;
1153
+ notNull: true;
1154
+ hasDefault: true;
1155
+ isPrimaryKey: false;
1156
+ isAutoincrement: false;
1157
+ hasRuntimeDefault: false;
1158
+ enumValues: ["sellable", "on_request", "unavailable"];
1159
+ baseColumn: never;
1160
+ identity: undefined;
1161
+ generated: undefined;
1162
+ }, {}, {}>;
1163
+ channelScope: import("drizzle-orm/pg-core").PgColumn<{
1164
+ name: "channel_scope";
1165
+ tableName: "market_product_rules";
1166
+ dataType: "string";
1167
+ columnType: "PgEnumColumn";
1168
+ data: "internal" | "all" | "b2c" | "b2b";
1169
+ driverParam: string;
1170
+ notNull: true;
1171
+ hasDefault: true;
1172
+ isPrimaryKey: false;
1173
+ isAutoincrement: false;
1174
+ hasRuntimeDefault: false;
1175
+ enumValues: ["all", "b2c", "b2b", "internal"];
1176
+ baseColumn: never;
1177
+ identity: undefined;
1178
+ generated: undefined;
1179
+ }, {}, {}>;
1180
+ active: import("drizzle-orm/pg-core").PgColumn<{
1181
+ name: "active";
1182
+ tableName: "market_product_rules";
1183
+ dataType: "boolean";
1184
+ columnType: "PgBoolean";
1185
+ data: boolean;
1186
+ driverParam: boolean;
1187
+ notNull: true;
1188
+ hasDefault: true;
1189
+ isPrimaryKey: false;
1190
+ isAutoincrement: false;
1191
+ hasRuntimeDefault: false;
1192
+ enumValues: undefined;
1193
+ baseColumn: never;
1194
+ identity: undefined;
1195
+ generated: undefined;
1196
+ }, {}, {}>;
1197
+ availableFrom: import("drizzle-orm/pg-core").PgColumn<{
1198
+ name: "available_from";
1199
+ tableName: "market_product_rules";
1200
+ dataType: "string";
1201
+ columnType: "PgDateString";
1202
+ data: string;
1203
+ driverParam: string;
1204
+ notNull: false;
1205
+ hasDefault: false;
1206
+ isPrimaryKey: false;
1207
+ isAutoincrement: false;
1208
+ hasRuntimeDefault: false;
1209
+ enumValues: undefined;
1210
+ baseColumn: never;
1211
+ identity: undefined;
1212
+ generated: undefined;
1213
+ }, {}, {}>;
1214
+ availableTo: import("drizzle-orm/pg-core").PgColumn<{
1215
+ name: "available_to";
1216
+ tableName: "market_product_rules";
1217
+ dataType: "string";
1218
+ columnType: "PgDateString";
1219
+ data: string;
1220
+ driverParam: string;
1221
+ notNull: false;
1222
+ hasDefault: false;
1223
+ isPrimaryKey: false;
1224
+ isAutoincrement: false;
1225
+ hasRuntimeDefault: false;
1226
+ enumValues: undefined;
1227
+ baseColumn: never;
1228
+ identity: undefined;
1229
+ generated: undefined;
1230
+ }, {}, {}>;
1231
+ notes: import("drizzle-orm/pg-core").PgColumn<{
1232
+ name: "notes";
1233
+ tableName: "market_product_rules";
1234
+ dataType: "string";
1235
+ columnType: "PgText";
1236
+ data: string;
1237
+ driverParam: string;
1238
+ notNull: false;
1239
+ hasDefault: false;
1240
+ isPrimaryKey: false;
1241
+ isAutoincrement: false;
1242
+ hasRuntimeDefault: false;
1243
+ enumValues: [string, ...string[]];
1244
+ baseColumn: never;
1245
+ identity: undefined;
1246
+ generated: undefined;
1247
+ }, {}, {}>;
1248
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1249
+ name: "created_at";
1250
+ tableName: "market_product_rules";
1251
+ dataType: "date";
1252
+ columnType: "PgTimestamp";
1253
+ data: Date;
1254
+ driverParam: string;
1255
+ notNull: true;
1256
+ hasDefault: true;
1257
+ isPrimaryKey: false;
1258
+ isAutoincrement: false;
1259
+ hasRuntimeDefault: false;
1260
+ enumValues: undefined;
1261
+ baseColumn: never;
1262
+ identity: undefined;
1263
+ generated: undefined;
1264
+ }, {}, {}>;
1265
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1266
+ name: "updated_at";
1267
+ tableName: "market_product_rules";
1268
+ dataType: "date";
1269
+ columnType: "PgTimestamp";
1270
+ data: Date;
1271
+ driverParam: string;
1272
+ notNull: true;
1273
+ hasDefault: true;
1274
+ isPrimaryKey: false;
1275
+ isAutoincrement: false;
1276
+ hasRuntimeDefault: false;
1277
+ enumValues: undefined;
1278
+ baseColumn: never;
1279
+ identity: undefined;
1280
+ generated: undefined;
1281
+ }, {}, {}>;
1282
+ };
1283
+ dialect: "pg";
1284
+ }>;
1285
+ export declare const marketChannelRules: import("drizzle-orm/pg-core").PgTableWithColumns<{
1286
+ name: "market_channel_rules";
1287
+ schema: undefined;
1288
+ columns: {
1289
+ id: import("drizzle-orm/pg-core").PgColumn<{
1290
+ name: string;
1291
+ tableName: "market_channel_rules";
1292
+ dataType: "string";
1293
+ columnType: "PgText";
1294
+ data: string;
1295
+ driverParam: string;
1296
+ notNull: true;
1297
+ hasDefault: true;
1298
+ isPrimaryKey: true;
1299
+ isAutoincrement: false;
1300
+ hasRuntimeDefault: true;
1301
+ enumValues: [string, ...string[]];
1302
+ baseColumn: never;
1303
+ identity: undefined;
1304
+ generated: undefined;
1305
+ }, {}, {}>;
1306
+ marketId: import("drizzle-orm/pg-core").PgColumn<{
1307
+ name: string;
1308
+ tableName: "market_channel_rules";
1309
+ dataType: "string";
1310
+ columnType: "PgText";
1311
+ data: string;
1312
+ driverParam: string;
1313
+ notNull: true;
1314
+ hasDefault: false;
1315
+ isPrimaryKey: false;
1316
+ isAutoincrement: false;
1317
+ hasRuntimeDefault: false;
1318
+ enumValues: [string, ...string[]];
1319
+ baseColumn: never;
1320
+ identity: undefined;
1321
+ generated: undefined;
1322
+ }, {}, {}>;
1323
+ channelId: import("drizzle-orm/pg-core").PgColumn<{
1324
+ name: "channel_id";
1325
+ tableName: "market_channel_rules";
1326
+ dataType: "string";
1327
+ columnType: "PgText";
1328
+ data: string;
1329
+ driverParam: string;
1330
+ notNull: true;
1331
+ hasDefault: false;
1332
+ isPrimaryKey: false;
1333
+ isAutoincrement: false;
1334
+ hasRuntimeDefault: false;
1335
+ enumValues: [string, ...string[]];
1336
+ baseColumn: never;
1337
+ identity: undefined;
1338
+ generated: undefined;
1339
+ }, {}, {}>;
1340
+ priceCatalogId: import("drizzle-orm/pg-core").PgColumn<{
1341
+ name: string;
1342
+ tableName: "market_channel_rules";
1343
+ dataType: "string";
1344
+ columnType: "PgText";
1345
+ data: string;
1346
+ driverParam: string;
1347
+ notNull: false;
1348
+ hasDefault: false;
1349
+ isPrimaryKey: false;
1350
+ isAutoincrement: false;
1351
+ hasRuntimeDefault: false;
1352
+ enumValues: [string, ...string[]];
1353
+ baseColumn: never;
1354
+ identity: undefined;
1355
+ generated: undefined;
1356
+ }, {}, {}>;
1357
+ visibility: import("drizzle-orm/pg-core").PgColumn<{
1358
+ name: "visibility";
1359
+ tableName: "market_channel_rules";
1360
+ dataType: "string";
1361
+ columnType: "PgEnumColumn";
1362
+ data: "public" | "private" | "hidden";
1363
+ driverParam: string;
1364
+ notNull: true;
1365
+ hasDefault: true;
1366
+ isPrimaryKey: false;
1367
+ isAutoincrement: false;
1368
+ hasRuntimeDefault: false;
1369
+ enumValues: ["public", "private", "hidden"];
1370
+ baseColumn: never;
1371
+ identity: undefined;
1372
+ generated: undefined;
1373
+ }, {}, {}>;
1374
+ sellability: import("drizzle-orm/pg-core").PgColumn<{
1375
+ name: "sellability";
1376
+ tableName: "market_channel_rules";
1377
+ dataType: "string";
1378
+ columnType: "PgEnumColumn";
1379
+ data: "sellable" | "on_request" | "unavailable";
1380
+ driverParam: string;
1381
+ notNull: true;
1382
+ hasDefault: true;
1383
+ isPrimaryKey: false;
1384
+ isAutoincrement: false;
1385
+ hasRuntimeDefault: false;
1386
+ enumValues: ["sellable", "on_request", "unavailable"];
1387
+ baseColumn: never;
1388
+ identity: undefined;
1389
+ generated: undefined;
1390
+ }, {}, {}>;
1391
+ active: import("drizzle-orm/pg-core").PgColumn<{
1392
+ name: "active";
1393
+ tableName: "market_channel_rules";
1394
+ dataType: "boolean";
1395
+ columnType: "PgBoolean";
1396
+ data: boolean;
1397
+ driverParam: boolean;
1398
+ notNull: true;
1399
+ hasDefault: true;
1400
+ isPrimaryKey: false;
1401
+ isAutoincrement: false;
1402
+ hasRuntimeDefault: false;
1403
+ enumValues: undefined;
1404
+ baseColumn: never;
1405
+ identity: undefined;
1406
+ generated: undefined;
1407
+ }, {}, {}>;
1408
+ priority: import("drizzle-orm/pg-core").PgColumn<{
1409
+ name: "priority";
1410
+ tableName: "market_channel_rules";
1411
+ dataType: "number";
1412
+ columnType: "PgInteger";
1413
+ data: number;
1414
+ driverParam: string | number;
1415
+ notNull: true;
1416
+ hasDefault: true;
1417
+ isPrimaryKey: false;
1418
+ isAutoincrement: false;
1419
+ hasRuntimeDefault: false;
1420
+ enumValues: undefined;
1421
+ baseColumn: never;
1422
+ identity: undefined;
1423
+ generated: undefined;
1424
+ }, {}, {}>;
1425
+ notes: import("drizzle-orm/pg-core").PgColumn<{
1426
+ name: "notes";
1427
+ tableName: "market_channel_rules";
1428
+ dataType: "string";
1429
+ columnType: "PgText";
1430
+ data: string;
1431
+ driverParam: string;
1432
+ notNull: false;
1433
+ hasDefault: false;
1434
+ isPrimaryKey: false;
1435
+ isAutoincrement: false;
1436
+ hasRuntimeDefault: false;
1437
+ enumValues: [string, ...string[]];
1438
+ baseColumn: never;
1439
+ identity: undefined;
1440
+ generated: undefined;
1441
+ }, {}, {}>;
1442
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1443
+ name: "created_at";
1444
+ tableName: "market_channel_rules";
1445
+ dataType: "date";
1446
+ columnType: "PgTimestamp";
1447
+ data: Date;
1448
+ driverParam: string;
1449
+ notNull: true;
1450
+ hasDefault: true;
1451
+ isPrimaryKey: false;
1452
+ isAutoincrement: false;
1453
+ hasRuntimeDefault: false;
1454
+ enumValues: undefined;
1455
+ baseColumn: never;
1456
+ identity: undefined;
1457
+ generated: undefined;
1458
+ }, {}, {}>;
1459
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1460
+ name: "updated_at";
1461
+ tableName: "market_channel_rules";
1462
+ dataType: "date";
1463
+ columnType: "PgTimestamp";
1464
+ data: Date;
1465
+ driverParam: string;
1466
+ notNull: true;
1467
+ hasDefault: true;
1468
+ isPrimaryKey: false;
1469
+ isAutoincrement: false;
1470
+ hasRuntimeDefault: false;
1471
+ enumValues: undefined;
1472
+ baseColumn: never;
1473
+ identity: undefined;
1474
+ generated: undefined;
1475
+ }, {}, {}>;
1476
+ };
1477
+ dialect: "pg";
1478
+ }>;
1479
+ export type Market = typeof markets.$inferSelect;
1480
+ export type NewMarket = typeof markets.$inferInsert;
1481
+ export type MarketLocale = typeof marketLocales.$inferSelect;
1482
+ export type NewMarketLocale = typeof marketLocales.$inferInsert;
1483
+ export type MarketCurrency = typeof marketCurrencies.$inferSelect;
1484
+ export type NewMarketCurrency = typeof marketCurrencies.$inferInsert;
1485
+ export type FxRateSet = typeof fxRateSets.$inferSelect;
1486
+ export type NewFxRateSet = typeof fxRateSets.$inferInsert;
1487
+ export type ExchangeRate = typeof exchangeRates.$inferSelect;
1488
+ export type NewExchangeRate = typeof exchangeRates.$inferInsert;
1489
+ export type MarketPriceCatalog = typeof marketPriceCatalogs.$inferSelect;
1490
+ export type NewMarketPriceCatalog = typeof marketPriceCatalogs.$inferInsert;
1491
+ export type MarketProductRule = typeof marketProductRules.$inferSelect;
1492
+ export type NewMarketProductRule = typeof marketProductRules.$inferInsert;
1493
+ export type MarketChannelRule = typeof marketChannelRules.$inferSelect;
1494
+ export type NewMarketChannelRule = typeof marketChannelRules.$inferInsert;
1495
+ export declare const marketsRelations: import("drizzle-orm").Relations<"markets", {
1496
+ locales: import("drizzle-orm").Many<"market_locales">;
1497
+ currencies: import("drizzle-orm").Many<"market_currencies">;
1498
+ priceCatalogs: import("drizzle-orm").Many<"market_price_catalogs">;
1499
+ productRules: import("drizzle-orm").Many<"market_product_rules">;
1500
+ channelRules: import("drizzle-orm").Many<"market_channel_rules">;
1501
+ }>;
1502
+ export declare const marketLocalesRelations: import("drizzle-orm").Relations<"market_locales", {
1503
+ market: import("drizzle-orm").One<"markets", true>;
1504
+ }>;
1505
+ export declare const marketCurrenciesRelations: import("drizzle-orm").Relations<"market_currencies", {
1506
+ market: import("drizzle-orm").One<"markets", true>;
1507
+ }>;
1508
+ export declare const fxRateSetsRelations: import("drizzle-orm").Relations<"fx_rate_sets", {
1509
+ exchangeRates: import("drizzle-orm").Many<"exchange_rates">;
1510
+ }>;
1511
+ export declare const exchangeRatesRelations: import("drizzle-orm").Relations<"exchange_rates", {
1512
+ fxRateSet: import("drizzle-orm").One<"fx_rate_sets", true>;
1513
+ }>;
1514
+ export declare const marketPriceCatalogsRelations: import("drizzle-orm").Relations<"market_price_catalogs", {
1515
+ market: import("drizzle-orm").One<"markets", true>;
1516
+ productRules: import("drizzle-orm").Many<"market_product_rules">;
1517
+ channelRules: import("drizzle-orm").Many<"market_channel_rules">;
1518
+ }>;
1519
+ export declare const marketProductRulesRelations: import("drizzle-orm").Relations<"market_product_rules", {
1520
+ market: import("drizzle-orm").One<"markets", true>;
1521
+ priceCatalog: import("drizzle-orm").One<"market_price_catalogs", false>;
1522
+ }>;
1523
+ export declare const marketChannelRulesRelations: import("drizzle-orm").Relations<"market_channel_rules", {
1524
+ market: import("drizzle-orm").One<"markets", true>;
1525
+ priceCatalog: import("drizzle-orm").One<"market_price_catalogs", false>;
1526
+ }>;
1527
+ //# sourceMappingURL=schema.d.ts.map