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