@voyantjs/ground 0.1.1 → 0.3.0

package/dist/schema-relations.d.ts

@@ -0,0 +1,63 @@
+export declare const groundOperatorsRelations: import("drizzle-orm").Relations<"ground_operators", {
+    facility: import("drizzle-orm").One<"facilities", false>;
+    vehicles: import("drizzle-orm").Many<"ground_vehicles">;
+    drivers: import("drizzle-orm").Many<"ground_drivers">;
+}>;
+export declare const groundVehiclesRelations: import("drizzle-orm").Relations<"ground_vehicles", {
+    operator: import("drizzle-orm").One<"ground_operators", false>;
+}>;
+export declare const groundDriversRelations: import("drizzle-orm").Relations<"ground_drivers", {
+    operator: import("drizzle-orm").One<"ground_operators", false>;
+}>;
+export declare const groundTransferPreferencesRelations: import("drizzle-orm").Relations<"ground_transfer_preferences", {
+    pickupFacility: import("drizzle-orm").One<"facilities", false>;
+    dropoffFacility: import("drizzle-orm").One<"facilities", false>;
+    pickupAddress: import("drizzle-orm").One<"identity_addresses", false>;
+    dropoffAddress: import("drizzle-orm").One<"identity_addresses", false>;
+    dispatches: import("drizzle-orm").Many<"ground_dispatches">;
+}>;
+export declare const groundDispatchesRelations: import("drizzle-orm").Relations<"ground_dispatches", {
+    transferPreference: import("drizzle-orm").One<"ground_transfer_preferences", true>;
+    operator: import("drizzle-orm").One<"ground_operators", false>;
+    vehicle: import("drizzle-orm").One<"ground_vehicles", false>;
+    driver: import("drizzle-orm").One<"ground_drivers", false>;
+    executionEvents: import("drizzle-orm").Many<"ground_execution_events">;
+    assignments: import("drizzle-orm").Many<"ground_dispatch_assignments">;
+    legs: import("drizzle-orm").Many<"ground_dispatch_legs">;
+    passengers: import("drizzle-orm").Many<"ground_dispatch_passengers">;
+    incidents: import("drizzle-orm").Many<"ground_service_incidents">;
+    checkpoints: import("drizzle-orm").Many<"ground_dispatch_checkpoints">;
+}>;
+export declare const groundExecutionEventsRelations: import("drizzle-orm").Relations<"ground_execution_events", {
+    dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
+    facility: import("drizzle-orm").One<"facilities", false>;
+    address: import("drizzle-orm").One<"identity_addresses", false>;
+}>;
+export declare const groundDispatchAssignmentsRelations: import("drizzle-orm").Relations<"ground_dispatch_assignments", {
+    dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
+    operator: import("drizzle-orm").One<"ground_operators", false>;
+    vehicle: import("drizzle-orm").One<"ground_vehicles", false>;
+    driver: import("drizzle-orm").One<"ground_drivers", false>;
+}>;
+export declare const groundDispatchLegsRelations: import("drizzle-orm").Relations<"ground_dispatch_legs", {
+    dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
+    facility: import("drizzle-orm").One<"facilities", false>;
+    address: import("drizzle-orm").One<"identity_addresses", false>;
+}>;
+export declare const groundDispatchPassengersRelations: import("drizzle-orm").Relations<"ground_dispatch_passengers", {
+    dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
+}>;
+export declare const groundDriverShiftsRelations: import("drizzle-orm").Relations<"ground_driver_shifts", {
+    driver: import("drizzle-orm").One<"ground_drivers", true>;
+    operator: import("drizzle-orm").One<"ground_operators", false>;
+    facility: import("drizzle-orm").One<"facilities", false>;
+}>;
+export declare const groundServiceIncidentsRelations: import("drizzle-orm").Relations<"ground_service_incidents", {
+    dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
+}>;
+export declare const groundDispatchCheckpointsRelations: import("drizzle-orm").Relations<"ground_dispatch_checkpoints", {
+    dispatch: import("drizzle-orm").One<"ground_dispatches", true>;
+    facility: import("drizzle-orm").One<"facilities", false>;
+    address: import("drizzle-orm").One<"identity_addresses", false>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map

package/dist/schema-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../src/schema-relations.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,wBAAwB;;;;EAIlC,CAAA;AAEH,eAAO,MAAM,uBAAuB;;EAKjC,CAAA;AAEH,eAAO,MAAM,sBAAsB;;EAKhC,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;;EAqB9C,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;EAuBnC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;EAaxC,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;EAoB9C,CAAA;AAED,eAAO,MAAM,2BAA2B;;;;EAarC,CAAA;AAEH,eAAO,MAAM,iCAAiC;;EAK3C,CAAA;AAEH,eAAO,MAAM,2BAA2B;;;;EAarC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;EAKzC,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;EAgB9C,CAAA"}

package/dist/schema-relations.js

@@ -0,0 +1,152 @@
+import { facilities } from "@voyantjs/facilities/schema";
+import { identityAddresses } from "@voyantjs/identity/schema";
+import { relations } from "drizzle-orm";
+import { groundDispatches, groundTransferPreferences } from "./schema-dispatch";
+import { groundDispatchAssignments, groundDispatchCheckpoints, groundDispatchLegs, groundDispatchPassengers, groundDriverShifts, groundExecutionEvents, groundServiceIncidents, } from "./schema-operations";
+import { groundDrivers, groundOperators, groundVehicles } from "./schema-operators";
+export const groundOperatorsRelations = relations(groundOperators, ({ one, many }) => ({
+    facility: one(facilities, { fields: [groundOperators.facilityId], references: [facilities.id] }),
+    vehicles: many(groundVehicles),
+    drivers: many(groundDrivers),
+}));
+export const groundVehiclesRelations = relations(groundVehicles, ({ one }) => ({
+    operator: one(groundOperators, {
+        fields: [groundVehicles.operatorId],
+        references: [groundOperators.id],
+    }),
+}));
+export const groundDriversRelations = relations(groundDrivers, ({ one }) => ({
+    operator: one(groundOperators, {
+        fields: [groundDrivers.operatorId],
+        references: [groundOperators.id],
+    }),
+}));
+export const groundTransferPreferencesRelations = relations(groundTransferPreferences, ({ one, many }) => ({
+    pickupFacility: one(facilities, {
+        fields: [groundTransferPreferences.pickupFacilityId],
+        references: [facilities.id],
+    }),
+    dropoffFacility: one(facilities, {
+        fields: [groundTransferPreferences.dropoffFacilityId],
+        references: [facilities.id],
+    }),
+    pickupAddress: one(identityAddresses, {
+        fields: [groundTransferPreferences.pickupAddressId],
+        references: [identityAddresses.id],
+    }),
+    dropoffAddress: one(identityAddresses, {
+        fields: [groundTransferPreferences.dropoffAddressId],
+        references: [identityAddresses.id],
+    }),
+    dispatches: many(groundDispatches),
+}));
+export const groundDispatchesRelations = relations(groundDispatches, ({ one, many }) => ({
+    transferPreference: one(groundTransferPreferences, {
+        fields: [groundDispatches.transferPreferenceId],
+        references: [groundTransferPreferences.id],
+    }),
+    operator: one(groundOperators, {
+        fields: [groundDispatches.operatorId],
+        references: [groundOperators.id],
+    }),
+    vehicle: one(groundVehicles, {
+        fields: [groundDispatches.vehicleId],
+        references: [groundVehicles.id],
+    }),
+    driver: one(groundDrivers, {
+        fields: [groundDispatches.driverId],
+        references: [groundDrivers.id],
+    }),
+    executionEvents: many(groundExecutionEvents),
+    assignments: many(groundDispatchAssignments),
+    legs: many(groundDispatchLegs),
+    passengers: many(groundDispatchPassengers),
+    incidents: many(groundServiceIncidents),
+    checkpoints: many(groundDispatchCheckpoints),
+}));
+export const groundExecutionEventsRelations = relations(groundExecutionEvents, ({ one }) => ({
+    dispatch: one(groundDispatches, {
+        fields: [groundExecutionEvents.dispatchId],
+        references: [groundDispatches.id],
+    }),
+    facility: one(facilities, {
+        fields: [groundExecutionEvents.facilityId],
+        references: [facilities.id],
+    }),
+    address: one(identityAddresses, {
+        fields: [groundExecutionEvents.addressId],
+        references: [identityAddresses.id],
+    }),
+}));
+export const groundDispatchAssignmentsRelations = relations(groundDispatchAssignments, ({ one }) => ({
+    dispatch: one(groundDispatches, {
+        fields: [groundDispatchAssignments.dispatchId],
+        references: [groundDispatches.id],
+    }),
+    operator: one(groundOperators, {
+        fields: [groundDispatchAssignments.operatorId],
+        references: [groundOperators.id],
+    }),
+    vehicle: one(groundVehicles, {
+        fields: [groundDispatchAssignments.vehicleId],
+        references: [groundVehicles.id],
+    }),
+    driver: one(groundDrivers, {
+        fields: [groundDispatchAssignments.driverId],
+        references: [groundDrivers.id],
+    }),
+}));
+export const groundDispatchLegsRelations = relations(groundDispatchLegs, ({ one }) => ({
+    dispatch: one(groundDispatches, {
+        fields: [groundDispatchLegs.dispatchId],
+        references: [groundDispatches.id],
+    }),
+    facility: one(facilities, {
+        fields: [groundDispatchLegs.facilityId],
+        references: [facilities.id],
+    }),
+    address: one(identityAddresses, {
+        fields: [groundDispatchLegs.addressId],
+        references: [identityAddresses.id],
+    }),
+}));
+export const groundDispatchPassengersRelations = relations(groundDispatchPassengers, ({ one }) => ({
+    dispatch: one(groundDispatches, {
+        fields: [groundDispatchPassengers.dispatchId],
+        references: [groundDispatches.id],
+    }),
+}));
+export const groundDriverShiftsRelations = relations(groundDriverShifts, ({ one }) => ({
+    driver: one(groundDrivers, {
+        fields: [groundDriverShifts.driverId],
+        references: [groundDrivers.id],
+    }),
+    operator: one(groundOperators, {
+        fields: [groundDriverShifts.operatorId],
+        references: [groundOperators.id],
+    }),
+    facility: one(facilities, {
+        fields: [groundDriverShifts.facilityId],
+        references: [facilities.id],
+    }),
+}));
+export const groundServiceIncidentsRelations = relations(groundServiceIncidents, ({ one }) => ({
+    dispatch: one(groundDispatches, {
+        fields: [groundServiceIncidents.dispatchId],
+        references: [groundDispatches.id],
+    }),
+}));
+export const groundDispatchCheckpointsRelations = relations(groundDispatchCheckpoints, ({ one }) => ({
+    dispatch: one(groundDispatches, {
+        fields: [groundDispatchCheckpoints.dispatchId],
+        references: [groundDispatches.id],
+    }),
+    facility: one(facilities, {
+        fields: [groundDispatchCheckpoints.facilityId],
+        references: [facilities.id],
+    }),
+    address: one(identityAddresses, {
+        fields: [groundDispatchCheckpoints.addressId],
+        references: [identityAddresses.id],
+    }),
+}));

package/dist/schema-shared.d.ts

@@ -0,0 +1,12 @@
+export declare const groundVehicleCategoryEnum: import("drizzle-orm/pg-core").PgEnum<["car", "sedan", "suv", "van", "minibus", "bus", "boat", "train", "other"]>;
+export declare const groundVehicleClassEnum: import("drizzle-orm/pg-core").PgEnum<["economy", "standard", "premium", "luxury", "accessible", "other"]>;
+export declare const groundServiceLevelEnum: import("drizzle-orm/pg-core").PgEnum<["private", "shared", "vip", "shuttle", "other"]>;
+export declare const groundDispatchStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "scheduled", "assigned", "en_route", "arrived", "picked_up", "completed", "cancelled", "no_show"]>;
+export declare const groundExecutionEventTypeEnum: import("drizzle-orm/pg-core").PgEnum<["scheduled", "assigned", "driver_en_route", "driver_arrived", "pickup_completed", "dropoff_completed", "cancelled", "issue", "note"]>;
+export declare const groundAssignmentSourceEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "suggested", "auto"]>;
+export declare const groundDispatchLegTypeEnum: import("drizzle-orm/pg-core").PgEnum<["pickup", "stop", "dropoff", "deadhead"]>;
+export declare const groundDriverShiftStatusEnum: import("drizzle-orm/pg-core").PgEnum<["scheduled", "available", "on_duty", "completed", "cancelled"]>;
+export declare const groundIncidentSeverityEnum: import("drizzle-orm/pg-core").PgEnum<["info", "warning", "critical"]>;
+export declare const groundIncidentResolutionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "mitigated", "resolved", "cancelled"]>;
+export declare const groundCheckpointStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "reached", "missed", "cancelled"]>;
+//# sourceMappingURL=schema-shared.d.ts.map

