tabletcommand-location 2.4.1 → 2.4.3

package/.claude/worktrees/sc-36275/definitions/test/mock.d.ts

@@ -0,0 +1,346 @@
+import * as mongoose from "mongoose";
+import { BackendModels, Agency, Department } from "tabletcommand-backend-models";
+export default function (modelsModule: typeof import("tabletcommand-backend-models")): {
+    department: Partial<Department>;
+    agency: Partial<Agency>;
+    clearTestData: (mods: BackendModels) => Promise<void>;
+    prepareTestData: (mods: BackendModels) => Promise<void>;
+    before: () => Promise<{
+        ADSB: import("mongoose").Model<import("tabletcommand-backend-models").ADSB, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ADSB, {}, {}> & import("tabletcommand-backend-models").ADSB & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ActionLog: import("mongoose").Model<import("tabletcommand-backend-models").ActionLog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ActionLog, {}, {}> & import("tabletcommand-backend-models").ActionLog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Agency: import("mongoose").Model<import("tabletcommand-backend-models/definitions/models/agency").Agency, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models/definitions/models/agency").Agency, {}, {}> & import("tabletcommand-backend-models/definitions/models/agency").Agency & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ArcGISGroup: import("mongoose").Model<import("tabletcommand-backend-models").ArcGISGroup, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ArcGISGroup, {}, {}> & import("tabletcommand-backend-models").ArcGISGroup & {
+            _id: import("mongoose").Types.ObjectId;
+        } & {
+            __v: number;
+        }, any>;
+        Assignment: import("mongoose").Model<import("tabletcommand-backend-models").Assignment, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Assignment, {}, {}> & import("tabletcommand-backend-models").Assignment & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Battalion: import("mongoose").Model<import("tabletcommand-backend-models").Battalion, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Battalion, {}, {}> & import("tabletcommand-backend-models").Battalion & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        BeaconLog: import("mongoose").Model<import("tabletcommand-backend-models").BeaconLog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").BeaconLog, {}, {}> & import("tabletcommand-backend-models").BeaconLog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADIncident: import("mongoose").Model<import("tabletcommand-backend-models").CADIncident, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADIncident, {}, {}> & import("tabletcommand-backend-models").CADIncident & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADIncidentBlock: import("mongoose").Model<import("tabletcommand-backend-models").CADIncidentBlock, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADIncidentBlock, {}, {}> & import("tabletcommand-backend-models").CADIncidentBlock & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADIncidentStream: import("mongoose").Model<import("tabletcommand-backend-models").CADIncidentStream, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADIncidentStream, {}, {}> & import("tabletcommand-backend-models").CADIncidentStream & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADInterfaceMetaData: import("mongoose").Model<import("tabletcommand-backend-models").CADInterfaceMetaData, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADInterfaceMetaData, {}, {}> & import("tabletcommand-backend-models").CADInterfaceMetaData & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADSimulation: import("mongoose").Model<import("tabletcommand-backend-models").CADSimulation, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADSimulation, {}, {}> & import("tabletcommand-backend-models").CADSimulation & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADStatus: import("mongoose").Model<import("tabletcommand-backend-models").CADStatus, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADStatus, {}, {}> & import("tabletcommand-backend-models").CADStatus & {
+            _id: import("mongoose").Types.ObjectId;
+        } & {
+            __v: number;
+        }, any>;
+        CADStatusMap: import("mongoose").Model<import("tabletcommand-backend-models").CADStatusMap, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADStatusMap, {}, {}> & import("tabletcommand-backend-models").CADStatusMap & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADVehicle: import("mongoose").Model<import("tabletcommand-backend-models").CADVehicle, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADVehicle, {}, {}> & import("tabletcommand-backend-models").CADVehicle & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CADVehicleStatus: import("mongoose").Model<import("tabletcommand-backend-models").CADVehicleStatus, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADVehicleStatus, {}, {}> & import("tabletcommand-backend-models").CADVehicleStatus & {
+            _id: import("mongoose").Types.ObjectId;
+        } & {
+            __v: number;
+        }, any>;
+        CADVehicleStatusHistory: import("mongoose").Model<import("tabletcommand-backend-models").CADVehicleStatusHistory, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CADVehicleStatusHistory, {}, {}> & import("tabletcommand-backend-models").CADVehicleStatusHistory & {
+            _id: import("mongoose").Types.ObjectId;
+        } & {
+            __v: number;
+        }, any>;
+        ChartDeviceStats: import("mongoose").Model<import("tabletcommand-backend-models").ChartDeviceStats, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ChartDeviceStats, {}, {}> & import("tabletcommand-backend-models").ChartDeviceStats & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ChartIncident: import("mongoose").Model<import("tabletcommand-backend-models").ChartIncident, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ChartIncident, {}, {}> & import("tabletcommand-backend-models").ChartIncident & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ChartManagedIncident: import("mongoose").Model<import("tabletcommand-backend-models").ChartManagedIncident, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ChartManagedIncident, {}, {}> & import("tabletcommand-backend-models").ChartManagedIncident & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ChartUser: import("mongoose").Model<import("tabletcommand-backend-models").ChartUser, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ChartUser, {}, {}> & import("tabletcommand-backend-models").ChartUser & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Checklist: import("mongoose").Model<import("tabletcommand-backend-models").Checklist, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Checklist, {}, {}> & import("tabletcommand-backend-models").Checklist & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ChecklistItem: import("mongoose").Model<import("tabletcommand-backend-models").ChecklistItem, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ChecklistItem, {}, {}> & import("tabletcommand-backend-models").ChecklistItem & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        CSVImport: import("mongoose").Model<import("tabletcommand-backend-models").CSVImport, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").CSVImport, {}, {}> & import("tabletcommand-backend-models").CSVImport & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        AudioStreamAuthentication: import("mongoose").Model<import("tabletcommand-backend-models").AudioStreamAuthentication, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").AudioStreamAuthentication, {}, {}> & import("tabletcommand-backend-models").AudioStreamAuthentication & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Department: import("mongoose").Model<import("tabletcommand-backend-models/definitions/models/department").Department, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models/definitions/models/department").Department, {}, {}> & import("tabletcommand-backend-models/definitions/models/department").Department & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        DeviceMapping: import("mongoose").Model<import("tabletcommand-backend-models").DeviceMapping, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").DeviceMapping, {}, {}> & import("tabletcommand-backend-models").DeviceMapping & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        DroneConnection: import("mongoose").Model<import("tabletcommand-backend-models").DroneConnection, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").DroneConnection, {}, {}> & import("tabletcommand-backend-models").DroneConnection & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Esri: import("mongoose").Model<import("tabletcommand-backend-models").Esri, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Esri, {}, {}> & import("tabletcommand-backend-models").Esri & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        GSTMapping: import("mongoose").Model<import("tabletcommand-backend-models").GSTMapping, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").GSTMapping, {}, {}> & import("tabletcommand-backend-models").GSTMapping & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        GlobalSettings: import("mongoose").Model<import("tabletcommand-backend-models").GlobalSettings, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").GlobalSettings, {}, {}> & import("tabletcommand-backend-models").GlobalSettings & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        IncidentEvent: import("mongoose").Model<import("tabletcommand-backend-models").IncidentEvent, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").IncidentEvent, {}, {}> & import("tabletcommand-backend-models").IncidentEvent & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        IncidentFilter: import("mongoose").Model<import("tabletcommand-backend-models").IncidentFilter, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").IncidentFilter, {}, {}> & import("tabletcommand-backend-models").IncidentFilter & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        IncidentFilterGlobal: import("mongoose").Model<import("tabletcommand-backend-models").IncidentFilterGlobal, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").IncidentFilterGlobal, {}, {}> & import("tabletcommand-backend-models").IncidentFilterGlobal & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        IncidentNotified: import("mongoose").Model<import("tabletcommand-backend-models").IncidentNotified, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").IncidentNotified, {}, {}> & import("tabletcommand-backend-models").IncidentNotified & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        IncidentShareCode: import("mongoose").Model<import("tabletcommand-backend-models").IncidentShareCode, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").IncidentShareCode, {}, {}> & import("tabletcommand-backend-models").IncidentShareCode & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        IncidentTakeover: import("mongoose").Model<import("tabletcommand-backend-models").IncidentTakeover, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").IncidentTakeover, {}, {}> & import("tabletcommand-backend-models").IncidentTakeover & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        JobLog: import("mongoose").Model<import("tabletcommand-backend-models").JobLog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").JobLog, {}, {}> & import("tabletcommand-backend-models").JobLog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        KindTypeCatalog: import("mongoose").Model<import("tabletcommand-backend-models").KindTypeCatalog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").KindTypeCatalog, {}, {}> & import("tabletcommand-backend-models").KindTypeCatalog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Location: import("mongoose").Model<import("tabletcommand-backend-models").Location, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Location, {}, {}> & import("tabletcommand-backend-models").Location & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        MailLog: import("mongoose").Model<import("tabletcommand-backend-models").MailLog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").MailLog, {}, {}> & import("tabletcommand-backend-models").MailLog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ManagedIncident: import("mongoose").Model<import("tabletcommand-backend-models").ManagedIncident, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ManagedIncident, {}, {}> & import("tabletcommand-backend-models").ManagedIncident & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Mark43IncidentRetry: import("mongoose").Model<import("tabletcommand-backend-models").Mark43IncidentRetry, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Mark43IncidentRetry, {}, {}> & import("tabletcommand-backend-models").Mark43IncidentRetry & {
+            _id: import("mongoose").Types.ObjectId;
+        } & {
+            __v: number;
+        }, any>;
+        Message: import("mongoose").Model<import("tabletcommand-backend-models").Message, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Message, {}, {}> & import("tabletcommand-backend-models").Message & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Monitor: import("mongoose").Model<import("tabletcommand-backend-models").Monitor, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Monitor, {}, {}> & import("tabletcommand-backend-models").Monitor & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        PersonnelImport: import("mongoose").Model<import("tabletcommand-backend-models").PersonnelImport, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").PersonnelImport, {}, {}> & import("tabletcommand-backend-models").PersonnelImport & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        PersonnelKnown: import("mongoose").Model<import("tabletcommand-backend-models").PersonnelKnown, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").PersonnelKnown, {}, {}> & import("tabletcommand-backend-models").PersonnelKnown & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Partner: import("mongoose").Model<import("tabletcommand-backend-models").Partner, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Partner, {}, {}> & import("tabletcommand-backend-models").Partner & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        PersonnelRoster: import("mongoose").Model<import("tabletcommand-backend-models").PersonnelRoster, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").PersonnelRoster, {}, {}> & import("tabletcommand-backend-models").PersonnelRoster & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        RateLimit: import("mongoose").Model<import("tabletcommand-backend-models").RateLimit, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").RateLimit, {}, {}> & import("tabletcommand-backend-models").RateLimit & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        ReleaseNote: import("mongoose").Model<import("tabletcommand-backend-models").ReleaseNote, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ReleaseNote, {}, {}> & import("tabletcommand-backend-models").ReleaseNote & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        RemoteLog: import("mongoose").Model<import("tabletcommand-backend-models").RemoteLog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").RemoteLog, {}, {}> & import("tabletcommand-backend-models").RemoteLog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        RemoteLogStream: import("mongoose").Model<import("tabletcommand-backend-models").RemoteLogStream, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").RemoteLogStream, {}, {}> & import("tabletcommand-backend-models").RemoteLogStream & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Session: import("mongoose").Model<import("tabletcommand-backend-models").Session, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Session, {}, {}> & import("tabletcommand-backend-models").Session & Required<{
+            _id: string;
+        }> & {
+            __v: number;
+        }, any>;
+        SAML: import("mongoose").Model<import("tabletcommand-backend-models").SAML, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").SAML, {}, {}> & import("tabletcommand-backend-models").SAML & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        SMSLog: import("mongoose").Model<import("tabletcommand-backend-models").SMSLog, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").SMSLog, {}, {}> & import("tabletcommand-backend-models").SMSLog & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        SMTPUnhandled: import("mongoose").Model<import("tabletcommand-backend-models").SMTPUnhandled, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").SMTPUnhandled, {}, {}> & import("tabletcommand-backend-models").SMTPUnhandled & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        StatusBeacon: import("mongoose").Model<import("tabletcommand-backend-models").StatusBeacon, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").StatusBeacon, {}, {}> & import("tabletcommand-backend-models").StatusBeacon & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        StatusBeaconTransition: import("mongoose").Model<import("tabletcommand-backend-models").StatusBeaconTransition, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").StatusBeaconTransition, {}, {}> & import("tabletcommand-backend-models").StatusBeaconTransition & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        Template: import("mongoose").Model<import("tabletcommand-backend-models").Template, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").Template, {}, {}> & import("tabletcommand-backend-models").Template & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        TrackerResponder: import("mongoose").Model<import("tabletcommand-backend-models").TrackerResponder, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").TrackerResponder, {}, {}> & import("tabletcommand-backend-models").TrackerResponder & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        User: import("mongoose").Model<import("tabletcommand-backend-models").User, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").User, {}, {}> & import("tabletcommand-backend-models").User & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        UserDevice: import("mongoose").Model<import("tabletcommand-backend-models").UserDevice, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").UserDevice, {}, {}> & import("tabletcommand-backend-models").UserDevice & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        UserRegistration: import("mongoose").Model<import("tabletcommand-backend-models").UserRegistration, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").UserRegistration, {}, {}> & import("tabletcommand-backend-models").UserRegistration & {
+            _id: import("mongoose").Types.ObjectId;
+        } & {
+            __v: number;
+        }, any>;
+        ValidationReport: import("mongoose").Model<import("tabletcommand-backend-models").ValidationReport, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").ValidationReport, {}, {}> & import("tabletcommand-backend-models").ValidationReport & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+        WatchDutyEvent: import("mongoose").Model<import("tabletcommand-backend-models").WatchDutyEvent, {}, {}, {}, import("mongoose").Document<unknown, {}, import("tabletcommand-backend-models").WatchDutyEvent, {}, {}> & import("tabletcommand-backend-models").WatchDutyEvent & Required<{
+            _id: import("mongoose").Types.ObjectId;
+        }> & {
+            __v: number;
+        }, any>;
+    }>;
+    beforeEach: () => Promise<void>;
+    after: () => Promise<void>;
+    afterEach: () => Promise<void>;
+    getModels: () => BackendModels;
+    getConnection: () => typeof mongoose;
+};
+//# sourceMappingURL=mock.d.ts.map

