@voyantjs/ground 0.1.1 → 0.3.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 (34) hide show
  1. package/dist/schema-dispatch.d.ts +733 -0
  2. package/dist/schema-dispatch.d.ts.map +1 -0
  3. package/dist/schema-dispatch.js +79 -0
  4. package/dist/schema-operations.d.ts +1368 -0
  5. package/dist/schema-operations.d.ts.map +1 -0
  6. package/dist/schema-operations.js +155 -0
  7. package/dist/schema-operators.d.ts +625 -0
  8. package/dist/schema-operators.d.ts.map +1 -0
  9. package/dist/schema-operators.js +62 -0
  10. package/dist/schema-relations.d.ts +63 -0
  11. package/dist/schema-relations.d.ts.map +1 -0
  12. package/dist/schema-relations.js +152 -0
  13. package/dist/schema-shared.d.ts +12 -0
  14. package/dist/schema-shared.d.ts.map +1 -0
  15. package/dist/schema-shared.js +84 -0
  16. package/dist/schema.d.ts +5 -2796
  17. package/dist/schema.d.ts.map +1 -1
  18. package/dist/schema.js +5 -513
  19. package/dist/service-dispatch-core.d.ts +255 -0
  20. package/dist/service-dispatch-core.d.ts.map +1 -0
  21. package/dist/service-dispatch-core.js +171 -0
  22. package/dist/service-dispatch-ops.d.ts +307 -0
  23. package/dist/service-dispatch-ops.d.ts.map +1 -0
  24. package/dist/service-dispatch-ops.js +272 -0
  25. package/dist/service-resources.d.ts +251 -0
  26. package/dist/service-resources.d.ts.map +1 -0
  27. package/dist/service-resources.js +183 -0
  28. package/dist/service-shared.d.ts +48 -0
  29. package/dist/service-shared.d.ts.map +1 -0
  30. package/dist/service-shared.js +7 -0
  31. package/dist/service.d.ts +63 -844
  32. package/dist/service.d.ts.map +1 -1
  33. package/dist/service.js +63 -628
  34. package/package.json +6 -6
