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