package/.claude/worktrees/sc-36275/definitions/test/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/test/mock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EACL,aAAa,EAEb,MAAM,EACN,UAAU,EAEX,MAAM,8BAA8B,CAAC;AAEtC,MAAM,CAAC,OAAO,WAAU,YAAY,EAAE,cAAc,8BAA8B,CAAC;;;0BA6F9C,aAAa;4BASX,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsD5B,aAAa;yBAIT,OAAO,QAAQ;EAgB1C"}

package/.claude/worktrees/sc-36275/definitions/test/query.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=query.d.ts.map

package/.claude/worktrees/sc-36275/definitions/test/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/test/query.ts"],"names":[],"mappings":""}

package/.claude/worktrees/sc-36275/definitions/types.d.ts

@@ -0,0 +1,53 @@
+import { Location, LocationKindType, LocationSource, LocationVisibility } from "tabletcommand-backend-models";
+export { LocationKindType, LocationSource, LocationVisibility, };
+export interface LocationPayload {
+    altitude?: number;
+    avlTime: string;
+    kindType: LocationKindType;
+    kind?: string;
+    type?: string;
+    locationType?: LocationKindType;
+    kindColor?: {
+        background: string;
+        text: string;
+    };
+    latitude: number;
+    longitude: number;
+    radioName: string;
+    source: LocationSource;
+    speed?: number;
+    heading?: number;
+    vehicleId: string;
+    visibility: LocationVisibility[];
+    personnelUUID?: string;
+    transponderUUID?: string;
+    userId?: string;
+    session?: string;
+    username?: string;
+}
+export interface Vehicle {
+    departmentId: string;
+    modifiedDate: number;
+    modified: Date;
+    radioName: string;
+    vehicleId: string;
+}
+export type DecodedLocation = {
+    cadAVL: Partial<Location>;
+    isValid: boolean;
+};
+export interface LocationDelta {
+    active?: boolean;
+    agencyCode?: string;
+    agencyName?: string;
+    device_type?: string;
+    opAreaCode?: string;
+    opAreaName?: string;
+    shared?: boolean;
+    state?: string;
+    username?: string;
+}
+export type LocationObject = {
+    [P in keyof Location]: Location[P];
+};
+//# sourceMappingURL=types.d.ts.map