package/dist/schema-operators.d.ts ADDED
@@ -0,0 +1,625 @@
1
+ export declare const groundOperators: import("drizzle-orm/pg-core").PgTableWithColumns<{
2
+ name: "ground_operators";
3
+ schema: undefined;
4
+ columns: {
5
+ id: import("drizzle-orm/pg-core").PgColumn<{
6
+ name: string;
7
+ tableName: "ground_operators";
8
+ dataType: "string";
9
+ columnType: "PgText";
10
+ data: string;
11
+ driverParam: string;
12
+ notNull: true;
13
+ hasDefault: true;
14
+ isPrimaryKey: true;
15
+ isAutoincrement: false;
16
+ hasRuntimeDefault: true;
17
+ enumValues: [string, ...string[]];
18
+ baseColumn: never;
19
+ identity: undefined;
20
+ generated: undefined;
21
+ }, {}, {}>;
22
+ supplierId: import("drizzle-orm/pg-core").PgColumn<{
23
+ name: "supplier_id";
24
+ tableName: "ground_operators";
25
+ dataType: "string";
26
+ columnType: "PgText";
27
+ data: string;
28
+ driverParam: string;
29
+ notNull: false;
30
+ hasDefault: false;
31
+ isPrimaryKey: false;
32
+ isAutoincrement: false;
33
+ hasRuntimeDefault: false;
34
+ enumValues: [string, ...string[]];
35
+ baseColumn: never;
36
+ identity: undefined;
37
+ generated: undefined;
38
+ }, {}, {}>;
39
+ facilityId: import("drizzle-orm/pg-core").PgColumn<{
40
+ name: string;
41
+ tableName: "ground_operators";
42
+ dataType: "string";
43
+ columnType: "PgText";
44
+ data: string;
45
+ driverParam: string;
46
+ notNull: false;
47
+ hasDefault: false;
48
+ isPrimaryKey: false;
49
+ isAutoincrement: false;
50
+ hasRuntimeDefault: false;
51
+ enumValues: [string, ...string[]];
52
+ baseColumn: never;
53
+ identity: undefined;
54
+ generated: undefined;
55
+ }, {}, {}>;
56
+ name: import("drizzle-orm/pg-core").PgColumn<{
57
+ name: "name";
58
+ tableName: "ground_operators";
59
+ dataType: "string";
60
+ columnType: "PgText";
61
+ data: string;
62
+ driverParam: string;
63
+ notNull: true;
64
+ hasDefault: false;
65
+ isPrimaryKey: false;
66
+ isAutoincrement: false;
67
+ hasRuntimeDefault: false;
68
+ enumValues: [string, ...string[]];
69
+ baseColumn: never;
70
+ identity: undefined;
71
+ generated: undefined;
72
+ }, {}, {}>;
73
+ code: import("drizzle-orm/pg-core").PgColumn<{
74
+ name: "code";
75
+ tableName: "ground_operators";
76
+ dataType: "string";
77
+ columnType: "PgText";
78
+ data: string;
79
+ driverParam: string;
80
+ notNull: false;
81
+ hasDefault: false;
82
+ isPrimaryKey: false;
83
+ isAutoincrement: false;
84
+ hasRuntimeDefault: false;
85
+ enumValues: [string, ...string[]];
86
+ baseColumn: never;
87
+ identity: undefined;
88
+ generated: undefined;
89
+ }, {}, {}>;
90
+ active: import("drizzle-orm/pg-core").PgColumn<{
91
+ name: "active";
92
+ tableName: "ground_operators";
93
+ dataType: "boolean";
94
+ columnType: "PgBoolean";
95
+ data: boolean;
96
+ driverParam: boolean;
97
+ notNull: true;
98
+ hasDefault: true;
99
+ isPrimaryKey: false;
100
+ isAutoincrement: false;
101
+ hasRuntimeDefault: false;
102
+ enumValues: undefined;
103
+ baseColumn: never;
104
+ identity: undefined;
105
+ generated: undefined;
106
+ }, {}, {}>;
107
+ notes: import("drizzle-orm/pg-core").PgColumn<{
108
+ name: "notes";
109
+ tableName: "ground_operators";
110
+ dataType: "string";
111
+ columnType: "PgText";
112
+ data: string;
113
+ driverParam: string;
114
+ notNull: false;
115
+ hasDefault: false;
116
+ isPrimaryKey: false;
117
+ isAutoincrement: false;
118
+ hasRuntimeDefault: false;
119
+ enumValues: [string, ...string[]];
120
+ baseColumn: never;
121
+ identity: undefined;
122
+ generated: undefined;
123
+ }, {}, {}>;
124
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
125
+ name: "created_at";
126
+ tableName: "ground_operators";
127
+ dataType: "date";
128
+ columnType: "PgTimestamp";
129
+ data: Date;
130
+ driverParam: string;
131
+ notNull: true;
132
+ hasDefault: true;
133
+ isPrimaryKey: false;
134
+ isAutoincrement: false;
135
+ hasRuntimeDefault: false;
136
+ enumValues: undefined;
137
+ baseColumn: never;
138
+ identity: undefined;
139
+ generated: undefined;
140
+ }, {}, {}>;
141
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
142
+ name: "updated_at";
143
+ tableName: "ground_operators";
144
+ dataType: "date";
145
+ columnType: "PgTimestamp";
146
+ data: Date;
147
+ driverParam: string;
148
+ notNull: true;
149
+ hasDefault: true;
150
+ isPrimaryKey: false;
151
+ isAutoincrement: false;
152
+ hasRuntimeDefault: false;
153
+ enumValues: undefined;
154
+ baseColumn: never;
155
+ identity: undefined;
156
+ generated: undefined;
157
+ }, {}, {}>;
158
+ };
159
+ dialect: "pg";
160
+ }>;
161
+ export declare const groundVehicles: import("drizzle-orm/pg-core").PgTableWithColumns<{
162
+ name: "ground_vehicles";
163
+ schema: undefined;
164
+ columns: {
165
+ id: import("drizzle-orm/pg-core").PgColumn<{
166
+ name: string;
167
+ tableName: "ground_vehicles";
168
+ dataType: "string";
169
+ columnType: "PgText";
170
+ data: string;
171
+ driverParam: string;
172
+ notNull: true;
173
+ hasDefault: true;
174
+ isPrimaryKey: true;
175
+ isAutoincrement: false;
176
+ hasRuntimeDefault: true;
177
+ enumValues: [string, ...string[]];
178
+ baseColumn: never;
179
+ identity: undefined;
180
+ generated: undefined;
181
+ }, {}, {}>;
182
+ resourceId: import("drizzle-orm/pg-core").PgColumn<{
183
+ name: "resource_id";
184
+ tableName: "ground_vehicles";
185
+ dataType: "string";
186
+ columnType: "PgText";
187
+ data: string;
188
+ driverParam: string;
189
+ notNull: true;
190
+ hasDefault: false;
191
+ isPrimaryKey: false;
192
+ isAutoincrement: false;
193
+ hasRuntimeDefault: false;
194
+ enumValues: [string, ...string[]];
195
+ baseColumn: never;
196
+ identity: undefined;
197
+ generated: undefined;
198
+ }, {}, {}>;
199
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
200
+ name: string;
201
+ tableName: "ground_vehicles";
202
+ dataType: "string";
203
+ columnType: "PgText";
204
+ data: string;
205
+ driverParam: string;
206
+ notNull: false;
207
+ hasDefault: false;
208
+ isPrimaryKey: false;
209
+ isAutoincrement: false;
210
+ hasRuntimeDefault: false;
211
+ enumValues: [string, ...string[]];
212
+ baseColumn: never;
213
+ identity: undefined;
214
+ generated: undefined;
215
+ }, {}, {}>;
216
+ category: import("drizzle-orm/pg-core").PgColumn<{
217
+ name: "category";
218
+ tableName: "ground_vehicles";
219
+ dataType: "string";
220
+ columnType: "PgEnumColumn";
221
+ data: "other" | "car" | "sedan" | "suv" | "van" | "minibus" | "bus" | "boat" | "train";
222
+ driverParam: string;
223
+ notNull: true;
224
+ hasDefault: true;
225
+ isPrimaryKey: false;
226
+ isAutoincrement: false;
227
+ hasRuntimeDefault: false;
228
+ enumValues: ["car", "sedan", "suv", "van", "minibus", "bus", "boat", "train", "other"];
229
+ baseColumn: never;
230
+ identity: undefined;
231
+ generated: undefined;
232
+ }, {}, {}>;
233
+ vehicleClass: import("drizzle-orm/pg-core").PgColumn<{
234
+ name: "vehicle_class";
235
+ tableName: "ground_vehicles";
236
+ dataType: "string";
237
+ columnType: "PgEnumColumn";
238
+ data: "other" | "economy" | "standard" | "premium" | "luxury" | "accessible";
239
+ driverParam: string;
240
+ notNull: true;
241
+ hasDefault: true;
242
+ isPrimaryKey: false;
243
+ isAutoincrement: false;
244
+ hasRuntimeDefault: false;
245
+ enumValues: ["economy", "standard", "premium", "luxury", "accessible", "other"];
246
+ baseColumn: never;
247
+ identity: undefined;
248
+ generated: undefined;
249
+ }, {}, {}>;
250
+ passengerCapacity: import("drizzle-orm/pg-core").PgColumn<{
251
+ name: "passenger_capacity";
252
+ tableName: "ground_vehicles";
253
+ dataType: "number";
254
+ columnType: "PgInteger";
255
+ data: number;
256
+ driverParam: string | number;
257
+ notNull: false;
258
+ hasDefault: false;
259
+ isPrimaryKey: false;
260
+ isAutoincrement: false;
261
+ hasRuntimeDefault: false;
262
+ enumValues: undefined;
263
+ baseColumn: never;
264
+ identity: undefined;
265
+ generated: undefined;
266
+ }, {}, {}>;
267
+ checkedBagCapacity: import("drizzle-orm/pg-core").PgColumn<{
268
+ name: "checked_bag_capacity";
269
+ tableName: "ground_vehicles";
270
+ dataType: "number";
271
+ columnType: "PgInteger";
272
+ data: number;
273
+ driverParam: string | number;
274
+ notNull: false;
275
+ hasDefault: false;
276
+ isPrimaryKey: false;
277
+ isAutoincrement: false;
278
+ hasRuntimeDefault: false;
279
+ enumValues: undefined;
280
+ baseColumn: never;
281
+ identity: undefined;
282
+ generated: undefined;
283
+ }, {}, {}>;
284
+ carryOnCapacity: import("drizzle-orm/pg-core").PgColumn<{
285
+ name: "carry_on_capacity";
286
+ tableName: "ground_vehicles";
287
+ dataType: "number";
288
+ columnType: "PgInteger";
289
+ data: number;
290
+ driverParam: string | number;
291
+ notNull: false;
292
+ hasDefault: false;
293
+ isPrimaryKey: false;
294
+ isAutoincrement: false;
295
+ hasRuntimeDefault: false;
296
+ enumValues: undefined;
297
+ baseColumn: never;
298
+ identity: undefined;
299
+ generated: undefined;
300
+ }, {}, {}>;
301
+ wheelchairCapacity: import("drizzle-orm/pg-core").PgColumn<{
302
+ name: "wheelchair_capacity";
303
+ tableName: "ground_vehicles";
304
+ dataType: "number";
305
+ columnType: "PgInteger";
306
+ data: number;
307
+ driverParam: string | number;
308
+ notNull: false;
309
+ hasDefault: false;
310
+ isPrimaryKey: false;
311
+ isAutoincrement: false;
312
+ hasRuntimeDefault: false;
313
+ enumValues: undefined;
314
+ baseColumn: never;
315
+ identity: undefined;
316
+ generated: undefined;
317
+ }, {}, {}>;
318
+ childSeatCapacity: import("drizzle-orm/pg-core").PgColumn<{
319
+ name: "child_seat_capacity";
320
+ tableName: "ground_vehicles";
321
+ dataType: "number";
322
+ columnType: "PgInteger";
323
+ data: number;
324
+ driverParam: string | number;
325
+ notNull: false;
326
+ hasDefault: false;
327
+ isPrimaryKey: false;
328
+ isAutoincrement: false;
329
+ hasRuntimeDefault: false;
330
+ enumValues: undefined;
331
+ baseColumn: never;
332
+ identity: undefined;
333
+ generated: undefined;
334
+ }, {}, {}>;
335
+ isAccessible: import("drizzle-orm/pg-core").PgColumn<{
336
+ name: "is_accessible";
337
+ tableName: "ground_vehicles";
338
+ dataType: "boolean";
339
+ columnType: "PgBoolean";
340
+ data: boolean;
341
+ driverParam: boolean;
342
+ notNull: true;
343
+ hasDefault: true;
344
+ isPrimaryKey: false;
345
+ isAutoincrement: false;
346
+ hasRuntimeDefault: false;
347
+ enumValues: undefined;
348
+ baseColumn: never;
349
+ identity: undefined;
350
+ generated: undefined;
351
+ }, {}, {}>;
352
+ active: import("drizzle-orm/pg-core").PgColumn<{
353
+ name: "active";
354
+ tableName: "ground_vehicles";
355
+ dataType: "boolean";
356
+ columnType: "PgBoolean";
357
+ data: boolean;
358
+ driverParam: boolean;
359
+ notNull: true;
360
+ hasDefault: true;
361
+ isPrimaryKey: false;
362
+ isAutoincrement: false;
363
+ hasRuntimeDefault: false;
364
+ enumValues: undefined;
365
+ baseColumn: never;
366
+ identity: undefined;
367
+ generated: undefined;
368
+ }, {}, {}>;
369
+ notes: import("drizzle-orm/pg-core").PgColumn<{
370
+ name: "notes";
371
+ tableName: "ground_vehicles";
372
+ dataType: "string";
373
+ columnType: "PgText";
374
+ data: string;
375
+ driverParam: string;
376
+ notNull: false;
377
+ hasDefault: false;
378
+ isPrimaryKey: false;
379
+ isAutoincrement: false;
380
+ hasRuntimeDefault: false;
381
+ enumValues: [string, ...string[]];
382
+ baseColumn: never;
383
+ identity: undefined;
384
+ generated: undefined;
385
+ }, {}, {}>;
386
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
387
+ name: "created_at";
388
+ tableName: "ground_vehicles";
389
+ dataType: "date";
390
+ columnType: "PgTimestamp";
391
+ data: Date;
392
+ driverParam: string;
393
+ notNull: true;
394
+ hasDefault: true;
395
+ isPrimaryKey: false;
396
+ isAutoincrement: false;
397
+ hasRuntimeDefault: false;
398
+ enumValues: undefined;
399
+ baseColumn: never;
400
+ identity: undefined;
401
+ generated: undefined;
402
+ }, {}, {}>;
403
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
404
+ name: "updated_at";
405
+ tableName: "ground_vehicles";
406
+ dataType: "date";
407
+ columnType: "PgTimestamp";
408
+ data: Date;
409
+ driverParam: string;
410
+ notNull: true;
411
+ hasDefault: true;
412
+ isPrimaryKey: false;
413
+ isAutoincrement: false;
414
+ hasRuntimeDefault: false;
415
+ enumValues: undefined;
416
+ baseColumn: never;
417
+ identity: undefined;
418
+ generated: undefined;
419
+ }, {}, {}>;
420
+ };
421
+ dialect: "pg";
422
+ }>;
423
+ export declare const groundDrivers: import("drizzle-orm/pg-core").PgTableWithColumns<{
424
+ name: "ground_drivers";
425
+ schema: undefined;
426
+ columns: {
427
+ id: import("drizzle-orm/pg-core").PgColumn<{
428
+ name: string;
429
+ tableName: "ground_drivers";
430
+ dataType: "string";
431
+ columnType: "PgText";
432
+ data: string;
433
+ driverParam: string;
434
+ notNull: true;
435
+ hasDefault: true;
436
+ isPrimaryKey: true;
437
+ isAutoincrement: false;
438
+ hasRuntimeDefault: true;
439
+ enumValues: [string, ...string[]];
440
+ baseColumn: never;
441
+ identity: undefined;
442
+ generated: undefined;
443
+ }, {}, {}>;
444
+ resourceId: import("drizzle-orm/pg-core").PgColumn<{
445
+ name: "resource_id";
446
+ tableName: "ground_drivers";
447
+ dataType: "string";
448
+ columnType: "PgText";
449
+ data: string;
450
+ driverParam: string;
451
+ notNull: true;
452
+ hasDefault: false;
453
+ isPrimaryKey: false;
454
+ isAutoincrement: false;
455
+ hasRuntimeDefault: false;
456
+ enumValues: [string, ...string[]];
457
+ baseColumn: never;
458
+ identity: undefined;
459
+ generated: undefined;
460
+ }, {}, {}>;
461
+ operatorId: import("drizzle-orm/pg-core").PgColumn<{
462
+ name: string;
463
+ tableName: "ground_drivers";
464
+ dataType: "string";
465
+ columnType: "PgText";
466
+ data: string;
467
+ driverParam: string;
468
+ notNull: false;
469
+ hasDefault: false;
470
+ isPrimaryKey: false;
471
+ isAutoincrement: false;
472
+ hasRuntimeDefault: false;
473
+ enumValues: [string, ...string[]];
474
+ baseColumn: never;
475
+ identity: undefined;
476
+ generated: undefined;
477
+ }, {}, {}>;
478
+ licenseNumber: import("drizzle-orm/pg-core").PgColumn<{
479
+ name: "license_number";
480
+ tableName: "ground_drivers";
481
+ dataType: "string";
482
+ columnType: "PgText";
483
+ data: string;
484
+ driverParam: string;
485
+ notNull: false;
486
+ hasDefault: false;
487
+ isPrimaryKey: false;
488
+ isAutoincrement: false;
489
+ hasRuntimeDefault: false;
490
+ enumValues: [string, ...string[]];
491
+ baseColumn: never;
492
+ identity: undefined;
493
+ generated: undefined;
494
+ }, {}, {}>;
495
+ spokenLanguages: import("drizzle-orm/pg-core").PgColumn<{
496
+ name: "spoken_languages";
497
+ tableName: "ground_drivers";
498
+ dataType: "json";
499
+ columnType: "PgJsonb";
500
+ data: string[];
501
+ driverParam: unknown;
502
+ notNull: true;
503
+ hasDefault: true;
504
+ isPrimaryKey: false;
505
+ isAutoincrement: false;
506
+ hasRuntimeDefault: false;
507
+ enumValues: undefined;
508
+ baseColumn: never;
509
+ identity: undefined;
510
+ generated: undefined;
511
+ }, {}, {
512
+ $type: string[];
513
+ }>;
514
+ isGuide: import("drizzle-orm/pg-core").PgColumn<{
515
+ name: "is_guide";
516
+ tableName: "ground_drivers";
517
+ dataType: "boolean";
518
+ columnType: "PgBoolean";
519
+ data: boolean;
520
+ driverParam: boolean;
521
+ notNull: true;
522
+ hasDefault: true;
523
+ isPrimaryKey: false;
524
+ isAutoincrement: false;
525
+ hasRuntimeDefault: false;
526
+ enumValues: undefined;
527
+ baseColumn: never;
528
+ identity: undefined;
529
+ generated: undefined;
530
+ }, {}, {}>;
531
+ isMeetAndGreetCapable: import("drizzle-orm/pg-core").PgColumn<{
532
+ name: "is_meet_and_greet_capable";
533
+ tableName: "ground_drivers";
534
+ dataType: "boolean";
535
+ columnType: "PgBoolean";
536
+ data: boolean;
537
+ driverParam: boolean;
538
+ notNull: true;
539
+ hasDefault: true;
540
+ isPrimaryKey: false;
541
+ isAutoincrement: false;
542
+ hasRuntimeDefault: false;
543
+ enumValues: undefined;
544
+ baseColumn: never;
545
+ identity: undefined;
546
+ generated: undefined;
547
+ }, {}, {}>;
548
+ active: import("drizzle-orm/pg-core").PgColumn<{
549
+ name: "active";
550
+ tableName: "ground_drivers";
551
+ dataType: "boolean";
552
+ columnType: "PgBoolean";
553
+ data: boolean;
554
+ driverParam: boolean;
555
+ notNull: true;
556
+ hasDefault: true;
557
+ isPrimaryKey: false;
558
+ isAutoincrement: false;
559
+ hasRuntimeDefault: false;
560
+ enumValues: undefined;
561
+ baseColumn: never;
562
+ identity: undefined;
563
+ generated: undefined;
564
+ }, {}, {}>;
565
+ notes: import("drizzle-orm/pg-core").PgColumn<{
566
+ name: "notes";
567
+ tableName: "ground_drivers";
568
+ dataType: "string";
569
+ columnType: "PgText";
570
+ data: string;
571
+ driverParam: string;
572
+ notNull: false;
573
+ hasDefault: false;
574
+ isPrimaryKey: false;
575
+ isAutoincrement: false;
576
+ hasRuntimeDefault: false;
577
+ enumValues: [string, ...string[]];
578
+ baseColumn: never;
579
+ identity: undefined;
580
+ generated: undefined;
581
+ }, {}, {}>;
582
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
583
+ name: "created_at";
584
+ tableName: "ground_drivers";
585
+ dataType: "date";
586
+ columnType: "PgTimestamp";
587
+ data: Date;
588
+ driverParam: string;
589
+ notNull: true;
590
+ hasDefault: true;
591
+ isPrimaryKey: false;
592
+ isAutoincrement: false;
593
+ hasRuntimeDefault: false;
594
+ enumValues: undefined;
595
+ baseColumn: never;
596
+ identity: undefined;
597
+ generated: undefined;
598
+ }, {}, {}>;
599
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
600
+ name: "updated_at";
601
+ tableName: "ground_drivers";
602
+ dataType: "date";
603
+ columnType: "PgTimestamp";
604
+ data: Date;
605
+ driverParam: string;
606
+ notNull: true;
607
+ hasDefault: true;
608
+ isPrimaryKey: false;
609
+ isAutoincrement: false;
610
+ hasRuntimeDefault: false;
611
+ enumValues: undefined;
612
+ baseColumn: never;
613
+ identity: undefined;
614
+ generated: undefined;
615
+ }, {}, {}>;
616
+ };
617
+ dialect: "pg";
618
+ }>;
619
+ export type GroundOperator = typeof groundOperators.$inferSelect;
620
+ export type NewGroundOperator = typeof groundOperators.$inferInsert;
621
+ export type GroundVehicle = typeof groundVehicles.$inferSelect;
622
+ export type NewGroundVehicle = typeof groundVehicles.$inferInsert;
623
+ export type GroundDriver = typeof groundDrivers.$inferSelect;
624
+ export type NewGroundDriver = typeof groundDrivers.$inferInsert;
625
+ //# sourceMappingURL=schema-operators.d.ts.map
package/dist/schema-operators.d.ts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"schema-operators.d.ts","sourceRoot":"","sources":["../src/schema-operators.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB3B,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B1B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBzB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,eAAe,CAAC,YAAY,CAAA;AAChE,MAAM,MAAM,iBAAiB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAA;AACnE,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AACjE,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA"}
package/dist/schema-operators.js ADDED
@@ -0,0 +1,62 @@
1
+ import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
2
+ import { facilities } from "@voyantjs/facilities/schema";
3
+ import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
4
+ import { groundVehicleCategoryEnum, groundVehicleClassEnum } from "./schema-shared";
5
+ export const groundOperators = pgTable("ground_operators", {
6
+ id: typeId("ground_operators"),
7
+ supplierId: text("supplier_id"),
8
+ facilityId: typeIdRef("facility_id").references(() => facilities.id, { onDelete: "set null" }),
9
+ name: text("name").notNull(),
10
+ code: text("code"),
11
+ active: boolean("active").notNull().default(true),
12
+ notes: text("notes"),
13
+ createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
14
+ updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
15
+ }, (table) => [
16
+ index("idx_ground_operators_supplier").on(table.supplierId),
17
+ index("idx_ground_operators_facility").on(table.facilityId),
18
+ index("idx_ground_operators_active").on(table.active),
19
+ ]);
20
+ export const groundVehicles = pgTable("ground_vehicles", {
21
+ id: typeId("ground_vehicles"),
22
+ resourceId: text("resource_id").notNull(),
23
+ operatorId: typeIdRef("operator_id").references(() => groundOperators.id, {
24
+ onDelete: "set null",
25
+ }),
26
+ category: groundVehicleCategoryEnum("category").notNull().default("other"),
27
+ vehicleClass: groundVehicleClassEnum("vehicle_class").notNull().default("standard"),
28
+ passengerCapacity: integer("passenger_capacity"),
29
+ checkedBagCapacity: integer("checked_bag_capacity"),
30
+ carryOnCapacity: integer("carry_on_capacity"),
31
+ wheelchairCapacity: integer("wheelchair_capacity"),
32
+ childSeatCapacity: integer("child_seat_capacity"),
33
+ isAccessible: boolean("is_accessible").notNull().default(false),
34
+ active: boolean("active").notNull().default(true),
35
+ notes: text("notes"),
36
+ createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
37
+ updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
38
+ }, (table) => [
39
+ uniqueIndex("uidx_ground_vehicles_resource").on(table.resourceId),
40
+ index("idx_ground_vehicles_operator").on(table.operatorId),
41
+ index("idx_ground_vehicles_category").on(table.category),
42
+ index("idx_ground_vehicles_active").on(table.active),
43
+ ]);
44
+ export const groundDrivers = pgTable("ground_drivers", {
45
+ id: typeId("ground_drivers"),
46
+ resourceId: text("resource_id").notNull(),
47
+ operatorId: typeIdRef("operator_id").references(() => groundOperators.id, {
48
+ onDelete: "set null",
49
+ }),
50
+ licenseNumber: text("license_number"),
51
+ spokenLanguages: jsonb("spoken_languages").$type().notNull().default([]),
52
+ isGuide: boolean("is_guide").notNull().default(false),
53
+ isMeetAndGreetCapable: boolean("is_meet_and_greet_capable").notNull().default(false),
54
+ active: boolean("active").notNull().default(true),
55
+ notes: text("notes"),
56
+ createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
57
+ updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
58
+ }, (table) => [
59
+ uniqueIndex("uidx_ground_drivers_resource").on(table.resourceId),
60
+ index("idx_ground_drivers_operator").on(table.operatorId),
61
+ index("idx_ground_drivers_active").on(table.active),
62
+ ]);