@voyantjs/availability 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 (24) hide show
  1. package/LICENSE +109 -0
  2. package/README.md +35 -0
  3. package/dist/generate-slots.d.ts +27 -0
  4. package/dist/generate-slots.d.ts.map +1 -0
  5. package/dist/generate-slots.js +71 -0
  6. package/dist/index.d.ts +12 -0
  7. package/dist/index.d.ts.map +1 -0
  8. package/dist/index.js +13 -0
  9. package/dist/routes.d.ts +2218 -0
  10. package/dist/routes.d.ts.map +1 -0
  11. package/dist/routes.js +541 -0
  12. package/dist/rrule.d.ts +30 -0
  13. package/dist/rrule.d.ts.map +1 -0
  14. package/dist/rrule.js +201 -0
  15. package/dist/schema.d.ts +2341 -0
  16. package/dist/schema.d.ts.map +1 -0
  17. package/dist/schema.js +315 -0
  18. package/dist/service.d.ts +732 -0
  19. package/dist/service.d.ts.map +1 -0
  20. package/dist/service.js +519 -0
  21. package/dist/validation.d.ts +564 -0
  22. package/dist/validation.d.ts.map +1 -0
  23. package/dist/validation.js +215 -0
  24. package/package.json +56 -0
package/dist/schema.d.ts ADDED
@@ -0,0 +1,2341 @@
1
+ export declare const availabilitySlotStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "closed", "sold_out", "cancelled"]>;
2
+ export declare const meetingModeEnum: import("drizzle-orm/pg-core").PgEnum<["meeting_only", "pickup_only", "meet_or_pickup"]>;
3
+ export declare const pickupGroupKindEnum: import("drizzle-orm/pg-core").PgEnum<["pickup", "dropoff", "meeting"]>;
4
+ export declare const pickupTimingModeEnum: import("drizzle-orm/pg-core").PgEnum<["fixed_time", "offset_from_start"]>;
5
+ export declare const availabilityRules: import("drizzle-orm/pg-core").PgTableWithColumns<{
6
+ name: "availability_rules";
7
+ schema: undefined;
8
+ columns: {
9
+ id: import("drizzle-orm/pg-core").PgColumn<{
10
+ name: string;
11
+ tableName: "availability_rules";
12
+ dataType: "string";
13
+ columnType: "PgText";
14
+ data: string;
15
+ driverParam: string;
16
+ notNull: true;
17
+ hasDefault: true;
18
+ isPrimaryKey: true;
19
+ isAutoincrement: false;
20
+ hasRuntimeDefault: true;
21
+ enumValues: [string, ...string[]];
22
+ baseColumn: never;
23
+ identity: undefined;
24
+ generated: undefined;
25
+ }, {}, {}>;
26
+ productId: import("drizzle-orm/pg-core").PgColumn<{
27
+ name: "product_id";
28
+ tableName: "availability_rules";
29
+ dataType: "string";
30
+ columnType: "PgText";
31
+ data: string;
32
+ driverParam: string;
33
+ notNull: true;
34
+ hasDefault: false;
35
+ isPrimaryKey: false;
36
+ isAutoincrement: false;
37
+ hasRuntimeDefault: false;
38
+ enumValues: [string, ...string[]];
39
+ baseColumn: never;
40
+ identity: undefined;
41
+ generated: undefined;
42
+ }, {}, {}>;
43
+ optionId: import("drizzle-orm/pg-core").PgColumn<{
44
+ name: "option_id";
45
+ tableName: "availability_rules";
46
+ dataType: "string";
47
+ columnType: "PgText";
48
+ data: string;
49
+ driverParam: string;
50
+ notNull: false;
51
+ hasDefault: false;
52
+ isPrimaryKey: false;
53
+ isAutoincrement: false;
54
+ hasRuntimeDefault: false;
55
+ enumValues: [string, ...string[]];
56
+ baseColumn: never;
57
+ identity: undefined;
58
+ generated: undefined;
59
+ }, {}, {}>;
60
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
61
+ name: "facility_id";
62
+ tableName: "availability_rules";
63
+ dataType: "string";
64
+ columnType: "PgText";
65
+ data: string;
66
+ driverParam: string;
67
+ notNull: false;
68
+ hasDefault: false;
69
+ isPrimaryKey: false;
70
+ isAutoincrement: false;
71
+ hasRuntimeDefault: false;
72
+ enumValues: [string, ...string[]];
73
+ baseColumn: never;
74
+ identity: undefined;
75
+ generated: undefined;
76
+ }, {}, {}>;
77
+ timezone: import("drizzle-orm/pg-core").PgColumn<{
78
+ name: "timezone";
79
+ tableName: "availability_rules";
80
+ dataType: "string";
81
+ columnType: "PgText";
82
+ data: string;
83
+ driverParam: string;
84
+ notNull: true;
85
+ hasDefault: false;
86
+ isPrimaryKey: false;
87
+ isAutoincrement: false;
88
+ hasRuntimeDefault: false;
89
+ enumValues: [string, ...string[]];
90
+ baseColumn: never;
91
+ identity: undefined;
92
+ generated: undefined;
93
+ }, {}, {}>;
94
+ recurrenceRule: import("drizzle-orm/pg-core").PgColumn<{
95
+ name: "recurrence_rule";
96
+ tableName: "availability_rules";
97
+ dataType: "string";
98
+ columnType: "PgText";
99
+ data: string;
100
+ driverParam: string;
101
+ notNull: true;
102
+ hasDefault: false;
103
+ isPrimaryKey: false;
104
+ isAutoincrement: false;
105
+ hasRuntimeDefault: false;
106
+ enumValues: [string, ...string[]];
107
+ baseColumn: never;
108
+ identity: undefined;
109
+ generated: undefined;
110
+ }, {}, {}>;
111
+ maxCapacity: import("drizzle-orm/pg-core").PgColumn<{
112
+ name: "max_capacity";
113
+ tableName: "availability_rules";
114
+ dataType: "number";
115
+ columnType: "PgInteger";
116
+ data: number;
117
+ driverParam: string | number;
118
+ notNull: true;
119
+ hasDefault: false;
120
+ isPrimaryKey: false;
121
+ isAutoincrement: false;
122
+ hasRuntimeDefault: false;
123
+ enumValues: undefined;
124
+ baseColumn: never;
125
+ identity: undefined;
126
+ generated: undefined;
127
+ }, {}, {}>;
128
+ maxPickupCapacity: import("drizzle-orm/pg-core").PgColumn<{
129
+ name: "max_pickup_capacity";
130
+ tableName: "availability_rules";
131
+ dataType: "number";
132
+ columnType: "PgInteger";
133
+ data: number;
134
+ driverParam: string | number;
135
+ notNull: false;
136
+ hasDefault: false;
137
+ isPrimaryKey: false;
138
+ isAutoincrement: false;
139
+ hasRuntimeDefault: false;
140
+ enumValues: undefined;
141
+ baseColumn: never;
142
+ identity: undefined;
143
+ generated: undefined;
144
+ }, {}, {}>;
145
+ minTotalPax: import("drizzle-orm/pg-core").PgColumn<{
146
+ name: "min_total_pax";
147
+ tableName: "availability_rules";
148
+ dataType: "number";
149
+ columnType: "PgInteger";
150
+ data: number;
151
+ driverParam: string | number;
152
+ notNull: false;
153
+ hasDefault: false;
154
+ isPrimaryKey: false;
155
+ isAutoincrement: false;
156
+ hasRuntimeDefault: false;
157
+ enumValues: undefined;
158
+ baseColumn: never;
159
+ identity: undefined;
160
+ generated: undefined;
161
+ }, {}, {}>;
162
+ cutoffMinutes: import("drizzle-orm/pg-core").PgColumn<{
163
+ name: "cutoff_minutes";
164
+ tableName: "availability_rules";
165
+ dataType: "number";
166
+ columnType: "PgInteger";
167
+ data: number;
168
+ driverParam: string | number;
169
+ notNull: false;
170
+ hasDefault: false;
171
+ isPrimaryKey: false;
172
+ isAutoincrement: false;
173
+ hasRuntimeDefault: false;
174
+ enumValues: undefined;
175
+ baseColumn: never;
176
+ identity: undefined;
177
+ generated: undefined;
178
+ }, {}, {}>;
179
+ earlyBookingLimitMinutes: import("drizzle-orm/pg-core").PgColumn<{
180
+ name: "early_booking_limit_minutes";
181
+ tableName: "availability_rules";
182
+ dataType: "number";
183
+ columnType: "PgInteger";
184
+ data: number;
185
+ driverParam: string | number;
186
+ notNull: false;
187
+ hasDefault: false;
188
+ isPrimaryKey: false;
189
+ isAutoincrement: false;
190
+ hasRuntimeDefault: false;
191
+ enumValues: undefined;
192
+ baseColumn: never;
193
+ identity: undefined;
194
+ generated: undefined;
195
+ }, {}, {}>;
196
+ active: import("drizzle-orm/pg-core").PgColumn<{
197
+ name: "active";
198
+ tableName: "availability_rules";
199
+ dataType: "boolean";
200
+ columnType: "PgBoolean";
201
+ data: boolean;
202
+ driverParam: boolean;
203
+ notNull: true;
204
+ hasDefault: true;
205
+ isPrimaryKey: false;
206
+ isAutoincrement: false;
207
+ hasRuntimeDefault: false;
208
+ enumValues: undefined;
209
+ baseColumn: never;
210
+ identity: undefined;
211
+ generated: undefined;
212
+ }, {}, {}>;
213
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
214
+ name: "created_at";
215
+ tableName: "availability_rules";
216
+ dataType: "date";
217
+ columnType: "PgTimestamp";
218
+ data: Date;
219
+ driverParam: string;
220
+ notNull: true;
221
+ hasDefault: true;
222
+ isPrimaryKey: false;
223
+ isAutoincrement: false;
224
+ hasRuntimeDefault: false;
225
+ enumValues: undefined;
226
+ baseColumn: never;
227
+ identity: undefined;
228
+ generated: undefined;
229
+ }, {}, {}>;
230
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
231
+ name: "updated_at";
232
+ tableName: "availability_rules";
233
+ dataType: "date";
234
+ columnType: "PgTimestamp";
235
+ data: Date;
236
+ driverParam: string;
237
+ notNull: true;
238
+ hasDefault: true;
239
+ isPrimaryKey: false;
240
+ isAutoincrement: false;
241
+ hasRuntimeDefault: false;
242
+ enumValues: undefined;
243
+ baseColumn: never;
244
+ identity: undefined;
245
+ generated: undefined;
246
+ }, {}, {}>;
247
+ };
248
+ dialect: "pg";
249
+ }>;
250
+ export declare const availabilityStartTimes: import("drizzle-orm/pg-core").PgTableWithColumns<{
251
+ name: "availability_start_times";
252
+ schema: undefined;
253
+ columns: {
254
+ id: import("drizzle-orm/pg-core").PgColumn<{
255
+ name: string;
256
+ tableName: "availability_start_times";
257
+ dataType: "string";
258
+ columnType: "PgText";
259
+ data: string;
260
+ driverParam: string;
261
+ notNull: true;
262
+ hasDefault: true;
263
+ isPrimaryKey: true;
264
+ isAutoincrement: false;
265
+ hasRuntimeDefault: true;
266
+ enumValues: [string, ...string[]];
267
+ baseColumn: never;
268
+ identity: undefined;
269
+ generated: undefined;
270
+ }, {}, {}>;
271
+ productId: import("drizzle-orm/pg-core").PgColumn<{
272
+ name: "product_id";
273
+ tableName: "availability_start_times";
274
+ dataType: "string";
275
+ columnType: "PgText";
276
+ data: string;
277
+ driverParam: string;
278
+ notNull: true;
279
+ hasDefault: false;
280
+ isPrimaryKey: false;
281
+ isAutoincrement: false;
282
+ hasRuntimeDefault: false;
283
+ enumValues: [string, ...string[]];
284
+ baseColumn: never;
285
+ identity: undefined;
286
+ generated: undefined;
287
+ }, {}, {}>;
288
+ optionId: import("drizzle-orm/pg-core").PgColumn<{
289
+ name: "option_id";
290
+ tableName: "availability_start_times";
291
+ dataType: "string";
292
+ columnType: "PgText";
293
+ data: string;
294
+ driverParam: string;
295
+ notNull: false;
296
+ hasDefault: false;
297
+ isPrimaryKey: false;
298
+ isAutoincrement: false;
299
+ hasRuntimeDefault: false;
300
+ enumValues: [string, ...string[]];
301
+ baseColumn: never;
302
+ identity: undefined;
303
+ generated: undefined;
304
+ }, {}, {}>;
305
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
306
+ name: "facility_id";
307
+ tableName: "availability_start_times";
308
+ dataType: "string";
309
+ columnType: "PgText";
310
+ data: string;
311
+ driverParam: string;
312
+ notNull: false;
313
+ hasDefault: false;
314
+ isPrimaryKey: false;
315
+ isAutoincrement: false;
316
+ hasRuntimeDefault: false;
317
+ enumValues: [string, ...string[]];
318
+ baseColumn: never;
319
+ identity: undefined;
320
+ generated: undefined;
321
+ }, {}, {}>;
322
+ label: import("drizzle-orm/pg-core").PgColumn<{
323
+ name: "label";
324
+ tableName: "availability_start_times";
325
+ dataType: "string";
326
+ columnType: "PgText";
327
+ data: string;
328
+ driverParam: string;
329
+ notNull: false;
330
+ hasDefault: false;
331
+ isPrimaryKey: false;
332
+ isAutoincrement: false;
333
+ hasRuntimeDefault: false;
334
+ enumValues: [string, ...string[]];
335
+ baseColumn: never;
336
+ identity: undefined;
337
+ generated: undefined;
338
+ }, {}, {}>;
339
+ startTimeLocal: import("drizzle-orm/pg-core").PgColumn<{
340
+ name: "start_time_local";
341
+ tableName: "availability_start_times";
342
+ dataType: "string";
343
+ columnType: "PgText";
344
+ data: string;
345
+ driverParam: string;
346
+ notNull: true;
347
+ hasDefault: false;
348
+ isPrimaryKey: false;
349
+ isAutoincrement: false;
350
+ hasRuntimeDefault: false;
351
+ enumValues: [string, ...string[]];
352
+ baseColumn: never;
353
+ identity: undefined;
354
+ generated: undefined;
355
+ }, {}, {}>;
356
+ durationMinutes: import("drizzle-orm/pg-core").PgColumn<{
357
+ name: "duration_minutes";
358
+ tableName: "availability_start_times";
359
+ dataType: "number";
360
+ columnType: "PgInteger";
361
+ data: number;
362
+ driverParam: string | number;
363
+ notNull: false;
364
+ hasDefault: false;
365
+ isPrimaryKey: false;
366
+ isAutoincrement: false;
367
+ hasRuntimeDefault: false;
368
+ enumValues: undefined;
369
+ baseColumn: never;
370
+ identity: undefined;
371
+ generated: undefined;
372
+ }, {}, {}>;
373
+ sortOrder: import("drizzle-orm/pg-core").PgColumn<{
374
+ name: "sort_order";
375
+ tableName: "availability_start_times";
376
+ dataType: "number";
377
+ columnType: "PgInteger";
378
+ data: number;
379
+ driverParam: string | number;
380
+ notNull: true;
381
+ hasDefault: true;
382
+ isPrimaryKey: false;
383
+ isAutoincrement: false;
384
+ hasRuntimeDefault: false;
385
+ enumValues: undefined;
386
+ baseColumn: never;
387
+ identity: undefined;
388
+ generated: undefined;
389
+ }, {}, {}>;
390
+ active: import("drizzle-orm/pg-core").PgColumn<{
391
+ name: "active";
392
+ tableName: "availability_start_times";
393
+ dataType: "boolean";
394
+ columnType: "PgBoolean";
395
+ data: boolean;
396
+ driverParam: boolean;
397
+ notNull: true;
398
+ hasDefault: true;
399
+ isPrimaryKey: false;
400
+ isAutoincrement: false;
401
+ hasRuntimeDefault: false;
402
+ enumValues: undefined;
403
+ baseColumn: never;
404
+ identity: undefined;
405
+ generated: undefined;
406
+ }, {}, {}>;
407
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
408
+ name: "created_at";
409
+ tableName: "availability_start_times";
410
+ dataType: "date";
411
+ columnType: "PgTimestamp";
412
+ data: Date;
413
+ driverParam: string;
414
+ notNull: true;
415
+ hasDefault: true;
416
+ isPrimaryKey: false;
417
+ isAutoincrement: false;
418
+ hasRuntimeDefault: false;
419
+ enumValues: undefined;
420
+ baseColumn: never;
421
+ identity: undefined;
422
+ generated: undefined;
423
+ }, {}, {}>;
424
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
425
+ name: "updated_at";
426
+ tableName: "availability_start_times";
427
+ dataType: "date";
428
+ columnType: "PgTimestamp";
429
+ data: Date;
430
+ driverParam: string;
431
+ notNull: true;
432
+ hasDefault: true;
433
+ isPrimaryKey: false;
434
+ isAutoincrement: false;
435
+ hasRuntimeDefault: false;
436
+ enumValues: undefined;
437
+ baseColumn: never;
438
+ identity: undefined;
439
+ generated: undefined;
440
+ }, {}, {}>;
441
+ };
442
+ dialect: "pg";
443
+ }>;
444
+ export declare const availabilitySlots: import("drizzle-orm/pg-core").PgTableWithColumns<{
445
+ name: "availability_slots";
446
+ schema: undefined;
447
+ columns: {
448
+ id: import("drizzle-orm/pg-core").PgColumn<{
449
+ name: string;
450
+ tableName: "availability_slots";
451
+ dataType: "string";
452
+ columnType: "PgText";
453
+ data: string;
454
+ driverParam: string;
455
+ notNull: true;
456
+ hasDefault: true;
457
+ isPrimaryKey: true;
458
+ isAutoincrement: false;
459
+ hasRuntimeDefault: true;
460
+ enumValues: [string, ...string[]];
461
+ baseColumn: never;
462
+ identity: undefined;
463
+ generated: undefined;
464
+ }, {}, {}>;
465
+ productId: import("drizzle-orm/pg-core").PgColumn<{
466
+ name: "product_id";
467
+ tableName: "availability_slots";
468
+ dataType: "string";
469
+ columnType: "PgText";
470
+ data: string;
471
+ driverParam: string;
472
+ notNull: true;
473
+ hasDefault: false;
474
+ isPrimaryKey: false;
475
+ isAutoincrement: false;
476
+ hasRuntimeDefault: false;
477
+ enumValues: [string, ...string[]];
478
+ baseColumn: never;
479
+ identity: undefined;
480
+ generated: undefined;
481
+ }, {}, {}>;
482
+ optionId: import("drizzle-orm/pg-core").PgColumn<{
483
+ name: "option_id";
484
+ tableName: "availability_slots";
485
+ dataType: "string";
486
+ columnType: "PgText";
487
+ data: string;
488
+ driverParam: string;
489
+ notNull: false;
490
+ hasDefault: false;
491
+ isPrimaryKey: false;
492
+ isAutoincrement: false;
493
+ hasRuntimeDefault: false;
494
+ enumValues: [string, ...string[]];
495
+ baseColumn: never;
496
+ identity: undefined;
497
+ generated: undefined;
498
+ }, {}, {}>;
499
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
500
+ name: "facility_id";
501
+ tableName: "availability_slots";
502
+ dataType: "string";
503
+ columnType: "PgText";
504
+ data: string;
505
+ driverParam: string;
506
+ notNull: false;
507
+ hasDefault: false;
508
+ isPrimaryKey: false;
509
+ isAutoincrement: false;
510
+ hasRuntimeDefault: false;
511
+ enumValues: [string, ...string[]];
512
+ baseColumn: never;
513
+ identity: undefined;
514
+ generated: undefined;
515
+ }, {}, {}>;
516
+ availabilityRuleId: import("drizzle-orm/pg-core").PgColumn<{
517
+ name: string;
518
+ tableName: "availability_slots";
519
+ dataType: "string";
520
+ columnType: "PgText";
521
+ data: string;
522
+ driverParam: string;
523
+ notNull: false;
524
+ hasDefault: false;
525
+ isPrimaryKey: false;
526
+ isAutoincrement: false;
527
+ hasRuntimeDefault: false;
528
+ enumValues: [string, ...string[]];
529
+ baseColumn: never;
530
+ identity: undefined;
531
+ generated: undefined;
532
+ }, {}, {}>;
533
+ startTimeId: import("drizzle-orm/pg-core").PgColumn<{
534
+ name: string;
535
+ tableName: "availability_slots";
536
+ dataType: "string";
537
+ columnType: "PgText";
538
+ data: string;
539
+ driverParam: string;
540
+ notNull: false;
541
+ hasDefault: false;
542
+ isPrimaryKey: false;
543
+ isAutoincrement: false;
544
+ hasRuntimeDefault: false;
545
+ enumValues: [string, ...string[]];
546
+ baseColumn: never;
547
+ identity: undefined;
548
+ generated: undefined;
549
+ }, {}, {}>;
550
+ dateLocal: import("drizzle-orm/pg-core").PgColumn<{
551
+ name: "date_local";
552
+ tableName: "availability_slots";
553
+ dataType: "string";
554
+ columnType: "PgDateString";
555
+ data: string;
556
+ driverParam: string;
557
+ notNull: true;
558
+ hasDefault: false;
559
+ isPrimaryKey: false;
560
+ isAutoincrement: false;
561
+ hasRuntimeDefault: false;
562
+ enumValues: undefined;
563
+ baseColumn: never;
564
+ identity: undefined;
565
+ generated: undefined;
566
+ }, {}, {}>;
567
+ startsAt: import("drizzle-orm/pg-core").PgColumn<{
568
+ name: "starts_at";
569
+ tableName: "availability_slots";
570
+ dataType: "date";
571
+ columnType: "PgTimestamp";
572
+ data: Date;
573
+ driverParam: string;
574
+ notNull: true;
575
+ hasDefault: false;
576
+ isPrimaryKey: false;
577
+ isAutoincrement: false;
578
+ hasRuntimeDefault: false;
579
+ enumValues: undefined;
580
+ baseColumn: never;
581
+ identity: undefined;
582
+ generated: undefined;
583
+ }, {}, {}>;
584
+ endsAt: import("drizzle-orm/pg-core").PgColumn<{
585
+ name: "ends_at";
586
+ tableName: "availability_slots";
587
+ dataType: "date";
588
+ columnType: "PgTimestamp";
589
+ data: Date;
590
+ driverParam: string;
591
+ notNull: false;
592
+ hasDefault: false;
593
+ isPrimaryKey: false;
594
+ isAutoincrement: false;
595
+ hasRuntimeDefault: false;
596
+ enumValues: undefined;
597
+ baseColumn: never;
598
+ identity: undefined;
599
+ generated: undefined;
600
+ }, {}, {}>;
601
+ timezone: import("drizzle-orm/pg-core").PgColumn<{
602
+ name: "timezone";
603
+ tableName: "availability_slots";
604
+ dataType: "string";
605
+ columnType: "PgText";
606
+ data: string;
607
+ driverParam: string;
608
+ notNull: true;
609
+ hasDefault: false;
610
+ isPrimaryKey: false;
611
+ isAutoincrement: false;
612
+ hasRuntimeDefault: false;
613
+ enumValues: [string, ...string[]];
614
+ baseColumn: never;
615
+ identity: undefined;
616
+ generated: undefined;
617
+ }, {}, {}>;
618
+ status: import("drizzle-orm/pg-core").PgColumn<{
619
+ name: "status";
620
+ tableName: "availability_slots";
621
+ dataType: "string";
622
+ columnType: "PgEnumColumn";
623
+ data: "open" | "closed" | "sold_out" | "cancelled";
624
+ driverParam: string;
625
+ notNull: true;
626
+ hasDefault: true;
627
+ isPrimaryKey: false;
628
+ isAutoincrement: false;
629
+ hasRuntimeDefault: false;
630
+ enumValues: ["open", "closed", "sold_out", "cancelled"];
631
+ baseColumn: never;
632
+ identity: undefined;
633
+ generated: undefined;
634
+ }, {}, {}>;
635
+ unlimited: import("drizzle-orm/pg-core").PgColumn<{
636
+ name: "unlimited";
637
+ tableName: "availability_slots";
638
+ dataType: "boolean";
639
+ columnType: "PgBoolean";
640
+ data: boolean;
641
+ driverParam: boolean;
642
+ notNull: true;
643
+ hasDefault: true;
644
+ isPrimaryKey: false;
645
+ isAutoincrement: false;
646
+ hasRuntimeDefault: false;
647
+ enumValues: undefined;
648
+ baseColumn: never;
649
+ identity: undefined;
650
+ generated: undefined;
651
+ }, {}, {}>;
652
+ initialPax: import("drizzle-orm/pg-core").PgColumn<{
653
+ name: "initial_pax";
654
+ tableName: "availability_slots";
655
+ dataType: "number";
656
+ columnType: "PgInteger";
657
+ data: number;
658
+ driverParam: string | number;
659
+ notNull: false;
660
+ hasDefault: false;
661
+ isPrimaryKey: false;
662
+ isAutoincrement: false;
663
+ hasRuntimeDefault: false;
664
+ enumValues: undefined;
665
+ baseColumn: never;
666
+ identity: undefined;
667
+ generated: undefined;
668
+ }, {}, {}>;
669
+ remainingPax: import("drizzle-orm/pg-core").PgColumn<{
670
+ name: "remaining_pax";
671
+ tableName: "availability_slots";
672
+ dataType: "number";
673
+ columnType: "PgInteger";
674
+ data: number;
675
+ driverParam: string | number;
676
+ notNull: false;
677
+ hasDefault: false;
678
+ isPrimaryKey: false;
679
+ isAutoincrement: false;
680
+ hasRuntimeDefault: false;
681
+ enumValues: undefined;
682
+ baseColumn: never;
683
+ identity: undefined;
684
+ generated: undefined;
685
+ }, {}, {}>;
686
+ initialPickups: import("drizzle-orm/pg-core").PgColumn<{
687
+ name: "initial_pickups";
688
+ tableName: "availability_slots";
689
+ dataType: "number";
690
+ columnType: "PgInteger";
691
+ data: number;
692
+ driverParam: string | number;
693
+ notNull: false;
694
+ hasDefault: false;
695
+ isPrimaryKey: false;
696
+ isAutoincrement: false;
697
+ hasRuntimeDefault: false;
698
+ enumValues: undefined;
699
+ baseColumn: never;
700
+ identity: undefined;
701
+ generated: undefined;
702
+ }, {}, {}>;
703
+ remainingPickups: import("drizzle-orm/pg-core").PgColumn<{
704
+ name: "remaining_pickups";
705
+ tableName: "availability_slots";
706
+ dataType: "number";
707
+ columnType: "PgInteger";
708
+ data: number;
709
+ driverParam: string | number;
710
+ notNull: false;
711
+ hasDefault: false;
712
+ isPrimaryKey: false;
713
+ isAutoincrement: false;
714
+ hasRuntimeDefault: false;
715
+ enumValues: undefined;
716
+ baseColumn: never;
717
+ identity: undefined;
718
+ generated: undefined;
719
+ }, {}, {}>;
720
+ remainingResources: import("drizzle-orm/pg-core").PgColumn<{
721
+ name: "remaining_resources";
722
+ tableName: "availability_slots";
723
+ dataType: "number";
724
+ columnType: "PgInteger";
725
+ data: number;
726
+ driverParam: string | number;
727
+ notNull: false;
728
+ hasDefault: false;
729
+ isPrimaryKey: false;
730
+ isAutoincrement: false;
731
+ hasRuntimeDefault: false;
732
+ enumValues: undefined;
733
+ baseColumn: never;
734
+ identity: undefined;
735
+ generated: undefined;
736
+ }, {}, {}>;
737
+ pastCutoff: import("drizzle-orm/pg-core").PgColumn<{
738
+ name: "past_cutoff";
739
+ tableName: "availability_slots";
740
+ dataType: "boolean";
741
+ columnType: "PgBoolean";
742
+ data: boolean;
743
+ driverParam: boolean;
744
+ notNull: true;
745
+ hasDefault: true;
746
+ isPrimaryKey: false;
747
+ isAutoincrement: false;
748
+ hasRuntimeDefault: false;
749
+ enumValues: undefined;
750
+ baseColumn: never;
751
+ identity: undefined;
752
+ generated: undefined;
753
+ }, {}, {}>;
754
+ tooEarly: import("drizzle-orm/pg-core").PgColumn<{
755
+ name: "too_early";
756
+ tableName: "availability_slots";
757
+ dataType: "boolean";
758
+ columnType: "PgBoolean";
759
+ data: boolean;
760
+ driverParam: boolean;
761
+ notNull: true;
762
+ hasDefault: true;
763
+ isPrimaryKey: false;
764
+ isAutoincrement: false;
765
+ hasRuntimeDefault: false;
766
+ enumValues: undefined;
767
+ baseColumn: never;
768
+ identity: undefined;
769
+ generated: undefined;
770
+ }, {}, {}>;
771
+ nights: import("drizzle-orm/pg-core").PgColumn<{
772
+ name: "nights";
773
+ tableName: "availability_slots";
774
+ dataType: "number";
775
+ columnType: "PgInteger";
776
+ data: number;
777
+ driverParam: string | number;
778
+ notNull: false;
779
+ hasDefault: false;
780
+ isPrimaryKey: false;
781
+ isAutoincrement: false;
782
+ hasRuntimeDefault: false;
783
+ enumValues: undefined;
784
+ baseColumn: never;
785
+ identity: undefined;
786
+ generated: undefined;
787
+ }, {}, {}>;
788
+ days: import("drizzle-orm/pg-core").PgColumn<{
789
+ name: "days";
790
+ tableName: "availability_slots";
791
+ dataType: "number";
792
+ columnType: "PgInteger";
793
+ data: number;
794
+ driverParam: string | number;
795
+ notNull: false;
796
+ hasDefault: false;
797
+ isPrimaryKey: false;
798
+ isAutoincrement: false;
799
+ hasRuntimeDefault: false;
800
+ enumValues: undefined;
801
+ baseColumn: never;
802
+ identity: undefined;
803
+ generated: undefined;
804
+ }, {}, {}>;
805
+ notes: import("drizzle-orm/pg-core").PgColumn<{
806
+ name: "notes";
807
+ tableName: "availability_slots";
808
+ dataType: "string";
809
+ columnType: "PgText";
810
+ data: string;
811
+ driverParam: string;
812
+ notNull: false;
813
+ hasDefault: false;
814
+ isPrimaryKey: false;
815
+ isAutoincrement: false;
816
+ hasRuntimeDefault: false;
817
+ enumValues: [string, ...string[]];
818
+ baseColumn: never;
819
+ identity: undefined;
820
+ generated: undefined;
821
+ }, {}, {}>;
822
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
823
+ name: "created_at";
824
+ tableName: "availability_slots";
825
+ dataType: "date";
826
+ columnType: "PgTimestamp";
827
+ data: Date;
828
+ driverParam: string;
829
+ notNull: true;
830
+ hasDefault: true;
831
+ isPrimaryKey: false;
832
+ isAutoincrement: false;
833
+ hasRuntimeDefault: false;
834
+ enumValues: undefined;
835
+ baseColumn: never;
836
+ identity: undefined;
837
+ generated: undefined;
838
+ }, {}, {}>;
839
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
840
+ name: "updated_at";
841
+ tableName: "availability_slots";
842
+ dataType: "date";
843
+ columnType: "PgTimestamp";
844
+ data: Date;
845
+ driverParam: string;
846
+ notNull: true;
847
+ hasDefault: true;
848
+ isPrimaryKey: false;
849
+ isAutoincrement: false;
850
+ hasRuntimeDefault: false;
851
+ enumValues: undefined;
852
+ baseColumn: never;
853
+ identity: undefined;
854
+ generated: undefined;
855
+ }, {}, {}>;
856
+ };
857
+ dialect: "pg";
858
+ }>;
859
+ export declare const availabilityCloseouts: import("drizzle-orm/pg-core").PgTableWithColumns<{
860
+ name: "availability_closeouts";
861
+ schema: undefined;
862
+ columns: {
863
+ id: import("drizzle-orm/pg-core").PgColumn<{
864
+ name: string;
865
+ tableName: "availability_closeouts";
866
+ dataType: "string";
867
+ columnType: "PgText";
868
+ data: string;
869
+ driverParam: string;
870
+ notNull: true;
871
+ hasDefault: true;
872
+ isPrimaryKey: true;
873
+ isAutoincrement: false;
874
+ hasRuntimeDefault: true;
875
+ enumValues: [string, ...string[]];
876
+ baseColumn: never;
877
+ identity: undefined;
878
+ generated: undefined;
879
+ }, {}, {}>;
880
+ productId: import("drizzle-orm/pg-core").PgColumn<{
881
+ name: "product_id";
882
+ tableName: "availability_closeouts";
883
+ dataType: "string";
884
+ columnType: "PgText";
885
+ data: string;
886
+ driverParam: string;
887
+ notNull: true;
888
+ hasDefault: false;
889
+ isPrimaryKey: false;
890
+ isAutoincrement: false;
891
+ hasRuntimeDefault: false;
892
+ enumValues: [string, ...string[]];
893
+ baseColumn: never;
894
+ identity: undefined;
895
+ generated: undefined;
896
+ }, {}, {}>;
897
+ slotId: import("drizzle-orm/pg-core").PgColumn<{
898
+ name: string;
899
+ tableName: "availability_closeouts";
900
+ dataType: "string";
901
+ columnType: "PgText";
902
+ data: string;
903
+ driverParam: string;
904
+ notNull: false;
905
+ hasDefault: false;
906
+ isPrimaryKey: false;
907
+ isAutoincrement: false;
908
+ hasRuntimeDefault: false;
909
+ enumValues: [string, ...string[]];
910
+ baseColumn: never;
911
+ identity: undefined;
912
+ generated: undefined;
913
+ }, {}, {}>;
914
+ dateLocal: import("drizzle-orm/pg-core").PgColumn<{
915
+ name: "date_local";
916
+ tableName: "availability_closeouts";
917
+ dataType: "string";
918
+ columnType: "PgDateString";
919
+ data: string;
920
+ driverParam: string;
921
+ notNull: true;
922
+ hasDefault: false;
923
+ isPrimaryKey: false;
924
+ isAutoincrement: false;
925
+ hasRuntimeDefault: false;
926
+ enumValues: undefined;
927
+ baseColumn: never;
928
+ identity: undefined;
929
+ generated: undefined;
930
+ }, {}, {}>;
931
+ reason: import("drizzle-orm/pg-core").PgColumn<{
932
+ name: "reason";
933
+ tableName: "availability_closeouts";
934
+ dataType: "string";
935
+ columnType: "PgText";
936
+ data: string;
937
+ driverParam: string;
938
+ notNull: false;
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
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
949
+ name: "created_by";
950
+ tableName: "availability_closeouts";
951
+ dataType: "string";
952
+ columnType: "PgText";
953
+ data: string;
954
+ driverParam: string;
955
+ notNull: false;
956
+ hasDefault: false;
957
+ isPrimaryKey: false;
958
+ isAutoincrement: false;
959
+ hasRuntimeDefault: false;
960
+ enumValues: [string, ...string[]];
961
+ baseColumn: never;
962
+ identity: undefined;
963
+ generated: undefined;
964
+ }, {}, {}>;
965
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
966
+ name: "created_at";
967
+ tableName: "availability_closeouts";
968
+ dataType: "date";
969
+ columnType: "PgTimestamp";
970
+ data: Date;
971
+ driverParam: string;
972
+ notNull: true;
973
+ hasDefault: true;
974
+ isPrimaryKey: false;
975
+ isAutoincrement: false;
976
+ hasRuntimeDefault: false;
977
+ enumValues: undefined;
978
+ baseColumn: never;
979
+ identity: undefined;
980
+ generated: undefined;
981
+ }, {}, {}>;
982
+ };
983
+ dialect: "pg";
984
+ }>;
985
+ export declare const availabilityPickupPoints: import("drizzle-orm/pg-core").PgTableWithColumns<{
986
+ name: "availability_pickup_points";
987
+ schema: undefined;
988
+ columns: {
989
+ id: import("drizzle-orm/pg-core").PgColumn<{
990
+ name: string;
991
+ tableName: "availability_pickup_points";
992
+ dataType: "string";
993
+ columnType: "PgText";
994
+ data: string;
995
+ driverParam: string;
996
+ notNull: true;
997
+ hasDefault: true;
998
+ isPrimaryKey: true;
999
+ isAutoincrement: false;
1000
+ hasRuntimeDefault: true;
1001
+ enumValues: [string, ...string[]];
1002
+ baseColumn: never;
1003
+ identity: undefined;
1004
+ generated: undefined;
1005
+ }, {}, {}>;
1006
+ productId: import("drizzle-orm/pg-core").PgColumn<{
1007
+ name: "product_id";
1008
+ tableName: "availability_pickup_points";
1009
+ dataType: "string";
1010
+ columnType: "PgText";
1011
+ data: string;
1012
+ driverParam: string;
1013
+ notNull: true;
1014
+ hasDefault: false;
1015
+ isPrimaryKey: false;
1016
+ isAutoincrement: false;
1017
+ hasRuntimeDefault: false;
1018
+ enumValues: [string, ...string[]];
1019
+ baseColumn: never;
1020
+ identity: undefined;
1021
+ generated: undefined;
1022
+ }, {}, {}>;
1023
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
1024
+ name: "facility_id";
1025
+ tableName: "availability_pickup_points";
1026
+ dataType: "string";
1027
+ columnType: "PgText";
1028
+ data: string;
1029
+ driverParam: string;
1030
+ notNull: false;
1031
+ hasDefault: false;
1032
+ isPrimaryKey: false;
1033
+ isAutoincrement: false;
1034
+ hasRuntimeDefault: false;
1035
+ enumValues: [string, ...string[]];
1036
+ baseColumn: never;
1037
+ identity: undefined;
1038
+ generated: undefined;
1039
+ }, {}, {}>;
1040
+ name: import("drizzle-orm/pg-core").PgColumn<{
1041
+ name: "name";
1042
+ tableName: "availability_pickup_points";
1043
+ dataType: "string";
1044
+ columnType: "PgText";
1045
+ data: string;
1046
+ driverParam: string;
1047
+ notNull: true;
1048
+ hasDefault: false;
1049
+ isPrimaryKey: false;
1050
+ isAutoincrement: false;
1051
+ hasRuntimeDefault: false;
1052
+ enumValues: [string, ...string[]];
1053
+ baseColumn: never;
1054
+ identity: undefined;
1055
+ generated: undefined;
1056
+ }, {}, {}>;
1057
+ description: import("drizzle-orm/pg-core").PgColumn<{
1058
+ name: "description";
1059
+ tableName: "availability_pickup_points";
1060
+ dataType: "string";
1061
+ columnType: "PgText";
1062
+ data: string;
1063
+ driverParam: string;
1064
+ notNull: false;
1065
+ hasDefault: false;
1066
+ isPrimaryKey: false;
1067
+ isAutoincrement: false;
1068
+ hasRuntimeDefault: false;
1069
+ enumValues: [string, ...string[]];
1070
+ baseColumn: never;
1071
+ identity: undefined;
1072
+ generated: undefined;
1073
+ }, {}, {}>;
1074
+ locationText: import("drizzle-orm/pg-core").PgColumn<{
1075
+ name: "location_text";
1076
+ tableName: "availability_pickup_points";
1077
+ dataType: "string";
1078
+ columnType: "PgText";
1079
+ data: string;
1080
+ driverParam: string;
1081
+ notNull: false;
1082
+ hasDefault: false;
1083
+ isPrimaryKey: false;
1084
+ isAutoincrement: false;
1085
+ hasRuntimeDefault: false;
1086
+ enumValues: [string, ...string[]];
1087
+ baseColumn: never;
1088
+ identity: undefined;
1089
+ generated: undefined;
1090
+ }, {}, {}>;
1091
+ active: import("drizzle-orm/pg-core").PgColumn<{
1092
+ name: "active";
1093
+ tableName: "availability_pickup_points";
1094
+ dataType: "boolean";
1095
+ columnType: "PgBoolean";
1096
+ data: boolean;
1097
+ driverParam: boolean;
1098
+ notNull: true;
1099
+ hasDefault: true;
1100
+ isPrimaryKey: false;
1101
+ isAutoincrement: false;
1102
+ hasRuntimeDefault: false;
1103
+ enumValues: undefined;
1104
+ baseColumn: never;
1105
+ identity: undefined;
1106
+ generated: undefined;
1107
+ }, {}, {}>;
1108
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1109
+ name: "created_at";
1110
+ tableName: "availability_pickup_points";
1111
+ dataType: "date";
1112
+ columnType: "PgTimestamp";
1113
+ data: Date;
1114
+ driverParam: string;
1115
+ notNull: true;
1116
+ hasDefault: true;
1117
+ isPrimaryKey: false;
1118
+ isAutoincrement: false;
1119
+ hasRuntimeDefault: false;
1120
+ enumValues: undefined;
1121
+ baseColumn: never;
1122
+ identity: undefined;
1123
+ generated: undefined;
1124
+ }, {}, {}>;
1125
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1126
+ name: "updated_at";
1127
+ tableName: "availability_pickup_points";
1128
+ dataType: "date";
1129
+ columnType: "PgTimestamp";
1130
+ data: Date;
1131
+ driverParam: string;
1132
+ notNull: true;
1133
+ hasDefault: true;
1134
+ isPrimaryKey: false;
1135
+ isAutoincrement: false;
1136
+ hasRuntimeDefault: false;
1137
+ enumValues: undefined;
1138
+ baseColumn: never;
1139
+ identity: undefined;
1140
+ generated: undefined;
1141
+ }, {}, {}>;
1142
+ };
1143
+ dialect: "pg";
1144
+ }>;
1145
+ export declare const availabilitySlotPickups: import("drizzle-orm/pg-core").PgTableWithColumns<{
1146
+ name: "availability_slot_pickups";
1147
+ schema: undefined;
1148
+ columns: {
1149
+ id: import("drizzle-orm/pg-core").PgColumn<{
1150
+ name: string;
1151
+ tableName: "availability_slot_pickups";
1152
+ dataType: "string";
1153
+ columnType: "PgText";
1154
+ data: string;
1155
+ driverParam: string;
1156
+ notNull: true;
1157
+ hasDefault: true;
1158
+ isPrimaryKey: true;
1159
+ isAutoincrement: false;
1160
+ hasRuntimeDefault: true;
1161
+ enumValues: [string, ...string[]];
1162
+ baseColumn: never;
1163
+ identity: undefined;
1164
+ generated: undefined;
1165
+ }, {}, {}>;
1166
+ slotId: import("drizzle-orm/pg-core").PgColumn<{
1167
+ name: string;
1168
+ tableName: "availability_slot_pickups";
1169
+ dataType: "string";
1170
+ columnType: "PgText";
1171
+ data: string;
1172
+ driverParam: string;
1173
+ notNull: true;
1174
+ hasDefault: false;
1175
+ isPrimaryKey: false;
1176
+ isAutoincrement: false;
1177
+ hasRuntimeDefault: false;
1178
+ enumValues: [string, ...string[]];
1179
+ baseColumn: never;
1180
+ identity: undefined;
1181
+ generated: undefined;
1182
+ }, {}, {}>;
1183
+ pickupPointId: import("drizzle-orm/pg-core").PgColumn<{
1184
+ name: string;
1185
+ tableName: "availability_slot_pickups";
1186
+ dataType: "string";
1187
+ columnType: "PgText";
1188
+ data: string;
1189
+ driverParam: string;
1190
+ notNull: true;
1191
+ hasDefault: false;
1192
+ isPrimaryKey: false;
1193
+ isAutoincrement: false;
1194
+ hasRuntimeDefault: false;
1195
+ enumValues: [string, ...string[]];
1196
+ baseColumn: never;
1197
+ identity: undefined;
1198
+ generated: undefined;
1199
+ }, {}, {}>;
1200
+ initialCapacity: import("drizzle-orm/pg-core").PgColumn<{
1201
+ name: "initial_capacity";
1202
+ tableName: "availability_slot_pickups";
1203
+ dataType: "number";
1204
+ columnType: "PgInteger";
1205
+ data: number;
1206
+ driverParam: string | number;
1207
+ notNull: false;
1208
+ hasDefault: false;
1209
+ isPrimaryKey: false;
1210
+ isAutoincrement: false;
1211
+ hasRuntimeDefault: false;
1212
+ enumValues: undefined;
1213
+ baseColumn: never;
1214
+ identity: undefined;
1215
+ generated: undefined;
1216
+ }, {}, {}>;
1217
+ remainingCapacity: import("drizzle-orm/pg-core").PgColumn<{
1218
+ name: "remaining_capacity";
1219
+ tableName: "availability_slot_pickups";
1220
+ dataType: "number";
1221
+ columnType: "PgInteger";
1222
+ data: number;
1223
+ driverParam: string | number;
1224
+ notNull: false;
1225
+ hasDefault: false;
1226
+ isPrimaryKey: false;
1227
+ isAutoincrement: false;
1228
+ hasRuntimeDefault: false;
1229
+ enumValues: undefined;
1230
+ baseColumn: never;
1231
+ identity: undefined;
1232
+ generated: undefined;
1233
+ }, {}, {}>;
1234
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1235
+ name: "created_at";
1236
+ tableName: "availability_slot_pickups";
1237
+ dataType: "date";
1238
+ columnType: "PgTimestamp";
1239
+ data: Date;
1240
+ driverParam: string;
1241
+ notNull: true;
1242
+ hasDefault: true;
1243
+ isPrimaryKey: false;
1244
+ isAutoincrement: false;
1245
+ hasRuntimeDefault: false;
1246
+ enumValues: undefined;
1247
+ baseColumn: never;
1248
+ identity: undefined;
1249
+ generated: undefined;
1250
+ }, {}, {}>;
1251
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1252
+ name: "updated_at";
1253
+ tableName: "availability_slot_pickups";
1254
+ dataType: "date";
1255
+ columnType: "PgTimestamp";
1256
+ data: Date;
1257
+ driverParam: string;
1258
+ notNull: true;
1259
+ hasDefault: true;
1260
+ isPrimaryKey: false;
1261
+ isAutoincrement: false;
1262
+ hasRuntimeDefault: false;
1263
+ enumValues: undefined;
1264
+ baseColumn: never;
1265
+ identity: undefined;
1266
+ generated: undefined;
1267
+ }, {}, {}>;
1268
+ };
1269
+ dialect: "pg";
1270
+ }>;
1271
+ export declare const productMeetingConfigs: import("drizzle-orm/pg-core").PgTableWithColumns<{
1272
+ name: "product_meeting_configs";
1273
+ schema: undefined;
1274
+ columns: {
1275
+ id: import("drizzle-orm/pg-core").PgColumn<{
1276
+ name: string;
1277
+ tableName: "product_meeting_configs";
1278
+ dataType: "string";
1279
+ columnType: "PgText";
1280
+ data: string;
1281
+ driverParam: string;
1282
+ notNull: true;
1283
+ hasDefault: true;
1284
+ isPrimaryKey: true;
1285
+ isAutoincrement: false;
1286
+ hasRuntimeDefault: true;
1287
+ enumValues: [string, ...string[]];
1288
+ baseColumn: never;
1289
+ identity: undefined;
1290
+ generated: undefined;
1291
+ }, {}, {}>;
1292
+ productId: import("drizzle-orm/pg-core").PgColumn<{
1293
+ name: "product_id";
1294
+ tableName: "product_meeting_configs";
1295
+ dataType: "string";
1296
+ columnType: "PgText";
1297
+ data: string;
1298
+ driverParam: string;
1299
+ notNull: true;
1300
+ hasDefault: false;
1301
+ isPrimaryKey: false;
1302
+ isAutoincrement: false;
1303
+ hasRuntimeDefault: false;
1304
+ enumValues: [string, ...string[]];
1305
+ baseColumn: never;
1306
+ identity: undefined;
1307
+ generated: undefined;
1308
+ }, {}, {}>;
1309
+ optionId: import("drizzle-orm/pg-core").PgColumn<{
1310
+ name: "option_id";
1311
+ tableName: "product_meeting_configs";
1312
+ dataType: "string";
1313
+ columnType: "PgText";
1314
+ data: string;
1315
+ driverParam: string;
1316
+ notNull: false;
1317
+ hasDefault: false;
1318
+ isPrimaryKey: false;
1319
+ isAutoincrement: false;
1320
+ hasRuntimeDefault: false;
1321
+ enumValues: [string, ...string[]];
1322
+ baseColumn: never;
1323
+ identity: undefined;
1324
+ generated: undefined;
1325
+ }, {}, {}>;
1326
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
1327
+ name: "facility_id";
1328
+ tableName: "product_meeting_configs";
1329
+ dataType: "string";
1330
+ columnType: "PgText";
1331
+ data: string;
1332
+ driverParam: string;
1333
+ notNull: false;
1334
+ hasDefault: false;
1335
+ isPrimaryKey: false;
1336
+ isAutoincrement: false;
1337
+ hasRuntimeDefault: false;
1338
+ enumValues: [string, ...string[]];
1339
+ baseColumn: never;
1340
+ identity: undefined;
1341
+ generated: undefined;
1342
+ }, {}, {}>;
1343
+ mode: import("drizzle-orm/pg-core").PgColumn<{
1344
+ name: "mode";
1345
+ tableName: "product_meeting_configs";
1346
+ dataType: "string";
1347
+ columnType: "PgEnumColumn";
1348
+ data: "meeting_only" | "pickup_only" | "meet_or_pickup";
1349
+ driverParam: string;
1350
+ notNull: true;
1351
+ hasDefault: true;
1352
+ isPrimaryKey: false;
1353
+ isAutoincrement: false;
1354
+ hasRuntimeDefault: false;
1355
+ enumValues: ["meeting_only", "pickup_only", "meet_or_pickup"];
1356
+ baseColumn: never;
1357
+ identity: undefined;
1358
+ generated: undefined;
1359
+ }, {}, {}>;
1360
+ allowCustomPickup: import("drizzle-orm/pg-core").PgColumn<{
1361
+ name: "allow_custom_pickup";
1362
+ tableName: "product_meeting_configs";
1363
+ dataType: "boolean";
1364
+ columnType: "PgBoolean";
1365
+ data: boolean;
1366
+ driverParam: boolean;
1367
+ notNull: true;
1368
+ hasDefault: true;
1369
+ isPrimaryKey: false;
1370
+ isAutoincrement: false;
1371
+ hasRuntimeDefault: false;
1372
+ enumValues: undefined;
1373
+ baseColumn: never;
1374
+ identity: undefined;
1375
+ generated: undefined;
1376
+ }, {}, {}>;
1377
+ allowCustomDropoff: import("drizzle-orm/pg-core").PgColumn<{
1378
+ name: "allow_custom_dropoff";
1379
+ tableName: "product_meeting_configs";
1380
+ dataType: "boolean";
1381
+ columnType: "PgBoolean";
1382
+ data: boolean;
1383
+ driverParam: boolean;
1384
+ notNull: true;
1385
+ hasDefault: true;
1386
+ isPrimaryKey: false;
1387
+ isAutoincrement: false;
1388
+ hasRuntimeDefault: false;
1389
+ enumValues: undefined;
1390
+ baseColumn: never;
1391
+ identity: undefined;
1392
+ generated: undefined;
1393
+ }, {}, {}>;
1394
+ requiresPickupSelection: import("drizzle-orm/pg-core").PgColumn<{
1395
+ name: "requires_pickup_selection";
1396
+ tableName: "product_meeting_configs";
1397
+ dataType: "boolean";
1398
+ columnType: "PgBoolean";
1399
+ data: boolean;
1400
+ driverParam: boolean;
1401
+ notNull: true;
1402
+ hasDefault: true;
1403
+ isPrimaryKey: false;
1404
+ isAutoincrement: false;
1405
+ hasRuntimeDefault: false;
1406
+ enumValues: undefined;
1407
+ baseColumn: never;
1408
+ identity: undefined;
1409
+ generated: undefined;
1410
+ }, {}, {}>;
1411
+ requiresDropoffSelection: import("drizzle-orm/pg-core").PgColumn<{
1412
+ name: "requires_dropoff_selection";
1413
+ tableName: "product_meeting_configs";
1414
+ dataType: "boolean";
1415
+ columnType: "PgBoolean";
1416
+ data: boolean;
1417
+ driverParam: boolean;
1418
+ notNull: true;
1419
+ hasDefault: true;
1420
+ isPrimaryKey: false;
1421
+ isAutoincrement: false;
1422
+ hasRuntimeDefault: false;
1423
+ enumValues: undefined;
1424
+ baseColumn: never;
1425
+ identity: undefined;
1426
+ generated: undefined;
1427
+ }, {}, {}>;
1428
+ usePickupAllotment: import("drizzle-orm/pg-core").PgColumn<{
1429
+ name: "use_pickup_allotment";
1430
+ tableName: "product_meeting_configs";
1431
+ dataType: "boolean";
1432
+ columnType: "PgBoolean";
1433
+ data: boolean;
1434
+ driverParam: boolean;
1435
+ notNull: true;
1436
+ hasDefault: true;
1437
+ isPrimaryKey: false;
1438
+ isAutoincrement: false;
1439
+ hasRuntimeDefault: false;
1440
+ enumValues: undefined;
1441
+ baseColumn: never;
1442
+ identity: undefined;
1443
+ generated: undefined;
1444
+ }, {}, {}>;
1445
+ meetingInstructions: import("drizzle-orm/pg-core").PgColumn<{
1446
+ name: "meeting_instructions";
1447
+ tableName: "product_meeting_configs";
1448
+ dataType: "string";
1449
+ columnType: "PgText";
1450
+ data: string;
1451
+ driverParam: string;
1452
+ notNull: false;
1453
+ hasDefault: false;
1454
+ isPrimaryKey: false;
1455
+ isAutoincrement: false;
1456
+ hasRuntimeDefault: false;
1457
+ enumValues: [string, ...string[]];
1458
+ baseColumn: never;
1459
+ identity: undefined;
1460
+ generated: undefined;
1461
+ }, {}, {}>;
1462
+ pickupInstructions: import("drizzle-orm/pg-core").PgColumn<{
1463
+ name: "pickup_instructions";
1464
+ tableName: "product_meeting_configs";
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
+ dropoffInstructions: import("drizzle-orm/pg-core").PgColumn<{
1480
+ name: "dropoff_instructions";
1481
+ tableName: "product_meeting_configs";
1482
+ dataType: "string";
1483
+ columnType: "PgText";
1484
+ data: string;
1485
+ driverParam: string;
1486
+ notNull: false;
1487
+ hasDefault: false;
1488
+ isPrimaryKey: false;
1489
+ isAutoincrement: false;
1490
+ hasRuntimeDefault: false;
1491
+ enumValues: [string, ...string[]];
1492
+ baseColumn: never;
1493
+ identity: undefined;
1494
+ generated: undefined;
1495
+ }, {}, {}>;
1496
+ active: import("drizzle-orm/pg-core").PgColumn<{
1497
+ name: "active";
1498
+ tableName: "product_meeting_configs";
1499
+ dataType: "boolean";
1500
+ columnType: "PgBoolean";
1501
+ data: boolean;
1502
+ driverParam: boolean;
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
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1514
+ name: "created_at";
1515
+ tableName: "product_meeting_configs";
1516
+ dataType: "date";
1517
+ columnType: "PgTimestamp";
1518
+ data: Date;
1519
+ driverParam: string;
1520
+ notNull: true;
1521
+ hasDefault: true;
1522
+ isPrimaryKey: false;
1523
+ isAutoincrement: false;
1524
+ hasRuntimeDefault: false;
1525
+ enumValues: undefined;
1526
+ baseColumn: never;
1527
+ identity: undefined;
1528
+ generated: undefined;
1529
+ }, {}, {}>;
1530
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1531
+ name: "updated_at";
1532
+ tableName: "product_meeting_configs";
1533
+ dataType: "date";
1534
+ columnType: "PgTimestamp";
1535
+ data: Date;
1536
+ driverParam: string;
1537
+ notNull: true;
1538
+ hasDefault: true;
1539
+ isPrimaryKey: false;
1540
+ isAutoincrement: false;
1541
+ hasRuntimeDefault: false;
1542
+ enumValues: undefined;
1543
+ baseColumn: never;
1544
+ identity: undefined;
1545
+ generated: undefined;
1546
+ }, {}, {}>;
1547
+ };
1548
+ dialect: "pg";
1549
+ }>;
1550
+ export declare const pickupGroups: import("drizzle-orm/pg-core").PgTableWithColumns<{
1551
+ name: "pickup_groups";
1552
+ schema: undefined;
1553
+ columns: {
1554
+ id: import("drizzle-orm/pg-core").PgColumn<{
1555
+ name: string;
1556
+ tableName: "pickup_groups";
1557
+ dataType: "string";
1558
+ columnType: "PgText";
1559
+ data: string;
1560
+ driverParam: string;
1561
+ notNull: true;
1562
+ hasDefault: true;
1563
+ isPrimaryKey: true;
1564
+ isAutoincrement: false;
1565
+ hasRuntimeDefault: true;
1566
+ enumValues: [string, ...string[]];
1567
+ baseColumn: never;
1568
+ identity: undefined;
1569
+ generated: undefined;
1570
+ }, {}, {}>;
1571
+ meetingConfigId: import("drizzle-orm/pg-core").PgColumn<{
1572
+ name: string;
1573
+ tableName: "pickup_groups";
1574
+ dataType: "string";
1575
+ columnType: "PgText";
1576
+ data: string;
1577
+ driverParam: string;
1578
+ notNull: true;
1579
+ hasDefault: false;
1580
+ isPrimaryKey: false;
1581
+ isAutoincrement: false;
1582
+ hasRuntimeDefault: false;
1583
+ enumValues: [string, ...string[]];
1584
+ baseColumn: never;
1585
+ identity: undefined;
1586
+ generated: undefined;
1587
+ }, {}, {}>;
1588
+ kind: import("drizzle-orm/pg-core").PgColumn<{
1589
+ name: "kind";
1590
+ tableName: "pickup_groups";
1591
+ dataType: "string";
1592
+ columnType: "PgEnumColumn";
1593
+ data: "pickup" | "dropoff" | "meeting";
1594
+ driverParam: string;
1595
+ notNull: true;
1596
+ hasDefault: false;
1597
+ isPrimaryKey: false;
1598
+ isAutoincrement: false;
1599
+ hasRuntimeDefault: false;
1600
+ enumValues: ["pickup", "dropoff", "meeting"];
1601
+ baseColumn: never;
1602
+ identity: undefined;
1603
+ generated: undefined;
1604
+ }, {}, {}>;
1605
+ name: import("drizzle-orm/pg-core").PgColumn<{
1606
+ name: "name";
1607
+ tableName: "pickup_groups";
1608
+ dataType: "string";
1609
+ columnType: "PgText";
1610
+ data: string;
1611
+ driverParam: string;
1612
+ notNull: true;
1613
+ hasDefault: false;
1614
+ isPrimaryKey: false;
1615
+ isAutoincrement: false;
1616
+ hasRuntimeDefault: false;
1617
+ enumValues: [string, ...string[]];
1618
+ baseColumn: never;
1619
+ identity: undefined;
1620
+ generated: undefined;
1621
+ }, {}, {}>;
1622
+ description: import("drizzle-orm/pg-core").PgColumn<{
1623
+ name: "description";
1624
+ tableName: "pickup_groups";
1625
+ dataType: "string";
1626
+ columnType: "PgText";
1627
+ data: string;
1628
+ driverParam: string;
1629
+ notNull: false;
1630
+ hasDefault: false;
1631
+ isPrimaryKey: false;
1632
+ isAutoincrement: false;
1633
+ hasRuntimeDefault: false;
1634
+ enumValues: [string, ...string[]];
1635
+ baseColumn: never;
1636
+ identity: undefined;
1637
+ generated: undefined;
1638
+ }, {}, {}>;
1639
+ active: import("drizzle-orm/pg-core").PgColumn<{
1640
+ name: "active";
1641
+ tableName: "pickup_groups";
1642
+ dataType: "boolean";
1643
+ columnType: "PgBoolean";
1644
+ data: boolean;
1645
+ driverParam: boolean;
1646
+ notNull: true;
1647
+ hasDefault: true;
1648
+ isPrimaryKey: false;
1649
+ isAutoincrement: false;
1650
+ hasRuntimeDefault: false;
1651
+ enumValues: undefined;
1652
+ baseColumn: never;
1653
+ identity: undefined;
1654
+ generated: undefined;
1655
+ }, {}, {}>;
1656
+ sortOrder: import("drizzle-orm/pg-core").PgColumn<{
1657
+ name: "sort_order";
1658
+ tableName: "pickup_groups";
1659
+ dataType: "number";
1660
+ columnType: "PgInteger";
1661
+ data: number;
1662
+ driverParam: string | number;
1663
+ notNull: true;
1664
+ hasDefault: true;
1665
+ isPrimaryKey: false;
1666
+ isAutoincrement: false;
1667
+ hasRuntimeDefault: false;
1668
+ enumValues: undefined;
1669
+ baseColumn: never;
1670
+ identity: undefined;
1671
+ generated: undefined;
1672
+ }, {}, {}>;
1673
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1674
+ name: "created_at";
1675
+ tableName: "pickup_groups";
1676
+ dataType: "date";
1677
+ columnType: "PgTimestamp";
1678
+ data: Date;
1679
+ driverParam: string;
1680
+ notNull: true;
1681
+ hasDefault: true;
1682
+ isPrimaryKey: false;
1683
+ isAutoincrement: false;
1684
+ hasRuntimeDefault: false;
1685
+ enumValues: undefined;
1686
+ baseColumn: never;
1687
+ identity: undefined;
1688
+ generated: undefined;
1689
+ }, {}, {}>;
1690
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1691
+ name: "updated_at";
1692
+ tableName: "pickup_groups";
1693
+ dataType: "date";
1694
+ columnType: "PgTimestamp";
1695
+ data: Date;
1696
+ driverParam: string;
1697
+ notNull: true;
1698
+ hasDefault: true;
1699
+ isPrimaryKey: false;
1700
+ isAutoincrement: false;
1701
+ hasRuntimeDefault: false;
1702
+ enumValues: undefined;
1703
+ baseColumn: never;
1704
+ identity: undefined;
1705
+ generated: undefined;
1706
+ }, {}, {}>;
1707
+ };
1708
+ dialect: "pg";
1709
+ }>;
1710
+ export declare const pickupLocations: import("drizzle-orm/pg-core").PgTableWithColumns<{
1711
+ name: "pickup_locations";
1712
+ schema: undefined;
1713
+ columns: {
1714
+ id: import("drizzle-orm/pg-core").PgColumn<{
1715
+ name: string;
1716
+ tableName: "pickup_locations";
1717
+ dataType: "string";
1718
+ columnType: "PgText";
1719
+ data: string;
1720
+ driverParam: string;
1721
+ notNull: true;
1722
+ hasDefault: true;
1723
+ isPrimaryKey: true;
1724
+ isAutoincrement: false;
1725
+ hasRuntimeDefault: true;
1726
+ enumValues: [string, ...string[]];
1727
+ baseColumn: never;
1728
+ identity: undefined;
1729
+ generated: undefined;
1730
+ }, {}, {}>;
1731
+ groupId: import("drizzle-orm/pg-core").PgColumn<{
1732
+ name: string;
1733
+ tableName: "pickup_locations";
1734
+ dataType: "string";
1735
+ columnType: "PgText";
1736
+ data: string;
1737
+ driverParam: string;
1738
+ notNull: true;
1739
+ hasDefault: false;
1740
+ isPrimaryKey: false;
1741
+ isAutoincrement: false;
1742
+ hasRuntimeDefault: false;
1743
+ enumValues: [string, ...string[]];
1744
+ baseColumn: never;
1745
+ identity: undefined;
1746
+ generated: undefined;
1747
+ }, {}, {}>;
1748
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
1749
+ name: "facility_id";
1750
+ tableName: "pickup_locations";
1751
+ dataType: "string";
1752
+ columnType: "PgText";
1753
+ data: string;
1754
+ driverParam: string;
1755
+ notNull: false;
1756
+ hasDefault: false;
1757
+ isPrimaryKey: false;
1758
+ isAutoincrement: false;
1759
+ hasRuntimeDefault: false;
1760
+ enumValues: [string, ...string[]];
1761
+ baseColumn: never;
1762
+ identity: undefined;
1763
+ generated: undefined;
1764
+ }, {}, {}>;
1765
+ name: import("drizzle-orm/pg-core").PgColumn<{
1766
+ name: "name";
1767
+ tableName: "pickup_locations";
1768
+ dataType: "string";
1769
+ columnType: "PgText";
1770
+ data: string;
1771
+ driverParam: string;
1772
+ notNull: true;
1773
+ hasDefault: false;
1774
+ isPrimaryKey: false;
1775
+ isAutoincrement: false;
1776
+ hasRuntimeDefault: false;
1777
+ enumValues: [string, ...string[]];
1778
+ baseColumn: never;
1779
+ identity: undefined;
1780
+ generated: undefined;
1781
+ }, {}, {}>;
1782
+ description: import("drizzle-orm/pg-core").PgColumn<{
1783
+ name: "description";
1784
+ tableName: "pickup_locations";
1785
+ dataType: "string";
1786
+ columnType: "PgText";
1787
+ data: string;
1788
+ driverParam: string;
1789
+ notNull: false;
1790
+ hasDefault: false;
1791
+ isPrimaryKey: false;
1792
+ isAutoincrement: false;
1793
+ hasRuntimeDefault: false;
1794
+ enumValues: [string, ...string[]];
1795
+ baseColumn: never;
1796
+ identity: undefined;
1797
+ generated: undefined;
1798
+ }, {}, {}>;
1799
+ locationText: import("drizzle-orm/pg-core").PgColumn<{
1800
+ name: "location_text";
1801
+ tableName: "pickup_locations";
1802
+ dataType: "string";
1803
+ columnType: "PgText";
1804
+ data: string;
1805
+ driverParam: string;
1806
+ notNull: false;
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
+ leadTimeMinutes: import("drizzle-orm/pg-core").PgColumn<{
1817
+ name: "lead_time_minutes";
1818
+ tableName: "pickup_locations";
1819
+ dataType: "number";
1820
+ columnType: "PgInteger";
1821
+ data: number;
1822
+ driverParam: string | number;
1823
+ notNull: false;
1824
+ hasDefault: false;
1825
+ isPrimaryKey: false;
1826
+ isAutoincrement: false;
1827
+ hasRuntimeDefault: false;
1828
+ enumValues: undefined;
1829
+ baseColumn: never;
1830
+ identity: undefined;
1831
+ generated: undefined;
1832
+ }, {}, {}>;
1833
+ active: import("drizzle-orm/pg-core").PgColumn<{
1834
+ name: "active";
1835
+ tableName: "pickup_locations";
1836
+ dataType: "boolean";
1837
+ columnType: "PgBoolean";
1838
+ data: boolean;
1839
+ driverParam: boolean;
1840
+ notNull: true;
1841
+ hasDefault: true;
1842
+ isPrimaryKey: false;
1843
+ isAutoincrement: false;
1844
+ hasRuntimeDefault: false;
1845
+ enumValues: undefined;
1846
+ baseColumn: never;
1847
+ identity: undefined;
1848
+ generated: undefined;
1849
+ }, {}, {}>;
1850
+ sortOrder: import("drizzle-orm/pg-core").PgColumn<{
1851
+ name: "sort_order";
1852
+ tableName: "pickup_locations";
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: "pickup_locations";
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: "pickup_locations";
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 locationPickupTimes: import("drizzle-orm/pg-core").PgTableWithColumns<{
1905
+ name: "location_pickup_times";
1906
+ schema: undefined;
1907
+ columns: {
1908
+ id: import("drizzle-orm/pg-core").PgColumn<{
1909
+ name: string;
1910
+ tableName: "location_pickup_times";
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
+ pickupLocationId: import("drizzle-orm/pg-core").PgColumn<{
1926
+ name: string;
1927
+ tableName: "location_pickup_times";
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
+ slotId: import("drizzle-orm/pg-core").PgColumn<{
1943
+ name: string;
1944
+ tableName: "location_pickup_times";
1945
+ dataType: "string";
1946
+ columnType: "PgText";
1947
+ data: string;
1948
+ driverParam: string;
1949
+ notNull: false;
1950
+ hasDefault: false;
1951
+ isPrimaryKey: false;
1952
+ isAutoincrement: false;
1953
+ hasRuntimeDefault: false;
1954
+ enumValues: [string, ...string[]];
1955
+ baseColumn: never;
1956
+ identity: undefined;
1957
+ generated: undefined;
1958
+ }, {}, {}>;
1959
+ startTimeId: import("drizzle-orm/pg-core").PgColumn<{
1960
+ name: string;
1961
+ tableName: "location_pickup_times";
1962
+ dataType: "string";
1963
+ columnType: "PgText";
1964
+ data: string;
1965
+ driverParam: string;
1966
+ notNull: false;
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
+ timingMode: import("drizzle-orm/pg-core").PgColumn<{
1977
+ name: "timing_mode";
1978
+ tableName: "location_pickup_times";
1979
+ dataType: "string";
1980
+ columnType: "PgEnumColumn";
1981
+ data: "fixed_time" | "offset_from_start";
1982
+ driverParam: string;
1983
+ notNull: true;
1984
+ hasDefault: true;
1985
+ isPrimaryKey: false;
1986
+ isAutoincrement: false;
1987
+ hasRuntimeDefault: false;
1988
+ enumValues: ["fixed_time", "offset_from_start"];
1989
+ baseColumn: never;
1990
+ identity: undefined;
1991
+ generated: undefined;
1992
+ }, {}, {}>;
1993
+ localTime: import("drizzle-orm/pg-core").PgColumn<{
1994
+ name: "local_time";
1995
+ tableName: "location_pickup_times";
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
+ offsetMinutes: import("drizzle-orm/pg-core").PgColumn<{
2011
+ name: "offset_minutes";
2012
+ tableName: "location_pickup_times";
2013
+ dataType: "number";
2014
+ columnType: "PgInteger";
2015
+ data: number;
2016
+ driverParam: string | number;
2017
+ notNull: false;
2018
+ hasDefault: false;
2019
+ isPrimaryKey: false;
2020
+ isAutoincrement: false;
2021
+ hasRuntimeDefault: false;
2022
+ enumValues: undefined;
2023
+ baseColumn: never;
2024
+ identity: undefined;
2025
+ generated: undefined;
2026
+ }, {}, {}>;
2027
+ instructions: import("drizzle-orm/pg-core").PgColumn<{
2028
+ name: "instructions";
2029
+ tableName: "location_pickup_times";
2030
+ dataType: "string";
2031
+ columnType: "PgText";
2032
+ data: string;
2033
+ driverParam: string;
2034
+ notNull: false;
2035
+ hasDefault: false;
2036
+ isPrimaryKey: false;
2037
+ isAutoincrement: false;
2038
+ hasRuntimeDefault: false;
2039
+ enumValues: [string, ...string[]];
2040
+ baseColumn: never;
2041
+ identity: undefined;
2042
+ generated: undefined;
2043
+ }, {}, {}>;
2044
+ initialCapacity: import("drizzle-orm/pg-core").PgColumn<{
2045
+ name: "initial_capacity";
2046
+ tableName: "location_pickup_times";
2047
+ dataType: "number";
2048
+ columnType: "PgInteger";
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
+ remainingCapacity: import("drizzle-orm/pg-core").PgColumn<{
2062
+ name: "remaining_capacity";
2063
+ tableName: "location_pickup_times";
2064
+ dataType: "number";
2065
+ columnType: "PgInteger";
2066
+ data: number;
2067
+ driverParam: string | number;
2068
+ notNull: false;
2069
+ hasDefault: false;
2070
+ isPrimaryKey: false;
2071
+ isAutoincrement: false;
2072
+ hasRuntimeDefault: false;
2073
+ enumValues: undefined;
2074
+ baseColumn: never;
2075
+ identity: undefined;
2076
+ generated: undefined;
2077
+ }, {}, {}>;
2078
+ active: import("drizzle-orm/pg-core").PgColumn<{
2079
+ name: "active";
2080
+ tableName: "location_pickup_times";
2081
+ dataType: "boolean";
2082
+ columnType: "PgBoolean";
2083
+ data: boolean;
2084
+ driverParam: boolean;
2085
+ notNull: true;
2086
+ hasDefault: true;
2087
+ isPrimaryKey: false;
2088
+ isAutoincrement: false;
2089
+ hasRuntimeDefault: false;
2090
+ enumValues: undefined;
2091
+ baseColumn: never;
2092
+ identity: undefined;
2093
+ generated: undefined;
2094
+ }, {}, {}>;
2095
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2096
+ name: "created_at";
2097
+ tableName: "location_pickup_times";
2098
+ dataType: "date";
2099
+ columnType: "PgTimestamp";
2100
+ data: Date;
2101
+ driverParam: string;
2102
+ notNull: true;
2103
+ hasDefault: true;
2104
+ isPrimaryKey: false;
2105
+ isAutoincrement: false;
2106
+ hasRuntimeDefault: false;
2107
+ enumValues: undefined;
2108
+ baseColumn: never;
2109
+ identity: undefined;
2110
+ generated: undefined;
2111
+ }, {}, {}>;
2112
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2113
+ name: "updated_at";
2114
+ tableName: "location_pickup_times";
2115
+ dataType: "date";
2116
+ columnType: "PgTimestamp";
2117
+ data: Date;
2118
+ driverParam: string;
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
+ };
2130
+ dialect: "pg";
2131
+ }>;
2132
+ export declare const customPickupAreas: import("drizzle-orm/pg-core").PgTableWithColumns<{
2133
+ name: "custom_pickup_areas";
2134
+ schema: undefined;
2135
+ columns: {
2136
+ id: import("drizzle-orm/pg-core").PgColumn<{
2137
+ name: string;
2138
+ tableName: "custom_pickup_areas";
2139
+ dataType: "string";
2140
+ columnType: "PgText";
2141
+ data: string;
2142
+ driverParam: string;
2143
+ notNull: true;
2144
+ hasDefault: true;
2145
+ isPrimaryKey: true;
2146
+ isAutoincrement: false;
2147
+ hasRuntimeDefault: true;
2148
+ enumValues: [string, ...string[]];
2149
+ baseColumn: never;
2150
+ identity: undefined;
2151
+ generated: undefined;
2152
+ }, {}, {}>;
2153
+ meetingConfigId: import("drizzle-orm/pg-core").PgColumn<{
2154
+ name: string;
2155
+ tableName: "custom_pickup_areas";
2156
+ dataType: "string";
2157
+ columnType: "PgText";
2158
+ data: string;
2159
+ driverParam: string;
2160
+ notNull: true;
2161
+ hasDefault: false;
2162
+ isPrimaryKey: false;
2163
+ isAutoincrement: false;
2164
+ hasRuntimeDefault: false;
2165
+ enumValues: [string, ...string[]];
2166
+ baseColumn: never;
2167
+ identity: undefined;
2168
+ generated: undefined;
2169
+ }, {}, {}>;
2170
+ name: import("drizzle-orm/pg-core").PgColumn<{
2171
+ name: "name";
2172
+ tableName: "custom_pickup_areas";
2173
+ dataType: "string";
2174
+ columnType: "PgText";
2175
+ data: string;
2176
+ driverParam: string;
2177
+ notNull: true;
2178
+ hasDefault: false;
2179
+ isPrimaryKey: false;
2180
+ isAutoincrement: false;
2181
+ hasRuntimeDefault: false;
2182
+ enumValues: [string, ...string[]];
2183
+ baseColumn: never;
2184
+ identity: undefined;
2185
+ generated: undefined;
2186
+ }, {}, {}>;
2187
+ description: import("drizzle-orm/pg-core").PgColumn<{
2188
+ name: "description";
2189
+ tableName: "custom_pickup_areas";
2190
+ dataType: "string";
2191
+ columnType: "PgText";
2192
+ data: string;
2193
+ driverParam: string;
2194
+ notNull: false;
2195
+ hasDefault: false;
2196
+ isPrimaryKey: false;
2197
+ isAutoincrement: false;
2198
+ hasRuntimeDefault: false;
2199
+ enumValues: [string, ...string[]];
2200
+ baseColumn: never;
2201
+ identity: undefined;
2202
+ generated: undefined;
2203
+ }, {}, {}>;
2204
+ geographicText: import("drizzle-orm/pg-core").PgColumn<{
2205
+ name: "geographic_text";
2206
+ tableName: "custom_pickup_areas";
2207
+ dataType: "string";
2208
+ columnType: "PgText";
2209
+ data: string;
2210
+ driverParam: string;
2211
+ notNull: false;
2212
+ hasDefault: false;
2213
+ isPrimaryKey: false;
2214
+ isAutoincrement: false;
2215
+ hasRuntimeDefault: false;
2216
+ enumValues: [string, ...string[]];
2217
+ baseColumn: never;
2218
+ identity: undefined;
2219
+ generated: undefined;
2220
+ }, {}, {}>;
2221
+ active: import("drizzle-orm/pg-core").PgColumn<{
2222
+ name: "active";
2223
+ tableName: "custom_pickup_areas";
2224
+ dataType: "boolean";
2225
+ columnType: "PgBoolean";
2226
+ data: boolean;
2227
+ driverParam: boolean;
2228
+ notNull: true;
2229
+ hasDefault: true;
2230
+ isPrimaryKey: false;
2231
+ isAutoincrement: false;
2232
+ hasRuntimeDefault: false;
2233
+ enumValues: undefined;
2234
+ baseColumn: never;
2235
+ identity: undefined;
2236
+ generated: undefined;
2237
+ }, {}, {}>;
2238
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2239
+ name: "created_at";
2240
+ tableName: "custom_pickup_areas";
2241
+ dataType: "date";
2242
+ columnType: "PgTimestamp";
2243
+ data: Date;
2244
+ driverParam: string;
2245
+ notNull: true;
2246
+ hasDefault: true;
2247
+ isPrimaryKey: false;
2248
+ isAutoincrement: false;
2249
+ hasRuntimeDefault: false;
2250
+ enumValues: undefined;
2251
+ baseColumn: never;
2252
+ identity: undefined;
2253
+ generated: undefined;
2254
+ }, {}, {}>;
2255
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2256
+ name: "updated_at";
2257
+ tableName: "custom_pickup_areas";
2258
+ dataType: "date";
2259
+ columnType: "PgTimestamp";
2260
+ data: Date;
2261
+ driverParam: string;
2262
+ notNull: true;
2263
+ hasDefault: true;
2264
+ isPrimaryKey: false;
2265
+ isAutoincrement: false;
2266
+ hasRuntimeDefault: false;
2267
+ enumValues: undefined;
2268
+ baseColumn: never;
2269
+ identity: undefined;
2270
+ generated: undefined;
2271
+ }, {}, {}>;
2272
+ };
2273
+ dialect: "pg";
2274
+ }>;
2275
+ export type AvailabilityRule = typeof availabilityRules.$inferSelect;
2276
+ export type NewAvailabilityRule = typeof availabilityRules.$inferInsert;
2277
+ export type AvailabilityStartTime = typeof availabilityStartTimes.$inferSelect;
2278
+ export type NewAvailabilityStartTime = typeof availabilityStartTimes.$inferInsert;
2279
+ export type AvailabilitySlot = typeof availabilitySlots.$inferSelect;
2280
+ export type NewAvailabilitySlot = typeof availabilitySlots.$inferInsert;
2281
+ export type AvailabilityCloseout = typeof availabilityCloseouts.$inferSelect;
2282
+ export type NewAvailabilityCloseout = typeof availabilityCloseouts.$inferInsert;
2283
+ export type AvailabilityPickupPoint = typeof availabilityPickupPoints.$inferSelect;
2284
+ export type NewAvailabilityPickupPoint = typeof availabilityPickupPoints.$inferInsert;
2285
+ export type AvailabilitySlotPickup = typeof availabilitySlotPickups.$inferSelect;
2286
+ export type NewAvailabilitySlotPickup = typeof availabilitySlotPickups.$inferInsert;
2287
+ export type ProductMeetingConfig = typeof productMeetingConfigs.$inferSelect;
2288
+ export type NewProductMeetingConfig = typeof productMeetingConfigs.$inferInsert;
2289
+ export type PickupGroup = typeof pickupGroups.$inferSelect;
2290
+ export type NewPickupGroup = typeof pickupGroups.$inferInsert;
2291
+ export type PickupLocation = typeof pickupLocations.$inferSelect;
2292
+ export type NewPickupLocation = typeof pickupLocations.$inferInsert;
2293
+ export type LocationPickupTime = typeof locationPickupTimes.$inferSelect;
2294
+ export type NewLocationPickupTime = typeof locationPickupTimes.$inferInsert;
2295
+ export type CustomPickupArea = typeof customPickupAreas.$inferSelect;
2296
+ export type NewCustomPickupArea = typeof customPickupAreas.$inferInsert;
2297
+ export declare const availabilityRulesRelations: import("drizzle-orm").Relations<"availability_rules", {
2298
+ slots: import("drizzle-orm").Many<"availability_slots">;
2299
+ }>;
2300
+ export declare const availabilityStartTimesRelations: import("drizzle-orm").Relations<"availability_start_times", {
2301
+ slots: import("drizzle-orm").Many<"availability_slots">;
2302
+ locationPickupTimes: import("drizzle-orm").Many<"location_pickup_times">;
2303
+ }>;
2304
+ export declare const availabilitySlotsRelations: import("drizzle-orm").Relations<"availability_slots", {
2305
+ rule: import("drizzle-orm").One<"availability_rules", false>;
2306
+ startTime: import("drizzle-orm").One<"availability_start_times", false>;
2307
+ pickups: import("drizzle-orm").Many<"availability_slot_pickups">;
2308
+ closeouts: import("drizzle-orm").Many<"availability_closeouts">;
2309
+ locationPickupTimes: import("drizzle-orm").Many<"location_pickup_times">;
2310
+ }>;
2311
+ export declare const availabilityCloseoutsRelations: import("drizzle-orm").Relations<"availability_closeouts", {
2312
+ slot: import("drizzle-orm").One<"availability_slots", false>;
2313
+ }>;
2314
+ export declare const availabilityPickupPointsRelations: import("drizzle-orm").Relations<"availability_pickup_points", {
2315
+ slotPickups: import("drizzle-orm").Many<"availability_slot_pickups">;
2316
+ }>;
2317
+ export declare const availabilitySlotPickupsRelations: import("drizzle-orm").Relations<"availability_slot_pickups", {
2318
+ slot: import("drizzle-orm").One<"availability_slots", true>;
2319
+ pickupPoint: import("drizzle-orm").One<"availability_pickup_points", true>;
2320
+ }>;
2321
+ export declare const productMeetingConfigsRelations: import("drizzle-orm").Relations<"product_meeting_configs", {
2322
+ pickupGroups: import("drizzle-orm").Many<"pickup_groups">;
2323
+ customPickupAreas: import("drizzle-orm").Many<"custom_pickup_areas">;
2324
+ }>;
2325
+ export declare const pickupGroupsRelations: import("drizzle-orm").Relations<"pickup_groups", {
2326
+ meetingConfig: import("drizzle-orm").One<"product_meeting_configs", true>;
2327
+ locations: import("drizzle-orm").Many<"pickup_locations">;
2328
+ }>;
2329
+ export declare const pickupLocationsRelations: import("drizzle-orm").Relations<"pickup_locations", {
2330
+ group: import("drizzle-orm").One<"pickup_groups", true>;
2331
+ pickupTimes: import("drizzle-orm").Many<"location_pickup_times">;
2332
+ }>;
2333
+ export declare const locationPickupTimesRelations: import("drizzle-orm").Relations<"location_pickup_times", {
2334
+ pickupLocation: import("drizzle-orm").One<"pickup_locations", true>;
2335
+ slot: import("drizzle-orm").One<"availability_slots", false>;
2336
+ startTime: import("drizzle-orm").One<"availability_start_times", false>;
2337
+ }>;
2338
+ export declare const customPickupAreasRelations: import("drizzle-orm").Relations<"custom_pickup_areas", {
2339
+ meetingConfig: import("drizzle-orm").One<"product_meeting_configs", true>;
2340
+ }>;
2341
+ //# sourceMappingURL=schema.d.ts.map