@voyantjs/ground 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (18) hide show
  1. package/LICENSE +109 -0
  2. package/README.md +42 -0
  3. package/dist/index.d.ts +11 -0
  4. package/dist/index.d.ts.map +1 -0
  5. package/dist/index.js +12 -0
  6. package/dist/routes.d.ts +1955 -0
  7. package/dist/routes.d.ts.map +1 -0
  8. package/dist/routes.js +316 -0
  9. package/dist/schema.d.ts +2797 -0
  10. package/dist/schema.d.ts.map +1 -0
  11. package/dist/schema.js +513 -0
  12. package/dist/service.d.ts +847 -0
  13. package/dist/service.d.ts.map +1 -0
  14. package/dist/service.js +630 -0
  15. package/dist/validation.d.ts +716 -0
  16. package/dist/validation.d.ts.map +1 -0
  17. package/dist/validation.js +298 -0
  18. package/package.json +53 -0
package/dist/schema.d.ts ADDED
@@ -0,0 +1,2797 @@
1
+ export declare const groundVehicleCategoryEnum: import("drizzle-orm/pg-core").PgEnum<["car", "sedan", "suv", "van", "minibus", "bus", "boat", "train", "other"]>;
2
+ export declare const groundVehicleClassEnum: import("drizzle-orm/pg-core").PgEnum<["economy", "standard", "premium", "luxury", "accessible", "other"]>;
3
+ export declare const groundServiceLevelEnum: import("drizzle-orm/pg-core").PgEnum<["private", "shared", "vip", "shuttle", "other"]>;
4
+ export declare const groundDispatchStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "scheduled", "assigned", "en_route", "arrived", "picked_up", "completed", "cancelled", "no_show"]>;
5
+ export declare const groundExecutionEventTypeEnum: import("drizzle-orm/pg-core").PgEnum<["scheduled", "assigned", "driver_en_route", "driver_arrived", "pickup_completed", "dropoff_completed", "cancelled", "issue", "note"]>;
6
+ export declare const groundAssignmentSourceEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "suggested", "auto"]>;
7
+ export declare const groundDispatchLegTypeEnum: import("drizzle-orm/pg-core").PgEnum<["pickup", "stop", "dropoff", "deadhead"]>;
8
+ export declare const groundDriverShiftStatusEnum: import("drizzle-orm/pg-core").PgEnum<["scheduled", "available", "on_duty", "completed", "cancelled"]>;
9
+ export declare const groundIncidentSeverityEnum: import("drizzle-orm/pg-core").PgEnum<["info", "warning", "critical"]>;
10
+ export declare const groundIncidentResolutionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "mitigated", "resolved", "cancelled"]>;
11
+ export declare const groundCheckpointStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "reached", "missed", "cancelled"]>;
12
+ export declare const groundOperators: import("drizzle-orm/pg-core").PgTableWithColumns<{
13
+ name: "ground_operators";
14
+ schema: undefined;
15
+ columns: {
16
+ id: import("drizzle-orm/pg-core").PgColumn<{
17
+ name: string;
18
+ tableName: "ground_operators";
19
+ dataType: "string";
20
+ columnType: "PgText";
21
+ data: string;
22
+ driverParam: string;
23
+ notNull: true;
24
+ hasDefault: true;
25
+ isPrimaryKey: true;
26
+ isAutoincrement: false;
27
+ hasRuntimeDefault: true;
28
+ enumValues: [string, ...string[]];
29
+ baseColumn: never;
30
+ identity: undefined;
31
+ generated: undefined;
32
+ }, {}, {}>;
33
+ supplierId: import("drizzle-orm/pg-core").PgColumn<{
34
+ name: "supplier_id";
35
+ tableName: "ground_operators";
36
+ dataType: "string";
37
+ columnType: "PgText";
38
+ data: string;
39
+ driverParam: string;
40
+ notNull: false;
41
+ hasDefault: false;
42
+ isPrimaryKey: false;
43
+ isAutoincrement: false;
44
+ hasRuntimeDefault: false;
45
+ enumValues: [string, ...string[]];
46
+ baseColumn: never;
47
+ identity: undefined;
48
+ generated: undefined;
49
+ }, {}, {}>;
50
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
51
+ name: string;
52
+ tableName: "ground_operators";
53
+ dataType: "string";
54
+ columnType: "PgText";
55
+ data: string;
56
+ driverParam: string;
57
+ notNull: false;
58
+ hasDefault: false;
59
+ isPrimaryKey: false;
60
+ isAutoincrement: false;
61
+ hasRuntimeDefault: false;
62
+ enumValues: [string, ...string[]];
63
+ baseColumn: never;
64
+ identity: undefined;
65
+ generated: undefined;
66
+ }, {}, {}>;
67
+ name: import("drizzle-orm/pg-core").PgColumn<{
68
+ name: "name";
69
+ tableName: "ground_operators";
70
+ dataType: "string";
71
+ columnType: "PgText";
72
+ data: string;
73
+ driverParam: string;
74
+ notNull: true;
75
+ hasDefault: false;
76
+ isPrimaryKey: false;
77
+ isAutoincrement: false;
78
+ hasRuntimeDefault: false;
79
+ enumValues: [string, ...string[]];
80
+ baseColumn: never;
81
+ identity: undefined;
82
+ generated: undefined;
83
+ }, {}, {}>;
84
+ code: import("drizzle-orm/pg-core").PgColumn<{
85
+ name: "code";
86
+ tableName: "ground_operators";
87
+ dataType: "string";
88
+ columnType: "PgText";
89
+ data: string;
90
+ driverParam: string;
91
+ notNull: false;
92
+ hasDefault: false;
93
+ isPrimaryKey: false;
94
+ isAutoincrement: false;
95
+ hasRuntimeDefault: false;
96
+ enumValues: [string, ...string[]];
97
+ baseColumn: never;
98
+ identity: undefined;
99
+ generated: undefined;
100
+ }, {}, {}>;
101
+ active: import("drizzle-orm/pg-core").PgColumn<{
102
+ name: "active";
103
+ tableName: "ground_operators";
104
+ dataType: "boolean";
105
+ columnType: "PgBoolean";
106
+ data: boolean;
107
+ driverParam: boolean;
108
+ notNull: true;
109
+ hasDefault: true;
110
+ isPrimaryKey: false;
111
+ isAutoincrement: false;
112
+ hasRuntimeDefault: false;
113
+ enumValues: undefined;
114
+ baseColumn: never;
115
+ identity: undefined;
116
+ generated: undefined;
117
+ }, {}, {}>;
118
+ notes: import("drizzle-orm/pg-core").PgColumn<{
119
+ name: "notes";
120
+ tableName: "ground_operators";
121
+ dataType: "string";
122
+ columnType: "PgText";
123
+ data: string;
124
+ driverParam: string;
125
+ notNull: false;
126
+ hasDefault: false;
127
+ isPrimaryKey: false;
128
+ isAutoincrement: false;
129
+ hasRuntimeDefault: false;
130
+ enumValues: [string, ...string[]];
131
+ baseColumn: never;
132
+ identity: undefined;
133
+ generated: undefined;
134
+ }, {}, {}>;
135
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
136
+ name: "created_at";
137
+ tableName: "ground_operators";
138
+ dataType: "date";
139
+ columnType: "PgTimestamp";
140
+ data: Date;
141
+ driverParam: string;
142
+ notNull: true;
143
+ hasDefault: true;
144
+ isPrimaryKey: false;
145
+ isAutoincrement: false;
146
+ hasRuntimeDefault: false;
147
+ enumValues: undefined;
148
+ baseColumn: never;
149
+ identity: undefined;
150
+ generated: undefined;
151
+ }, {}, {}>;
152
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
153
+ name: "updated_at";
154
+ tableName: "ground_operators";
155
+ dataType: "date";
156
+ columnType: "PgTimestamp";
157
+ data: Date;
158
+ driverParam: string;
159
+ notNull: true;
160
+ hasDefault: true;
161
+ isPrimaryKey: false;
162
+ isAutoincrement: false;
163
+ hasRuntimeDefault: false;
164
+ enumValues: undefined;
165
+ baseColumn: never;
166
+ identity: undefined;
167
+ generated: undefined;
168
+ }, {}, {}>;
169
+ };
170
+ dialect: "pg";
171
+ }>;
172
+ export declare const groundVehicles: import("drizzle-orm/pg-core").PgTableWithColumns<{
173
+ name: "ground_vehicles";
174
+ schema: undefined;
175
+ columns: {
176
+ id: import("drizzle-orm/pg-core").PgColumn<{
177
+ name: string;
178
+ tableName: "ground_vehicles";
179
+ dataType: "string";
180
+ columnType: "PgText";
181
+ data: string;
182
+ driverParam: string;
183
+ notNull: true;
184
+ hasDefault: true;
185
+ isPrimaryKey: true;
186
+ isAutoincrement: false;
187
+ hasRuntimeDefault: true;
188
+ enumValues: [string, ...string[]];
189
+ baseColumn: never;
190
+ identity: undefined;
191
+ generated: undefined;
192
+ }, {}, {}>;
193
+ resourceId: import("drizzle-orm/pg-core").PgColumn<{
194
+ name: "resource_id";
195
+ tableName: "ground_vehicles";
196
+ dataType: "string";
197
+ columnType: "PgText";
198
+ data: string;
199
+ driverParam: string;
200
+ notNull: true;
201
+ hasDefault: false;
202
+ isPrimaryKey: false;
203
+ isAutoincrement: false;
204
+ hasRuntimeDefault: false;
205
+ enumValues: [string, ...string[]];
206
+ baseColumn: never;
207
+ identity: undefined;
208
+ generated: undefined;
209
+ }, {}, {}>;
210
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
211
+ name: string;
212
+ tableName: "ground_vehicles";
213
+ dataType: "string";
214
+ columnType: "PgText";
215
+ data: string;
216
+ driverParam: string;
217
+ notNull: false;
218
+ hasDefault: false;
219
+ isPrimaryKey: false;
220
+ isAutoincrement: false;
221
+ hasRuntimeDefault: false;
222
+ enumValues: [string, ...string[]];
223
+ baseColumn: never;
224
+ identity: undefined;
225
+ generated: undefined;
226
+ }, {}, {}>;
227
+ category: import("drizzle-orm/pg-core").PgColumn<{
228
+ name: "category";
229
+ tableName: "ground_vehicles";
230
+ dataType: "string";
231
+ columnType: "PgEnumColumn";
232
+ data: "other" | "car" | "sedan" | "suv" | "van" | "minibus" | "bus" | "boat" | "train";
233
+ driverParam: string;
234
+ notNull: true;
235
+ hasDefault: true;
236
+ isPrimaryKey: false;
237
+ isAutoincrement: false;
238
+ hasRuntimeDefault: false;
239
+ enumValues: ["car", "sedan", "suv", "van", "minibus", "bus", "boat", "train", "other"];
240
+ baseColumn: never;
241
+ identity: undefined;
242
+ generated: undefined;
243
+ }, {}, {}>;
244
+ vehicleClass: import("drizzle-orm/pg-core").PgColumn<{
245
+ name: "vehicle_class";
246
+ tableName: "ground_vehicles";
247
+ dataType: "string";
248
+ columnType: "PgEnumColumn";
249
+ data: "other" | "economy" | "standard" | "premium" | "luxury" | "accessible";
250
+ driverParam: string;
251
+ notNull: true;
252
+ hasDefault: true;
253
+ isPrimaryKey: false;
254
+ isAutoincrement: false;
255
+ hasRuntimeDefault: false;
256
+ enumValues: ["economy", "standard", "premium", "luxury", "accessible", "other"];
257
+ baseColumn: never;
258
+ identity: undefined;
259
+ generated: undefined;
260
+ }, {}, {}>;
261
+ passengerCapacity: import("drizzle-orm/pg-core").PgColumn<{
262
+ name: "passenger_capacity";
263
+ tableName: "ground_vehicles";
264
+ dataType: "number";
265
+ columnType: "PgInteger";
266
+ data: number;
267
+ driverParam: string | number;
268
+ notNull: false;
269
+ hasDefault: false;
270
+ isPrimaryKey: false;
271
+ isAutoincrement: false;
272
+ hasRuntimeDefault: false;
273
+ enumValues: undefined;
274
+ baseColumn: never;
275
+ identity: undefined;
276
+ generated: undefined;
277
+ }, {}, {}>;
278
+ checkedBagCapacity: import("drizzle-orm/pg-core").PgColumn<{
279
+ name: "checked_bag_capacity";
280
+ tableName: "ground_vehicles";
281
+ dataType: "number";
282
+ columnType: "PgInteger";
283
+ data: number;
284
+ driverParam: string | number;
285
+ notNull: false;
286
+ hasDefault: false;
287
+ isPrimaryKey: false;
288
+ isAutoincrement: false;
289
+ hasRuntimeDefault: false;
290
+ enumValues: undefined;
291
+ baseColumn: never;
292
+ identity: undefined;
293
+ generated: undefined;
294
+ }, {}, {}>;
295
+ carryOnCapacity: import("drizzle-orm/pg-core").PgColumn<{
296
+ name: "carry_on_capacity";
297
+ tableName: "ground_vehicles";
298
+ dataType: "number";
299
+ columnType: "PgInteger";
300
+ data: number;
301
+ driverParam: string | number;
302
+ notNull: false;
303
+ hasDefault: false;
304
+ isPrimaryKey: false;
305
+ isAutoincrement: false;
306
+ hasRuntimeDefault: false;
307
+ enumValues: undefined;
308
+ baseColumn: never;
309
+ identity: undefined;
310
+ generated: undefined;
311
+ }, {}, {}>;
312
+ wheelchairCapacity: import("drizzle-orm/pg-core").PgColumn<{
313
+ name: "wheelchair_capacity";
314
+ tableName: "ground_vehicles";
315
+ dataType: "number";
316
+ columnType: "PgInteger";
317
+ data: number;
318
+ driverParam: string | number;
319
+ notNull: false;
320
+ hasDefault: false;
321
+ isPrimaryKey: false;
322
+ isAutoincrement: false;
323
+ hasRuntimeDefault: false;
324
+ enumValues: undefined;
325
+ baseColumn: never;
326
+ identity: undefined;
327
+ generated: undefined;
328
+ }, {}, {}>;
329
+ childSeatCapacity: import("drizzle-orm/pg-core").PgColumn<{
330
+ name: "child_seat_capacity";
331
+ tableName: "ground_vehicles";
332
+ dataType: "number";
333
+ columnType: "PgInteger";
334
+ data: number;
335
+ driverParam: string | number;
336
+ notNull: false;
337
+ hasDefault: false;
338
+ isPrimaryKey: false;
339
+ isAutoincrement: false;
340
+ hasRuntimeDefault: false;
341
+ enumValues: undefined;
342
+ baseColumn: never;
343
+ identity: undefined;
344
+ generated: undefined;
345
+ }, {}, {}>;
346
+ isAccessible: import("drizzle-orm/pg-core").PgColumn<{
347
+ name: "is_accessible";
348
+ tableName: "ground_vehicles";
349
+ dataType: "boolean";
350
+ columnType: "PgBoolean";
351
+ data: boolean;
352
+ driverParam: boolean;
353
+ notNull: true;
354
+ hasDefault: true;
355
+ isPrimaryKey: false;
356
+ isAutoincrement: false;
357
+ hasRuntimeDefault: false;
358
+ enumValues: undefined;
359
+ baseColumn: never;
360
+ identity: undefined;
361
+ generated: undefined;
362
+ }, {}, {}>;
363
+ active: import("drizzle-orm/pg-core").PgColumn<{
364
+ name: "active";
365
+ tableName: "ground_vehicles";
366
+ dataType: "boolean";
367
+ columnType: "PgBoolean";
368
+ data: boolean;
369
+ driverParam: boolean;
370
+ notNull: true;
371
+ hasDefault: true;
372
+ isPrimaryKey: false;
373
+ isAutoincrement: false;
374
+ hasRuntimeDefault: false;
375
+ enumValues: undefined;
376
+ baseColumn: never;
377
+ identity: undefined;
378
+ generated: undefined;
379
+ }, {}, {}>;
380
+ notes: import("drizzle-orm/pg-core").PgColumn<{
381
+ name: "notes";
382
+ tableName: "ground_vehicles";
383
+ dataType: "string";
384
+ columnType: "PgText";
385
+ data: string;
386
+ driverParam: string;
387
+ notNull: false;
388
+ hasDefault: false;
389
+ isPrimaryKey: false;
390
+ isAutoincrement: false;
391
+ hasRuntimeDefault: false;
392
+ enumValues: [string, ...string[]];
393
+ baseColumn: never;
394
+ identity: undefined;
395
+ generated: undefined;
396
+ }, {}, {}>;
397
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
398
+ name: "created_at";
399
+ tableName: "ground_vehicles";
400
+ dataType: "date";
401
+ columnType: "PgTimestamp";
402
+ data: Date;
403
+ driverParam: string;
404
+ notNull: true;
405
+ hasDefault: true;
406
+ isPrimaryKey: false;
407
+ isAutoincrement: false;
408
+ hasRuntimeDefault: false;
409
+ enumValues: undefined;
410
+ baseColumn: never;
411
+ identity: undefined;
412
+ generated: undefined;
413
+ }, {}, {}>;
414
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
415
+ name: "updated_at";
416
+ tableName: "ground_vehicles";
417
+ dataType: "date";
418
+ columnType: "PgTimestamp";
419
+ data: Date;
420
+ driverParam: string;
421
+ notNull: true;
422
+ hasDefault: true;
423
+ isPrimaryKey: false;
424
+ isAutoincrement: false;
425
+ hasRuntimeDefault: false;
426
+ enumValues: undefined;
427
+ baseColumn: never;
428
+ identity: undefined;
429
+ generated: undefined;
430
+ }, {}, {}>;
431
+ };
432
+ dialect: "pg";
433
+ }>;
434
+ export declare const groundDrivers: import("drizzle-orm/pg-core").PgTableWithColumns<{
435
+ name: "ground_drivers";
436
+ schema: undefined;
437
+ columns: {
438
+ id: import("drizzle-orm/pg-core").PgColumn<{
439
+ name: string;
440
+ tableName: "ground_drivers";
441
+ dataType: "string";
442
+ columnType: "PgText";
443
+ data: string;
444
+ driverParam: string;
445
+ notNull: true;
446
+ hasDefault: true;
447
+ isPrimaryKey: true;
448
+ isAutoincrement: false;
449
+ hasRuntimeDefault: true;
450
+ enumValues: [string, ...string[]];
451
+ baseColumn: never;
452
+ identity: undefined;
453
+ generated: undefined;
454
+ }, {}, {}>;
455
+ resourceId: import("drizzle-orm/pg-core").PgColumn<{
456
+ name: "resource_id";
457
+ tableName: "ground_drivers";
458
+ dataType: "string";
459
+ columnType: "PgText";
460
+ data: string;
461
+ driverParam: string;
462
+ notNull: true;
463
+ hasDefault: false;
464
+ isPrimaryKey: false;
465
+ isAutoincrement: false;
466
+ hasRuntimeDefault: false;
467
+ enumValues: [string, ...string[]];
468
+ baseColumn: never;
469
+ identity: undefined;
470
+ generated: undefined;
471
+ }, {}, {}>;
472
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
473
+ name: string;
474
+ tableName: "ground_drivers";
475
+ dataType: "string";
476
+ columnType: "PgText";
477
+ data: string;
478
+ driverParam: string;
479
+ notNull: false;
480
+ hasDefault: false;
481
+ isPrimaryKey: false;
482
+ isAutoincrement: false;
483
+ hasRuntimeDefault: false;
484
+ enumValues: [string, ...string[]];
485
+ baseColumn: never;
486
+ identity: undefined;
487
+ generated: undefined;
488
+ }, {}, {}>;
489
+ licenseNumber: import("drizzle-orm/pg-core").PgColumn<{
490
+ name: "license_number";
491
+ tableName: "ground_drivers";
492
+ dataType: "string";
493
+ columnType: "PgText";
494
+ data: string;
495
+ driverParam: string;
496
+ notNull: false;
497
+ hasDefault: false;
498
+ isPrimaryKey: false;
499
+ isAutoincrement: false;
500
+ hasRuntimeDefault: false;
501
+ enumValues: [string, ...string[]];
502
+ baseColumn: never;
503
+ identity: undefined;
504
+ generated: undefined;
505
+ }, {}, {}>;
506
+ spokenLanguages: import("drizzle-orm/pg-core").PgColumn<{
507
+ name: "spoken_languages";
508
+ tableName: "ground_drivers";
509
+ dataType: "json";
510
+ columnType: "PgJsonb";
511
+ data: string[];
512
+ driverParam: unknown;
513
+ notNull: true;
514
+ hasDefault: true;
515
+ isPrimaryKey: false;
516
+ isAutoincrement: false;
517
+ hasRuntimeDefault: false;
518
+ enumValues: undefined;
519
+ baseColumn: never;
520
+ identity: undefined;
521
+ generated: undefined;
522
+ }, {}, {
523
+ $type: string[];
524
+ }>;
525
+ isGuide: import("drizzle-orm/pg-core").PgColumn<{
526
+ name: "is_guide";
527
+ tableName: "ground_drivers";
528
+ dataType: "boolean";
529
+ columnType: "PgBoolean";
530
+ data: boolean;
531
+ driverParam: boolean;
532
+ notNull: true;
533
+ hasDefault: true;
534
+ isPrimaryKey: false;
535
+ isAutoincrement: false;
536
+ hasRuntimeDefault: false;
537
+ enumValues: undefined;
538
+ baseColumn: never;
539
+ identity: undefined;
540
+ generated: undefined;
541
+ }, {}, {}>;
542
+ isMeetAndGreetCapable: import("drizzle-orm/pg-core").PgColumn<{
543
+ name: "is_meet_and_greet_capable";
544
+ tableName: "ground_drivers";
545
+ dataType: "boolean";
546
+ columnType: "PgBoolean";
547
+ data: boolean;
548
+ driverParam: boolean;
549
+ notNull: true;
550
+ hasDefault: true;
551
+ isPrimaryKey: false;
552
+ isAutoincrement: false;
553
+ hasRuntimeDefault: false;
554
+ enumValues: undefined;
555
+ baseColumn: never;
556
+ identity: undefined;
557
+ generated: undefined;
558
+ }, {}, {}>;
559
+ active: import("drizzle-orm/pg-core").PgColumn<{
560
+ name: "active";
561
+ tableName: "ground_drivers";
562
+ dataType: "boolean";
563
+ columnType: "PgBoolean";
564
+ data: boolean;
565
+ driverParam: boolean;
566
+ notNull: true;
567
+ hasDefault: true;
568
+ isPrimaryKey: false;
569
+ isAutoincrement: false;
570
+ hasRuntimeDefault: false;
571
+ enumValues: undefined;
572
+ baseColumn: never;
573
+ identity: undefined;
574
+ generated: undefined;
575
+ }, {}, {}>;
576
+ notes: import("drizzle-orm/pg-core").PgColumn<{
577
+ name: "notes";
578
+ tableName: "ground_drivers";
579
+ dataType: "string";
580
+ columnType: "PgText";
581
+ data: string;
582
+ driverParam: string;
583
+ notNull: false;
584
+ hasDefault: false;
585
+ isPrimaryKey: false;
586
+ isAutoincrement: false;
587
+ hasRuntimeDefault: false;
588
+ enumValues: [string, ...string[]];
589
+ baseColumn: never;
590
+ identity: undefined;
591
+ generated: undefined;
592
+ }, {}, {}>;
593
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
594
+ name: "created_at";
595
+ tableName: "ground_drivers";
596
+ dataType: "date";
597
+ columnType: "PgTimestamp";
598
+ data: Date;
599
+ driverParam: string;
600
+ notNull: true;
601
+ hasDefault: true;
602
+ isPrimaryKey: false;
603
+ isAutoincrement: false;
604
+ hasRuntimeDefault: false;
605
+ enumValues: undefined;
606
+ baseColumn: never;
607
+ identity: undefined;
608
+ generated: undefined;
609
+ }, {}, {}>;
610
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
611
+ name: "updated_at";
612
+ tableName: "ground_drivers";
613
+ dataType: "date";
614
+ columnType: "PgTimestamp";
615
+ data: Date;
616
+ driverParam: string;
617
+ notNull: true;
618
+ hasDefault: true;
619
+ isPrimaryKey: false;
620
+ isAutoincrement: false;
621
+ hasRuntimeDefault: false;
622
+ enumValues: undefined;
623
+ baseColumn: never;
624
+ identity: undefined;
625
+ generated: undefined;
626
+ }, {}, {}>;
627
+ };
628
+ dialect: "pg";
629
+ }>;
630
+ export declare const groundTransferPreferences: import("drizzle-orm/pg-core").PgTableWithColumns<{
631
+ name: "ground_transfer_preferences";
632
+ schema: undefined;
633
+ columns: {
634
+ id: import("drizzle-orm/pg-core").PgColumn<{
635
+ name: string;
636
+ tableName: "ground_transfer_preferences";
637
+ dataType: "string";
638
+ columnType: "PgText";
639
+ data: string;
640
+ driverParam: string;
641
+ notNull: true;
642
+ hasDefault: true;
643
+ isPrimaryKey: true;
644
+ isAutoincrement: false;
645
+ hasRuntimeDefault: true;
646
+ enumValues: [string, ...string[]];
647
+ baseColumn: never;
648
+ identity: undefined;
649
+ generated: undefined;
650
+ }, {}, {}>;
651
+ bookingId: import("drizzle-orm/pg-core").PgColumn<{
652
+ name: "booking_id";
653
+ tableName: "ground_transfer_preferences";
654
+ dataType: "string";
655
+ columnType: "PgText";
656
+ data: string;
657
+ driverParam: string;
658
+ notNull: true;
659
+ hasDefault: false;
660
+ isPrimaryKey: false;
661
+ isAutoincrement: false;
662
+ hasRuntimeDefault: false;
663
+ enumValues: [string, ...string[]];
664
+ baseColumn: never;
665
+ identity: undefined;
666
+ generated: undefined;
667
+ }, {}, {}>;
668
+ bookingItemId: import("drizzle-orm/pg-core").PgColumn<{
669
+ name: "booking_item_id";
670
+ tableName: "ground_transfer_preferences";
671
+ dataType: "string";
672
+ columnType: "PgText";
673
+ data: string;
674
+ driverParam: string;
675
+ notNull: false;
676
+ hasDefault: false;
677
+ isPrimaryKey: false;
678
+ isAutoincrement: false;
679
+ hasRuntimeDefault: false;
680
+ enumValues: [string, ...string[]];
681
+ baseColumn: never;
682
+ identity: undefined;
683
+ generated: undefined;
684
+ }, {}, {}>;
685
+ pickupFacilityId: import("drizzle-orm/pg-core").PgColumn<{
686
+ name: string;
687
+ tableName: "ground_transfer_preferences";
688
+ dataType: "string";
689
+ columnType: "PgText";
690
+ data: string;
691
+ driverParam: string;
692
+ notNull: false;
693
+ hasDefault: false;
694
+ isPrimaryKey: false;
695
+ isAutoincrement: false;
696
+ hasRuntimeDefault: false;
697
+ enumValues: [string, ...string[]];
698
+ baseColumn: never;
699
+ identity: undefined;
700
+ generated: undefined;
701
+ }, {}, {}>;
702
+ dropoffFacilityId: import("drizzle-orm/pg-core").PgColumn<{
703
+ name: string;
704
+ tableName: "ground_transfer_preferences";
705
+ dataType: "string";
706
+ columnType: "PgText";
707
+ data: string;
708
+ driverParam: string;
709
+ notNull: false;
710
+ hasDefault: false;
711
+ isPrimaryKey: false;
712
+ isAutoincrement: false;
713
+ hasRuntimeDefault: false;
714
+ enumValues: [string, ...string[]];
715
+ baseColumn: never;
716
+ identity: undefined;
717
+ generated: undefined;
718
+ }, {}, {}>;
719
+ pickupAddressId: import("drizzle-orm/pg-core").PgColumn<{
720
+ name: string;
721
+ tableName: "ground_transfer_preferences";
722
+ dataType: "string";
723
+ columnType: "PgText";
724
+ data: string;
725
+ driverParam: string;
726
+ notNull: false;
727
+ hasDefault: false;
728
+ isPrimaryKey: false;
729
+ isAutoincrement: false;
730
+ hasRuntimeDefault: false;
731
+ enumValues: [string, ...string[]];
732
+ baseColumn: never;
733
+ identity: undefined;
734
+ generated: undefined;
735
+ }, {}, {}>;
736
+ dropoffAddressId: import("drizzle-orm/pg-core").PgColumn<{
737
+ name: string;
738
+ tableName: "ground_transfer_preferences";
739
+ dataType: "string";
740
+ columnType: "PgText";
741
+ data: string;
742
+ driverParam: string;
743
+ notNull: false;
744
+ hasDefault: false;
745
+ isPrimaryKey: false;
746
+ isAutoincrement: false;
747
+ hasRuntimeDefault: false;
748
+ enumValues: [string, ...string[]];
749
+ baseColumn: never;
750
+ identity: undefined;
751
+ generated: undefined;
752
+ }, {}, {}>;
753
+ requestedVehicleCategory: import("drizzle-orm/pg-core").PgColumn<{
754
+ name: "requested_vehicle_category";
755
+ tableName: "ground_transfer_preferences";
756
+ dataType: "string";
757
+ columnType: "PgEnumColumn";
758
+ data: "other" | "car" | "sedan" | "suv" | "van" | "minibus" | "bus" | "boat" | "train";
759
+ driverParam: string;
760
+ notNull: false;
761
+ hasDefault: false;
762
+ isPrimaryKey: false;
763
+ isAutoincrement: false;
764
+ hasRuntimeDefault: false;
765
+ enumValues: ["car", "sedan", "suv", "van", "minibus", "bus", "boat", "train", "other"];
766
+ baseColumn: never;
767
+ identity: undefined;
768
+ generated: undefined;
769
+ }, {}, {}>;
770
+ requestedVehicleClass: import("drizzle-orm/pg-core").PgColumn<{
771
+ name: "requested_vehicle_class";
772
+ tableName: "ground_transfer_preferences";
773
+ dataType: "string";
774
+ columnType: "PgEnumColumn";
775
+ data: "other" | "economy" | "standard" | "premium" | "luxury" | "accessible";
776
+ driverParam: string;
777
+ notNull: false;
778
+ hasDefault: false;
779
+ isPrimaryKey: false;
780
+ isAutoincrement: false;
781
+ hasRuntimeDefault: false;
782
+ enumValues: ["economy", "standard", "premium", "luxury", "accessible", "other"];
783
+ baseColumn: never;
784
+ identity: undefined;
785
+ generated: undefined;
786
+ }, {}, {}>;
787
+ serviceLevel: import("drizzle-orm/pg-core").PgColumn<{
788
+ name: "service_level";
789
+ tableName: "ground_transfer_preferences";
790
+ dataType: "string";
791
+ columnType: "PgEnumColumn";
792
+ data: "other" | "private" | "shared" | "vip" | "shuttle";
793
+ driverParam: string;
794
+ notNull: true;
795
+ hasDefault: true;
796
+ isPrimaryKey: false;
797
+ isAutoincrement: false;
798
+ hasRuntimeDefault: false;
799
+ enumValues: ["private", "shared", "vip", "shuttle", "other"];
800
+ baseColumn: never;
801
+ identity: undefined;
802
+ generated: undefined;
803
+ }, {}, {}>;
804
+ passengerCount: import("drizzle-orm/pg-core").PgColumn<{
805
+ name: "passenger_count";
806
+ tableName: "ground_transfer_preferences";
807
+ dataType: "number";
808
+ columnType: "PgInteger";
809
+ data: number;
810
+ driverParam: string | number;
811
+ notNull: false;
812
+ hasDefault: false;
813
+ isPrimaryKey: false;
814
+ isAutoincrement: false;
815
+ hasRuntimeDefault: false;
816
+ enumValues: undefined;
817
+ baseColumn: never;
818
+ identity: undefined;
819
+ generated: undefined;
820
+ }, {}, {}>;
821
+ checkedBags: import("drizzle-orm/pg-core").PgColumn<{
822
+ name: "checked_bags";
823
+ tableName: "ground_transfer_preferences";
824
+ dataType: "number";
825
+ columnType: "PgInteger";
826
+ data: number;
827
+ driverParam: string | number;
828
+ notNull: false;
829
+ hasDefault: false;
830
+ isPrimaryKey: false;
831
+ isAutoincrement: false;
832
+ hasRuntimeDefault: false;
833
+ enumValues: undefined;
834
+ baseColumn: never;
835
+ identity: undefined;
836
+ generated: undefined;
837
+ }, {}, {}>;
838
+ carryOnBags: import("drizzle-orm/pg-core").PgColumn<{
839
+ name: "carry_on_bags";
840
+ tableName: "ground_transfer_preferences";
841
+ dataType: "number";
842
+ columnType: "PgInteger";
843
+ data: number;
844
+ driverParam: string | number;
845
+ notNull: false;
846
+ hasDefault: false;
847
+ isPrimaryKey: false;
848
+ isAutoincrement: false;
849
+ hasRuntimeDefault: false;
850
+ enumValues: undefined;
851
+ baseColumn: never;
852
+ identity: undefined;
853
+ generated: undefined;
854
+ }, {}, {}>;
855
+ wheelchairCount: import("drizzle-orm/pg-core").PgColumn<{
856
+ name: "wheelchair_count";
857
+ tableName: "ground_transfer_preferences";
858
+ dataType: "number";
859
+ columnType: "PgInteger";
860
+ data: number;
861
+ driverParam: string | number;
862
+ notNull: false;
863
+ hasDefault: false;
864
+ isPrimaryKey: false;
865
+ isAutoincrement: false;
866
+ hasRuntimeDefault: false;
867
+ enumValues: undefined;
868
+ baseColumn: never;
869
+ identity: undefined;
870
+ generated: undefined;
871
+ }, {}, {}>;
872
+ childSeatCount: import("drizzle-orm/pg-core").PgColumn<{
873
+ name: "child_seat_count";
874
+ tableName: "ground_transfer_preferences";
875
+ dataType: "number";
876
+ columnType: "PgInteger";
877
+ data: number;
878
+ driverParam: string | number;
879
+ notNull: false;
880
+ hasDefault: false;
881
+ isPrimaryKey: false;
882
+ isAutoincrement: false;
883
+ hasRuntimeDefault: false;
884
+ enumValues: undefined;
885
+ baseColumn: never;
886
+ identity: undefined;
887
+ generated: undefined;
888
+ }, {}, {}>;
889
+ driverLanguage: import("drizzle-orm/pg-core").PgColumn<{
890
+ name: "driver_language";
891
+ tableName: "ground_transfer_preferences";
892
+ dataType: "string";
893
+ columnType: "PgText";
894
+ data: string;
895
+ driverParam: string;
896
+ notNull: false;
897
+ hasDefault: false;
898
+ isPrimaryKey: false;
899
+ isAutoincrement: false;
900
+ hasRuntimeDefault: false;
901
+ enumValues: [string, ...string[]];
902
+ baseColumn: never;
903
+ identity: undefined;
904
+ generated: undefined;
905
+ }, {}, {}>;
906
+ meetAndGreet: import("drizzle-orm/pg-core").PgColumn<{
907
+ name: "meet_and_greet";
908
+ tableName: "ground_transfer_preferences";
909
+ dataType: "boolean";
910
+ columnType: "PgBoolean";
911
+ data: boolean;
912
+ driverParam: boolean;
913
+ notNull: true;
914
+ hasDefault: true;
915
+ isPrimaryKey: false;
916
+ isAutoincrement: false;
917
+ hasRuntimeDefault: false;
918
+ enumValues: undefined;
919
+ baseColumn: never;
920
+ identity: undefined;
921
+ generated: undefined;
922
+ }, {}, {}>;
923
+ accessibilityNotes: import("drizzle-orm/pg-core").PgColumn<{
924
+ name: "accessibility_notes";
925
+ tableName: "ground_transfer_preferences";
926
+ dataType: "string";
927
+ columnType: "PgText";
928
+ data: string;
929
+ driverParam: string;
930
+ notNull: false;
931
+ hasDefault: false;
932
+ isPrimaryKey: false;
933
+ isAutoincrement: false;
934
+ hasRuntimeDefault: false;
935
+ enumValues: [string, ...string[]];
936
+ baseColumn: never;
937
+ identity: undefined;
938
+ generated: undefined;
939
+ }, {}, {}>;
940
+ pickupNotes: import("drizzle-orm/pg-core").PgColumn<{
941
+ name: "pickup_notes";
942
+ tableName: "ground_transfer_preferences";
943
+ dataType: "string";
944
+ columnType: "PgText";
945
+ data: string;
946
+ driverParam: string;
947
+ notNull: false;
948
+ hasDefault: false;
949
+ isPrimaryKey: false;
950
+ isAutoincrement: false;
951
+ hasRuntimeDefault: false;
952
+ enumValues: [string, ...string[]];
953
+ baseColumn: never;
954
+ identity: undefined;
955
+ generated: undefined;
956
+ }, {}, {}>;
957
+ dropoffNotes: import("drizzle-orm/pg-core").PgColumn<{
958
+ name: "dropoff_notes";
959
+ tableName: "ground_transfer_preferences";
960
+ dataType: "string";
961
+ columnType: "PgText";
962
+ data: string;
963
+ driverParam: string;
964
+ notNull: false;
965
+ hasDefault: false;
966
+ isPrimaryKey: false;
967
+ isAutoincrement: false;
968
+ hasRuntimeDefault: false;
969
+ enumValues: [string, ...string[]];
970
+ baseColumn: never;
971
+ identity: undefined;
972
+ generated: undefined;
973
+ }, {}, {}>;
974
+ notes: import("drizzle-orm/pg-core").PgColumn<{
975
+ name: "notes";
976
+ tableName: "ground_transfer_preferences";
977
+ dataType: "string";
978
+ columnType: "PgText";
979
+ data: string;
980
+ driverParam: string;
981
+ notNull: false;
982
+ hasDefault: false;
983
+ isPrimaryKey: false;
984
+ isAutoincrement: false;
985
+ hasRuntimeDefault: false;
986
+ enumValues: [string, ...string[]];
987
+ baseColumn: never;
988
+ identity: undefined;
989
+ generated: undefined;
990
+ }, {}, {}>;
991
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
992
+ name: "created_at";
993
+ tableName: "ground_transfer_preferences";
994
+ dataType: "date";
995
+ columnType: "PgTimestamp";
996
+ data: Date;
997
+ driverParam: string;
998
+ notNull: true;
999
+ hasDefault: true;
1000
+ isPrimaryKey: false;
1001
+ isAutoincrement: false;
1002
+ hasRuntimeDefault: false;
1003
+ enumValues: undefined;
1004
+ baseColumn: never;
1005
+ identity: undefined;
1006
+ generated: undefined;
1007
+ }, {}, {}>;
1008
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1009
+ name: "updated_at";
1010
+ tableName: "ground_transfer_preferences";
1011
+ dataType: "date";
1012
+ columnType: "PgTimestamp";
1013
+ data: Date;
1014
+ driverParam: string;
1015
+ notNull: true;
1016
+ hasDefault: true;
1017
+ isPrimaryKey: false;
1018
+ isAutoincrement: false;
1019
+ hasRuntimeDefault: false;
1020
+ enumValues: undefined;
1021
+ baseColumn: never;
1022
+ identity: undefined;
1023
+ generated: undefined;
1024
+ }, {}, {}>;
1025
+ };
1026
+ dialect: "pg";
1027
+ }>;
1028
+ export declare const groundDispatches: import("drizzle-orm/pg-core").PgTableWithColumns<{
1029
+ name: "ground_dispatches";
1030
+ schema: undefined;
1031
+ columns: {
1032
+ id: import("drizzle-orm/pg-core").PgColumn<{
1033
+ name: string;
1034
+ tableName: "ground_dispatches";
1035
+ dataType: "string";
1036
+ columnType: "PgText";
1037
+ data: string;
1038
+ driverParam: string;
1039
+ notNull: true;
1040
+ hasDefault: true;
1041
+ isPrimaryKey: true;
1042
+ isAutoincrement: false;
1043
+ hasRuntimeDefault: true;
1044
+ enumValues: [string, ...string[]];
1045
+ baseColumn: never;
1046
+ identity: undefined;
1047
+ generated: undefined;
1048
+ }, {}, {}>;
1049
+ transferPreferenceId: import("drizzle-orm/pg-core").PgColumn<{
1050
+ name: string;
1051
+ tableName: "ground_dispatches";
1052
+ dataType: "string";
1053
+ columnType: "PgText";
1054
+ data: string;
1055
+ driverParam: string;
1056
+ notNull: true;
1057
+ hasDefault: false;
1058
+ isPrimaryKey: false;
1059
+ isAutoincrement: false;
1060
+ hasRuntimeDefault: false;
1061
+ enumValues: [string, ...string[]];
1062
+ baseColumn: never;
1063
+ identity: undefined;
1064
+ generated: undefined;
1065
+ }, {}, {}>;
1066
+ bookingId: import("drizzle-orm/pg-core").PgColumn<{
1067
+ name: "booking_id";
1068
+ tableName: "ground_dispatches";
1069
+ dataType: "string";
1070
+ columnType: "PgText";
1071
+ data: string;
1072
+ driverParam: string;
1073
+ notNull: true;
1074
+ hasDefault: false;
1075
+ isPrimaryKey: false;
1076
+ isAutoincrement: false;
1077
+ hasRuntimeDefault: false;
1078
+ enumValues: [string, ...string[]];
1079
+ baseColumn: never;
1080
+ identity: undefined;
1081
+ generated: undefined;
1082
+ }, {}, {}>;
1083
+ bookingItemId: import("drizzle-orm/pg-core").PgColumn<{
1084
+ name: "booking_item_id";
1085
+ tableName: "ground_dispatches";
1086
+ dataType: "string";
1087
+ columnType: "PgText";
1088
+ data: string;
1089
+ driverParam: string;
1090
+ notNull: false;
1091
+ hasDefault: false;
1092
+ isPrimaryKey: false;
1093
+ isAutoincrement: false;
1094
+ hasRuntimeDefault: false;
1095
+ enumValues: [string, ...string[]];
1096
+ baseColumn: never;
1097
+ identity: undefined;
1098
+ generated: undefined;
1099
+ }, {}, {}>;
1100
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
1101
+ name: string;
1102
+ tableName: "ground_dispatches";
1103
+ dataType: "string";
1104
+ columnType: "PgText";
1105
+ data: string;
1106
+ driverParam: string;
1107
+ notNull: false;
1108
+ hasDefault: false;
1109
+ isPrimaryKey: false;
1110
+ isAutoincrement: false;
1111
+ hasRuntimeDefault: false;
1112
+ enumValues: [string, ...string[]];
1113
+ baseColumn: never;
1114
+ identity: undefined;
1115
+ generated: undefined;
1116
+ }, {}, {}>;
1117
+ vehicleId: import("drizzle-orm/pg-core").PgColumn<{
1118
+ name: string;
1119
+ tableName: "ground_dispatches";
1120
+ dataType: "string";
1121
+ columnType: "PgText";
1122
+ data: string;
1123
+ driverParam: string;
1124
+ notNull: false;
1125
+ hasDefault: false;
1126
+ isPrimaryKey: false;
1127
+ isAutoincrement: false;
1128
+ hasRuntimeDefault: false;
1129
+ enumValues: [string, ...string[]];
1130
+ baseColumn: never;
1131
+ identity: undefined;
1132
+ generated: undefined;
1133
+ }, {}, {}>;
1134
+ driverId: import("drizzle-orm/pg-core").PgColumn<{
1135
+ name: string;
1136
+ tableName: "ground_dispatches";
1137
+ dataType: "string";
1138
+ columnType: "PgText";
1139
+ data: string;
1140
+ driverParam: string;
1141
+ notNull: false;
1142
+ hasDefault: false;
1143
+ isPrimaryKey: false;
1144
+ isAutoincrement: false;
1145
+ hasRuntimeDefault: false;
1146
+ enumValues: [string, ...string[]];
1147
+ baseColumn: never;
1148
+ identity: undefined;
1149
+ generated: undefined;
1150
+ }, {}, {}>;
1151
+ serviceDate: import("drizzle-orm/pg-core").PgColumn<{
1152
+ name: "service_date";
1153
+ tableName: "ground_dispatches";
1154
+ dataType: "string";
1155
+ columnType: "PgDateString";
1156
+ data: string;
1157
+ driverParam: string;
1158
+ notNull: false;
1159
+ hasDefault: false;
1160
+ isPrimaryKey: false;
1161
+ isAutoincrement: false;
1162
+ hasRuntimeDefault: false;
1163
+ enumValues: undefined;
1164
+ baseColumn: never;
1165
+ identity: undefined;
1166
+ generated: undefined;
1167
+ }, {}, {}>;
1168
+ scheduledPickupAt: import("drizzle-orm/pg-core").PgColumn<{
1169
+ name: "scheduled_pickup_at";
1170
+ tableName: "ground_dispatches";
1171
+ dataType: "date";
1172
+ columnType: "PgTimestamp";
1173
+ data: Date;
1174
+ driverParam: string;
1175
+ notNull: false;
1176
+ hasDefault: false;
1177
+ isPrimaryKey: false;
1178
+ isAutoincrement: false;
1179
+ hasRuntimeDefault: false;
1180
+ enumValues: undefined;
1181
+ baseColumn: never;
1182
+ identity: undefined;
1183
+ generated: undefined;
1184
+ }, {}, {}>;
1185
+ scheduledDropoffAt: import("drizzle-orm/pg-core").PgColumn<{
1186
+ name: "scheduled_dropoff_at";
1187
+ tableName: "ground_dispatches";
1188
+ dataType: "date";
1189
+ columnType: "PgTimestamp";
1190
+ data: Date;
1191
+ driverParam: string;
1192
+ notNull: false;
1193
+ hasDefault: false;
1194
+ isPrimaryKey: false;
1195
+ isAutoincrement: false;
1196
+ hasRuntimeDefault: false;
1197
+ enumValues: undefined;
1198
+ baseColumn: never;
1199
+ identity: undefined;
1200
+ generated: undefined;
1201
+ }, {}, {}>;
1202
+ actualPickupAt: import("drizzle-orm/pg-core").PgColumn<{
1203
+ name: "actual_pickup_at";
1204
+ tableName: "ground_dispatches";
1205
+ dataType: "date";
1206
+ columnType: "PgTimestamp";
1207
+ data: Date;
1208
+ driverParam: string;
1209
+ notNull: false;
1210
+ hasDefault: false;
1211
+ isPrimaryKey: false;
1212
+ isAutoincrement: false;
1213
+ hasRuntimeDefault: false;
1214
+ enumValues: undefined;
1215
+ baseColumn: never;
1216
+ identity: undefined;
1217
+ generated: undefined;
1218
+ }, {}, {}>;
1219
+ actualDropoffAt: import("drizzle-orm/pg-core").PgColumn<{
1220
+ name: "actual_dropoff_at";
1221
+ tableName: "ground_dispatches";
1222
+ dataType: "date";
1223
+ columnType: "PgTimestamp";
1224
+ data: Date;
1225
+ driverParam: string;
1226
+ notNull: false;
1227
+ hasDefault: false;
1228
+ isPrimaryKey: false;
1229
+ isAutoincrement: false;
1230
+ hasRuntimeDefault: false;
1231
+ enumValues: undefined;
1232
+ baseColumn: never;
1233
+ identity: undefined;
1234
+ generated: undefined;
1235
+ }, {}, {}>;
1236
+ status: import("drizzle-orm/pg-core").PgColumn<{
1237
+ name: "status";
1238
+ tableName: "ground_dispatches";
1239
+ dataType: "string";
1240
+ columnType: "PgEnumColumn";
1241
+ data: "draft" | "scheduled" | "assigned" | "en_route" | "arrived" | "picked_up" | "completed" | "cancelled" | "no_show";
1242
+ driverParam: string;
1243
+ notNull: true;
1244
+ hasDefault: true;
1245
+ isPrimaryKey: false;
1246
+ isAutoincrement: false;
1247
+ hasRuntimeDefault: false;
1248
+ enumValues: ["draft", "scheduled", "assigned", "en_route", "arrived", "picked_up", "completed", "cancelled", "no_show"];
1249
+ baseColumn: never;
1250
+ identity: undefined;
1251
+ generated: undefined;
1252
+ }, {}, {}>;
1253
+ passengerCount: import("drizzle-orm/pg-core").PgColumn<{
1254
+ name: "passenger_count";
1255
+ tableName: "ground_dispatches";
1256
+ dataType: "number";
1257
+ columnType: "PgInteger";
1258
+ data: number;
1259
+ driverParam: string | number;
1260
+ notNull: false;
1261
+ hasDefault: false;
1262
+ isPrimaryKey: false;
1263
+ isAutoincrement: false;
1264
+ hasRuntimeDefault: false;
1265
+ enumValues: undefined;
1266
+ baseColumn: never;
1267
+ identity: undefined;
1268
+ generated: undefined;
1269
+ }, {}, {}>;
1270
+ checkedBags: import("drizzle-orm/pg-core").PgColumn<{
1271
+ name: "checked_bags";
1272
+ tableName: "ground_dispatches";
1273
+ dataType: "number";
1274
+ columnType: "PgInteger";
1275
+ data: number;
1276
+ driverParam: string | number;
1277
+ notNull: false;
1278
+ hasDefault: false;
1279
+ isPrimaryKey: false;
1280
+ isAutoincrement: false;
1281
+ hasRuntimeDefault: false;
1282
+ enumValues: undefined;
1283
+ baseColumn: never;
1284
+ identity: undefined;
1285
+ generated: undefined;
1286
+ }, {}, {}>;
1287
+ carryOnBags: import("drizzle-orm/pg-core").PgColumn<{
1288
+ name: "carry_on_bags";
1289
+ tableName: "ground_dispatches";
1290
+ dataType: "number";
1291
+ columnType: "PgInteger";
1292
+ data: number;
1293
+ driverParam: string | number;
1294
+ notNull: false;
1295
+ hasDefault: false;
1296
+ isPrimaryKey: false;
1297
+ isAutoincrement: false;
1298
+ hasRuntimeDefault: false;
1299
+ enumValues: undefined;
1300
+ baseColumn: never;
1301
+ identity: undefined;
1302
+ generated: undefined;
1303
+ }, {}, {}>;
1304
+ notes: import("drizzle-orm/pg-core").PgColumn<{
1305
+ name: "notes";
1306
+ tableName: "ground_dispatches";
1307
+ dataType: "string";
1308
+ columnType: "PgText";
1309
+ data: string;
1310
+ driverParam: string;
1311
+ notNull: false;
1312
+ hasDefault: false;
1313
+ isPrimaryKey: false;
1314
+ isAutoincrement: false;
1315
+ hasRuntimeDefault: false;
1316
+ enumValues: [string, ...string[]];
1317
+ baseColumn: never;
1318
+ identity: undefined;
1319
+ generated: undefined;
1320
+ }, {}, {}>;
1321
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1322
+ name: "created_at";
1323
+ tableName: "ground_dispatches";
1324
+ dataType: "date";
1325
+ columnType: "PgTimestamp";
1326
+ data: Date;
1327
+ driverParam: string;
1328
+ notNull: true;
1329
+ hasDefault: true;
1330
+ isPrimaryKey: false;
1331
+ isAutoincrement: false;
1332
+ hasRuntimeDefault: false;
1333
+ enumValues: undefined;
1334
+ baseColumn: never;
1335
+ identity: undefined;
1336
+ generated: undefined;
1337
+ }, {}, {}>;
1338
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1339
+ name: "updated_at";
1340
+ tableName: "ground_dispatches";
1341
+ dataType: "date";
1342
+ columnType: "PgTimestamp";
1343
+ data: Date;
1344
+ driverParam: string;
1345
+ notNull: true;
1346
+ hasDefault: true;
1347
+ isPrimaryKey: false;
1348
+ isAutoincrement: false;
1349
+ hasRuntimeDefault: false;
1350
+ enumValues: undefined;
1351
+ baseColumn: never;
1352
+ identity: undefined;
1353
+ generated: undefined;
1354
+ }, {}, {}>;
1355
+ };
1356
+ dialect: "pg";
1357
+ }>;
1358
+ export declare const groundExecutionEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
1359
+ name: "ground_execution_events";
1360
+ schema: undefined;
1361
+ columns: {
1362
+ id: import("drizzle-orm/pg-core").PgColumn<{
1363
+ name: string;
1364
+ tableName: "ground_execution_events";
1365
+ dataType: "string";
1366
+ columnType: "PgText";
1367
+ data: string;
1368
+ driverParam: string;
1369
+ notNull: true;
1370
+ hasDefault: true;
1371
+ isPrimaryKey: true;
1372
+ isAutoincrement: false;
1373
+ hasRuntimeDefault: true;
1374
+ enumValues: [string, ...string[]];
1375
+ baseColumn: never;
1376
+ identity: undefined;
1377
+ generated: undefined;
1378
+ }, {}, {}>;
1379
+ dispatchId: import("drizzle-orm/pg-core").PgColumn<{
1380
+ name: string;
1381
+ tableName: "ground_execution_events";
1382
+ dataType: "string";
1383
+ columnType: "PgText";
1384
+ data: string;
1385
+ driverParam: string;
1386
+ notNull: true;
1387
+ hasDefault: false;
1388
+ isPrimaryKey: false;
1389
+ isAutoincrement: false;
1390
+ hasRuntimeDefault: false;
1391
+ enumValues: [string, ...string[]];
1392
+ baseColumn: never;
1393
+ identity: undefined;
1394
+ generated: undefined;
1395
+ }, {}, {}>;
1396
+ eventType: import("drizzle-orm/pg-core").PgColumn<{
1397
+ name: "event_type";
1398
+ tableName: "ground_execution_events";
1399
+ dataType: "string";
1400
+ columnType: "PgEnumColumn";
1401
+ data: "scheduled" | "assigned" | "cancelled" | "driver_en_route" | "driver_arrived" | "pickup_completed" | "dropoff_completed" | "issue" | "note";
1402
+ driverParam: string;
1403
+ notNull: true;
1404
+ hasDefault: true;
1405
+ isPrimaryKey: false;
1406
+ isAutoincrement: false;
1407
+ hasRuntimeDefault: false;
1408
+ enumValues: ["scheduled", "assigned", "driver_en_route", "driver_arrived", "pickup_completed", "dropoff_completed", "cancelled", "issue", "note"];
1409
+ baseColumn: never;
1410
+ identity: undefined;
1411
+ generated: undefined;
1412
+ }, {}, {}>;
1413
+ occurredAt: import("drizzle-orm/pg-core").PgColumn<{
1414
+ name: "occurred_at";
1415
+ tableName: "ground_execution_events";
1416
+ dataType: "date";
1417
+ columnType: "PgTimestamp";
1418
+ data: Date;
1419
+ driverParam: string;
1420
+ notNull: true;
1421
+ hasDefault: true;
1422
+ isPrimaryKey: false;
1423
+ isAutoincrement: false;
1424
+ hasRuntimeDefault: false;
1425
+ enumValues: undefined;
1426
+ baseColumn: never;
1427
+ identity: undefined;
1428
+ generated: undefined;
1429
+ }, {}, {}>;
1430
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
1431
+ name: string;
1432
+ tableName: "ground_execution_events";
1433
+ dataType: "string";
1434
+ columnType: "PgText";
1435
+ data: string;
1436
+ driverParam: string;
1437
+ notNull: false;
1438
+ hasDefault: false;
1439
+ isPrimaryKey: false;
1440
+ isAutoincrement: false;
1441
+ hasRuntimeDefault: false;
1442
+ enumValues: [string, ...string[]];
1443
+ baseColumn: never;
1444
+ identity: undefined;
1445
+ generated: undefined;
1446
+ }, {}, {}>;
1447
+ addressId: import("drizzle-orm/pg-core").PgColumn<{
1448
+ name: string;
1449
+ tableName: "ground_execution_events";
1450
+ dataType: "string";
1451
+ columnType: "PgText";
1452
+ data: string;
1453
+ driverParam: string;
1454
+ notNull: false;
1455
+ hasDefault: false;
1456
+ isPrimaryKey: false;
1457
+ isAutoincrement: false;
1458
+ hasRuntimeDefault: false;
1459
+ enumValues: [string, ...string[]];
1460
+ baseColumn: never;
1461
+ identity: undefined;
1462
+ generated: undefined;
1463
+ }, {}, {}>;
1464
+ notes: import("drizzle-orm/pg-core").PgColumn<{
1465
+ name: "notes";
1466
+ tableName: "ground_execution_events";
1467
+ dataType: "string";
1468
+ columnType: "PgText";
1469
+ data: string;
1470
+ driverParam: string;
1471
+ notNull: false;
1472
+ hasDefault: false;
1473
+ isPrimaryKey: false;
1474
+ isAutoincrement: false;
1475
+ hasRuntimeDefault: false;
1476
+ enumValues: [string, ...string[]];
1477
+ baseColumn: never;
1478
+ identity: undefined;
1479
+ generated: undefined;
1480
+ }, {}, {}>;
1481
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1482
+ name: "metadata";
1483
+ tableName: "ground_execution_events";
1484
+ dataType: "json";
1485
+ columnType: "PgJsonb";
1486
+ data: Record<string, unknown>;
1487
+ driverParam: unknown;
1488
+ notNull: false;
1489
+ hasDefault: false;
1490
+ isPrimaryKey: false;
1491
+ isAutoincrement: false;
1492
+ hasRuntimeDefault: false;
1493
+ enumValues: undefined;
1494
+ baseColumn: never;
1495
+ identity: undefined;
1496
+ generated: undefined;
1497
+ }, {}, {
1498
+ $type: Record<string, unknown>;
1499
+ }>;
1500
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1501
+ name: "created_at";
1502
+ tableName: "ground_execution_events";
1503
+ dataType: "date";
1504
+ columnType: "PgTimestamp";
1505
+ data: Date;
1506
+ driverParam: string;
1507
+ notNull: true;
1508
+ hasDefault: true;
1509
+ isPrimaryKey: false;
1510
+ isAutoincrement: false;
1511
+ hasRuntimeDefault: false;
1512
+ enumValues: undefined;
1513
+ baseColumn: never;
1514
+ identity: undefined;
1515
+ generated: undefined;
1516
+ }, {}, {}>;
1517
+ };
1518
+ dialect: "pg";
1519
+ }>;
1520
+ export declare const groundDispatchAssignments: import("drizzle-orm/pg-core").PgTableWithColumns<{
1521
+ name: "ground_dispatch_assignments";
1522
+ schema: undefined;
1523
+ columns: {
1524
+ id: import("drizzle-orm/pg-core").PgColumn<{
1525
+ name: string;
1526
+ tableName: "ground_dispatch_assignments";
1527
+ dataType: "string";
1528
+ columnType: "PgText";
1529
+ data: string;
1530
+ driverParam: string;
1531
+ notNull: true;
1532
+ hasDefault: true;
1533
+ isPrimaryKey: true;
1534
+ isAutoincrement: false;
1535
+ hasRuntimeDefault: true;
1536
+ enumValues: [string, ...string[]];
1537
+ baseColumn: never;
1538
+ identity: undefined;
1539
+ generated: undefined;
1540
+ }, {}, {}>;
1541
+ dispatchId: import("drizzle-orm/pg-core").PgColumn<{
1542
+ name: string;
1543
+ tableName: "ground_dispatch_assignments";
1544
+ dataType: "string";
1545
+ columnType: "PgText";
1546
+ data: string;
1547
+ driverParam: string;
1548
+ notNull: true;
1549
+ hasDefault: false;
1550
+ isPrimaryKey: false;
1551
+ isAutoincrement: false;
1552
+ hasRuntimeDefault: false;
1553
+ enumValues: [string, ...string[]];
1554
+ baseColumn: never;
1555
+ identity: undefined;
1556
+ generated: undefined;
1557
+ }, {}, {}>;
1558
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
1559
+ name: string;
1560
+ tableName: "ground_dispatch_assignments";
1561
+ dataType: "string";
1562
+ columnType: "PgText";
1563
+ data: string;
1564
+ driverParam: string;
1565
+ notNull: false;
1566
+ hasDefault: false;
1567
+ isPrimaryKey: false;
1568
+ isAutoincrement: false;
1569
+ hasRuntimeDefault: false;
1570
+ enumValues: [string, ...string[]];
1571
+ baseColumn: never;
1572
+ identity: undefined;
1573
+ generated: undefined;
1574
+ }, {}, {}>;
1575
+ vehicleId: import("drizzle-orm/pg-core").PgColumn<{
1576
+ name: string;
1577
+ tableName: "ground_dispatch_assignments";
1578
+ dataType: "string";
1579
+ columnType: "PgText";
1580
+ data: string;
1581
+ driverParam: string;
1582
+ notNull: false;
1583
+ hasDefault: false;
1584
+ isPrimaryKey: false;
1585
+ isAutoincrement: false;
1586
+ hasRuntimeDefault: false;
1587
+ enumValues: [string, ...string[]];
1588
+ baseColumn: never;
1589
+ identity: undefined;
1590
+ generated: undefined;
1591
+ }, {}, {}>;
1592
+ driverId: import("drizzle-orm/pg-core").PgColumn<{
1593
+ name: string;
1594
+ tableName: "ground_dispatch_assignments";
1595
+ dataType: "string";
1596
+ columnType: "PgText";
1597
+ data: string;
1598
+ driverParam: string;
1599
+ notNull: false;
1600
+ hasDefault: false;
1601
+ isPrimaryKey: false;
1602
+ isAutoincrement: false;
1603
+ hasRuntimeDefault: false;
1604
+ enumValues: [string, ...string[]];
1605
+ baseColumn: never;
1606
+ identity: undefined;
1607
+ generated: undefined;
1608
+ }, {}, {}>;
1609
+ assignmentSource: import("drizzle-orm/pg-core").PgColumn<{
1610
+ name: "assignment_source";
1611
+ tableName: "ground_dispatch_assignments";
1612
+ dataType: "string";
1613
+ columnType: "PgEnumColumn";
1614
+ data: "manual" | "suggested" | "auto";
1615
+ driverParam: string;
1616
+ notNull: true;
1617
+ hasDefault: true;
1618
+ isPrimaryKey: false;
1619
+ isAutoincrement: false;
1620
+ hasRuntimeDefault: false;
1621
+ enumValues: ["manual", "suggested", "auto"];
1622
+ baseColumn: never;
1623
+ identity: undefined;
1624
+ generated: undefined;
1625
+ }, {}, {}>;
1626
+ assignedAt: import("drizzle-orm/pg-core").PgColumn<{
1627
+ name: "assigned_at";
1628
+ tableName: "ground_dispatch_assignments";
1629
+ dataType: "date";
1630
+ columnType: "PgTimestamp";
1631
+ data: Date;
1632
+ driverParam: string;
1633
+ notNull: true;
1634
+ hasDefault: true;
1635
+ isPrimaryKey: false;
1636
+ isAutoincrement: false;
1637
+ hasRuntimeDefault: false;
1638
+ enumValues: undefined;
1639
+ baseColumn: never;
1640
+ identity: undefined;
1641
+ generated: undefined;
1642
+ }, {}, {}>;
1643
+ acceptedAt: import("drizzle-orm/pg-core").PgColumn<{
1644
+ name: "accepted_at";
1645
+ tableName: "ground_dispatch_assignments";
1646
+ dataType: "date";
1647
+ columnType: "PgTimestamp";
1648
+ data: Date;
1649
+ driverParam: string;
1650
+ notNull: false;
1651
+ hasDefault: false;
1652
+ isPrimaryKey: false;
1653
+ isAutoincrement: false;
1654
+ hasRuntimeDefault: false;
1655
+ enumValues: undefined;
1656
+ baseColumn: never;
1657
+ identity: undefined;
1658
+ generated: undefined;
1659
+ }, {}, {}>;
1660
+ notes: import("drizzle-orm/pg-core").PgColumn<{
1661
+ name: "notes";
1662
+ tableName: "ground_dispatch_assignments";
1663
+ dataType: "string";
1664
+ columnType: "PgText";
1665
+ data: string;
1666
+ driverParam: string;
1667
+ notNull: false;
1668
+ hasDefault: false;
1669
+ isPrimaryKey: false;
1670
+ isAutoincrement: false;
1671
+ hasRuntimeDefault: false;
1672
+ enumValues: [string, ...string[]];
1673
+ baseColumn: never;
1674
+ identity: undefined;
1675
+ generated: undefined;
1676
+ }, {}, {}>;
1677
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1678
+ name: "metadata";
1679
+ tableName: "ground_dispatch_assignments";
1680
+ dataType: "json";
1681
+ columnType: "PgJsonb";
1682
+ data: Record<string, unknown>;
1683
+ driverParam: unknown;
1684
+ notNull: false;
1685
+ hasDefault: false;
1686
+ isPrimaryKey: false;
1687
+ isAutoincrement: false;
1688
+ hasRuntimeDefault: false;
1689
+ enumValues: undefined;
1690
+ baseColumn: never;
1691
+ identity: undefined;
1692
+ generated: undefined;
1693
+ }, {}, {
1694
+ $type: Record<string, unknown>;
1695
+ }>;
1696
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1697
+ name: "created_at";
1698
+ tableName: "ground_dispatch_assignments";
1699
+ dataType: "date";
1700
+ columnType: "PgTimestamp";
1701
+ data: Date;
1702
+ driverParam: string;
1703
+ notNull: true;
1704
+ hasDefault: true;
1705
+ isPrimaryKey: false;
1706
+ isAutoincrement: false;
1707
+ hasRuntimeDefault: false;
1708
+ enumValues: undefined;
1709
+ baseColumn: never;
1710
+ identity: undefined;
1711
+ generated: undefined;
1712
+ }, {}, {}>;
1713
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1714
+ name: "updated_at";
1715
+ tableName: "ground_dispatch_assignments";
1716
+ dataType: "date";
1717
+ columnType: "PgTimestamp";
1718
+ data: Date;
1719
+ driverParam: string;
1720
+ notNull: true;
1721
+ hasDefault: true;
1722
+ isPrimaryKey: false;
1723
+ isAutoincrement: false;
1724
+ hasRuntimeDefault: false;
1725
+ enumValues: undefined;
1726
+ baseColumn: never;
1727
+ identity: undefined;
1728
+ generated: undefined;
1729
+ }, {}, {}>;
1730
+ };
1731
+ dialect: "pg";
1732
+ }>;
1733
+ export declare const groundDispatchLegs: import("drizzle-orm/pg-core").PgTableWithColumns<{
1734
+ name: "ground_dispatch_legs";
1735
+ schema: undefined;
1736
+ columns: {
1737
+ id: import("drizzle-orm/pg-core").PgColumn<{
1738
+ name: string;
1739
+ tableName: "ground_dispatch_legs";
1740
+ dataType: "string";
1741
+ columnType: "PgText";
1742
+ data: string;
1743
+ driverParam: string;
1744
+ notNull: true;
1745
+ hasDefault: true;
1746
+ isPrimaryKey: true;
1747
+ isAutoincrement: false;
1748
+ hasRuntimeDefault: true;
1749
+ enumValues: [string, ...string[]];
1750
+ baseColumn: never;
1751
+ identity: undefined;
1752
+ generated: undefined;
1753
+ }, {}, {}>;
1754
+ dispatchId: import("drizzle-orm/pg-core").PgColumn<{
1755
+ name: string;
1756
+ tableName: "ground_dispatch_legs";
1757
+ dataType: "string";
1758
+ columnType: "PgText";
1759
+ data: string;
1760
+ driverParam: string;
1761
+ notNull: true;
1762
+ hasDefault: false;
1763
+ isPrimaryKey: false;
1764
+ isAutoincrement: false;
1765
+ hasRuntimeDefault: false;
1766
+ enumValues: [string, ...string[]];
1767
+ baseColumn: never;
1768
+ identity: undefined;
1769
+ generated: undefined;
1770
+ }, {}, {}>;
1771
+ sequence: import("drizzle-orm/pg-core").PgColumn<{
1772
+ name: "sequence";
1773
+ tableName: "ground_dispatch_legs";
1774
+ dataType: "number";
1775
+ columnType: "PgInteger";
1776
+ data: number;
1777
+ driverParam: string | number;
1778
+ notNull: true;
1779
+ hasDefault: true;
1780
+ isPrimaryKey: false;
1781
+ isAutoincrement: false;
1782
+ hasRuntimeDefault: false;
1783
+ enumValues: undefined;
1784
+ baseColumn: never;
1785
+ identity: undefined;
1786
+ generated: undefined;
1787
+ }, {}, {}>;
1788
+ legType: import("drizzle-orm/pg-core").PgColumn<{
1789
+ name: "leg_type";
1790
+ tableName: "ground_dispatch_legs";
1791
+ dataType: "string";
1792
+ columnType: "PgEnumColumn";
1793
+ data: "pickup" | "stop" | "dropoff" | "deadhead";
1794
+ driverParam: string;
1795
+ notNull: true;
1796
+ hasDefault: true;
1797
+ isPrimaryKey: false;
1798
+ isAutoincrement: false;
1799
+ hasRuntimeDefault: false;
1800
+ enumValues: ["pickup", "stop", "dropoff", "deadhead"];
1801
+ baseColumn: never;
1802
+ identity: undefined;
1803
+ generated: undefined;
1804
+ }, {}, {}>;
1805
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
1806
+ name: string;
1807
+ tableName: "ground_dispatch_legs";
1808
+ dataType: "string";
1809
+ columnType: "PgText";
1810
+ data: string;
1811
+ driverParam: string;
1812
+ notNull: false;
1813
+ hasDefault: false;
1814
+ isPrimaryKey: false;
1815
+ isAutoincrement: false;
1816
+ hasRuntimeDefault: false;
1817
+ enumValues: [string, ...string[]];
1818
+ baseColumn: never;
1819
+ identity: undefined;
1820
+ generated: undefined;
1821
+ }, {}, {}>;
1822
+ addressId: import("drizzle-orm/pg-core").PgColumn<{
1823
+ name: string;
1824
+ tableName: "ground_dispatch_legs";
1825
+ dataType: "string";
1826
+ columnType: "PgText";
1827
+ data: string;
1828
+ driverParam: string;
1829
+ notNull: false;
1830
+ hasDefault: false;
1831
+ isPrimaryKey: false;
1832
+ isAutoincrement: false;
1833
+ hasRuntimeDefault: false;
1834
+ enumValues: [string, ...string[]];
1835
+ baseColumn: never;
1836
+ identity: undefined;
1837
+ generated: undefined;
1838
+ }, {}, {}>;
1839
+ scheduledAt: import("drizzle-orm/pg-core").PgColumn<{
1840
+ name: "scheduled_at";
1841
+ tableName: "ground_dispatch_legs";
1842
+ dataType: "date";
1843
+ columnType: "PgTimestamp";
1844
+ data: Date;
1845
+ driverParam: string;
1846
+ notNull: false;
1847
+ hasDefault: false;
1848
+ isPrimaryKey: false;
1849
+ isAutoincrement: false;
1850
+ hasRuntimeDefault: false;
1851
+ enumValues: undefined;
1852
+ baseColumn: never;
1853
+ identity: undefined;
1854
+ generated: undefined;
1855
+ }, {}, {}>;
1856
+ actualAt: import("drizzle-orm/pg-core").PgColumn<{
1857
+ name: "actual_at";
1858
+ tableName: "ground_dispatch_legs";
1859
+ dataType: "date";
1860
+ columnType: "PgTimestamp";
1861
+ data: Date;
1862
+ driverParam: string;
1863
+ notNull: false;
1864
+ hasDefault: false;
1865
+ isPrimaryKey: false;
1866
+ isAutoincrement: false;
1867
+ hasRuntimeDefault: false;
1868
+ enumValues: undefined;
1869
+ baseColumn: never;
1870
+ identity: undefined;
1871
+ generated: undefined;
1872
+ }, {}, {}>;
1873
+ notes: import("drizzle-orm/pg-core").PgColumn<{
1874
+ name: "notes";
1875
+ tableName: "ground_dispatch_legs";
1876
+ dataType: "string";
1877
+ columnType: "PgText";
1878
+ data: string;
1879
+ driverParam: string;
1880
+ notNull: false;
1881
+ hasDefault: false;
1882
+ isPrimaryKey: false;
1883
+ isAutoincrement: false;
1884
+ hasRuntimeDefault: false;
1885
+ enumValues: [string, ...string[]];
1886
+ baseColumn: never;
1887
+ identity: undefined;
1888
+ generated: undefined;
1889
+ }, {}, {}>;
1890
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1891
+ name: "metadata";
1892
+ tableName: "ground_dispatch_legs";
1893
+ dataType: "json";
1894
+ columnType: "PgJsonb";
1895
+ data: Record<string, unknown>;
1896
+ driverParam: unknown;
1897
+ notNull: false;
1898
+ hasDefault: false;
1899
+ isPrimaryKey: false;
1900
+ isAutoincrement: false;
1901
+ hasRuntimeDefault: false;
1902
+ enumValues: undefined;
1903
+ baseColumn: never;
1904
+ identity: undefined;
1905
+ generated: undefined;
1906
+ }, {}, {
1907
+ $type: Record<string, unknown>;
1908
+ }>;
1909
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1910
+ name: "created_at";
1911
+ tableName: "ground_dispatch_legs";
1912
+ dataType: "date";
1913
+ columnType: "PgTimestamp";
1914
+ data: Date;
1915
+ driverParam: string;
1916
+ notNull: true;
1917
+ hasDefault: true;
1918
+ isPrimaryKey: false;
1919
+ isAutoincrement: false;
1920
+ hasRuntimeDefault: false;
1921
+ enumValues: undefined;
1922
+ baseColumn: never;
1923
+ identity: undefined;
1924
+ generated: undefined;
1925
+ }, {}, {}>;
1926
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1927
+ name: "updated_at";
1928
+ tableName: "ground_dispatch_legs";
1929
+ dataType: "date";
1930
+ columnType: "PgTimestamp";
1931
+ data: Date;
1932
+ driverParam: string;
1933
+ notNull: true;
1934
+ hasDefault: true;
1935
+ isPrimaryKey: false;
1936
+ isAutoincrement: false;
1937
+ hasRuntimeDefault: false;
1938
+ enumValues: undefined;
1939
+ baseColumn: never;
1940
+ identity: undefined;
1941
+ generated: undefined;
1942
+ }, {}, {}>;
1943
+ };
1944
+ dialect: "pg";
1945
+ }>;
1946
+ export declare const groundDispatchPassengers: import("drizzle-orm/pg-core").PgTableWithColumns<{
1947
+ name: "ground_dispatch_passengers";
1948
+ schema: undefined;
1949
+ columns: {
1950
+ id: import("drizzle-orm/pg-core").PgColumn<{
1951
+ name: string;
1952
+ tableName: "ground_dispatch_passengers";
1953
+ dataType: "string";
1954
+ columnType: "PgText";
1955
+ data: string;
1956
+ driverParam: string;
1957
+ notNull: true;
1958
+ hasDefault: true;
1959
+ isPrimaryKey: true;
1960
+ isAutoincrement: false;
1961
+ hasRuntimeDefault: true;
1962
+ enumValues: [string, ...string[]];
1963
+ baseColumn: never;
1964
+ identity: undefined;
1965
+ generated: undefined;
1966
+ }, {}, {}>;
1967
+ dispatchId: import("drizzle-orm/pg-core").PgColumn<{
1968
+ name: string;
1969
+ tableName: "ground_dispatch_passengers";
1970
+ dataType: "string";
1971
+ columnType: "PgText";
1972
+ data: string;
1973
+ driverParam: string;
1974
+ notNull: true;
1975
+ hasDefault: false;
1976
+ isPrimaryKey: false;
1977
+ isAutoincrement: false;
1978
+ hasRuntimeDefault: false;
1979
+ enumValues: [string, ...string[]];
1980
+ baseColumn: never;
1981
+ identity: undefined;
1982
+ generated: undefined;
1983
+ }, {}, {}>;
1984
+ participantId: import("drizzle-orm/pg-core").PgColumn<{
1985
+ name: "participant_id";
1986
+ tableName: "ground_dispatch_passengers";
1987
+ dataType: "string";
1988
+ columnType: "PgText";
1989
+ data: string;
1990
+ driverParam: string;
1991
+ notNull: false;
1992
+ hasDefault: false;
1993
+ isPrimaryKey: false;
1994
+ isAutoincrement: false;
1995
+ hasRuntimeDefault: false;
1996
+ enumValues: [string, ...string[]];
1997
+ baseColumn: never;
1998
+ identity: undefined;
1999
+ generated: undefined;
2000
+ }, {}, {}>;
2001
+ displayName: import("drizzle-orm/pg-core").PgColumn<{
2002
+ name: "display_name";
2003
+ tableName: "ground_dispatch_passengers";
2004
+ dataType: "string";
2005
+ columnType: "PgText";
2006
+ data: string;
2007
+ driverParam: string;
2008
+ notNull: false;
2009
+ hasDefault: false;
2010
+ isPrimaryKey: false;
2011
+ isAutoincrement: false;
2012
+ hasRuntimeDefault: false;
2013
+ enumValues: [string, ...string[]];
2014
+ baseColumn: never;
2015
+ identity: undefined;
2016
+ generated: undefined;
2017
+ }, {}, {}>;
2018
+ seatLabel: import("drizzle-orm/pg-core").PgColumn<{
2019
+ name: "seat_label";
2020
+ tableName: "ground_dispatch_passengers";
2021
+ dataType: "string";
2022
+ columnType: "PgText";
2023
+ data: string;
2024
+ driverParam: string;
2025
+ notNull: false;
2026
+ hasDefault: false;
2027
+ isPrimaryKey: false;
2028
+ isAutoincrement: false;
2029
+ hasRuntimeDefault: false;
2030
+ enumValues: [string, ...string[]];
2031
+ baseColumn: never;
2032
+ identity: undefined;
2033
+ generated: undefined;
2034
+ }, {}, {}>;
2035
+ notes: import("drizzle-orm/pg-core").PgColumn<{
2036
+ name: "notes";
2037
+ tableName: "ground_dispatch_passengers";
2038
+ dataType: "string";
2039
+ columnType: "PgText";
2040
+ data: string;
2041
+ driverParam: string;
2042
+ notNull: false;
2043
+ hasDefault: false;
2044
+ isPrimaryKey: false;
2045
+ isAutoincrement: false;
2046
+ hasRuntimeDefault: false;
2047
+ enumValues: [string, ...string[]];
2048
+ baseColumn: never;
2049
+ identity: undefined;
2050
+ generated: undefined;
2051
+ }, {}, {}>;
2052
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2053
+ name: "created_at";
2054
+ tableName: "ground_dispatch_passengers";
2055
+ dataType: "date";
2056
+ columnType: "PgTimestamp";
2057
+ data: Date;
2058
+ driverParam: string;
2059
+ notNull: true;
2060
+ hasDefault: true;
2061
+ isPrimaryKey: false;
2062
+ isAutoincrement: false;
2063
+ hasRuntimeDefault: false;
2064
+ enumValues: undefined;
2065
+ baseColumn: never;
2066
+ identity: undefined;
2067
+ generated: undefined;
2068
+ }, {}, {}>;
2069
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2070
+ name: "updated_at";
2071
+ tableName: "ground_dispatch_passengers";
2072
+ dataType: "date";
2073
+ columnType: "PgTimestamp";
2074
+ data: Date;
2075
+ driverParam: string;
2076
+ notNull: true;
2077
+ hasDefault: true;
2078
+ isPrimaryKey: false;
2079
+ isAutoincrement: false;
2080
+ hasRuntimeDefault: false;
2081
+ enumValues: undefined;
2082
+ baseColumn: never;
2083
+ identity: undefined;
2084
+ generated: undefined;
2085
+ }, {}, {}>;
2086
+ };
2087
+ dialect: "pg";
2088
+ }>;
2089
+ export declare const groundDriverShifts: import("drizzle-orm/pg-core").PgTableWithColumns<{
2090
+ name: "ground_driver_shifts";
2091
+ schema: undefined;
2092
+ columns: {
2093
+ id: import("drizzle-orm/pg-core").PgColumn<{
2094
+ name: string;
2095
+ tableName: "ground_driver_shifts";
2096
+ dataType: "string";
2097
+ columnType: "PgText";
2098
+ data: string;
2099
+ driverParam: string;
2100
+ notNull: true;
2101
+ hasDefault: true;
2102
+ isPrimaryKey: true;
2103
+ isAutoincrement: false;
2104
+ hasRuntimeDefault: true;
2105
+ enumValues: [string, ...string[]];
2106
+ baseColumn: never;
2107
+ identity: undefined;
2108
+ generated: undefined;
2109
+ }, {}, {}>;
2110
+ driverId: import("drizzle-orm/pg-core").PgColumn<{
2111
+ name: string;
2112
+ tableName: "ground_driver_shifts";
2113
+ dataType: "string";
2114
+ columnType: "PgText";
2115
+ data: string;
2116
+ driverParam: string;
2117
+ notNull: true;
2118
+ hasDefault: false;
2119
+ isPrimaryKey: false;
2120
+ isAutoincrement: false;
2121
+ hasRuntimeDefault: false;
2122
+ enumValues: [string, ...string[]];
2123
+ baseColumn: never;
2124
+ identity: undefined;
2125
+ generated: undefined;
2126
+ }, {}, {}>;
2127
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
2128
+ name: string;
2129
+ tableName: "ground_driver_shifts";
2130
+ dataType: "string";
2131
+ columnType: "PgText";
2132
+ data: string;
2133
+ driverParam: string;
2134
+ notNull: false;
2135
+ hasDefault: false;
2136
+ isPrimaryKey: false;
2137
+ isAutoincrement: false;
2138
+ hasRuntimeDefault: false;
2139
+ enumValues: [string, ...string[]];
2140
+ baseColumn: never;
2141
+ identity: undefined;
2142
+ generated: undefined;
2143
+ }, {}, {}>;
2144
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
2145
+ name: string;
2146
+ tableName: "ground_driver_shifts";
2147
+ dataType: "string";
2148
+ columnType: "PgText";
2149
+ data: string;
2150
+ driverParam: string;
2151
+ notNull: false;
2152
+ hasDefault: false;
2153
+ isPrimaryKey: false;
2154
+ isAutoincrement: false;
2155
+ hasRuntimeDefault: false;
2156
+ enumValues: [string, ...string[]];
2157
+ baseColumn: never;
2158
+ identity: undefined;
2159
+ generated: undefined;
2160
+ }, {}, {}>;
2161
+ startsAt: import("drizzle-orm/pg-core").PgColumn<{
2162
+ name: "starts_at";
2163
+ tableName: "ground_driver_shifts";
2164
+ dataType: "date";
2165
+ columnType: "PgTimestamp";
2166
+ data: Date;
2167
+ driverParam: string;
2168
+ notNull: true;
2169
+ hasDefault: false;
2170
+ isPrimaryKey: false;
2171
+ isAutoincrement: false;
2172
+ hasRuntimeDefault: false;
2173
+ enumValues: undefined;
2174
+ baseColumn: never;
2175
+ identity: undefined;
2176
+ generated: undefined;
2177
+ }, {}, {}>;
2178
+ endsAt: import("drizzle-orm/pg-core").PgColumn<{
2179
+ name: "ends_at";
2180
+ tableName: "ground_driver_shifts";
2181
+ dataType: "date";
2182
+ columnType: "PgTimestamp";
2183
+ data: Date;
2184
+ driverParam: string;
2185
+ notNull: true;
2186
+ hasDefault: false;
2187
+ isPrimaryKey: false;
2188
+ isAutoincrement: false;
2189
+ hasRuntimeDefault: false;
2190
+ enumValues: undefined;
2191
+ baseColumn: never;
2192
+ identity: undefined;
2193
+ generated: undefined;
2194
+ }, {}, {}>;
2195
+ status: import("drizzle-orm/pg-core").PgColumn<{
2196
+ name: "status";
2197
+ tableName: "ground_driver_shifts";
2198
+ dataType: "string";
2199
+ columnType: "PgEnumColumn";
2200
+ data: "scheduled" | "completed" | "cancelled" | "available" | "on_duty";
2201
+ driverParam: string;
2202
+ notNull: true;
2203
+ hasDefault: true;
2204
+ isPrimaryKey: false;
2205
+ isAutoincrement: false;
2206
+ hasRuntimeDefault: false;
2207
+ enumValues: ["scheduled", "available", "on_duty", "completed", "cancelled"];
2208
+ baseColumn: never;
2209
+ identity: undefined;
2210
+ generated: undefined;
2211
+ }, {}, {}>;
2212
+ notes: import("drizzle-orm/pg-core").PgColumn<{
2213
+ name: "notes";
2214
+ tableName: "ground_driver_shifts";
2215
+ dataType: "string";
2216
+ columnType: "PgText";
2217
+ data: string;
2218
+ driverParam: string;
2219
+ notNull: false;
2220
+ hasDefault: false;
2221
+ isPrimaryKey: false;
2222
+ isAutoincrement: false;
2223
+ hasRuntimeDefault: false;
2224
+ enumValues: [string, ...string[]];
2225
+ baseColumn: never;
2226
+ identity: undefined;
2227
+ generated: undefined;
2228
+ }, {}, {}>;
2229
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2230
+ name: "metadata";
2231
+ tableName: "ground_driver_shifts";
2232
+ dataType: "json";
2233
+ columnType: "PgJsonb";
2234
+ data: Record<string, unknown>;
2235
+ driverParam: unknown;
2236
+ notNull: false;
2237
+ hasDefault: false;
2238
+ isPrimaryKey: false;
2239
+ isAutoincrement: false;
2240
+ hasRuntimeDefault: false;
2241
+ enumValues: undefined;
2242
+ baseColumn: never;
2243
+ identity: undefined;
2244
+ generated: undefined;
2245
+ }, {}, {
2246
+ $type: Record<string, unknown>;
2247
+ }>;
2248
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2249
+ name: "created_at";
2250
+ tableName: "ground_driver_shifts";
2251
+ dataType: "date";
2252
+ columnType: "PgTimestamp";
2253
+ data: Date;
2254
+ driverParam: string;
2255
+ notNull: true;
2256
+ hasDefault: true;
2257
+ isPrimaryKey: false;
2258
+ isAutoincrement: false;
2259
+ hasRuntimeDefault: false;
2260
+ enumValues: undefined;
2261
+ baseColumn: never;
2262
+ identity: undefined;
2263
+ generated: undefined;
2264
+ }, {}, {}>;
2265
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2266
+ name: "updated_at";
2267
+ tableName: "ground_driver_shifts";
2268
+ dataType: "date";
2269
+ columnType: "PgTimestamp";
2270
+ data: Date;
2271
+ driverParam: string;
2272
+ notNull: true;
2273
+ hasDefault: true;
2274
+ isPrimaryKey: false;
2275
+ isAutoincrement: false;
2276
+ hasRuntimeDefault: false;
2277
+ enumValues: undefined;
2278
+ baseColumn: never;
2279
+ identity: undefined;
2280
+ generated: undefined;
2281
+ }, {}, {}>;
2282
+ };
2283
+ dialect: "pg";
2284
+ }>;
2285
+ export declare const groundServiceIncidents: import("drizzle-orm/pg-core").PgTableWithColumns<{
2286
+ name: "ground_service_incidents";
2287
+ schema: undefined;
2288
+ columns: {
2289
+ id: import("drizzle-orm/pg-core").PgColumn<{
2290
+ name: string;
2291
+ tableName: "ground_service_incidents";
2292
+ dataType: "string";
2293
+ columnType: "PgText";
2294
+ data: string;
2295
+ driverParam: string;
2296
+ notNull: true;
2297
+ hasDefault: true;
2298
+ isPrimaryKey: true;
2299
+ isAutoincrement: false;
2300
+ hasRuntimeDefault: true;
2301
+ enumValues: [string, ...string[]];
2302
+ baseColumn: never;
2303
+ identity: undefined;
2304
+ generated: undefined;
2305
+ }, {}, {}>;
2306
+ dispatchId: import("drizzle-orm/pg-core").PgColumn<{
2307
+ name: string;
2308
+ tableName: "ground_service_incidents";
2309
+ dataType: "string";
2310
+ columnType: "PgText";
2311
+ data: string;
2312
+ driverParam: string;
2313
+ notNull: true;
2314
+ hasDefault: false;
2315
+ isPrimaryKey: false;
2316
+ isAutoincrement: false;
2317
+ hasRuntimeDefault: false;
2318
+ enumValues: [string, ...string[]];
2319
+ baseColumn: never;
2320
+ identity: undefined;
2321
+ generated: undefined;
2322
+ }, {}, {}>;
2323
+ severity: import("drizzle-orm/pg-core").PgColumn<{
2324
+ name: "severity";
2325
+ tableName: "ground_service_incidents";
2326
+ dataType: "string";
2327
+ columnType: "PgEnumColumn";
2328
+ data: "info" | "warning" | "critical";
2329
+ driverParam: string;
2330
+ notNull: true;
2331
+ hasDefault: true;
2332
+ isPrimaryKey: false;
2333
+ isAutoincrement: false;
2334
+ hasRuntimeDefault: false;
2335
+ enumValues: ["info", "warning", "critical"];
2336
+ baseColumn: never;
2337
+ identity: undefined;
2338
+ generated: undefined;
2339
+ }, {}, {}>;
2340
+ incidentType: import("drizzle-orm/pg-core").PgColumn<{
2341
+ name: "incident_type";
2342
+ tableName: "ground_service_incidents";
2343
+ dataType: "string";
2344
+ columnType: "PgText";
2345
+ data: string;
2346
+ driverParam: string;
2347
+ notNull: true;
2348
+ hasDefault: false;
2349
+ isPrimaryKey: false;
2350
+ isAutoincrement: false;
2351
+ hasRuntimeDefault: false;
2352
+ enumValues: [string, ...string[]];
2353
+ baseColumn: never;
2354
+ identity: undefined;
2355
+ generated: undefined;
2356
+ }, {}, {}>;
2357
+ resolutionStatus: import("drizzle-orm/pg-core").PgColumn<{
2358
+ name: "resolution_status";
2359
+ tableName: "ground_service_incidents";
2360
+ dataType: "string";
2361
+ columnType: "PgEnumColumn";
2362
+ data: "cancelled" | "open" | "mitigated" | "resolved";
2363
+ driverParam: string;
2364
+ notNull: true;
2365
+ hasDefault: true;
2366
+ isPrimaryKey: false;
2367
+ isAutoincrement: false;
2368
+ hasRuntimeDefault: false;
2369
+ enumValues: ["open", "mitigated", "resolved", "cancelled"];
2370
+ baseColumn: never;
2371
+ identity: undefined;
2372
+ generated: undefined;
2373
+ }, {}, {}>;
2374
+ openedAt: import("drizzle-orm/pg-core").PgColumn<{
2375
+ name: "opened_at";
2376
+ tableName: "ground_service_incidents";
2377
+ dataType: "date";
2378
+ columnType: "PgTimestamp";
2379
+ data: Date;
2380
+ driverParam: string;
2381
+ notNull: true;
2382
+ hasDefault: true;
2383
+ isPrimaryKey: false;
2384
+ isAutoincrement: false;
2385
+ hasRuntimeDefault: false;
2386
+ enumValues: undefined;
2387
+ baseColumn: never;
2388
+ identity: undefined;
2389
+ generated: undefined;
2390
+ }, {}, {}>;
2391
+ resolvedAt: import("drizzle-orm/pg-core").PgColumn<{
2392
+ name: "resolved_at";
2393
+ tableName: "ground_service_incidents";
2394
+ dataType: "date";
2395
+ columnType: "PgTimestamp";
2396
+ data: Date;
2397
+ driverParam: string;
2398
+ notNull: false;
2399
+ hasDefault: false;
2400
+ isPrimaryKey: false;
2401
+ isAutoincrement: false;
2402
+ hasRuntimeDefault: false;
2403
+ enumValues: undefined;
2404
+ baseColumn: never;
2405
+ identity: undefined;
2406
+ generated: undefined;
2407
+ }, {}, {}>;
2408
+ notes: import("drizzle-orm/pg-core").PgColumn<{
2409
+ name: "notes";
2410
+ tableName: "ground_service_incidents";
2411
+ dataType: "string";
2412
+ columnType: "PgText";
2413
+ data: string;
2414
+ driverParam: string;
2415
+ notNull: false;
2416
+ hasDefault: false;
2417
+ isPrimaryKey: false;
2418
+ isAutoincrement: false;
2419
+ hasRuntimeDefault: false;
2420
+ enumValues: [string, ...string[]];
2421
+ baseColumn: never;
2422
+ identity: undefined;
2423
+ generated: undefined;
2424
+ }, {}, {}>;
2425
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2426
+ name: "metadata";
2427
+ tableName: "ground_service_incidents";
2428
+ dataType: "json";
2429
+ columnType: "PgJsonb";
2430
+ data: Record<string, unknown>;
2431
+ driverParam: unknown;
2432
+ notNull: false;
2433
+ hasDefault: false;
2434
+ isPrimaryKey: false;
2435
+ isAutoincrement: false;
2436
+ hasRuntimeDefault: false;
2437
+ enumValues: undefined;
2438
+ baseColumn: never;
2439
+ identity: undefined;
2440
+ generated: undefined;
2441
+ }, {}, {
2442
+ $type: Record<string, unknown>;
2443
+ }>;
2444
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2445
+ name: "created_at";
2446
+ tableName: "ground_service_incidents";
2447
+ dataType: "date";
2448
+ columnType: "PgTimestamp";
2449
+ data: Date;
2450
+ driverParam: string;
2451
+ notNull: true;
2452
+ hasDefault: true;
2453
+ isPrimaryKey: false;
2454
+ isAutoincrement: false;
2455
+ hasRuntimeDefault: false;
2456
+ enumValues: undefined;
2457
+ baseColumn: never;
2458
+ identity: undefined;
2459
+ generated: undefined;
2460
+ }, {}, {}>;
2461
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2462
+ name: "updated_at";
2463
+ tableName: "ground_service_incidents";
2464
+ dataType: "date";
2465
+ columnType: "PgTimestamp";
2466
+ data: Date;
2467
+ driverParam: string;
2468
+ notNull: true;
2469
+ hasDefault: true;
2470
+ isPrimaryKey: false;
2471
+ isAutoincrement: false;
2472
+ hasRuntimeDefault: false;
2473
+ enumValues: undefined;
2474
+ baseColumn: never;
2475
+ identity: undefined;
2476
+ generated: undefined;
2477
+ }, {}, {}>;
2478
+ };
2479
+ dialect: "pg";
2480
+ }>;
2481
+ export declare const groundDispatchCheckpoints: import("drizzle-orm/pg-core").PgTableWithColumns<{
2482
+ name: "ground_dispatch_checkpoints";
2483
+ schema: undefined;
2484
+ columns: {
2485
+ id: import("drizzle-orm/pg-core").PgColumn<{
2486
+ name: string;
2487
+ tableName: "ground_dispatch_checkpoints";
2488
+ dataType: "string";
2489
+ columnType: "PgText";
2490
+ data: string;
2491
+ driverParam: string;
2492
+ notNull: true;
2493
+ hasDefault: true;
2494
+ isPrimaryKey: true;
2495
+ isAutoincrement: false;
2496
+ hasRuntimeDefault: true;
2497
+ enumValues: [string, ...string[]];
2498
+ baseColumn: never;
2499
+ identity: undefined;
2500
+ generated: undefined;
2501
+ }, {}, {}>;
2502
+ dispatchId: import("drizzle-orm/pg-core").PgColumn<{
2503
+ name: string;
2504
+ tableName: "ground_dispatch_checkpoints";
2505
+ dataType: "string";
2506
+ columnType: "PgText";
2507
+ data: string;
2508
+ driverParam: string;
2509
+ notNull: true;
2510
+ hasDefault: false;
2511
+ isPrimaryKey: false;
2512
+ isAutoincrement: false;
2513
+ hasRuntimeDefault: false;
2514
+ enumValues: [string, ...string[]];
2515
+ baseColumn: never;
2516
+ identity: undefined;
2517
+ generated: undefined;
2518
+ }, {}, {}>;
2519
+ sequence: import("drizzle-orm/pg-core").PgColumn<{
2520
+ name: "sequence";
2521
+ tableName: "ground_dispatch_checkpoints";
2522
+ dataType: "number";
2523
+ columnType: "PgInteger";
2524
+ data: number;
2525
+ driverParam: string | number;
2526
+ notNull: true;
2527
+ hasDefault: true;
2528
+ isPrimaryKey: false;
2529
+ isAutoincrement: false;
2530
+ hasRuntimeDefault: false;
2531
+ enumValues: undefined;
2532
+ baseColumn: never;
2533
+ identity: undefined;
2534
+ generated: undefined;
2535
+ }, {}, {}>;
2536
+ checkpointType: import("drizzle-orm/pg-core").PgColumn<{
2537
+ name: "checkpoint_type";
2538
+ tableName: "ground_dispatch_checkpoints";
2539
+ dataType: "string";
2540
+ columnType: "PgText";
2541
+ data: string;
2542
+ driverParam: string;
2543
+ notNull: true;
2544
+ hasDefault: false;
2545
+ isPrimaryKey: false;
2546
+ isAutoincrement: false;
2547
+ hasRuntimeDefault: false;
2548
+ enumValues: [string, ...string[]];
2549
+ baseColumn: never;
2550
+ identity: undefined;
2551
+ generated: undefined;
2552
+ }, {}, {}>;
2553
+ status: import("drizzle-orm/pg-core").PgColumn<{
2554
+ name: "status";
2555
+ tableName: "ground_dispatch_checkpoints";
2556
+ dataType: "string";
2557
+ columnType: "PgEnumColumn";
2558
+ data: "cancelled" | "pending" | "reached" | "missed";
2559
+ driverParam: string;
2560
+ notNull: true;
2561
+ hasDefault: true;
2562
+ isPrimaryKey: false;
2563
+ isAutoincrement: false;
2564
+ hasRuntimeDefault: false;
2565
+ enumValues: ["pending", "reached", "missed", "cancelled"];
2566
+ baseColumn: never;
2567
+ identity: undefined;
2568
+ generated: undefined;
2569
+ }, {}, {}>;
2570
+ plannedAt: import("drizzle-orm/pg-core").PgColumn<{
2571
+ name: "planned_at";
2572
+ tableName: "ground_dispatch_checkpoints";
2573
+ dataType: "date";
2574
+ columnType: "PgTimestamp";
2575
+ data: Date;
2576
+ driverParam: string;
2577
+ notNull: false;
2578
+ hasDefault: false;
2579
+ isPrimaryKey: false;
2580
+ isAutoincrement: false;
2581
+ hasRuntimeDefault: false;
2582
+ enumValues: undefined;
2583
+ baseColumn: never;
2584
+ identity: undefined;
2585
+ generated: undefined;
2586
+ }, {}, {}>;
2587
+ actualAt: import("drizzle-orm/pg-core").PgColumn<{
2588
+ name: "actual_at";
2589
+ tableName: "ground_dispatch_checkpoints";
2590
+ dataType: "date";
2591
+ columnType: "PgTimestamp";
2592
+ data: Date;
2593
+ driverParam: string;
2594
+ notNull: false;
2595
+ hasDefault: false;
2596
+ isPrimaryKey: false;
2597
+ isAutoincrement: false;
2598
+ hasRuntimeDefault: false;
2599
+ enumValues: undefined;
2600
+ baseColumn: never;
2601
+ identity: undefined;
2602
+ generated: undefined;
2603
+ }, {}, {}>;
2604
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
2605
+ name: string;
2606
+ tableName: "ground_dispatch_checkpoints";
2607
+ dataType: "string";
2608
+ columnType: "PgText";
2609
+ data: string;
2610
+ driverParam: string;
2611
+ notNull: false;
2612
+ hasDefault: false;
2613
+ isPrimaryKey: false;
2614
+ isAutoincrement: false;
2615
+ hasRuntimeDefault: false;
2616
+ enumValues: [string, ...string[]];
2617
+ baseColumn: never;
2618
+ identity: undefined;
2619
+ generated: undefined;
2620
+ }, {}, {}>;
2621
+ addressId: import("drizzle-orm/pg-core").PgColumn<{
2622
+ name: string;
2623
+ tableName: "ground_dispatch_checkpoints";
2624
+ dataType: "string";
2625
+ columnType: "PgText";
2626
+ data: string;
2627
+ driverParam: string;
2628
+ notNull: false;
2629
+ hasDefault: false;
2630
+ isPrimaryKey: false;
2631
+ isAutoincrement: false;
2632
+ hasRuntimeDefault: false;
2633
+ enumValues: [string, ...string[]];
2634
+ baseColumn: never;
2635
+ identity: undefined;
2636
+ generated: undefined;
2637
+ }, {}, {}>;
2638
+ notes: import("drizzle-orm/pg-core").PgColumn<{
2639
+ name: "notes";
2640
+ tableName: "ground_dispatch_checkpoints";
2641
+ dataType: "string";
2642
+ columnType: "PgText";
2643
+ data: string;
2644
+ driverParam: string;
2645
+ notNull: false;
2646
+ hasDefault: false;
2647
+ isPrimaryKey: false;
2648
+ isAutoincrement: false;
2649
+ hasRuntimeDefault: false;
2650
+ enumValues: [string, ...string[]];
2651
+ baseColumn: never;
2652
+ identity: undefined;
2653
+ generated: undefined;
2654
+ }, {}, {}>;
2655
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2656
+ name: "metadata";
2657
+ tableName: "ground_dispatch_checkpoints";
2658
+ dataType: "json";
2659
+ columnType: "PgJsonb";
2660
+ data: Record<string, unknown>;
2661
+ driverParam: unknown;
2662
+ notNull: false;
2663
+ hasDefault: false;
2664
+ isPrimaryKey: false;
2665
+ isAutoincrement: false;
2666
+ hasRuntimeDefault: false;
2667
+ enumValues: undefined;
2668
+ baseColumn: never;
2669
+ identity: undefined;
2670
+ generated: undefined;
2671
+ }, {}, {
2672
+ $type: Record<string, unknown>;
2673
+ }>;
2674
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2675
+ name: "created_at";
2676
+ tableName: "ground_dispatch_checkpoints";
2677
+ dataType: "date";
2678
+ columnType: "PgTimestamp";
2679
+ data: Date;
2680
+ driverParam: string;
2681
+ notNull: true;
2682
+ hasDefault: true;
2683
+ isPrimaryKey: false;
2684
+ isAutoincrement: false;
2685
+ hasRuntimeDefault: false;
2686
+ enumValues: undefined;
2687
+ baseColumn: never;
2688
+ identity: undefined;
2689
+ generated: undefined;
2690
+ }, {}, {}>;
2691
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2692
+ name: "updated_at";
2693
+ tableName: "ground_dispatch_checkpoints";
2694
+ dataType: "date";
2695
+ columnType: "PgTimestamp";
2696
+ data: Date;
2697
+ driverParam: string;
2698
+ notNull: true;
2699
+ hasDefault: true;
2700
+ isPrimaryKey: false;
2701
+ isAutoincrement: false;
2702
+ hasRuntimeDefault: false;
2703
+ enumValues: undefined;
2704
+ baseColumn: never;
2705
+ identity: undefined;
2706
+ generated: undefined;
2707
+ }, {}, {}>;
2708
+ };
2709
+ dialect: "pg";
2710
+ }>;
2711
+ export type GroundOperator = typeof groundOperators.$inferSelect;
2712
+ export type NewGroundOperator = typeof groundOperators.$inferInsert;
2713
+ export type GroundVehicle = typeof groundVehicles.$inferSelect;
2714
+ export type NewGroundVehicle = typeof groundVehicles.$inferInsert;
2715
+ export type GroundDriver = typeof groundDrivers.$inferSelect;
2716
+ export type NewGroundDriver = typeof groundDrivers.$inferInsert;
2717
+ export type GroundTransferPreference = typeof groundTransferPreferences.$inferSelect;
2718
+ export type NewGroundTransferPreference = typeof groundTransferPreferences.$inferInsert;
2719
+ export type GroundDispatch = typeof groundDispatches.$inferSelect;
2720
+ export type NewGroundDispatch = typeof groundDispatches.$inferInsert;
2721
+ export type GroundExecutionEvent = typeof groundExecutionEvents.$inferSelect;
2722
+ export type NewGroundExecutionEvent = typeof groundExecutionEvents.$inferInsert;
2723
+ export type GroundDispatchAssignment = typeof groundDispatchAssignments.$inferSelect;
2724
+ export type NewGroundDispatchAssignment = typeof groundDispatchAssignments.$inferInsert;
2725
+ export type GroundDispatchLeg = typeof groundDispatchLegs.$inferSelect;
2726
+ export type NewGroundDispatchLeg = typeof groundDispatchLegs.$inferInsert;
2727
+ export type GroundDispatchPassenger = typeof groundDispatchPassengers.$inferSelect;
2728
+ export type NewGroundDispatchPassenger = typeof groundDispatchPassengers.$inferInsert;
2729
+ export type GroundDriverShift = typeof groundDriverShifts.$inferSelect;
2730
+ export type NewGroundDriverShift = typeof groundDriverShifts.$inferInsert;
2731
+ export type GroundServiceIncident = typeof groundServiceIncidents.$inferSelect;
2732
+ export type NewGroundServiceIncident = typeof groundServiceIncidents.$inferInsert;
2733
+ export type GroundDispatchCheckpoint = typeof groundDispatchCheckpoints.$inferSelect;
2734
+ export type NewGroundDispatchCheckpoint = typeof groundDispatchCheckpoints.$inferInsert;
2735
+ export declare const groundOperatorsRelations: import("drizzle-orm").Relations<"ground_operators", {
2736
+ facility: import("drizzle-orm").One<"facilities", false>;
2737
+ vehicles: import("drizzle-orm").Many<"ground_vehicles">;
2738
+ drivers: import("drizzle-orm").Many<"ground_drivers">;
2739
+ }>;
2740
+ export declare const groundVehiclesRelations: import("drizzle-orm").Relations<"ground_vehicles", {
2741
+ operator: import("drizzle-orm").One<"ground_operators", false>;
2742
+ }>;
2743
+ export declare const groundDriversRelations: import("drizzle-orm").Relations<"ground_drivers", {
2744
+ operator: import("drizzle-orm").One<"ground_operators", false>;
2745
+ }>;
2746
+ export declare const groundTransferPreferencesRelations: import("drizzle-orm").Relations<"ground_transfer_preferences", {
2747
+ pickupFacility: import("drizzle-orm").One<"facilities", false>;
2748
+ dropoffFacility: import("drizzle-orm").One<"facilities", false>;
2749
+ pickupAddress: import("drizzle-orm").One<"identity_addresses", false>;
2750
+ dropoffAddress: import("drizzle-orm").One<"identity_addresses", false>;
2751
+ dispatches: import("drizzle-orm").Many<"ground_dispatches">;
2752
+ }>;
2753
+ export declare const groundDispatchesRelations: import("drizzle-orm").Relations<"ground_dispatches", {
2754
+ transferPreference: import("drizzle-orm").One<"ground_transfer_preferences", true>;
2755
+ operator: import("drizzle-orm").One<"ground_operators", false>;
2756
+ vehicle: import("drizzle-orm").One<"ground_vehicles", false>;
2757
+ driver: import("drizzle-orm").One<"ground_drivers", false>;
2758
+ executionEvents: import("drizzle-orm").Many<"ground_execution_events">;
2759
+ assignments: import("drizzle-orm").Many<"ground_dispatch_assignments">;
2760
+ legs: import("drizzle-orm").Many<"ground_dispatch_legs">;
2761
+ passengers: import("drizzle-orm").Many<"ground_dispatch_passengers">;
2762
+ incidents: import("drizzle-orm").Many<"ground_service_incidents">;
2763
+ checkpoints: import("drizzle-orm").Many<"ground_dispatch_checkpoints">;
2764
+ }>;
2765
+ export declare const groundExecutionEventsRelations: import("drizzle-orm").Relations<"ground_execution_events", {
2766
+ dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
2767
+ facility: import("drizzle-orm").One<"facilities", false>;
2768
+ address: import("drizzle-orm").One<"identity_addresses", false>;
2769
+ }>;
2770
+ export declare const groundDispatchAssignmentsRelations: import("drizzle-orm").Relations<"ground_dispatch_assignments", {
2771
+ dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
2772
+ operator: import("drizzle-orm").One<"ground_operators", false>;
2773
+ vehicle: import("drizzle-orm").One<"ground_vehicles", false>;
2774
+ driver: import("drizzle-orm").One<"ground_drivers", false>;
2775
+ }>;
2776
+ export declare const groundDispatchLegsRelations: import("drizzle-orm").Relations<"ground_dispatch_legs", {
2777
+ dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
2778
+ facility: import("drizzle-orm").One<"facilities", false>;
2779
+ address: import("drizzle-orm").One<"identity_addresses", false>;
2780
+ }>;
2781
+ export declare const groundDispatchPassengersRelations: import("drizzle-orm").Relations<"ground_dispatch_passengers", {
2782
+ dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
2783
+ }>;
2784
+ export declare const groundDriverShiftsRelations: import("drizzle-orm").Relations<"ground_driver_shifts", {
2785
+ driver: import("drizzle-orm").One<"ground_drivers", true>;
2786
+ operator: import("drizzle-orm").One<"ground_operators", false>;
2787
+ facility: import("drizzle-orm").One<"facilities", false>;
2788
+ }>;
2789
+ export declare const groundServiceIncidentsRelations: import("drizzle-orm").Relations<"ground_service_incidents", {
2790
+ dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
2791
+ }>;
2792
+ export declare const groundDispatchCheckpointsRelations: import("drizzle-orm").Relations<"ground_dispatch_checkpoints", {
2793
+ dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
2794
+ facility: import("drizzle-orm").One<"facilities", false>;
2795
+ address: import("drizzle-orm").One<"identity_addresses", false>;
2796
+ }>;
2797
+ //# sourceMappingURL=schema.d.ts.map