package/.claude/worktrees/sc-36275/definitions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EACnB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,kBAAkB,GACnB,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,SAAS,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,kBAAkB,EAAE,CAAC;IAIjC,aAAa,CAAC,EAAE,MAAM,CAAC;IAIvB,eAAe,CAAC,EAAE,MAAM,CAAC;IAKzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,OAAO;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,IAAI,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAA;CACjB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,cAAc,GAAG;KAC1B,CAAC,IAAI,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC;CACnC,CAAC"}

package/.claude/worktrees/sc-36275/eslint.config.mjs

@@ -0,0 +1,95 @@
+import { defineConfig } from "eslint/config";
+import promise from "eslint-plugin-promise";
+import security from "eslint-plugin-security";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+import neostandard, { plugins } from "neostandard";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all
+});
+
+export default defineConfig([
+  ...neostandard({
+    env: [
+      "node",
+    ],
+    ts: true,
+  }),
+  plugins.n.configs["flat/recommended"],
+  {
+    extends: compat.extends(
+      "eslint:recommended",
+      "plugin:security/recommended-legacy",
+    ),
+
+    plugins: {
+      promise,
+      security,
+    },
+
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+
+      parser: tsParser,
+      ecmaVersion: 2019,
+      sourceType: "commonjs",
+
+      parserOptions: {
+        project: "./src/tsconfig.json",
+      },
+    },
+
+    settings: {
+      node: {
+        version: ">=24.15.0",
+      }
+    },
+
+    rules: {
+      quotes: [2, "double"],
+      semi: [2, "always"],
+      "@typescript-eslint/await-thenable": [1],
+      "@typescript-eslint/no-floating-promises": [1],
+      "@typescript-eslint/no-for-in-array": [1],
+
+      "space-before-function-paren": [0],
+      "@typescript-eslint/explicit-module-boundary-types": 0,
+      "@typescript-eslint/no-empty-interface": 0,
+      "@typescript-eslint/require-await": 0,
+      "@typescript-eslint/restrict-template-expressions": 0,
+
+      "@typescript-eslint/no-misused-promises": ["warn", {
+        checksVoidReturn: false,
+      }],
+      //
+      "@stylistic/quotes": [2, "double"],
+      "@stylistic/space-before-function-paren": [0],
+      "@stylistic/semi": [2, "always"],
+      "import-x/first": [0],
+      "camelcase": [0],
+      "n/no-process-exit": [0],
+      "n/no-unpublished-import": ["error", {
+        "allowModules": ["chai"]
+      }],
+      // this is a workaround for import of .ts files
+      "n/no-missing-import": [0],
+    },
+  },
+  {
+    files: ["src/test/**"],
+    rules: {
+      "@typescript-eslint/no-floating-promises": [0],
+    },
+  }
+]);

package/.claude/worktrees/sc-36275/gulpfile.js

@@ -0,0 +1,23 @@
+const gulp = require("gulp");
+const exec = require("gulp-execa");
+const { deleteAsync } = require("del");
+
+gulp.task("clean", function() {
+  return deleteAsync(["build/**", "definitions/**"], {
+    force: true
+  });
+});
+
+gulp.task("ts", exec.task("tsc -p src"));
+
+gulp.task("type-coverage", exec.task("type-coverage --detail"));
+
+gulp.task("cspell", exec.task("cspell --no-progress"));
+
+gulp.task("lint", exec.task("eslint src"));
+
+gulp.task("test", exec.task("tsx --test --test-concurrency=1 --test-reporter=spec src/test/*.ts"));
+
+gulp.task("build", gulp.series("clean", "ts"));
+
+gulp.task("default", gulp.series("cspell", "type-coverage", "lint", "build", "test"));