package/dist/schema-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-shared.d.ts","sourceRoot":"","sources":["../src/schema-shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,kHAUpC,CAAA;AAEF,eAAO,MAAM,sBAAsB,2GAOjC,CAAA;AAEF,eAAO,MAAM,sBAAsB,wFAMjC,CAAA;AAEF,eAAO,MAAM,wBAAwB,mJAUnC,CAAA;AAEF,eAAO,MAAM,4BAA4B,6KAUvC,CAAA;AAEF,eAAO,MAAM,0BAA0B,uEAIrC,CAAA;AAEF,eAAO,MAAM,yBAAyB,iFAKpC,CAAA;AAEF,eAAO,MAAM,2BAA2B,uGAMtC,CAAA;AAEF,eAAO,MAAM,0BAA0B,uEAIrC,CAAA;AAEF,eAAO,MAAM,kCAAkC,sFAK7C,CAAA;AAEF,eAAO,MAAM,0BAA0B,qFAKrC,CAAA"}

package/dist/schema-shared.js

@@ -0,0 +1,84 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const groundVehicleCategoryEnum = pgEnum("ground_vehicle_category", [
+    "car",
+    "sedan",
+    "suv",
+    "van",
+    "minibus",
+    "bus",
+    "boat",
+    "train",
+    "other",
+]);
+export const groundVehicleClassEnum = pgEnum("ground_vehicle_class", [
+    "economy",
+    "standard",
+    "premium",
+    "luxury",
+    "accessible",
+    "other",
+]);
+export const groundServiceLevelEnum = pgEnum("ground_service_level", [
+    "private",
+    "shared",
+    "vip",
+    "shuttle",
+    "other",
+]);
+export const groundDispatchStatusEnum = pgEnum("ground_dispatch_status", [
+    "draft",
+    "scheduled",
+    "assigned",
+    "en_route",
+    "arrived",
+    "picked_up",
+    "completed",
+    "cancelled",
+    "no_show",
+]);
+export const groundExecutionEventTypeEnum = pgEnum("ground_execution_event_type", [
+    "scheduled",
+    "assigned",
+    "driver_en_route",
+    "driver_arrived",
+    "pickup_completed",
+    "dropoff_completed",
+    "cancelled",
+    "issue",
+    "note",
+]);
+export const groundAssignmentSourceEnum = pgEnum("ground_assignment_source", [
+    "manual",
+    "suggested",
+    "auto",
+]);
+export const groundDispatchLegTypeEnum = pgEnum("ground_dispatch_leg_type", [
+    "pickup",
+    "stop",
+    "dropoff",
+    "deadhead",
+]);
+export const groundDriverShiftStatusEnum = pgEnum("ground_driver_shift_status", [
+    "scheduled",
+    "available",
+    "on_duty",
+    "completed",
+    "cancelled",
+]);
+export const groundIncidentSeverityEnum = pgEnum("ground_incident_severity", [
+    "info",
+    "warning",
+    "critical",
+]);
+export const groundIncidentResolutionStatusEnum = pgEnum("ground_incident_resolution_status", [
+    "open",
+    "mitigated",
+    "resolved",
+    "cancelled",
+]);
+export const groundCheckpointStatusEnum = pgEnum("ground_checkpoint_status", [
+    "pending",
+    "reached",
+    "missed",
+    "cancelled",
+]);