tabletcommand-backend-models 5.17.41 → 5.18.0

package/definitions/models/checklist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checklist.d.ts","sourceRoot":"","sources":["../../src/models/checklist.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,EACL,cAAc,EAOd,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAIpB,wBAAsB,eAAe,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6E7D;AAED,MAAM,WAAW,SAAU,SAAQ,8BAA8B,CAAC,OAAO,eAAe,CAAC;CAAI;AAC7F,MAAM,WAAW,cAAe,SAAQ,+BAA+B,CAAC,SAAS,CAAC;CAAI;;AACtF,wBAAiG"}
+{"version":3,"file":"checklist.d.ts","sourceRoot":"","sources":["../../src/models/checklist.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,EACL,cAAc,EAGd,WAAW,EAIX,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAIpB,wBAAgB,eAAe,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6EvD;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAG7D;AAED,MAAM,WAAW,SAAU,SAAQ,8BAA8B,CAAC,OAAO,eAAe,CAAC;CAAI;AAC7F,MAAM,WAAW,cAAe,SAAQ,+BAA+B,CAAC,SAAS,CAAC;CAAI;;AACtF,wBAAiG"}

package/definitions/models/personnel-import.d.ts

@@ -1,5 +1,86 @@
 /// <reference types="mongoose" />
-import { MongooseModule, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, ReplaceModelReturnType } from "../helpers";
+import { currentDate, MongooseModule, retrieveCurrentUnixTime, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, ReplaceModelReturnType } from "../helpers";
+export declare function PersonnelImportSchema(mongoose: MongooseModule): import("mongoose").Schema<any> & {
+    _interface: import("../helpers").MongooseInterface<{
+        _id: {
+            type: import("mongoose").Types.ObjectIdConstructor;
+            auto: boolean;
+        };
+        PersonnelID: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        PersonnelName: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        PersonnelRank: {
+            type: StringConstructor;
+            default: string;
+        };
+        PersonnelWorkCode: {
+            type: StringConstructor;
+            default: string;
+        };
+        PersonnelNote: {
+            type: StringConstructor;
+            default: string;
+        };
+        departmentId: {
+            type: StringConstructor;
+        };
+        radioNames: {
+            type: StringConstructor[];
+            default: never[];
+        };
+        shiftStartTime: {
+            type: NumberConstructor;
+            default: number;
+        };
+        shiftEndTime: {
+            type: NumberConstructor;
+            default: number;
+        };
+        shiftStart: {
+            type: DateConstructor;
+            default: string;
+        };
+        shiftEnd: {
+            type: DateConstructor;
+            default: string;
+        };
+        modified_unix_date: {
+            type: NumberConstructor;
+            default: typeof retrieveCurrentUnixTime;
+        };
+        modified: {
+            type: DateConstructor;
+            default: typeof currentDate;
+        };
+        active: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        agencyName: {
+            type: StringConstructor;
+            default: string;
+        };
+        agencyCode: {
+            type: StringConstructor;
+            default: string;
+        };
+        agencyId: {
+            type: typeof import("mongoose").Schema.Types.ObjectId;
+            ref: string;
+            default: null;
+        };
+        importNotes: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>;
+    _methods: unknown;
+};
 export declare function PersonnelImportModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
     _id: import("bson").ObjectID;
     PersonnelID: string;

package/definitions/models/personnel-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"personnel-import.d.ts","sourceRoot":"","sources":["../../src/models/personnel-import.ts"],"names":[],"mappings":";AAAA,OAAO,EAIL,cAAc,EAEd,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFnE;AAED,MAAM,WAAW,eAAgB,SAAQ,8BAA8B,CAAC,OAAO,qBAAqB,CAAC;CAAI;AACzG,MAAM,WAAW,oBAAqB,SAAQ,+BAA+B,CAAC,eAAe,CAAC;CAAI;;AAClG,wBAAmH"}
+{"version":3,"file":"personnel-import.d.ts","sourceRoot":"","sources":["../../src/models/personnel-import.ts"],"names":[],"mappings":";AAAA,OAAO,EAGL,WAAW,EACX,cAAc,EACd,uBAAuB,EACvB,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyF7D;AAED,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;GAGnE;AAED,MAAM,WAAW,eAAgB,SAAQ,8BAA8B,CAAC,OAAO,qBAAqB,CAAC;CAAI;AACzG,MAAM,WAAW,oBAAqB,SAAQ,+BAA+B,CAAC,eAAe,CAAC;CAAI;;AAClG,wBAAmH"}

package/definitions/models/template.d.ts

@@ -1,6 +1,94 @@
 /// <reference types="mongoose" />
 import * as uuid from "uuid";
-import { ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, MongooseModule, ReplaceModelReturnType } from "../helpers";
+import { currentDate, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, MongooseModule, ReplaceModelReturnType, retrieveCurrentUnixTime } from "../helpers";
+export declare function TemplateSchema(mongoose: MongooseModule): import("mongoose").Schema<any> & {
+    _interface: import("../helpers").MongooseInterface<{
+        _id: {
+            type: import("mongoose").Types.ObjectIdConstructor;
+            auto: boolean;
+        };
+        position: {
+            type: NumberConstructor;
+            default: number;
+        };
+        userId: StringConstructor;
+        uuid: {
+            type: StringConstructor;
+            default: (<T extends ArrayLike<number>>(options: uuid.V4Options | null | undefined, buffer: T, offset?: number | undefined) => T) & ((options?: uuid.V4Options | undefined) => string);
+        };
+        isMandatory: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        modified_unix_date: {
+            type: NumberConstructor;
+            default: typeof retrieveCurrentUnixTime;
+        };
+        modified: {
+            type: DateConstructor;
+            default: typeof currentDate;
+        };
+        departmentId: {
+            type: StringConstructor;
+            required: boolean;
+            index: true;
+        };
+        active: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        name: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        checklist: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    name: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    position: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        group: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    name: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    position: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    uuid: {
+                        type: StringConstructor;
+                        default: (<T extends ArrayLike<number>>(options: uuid.V4Options | null | undefined, buffer: T, offset?: number | undefined) => T) & ((options?: uuid.V4Options | undefined) => string);
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        agencyId: {
+            type: typeof import("mongoose").Schema.Types.ObjectId;
+            ref: string;
+            default: null;
+        };
+    }>;
+    _methods: unknown;
+};
 export declare function TemplateModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
     _id: import("bson").ObjectID;
     position: number;

package/definitions/models/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/models/template.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,EAKL,8BAA8B,EAE9B,+BAA+B,EAE/B,cAAc,EACd,sBAAsB,EAEvB,MAAM,YAAY,CAAC;AAEpB,wBAAsB,cAAc,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2H5D;AAED,MAAM,WAAW,QAAS,SAAQ,8BAA8B,CAAC,OAAO,cAAc,CAAC;CAAI;AAC3F,MAAM,WAAW,aAAc,SAAQ,+BAA+B,CAAC,QAAQ,CAAC;CAAI;;AACpF,wBAA8F"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/models/template.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,EAGL,WAAW,EAEX,8BAA8B,EAE9B,+BAA+B,EAE/B,cAAc,EACd,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2HtD;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAG5D;AAED,MAAM,WAAW,QAAS,SAAQ,8BAA8B,CAAC,OAAO,cAAc,CAAC;CAAI;AAC3F,MAAM,WAAW,aAAc,SAAQ,+BAA+B,CAAC,QAAQ,CAAC;CAAI;;AACpF,wBAA8F"}

package/definitions/models/user.d.ts

@@ -1,5 +1,286 @@
 /// <reference types="mongoose" />
+import * as uuid from "uuid";
 import { MongooseModule, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, ReplaceModelReturnType, currentDate } from "../helpers";
+export declare function UserSchema(mongoose: MongooseModule): import("mongoose").Schema<any> & {
+    _interface: import("../helpers").MongooseInterface<{
+        nick: {
+            type: StringConstructor;
+            default: string;
+            index: true;
+        };
+        email: {
+            type: StringConstructor;
+            default: string;
+            index: true;
+        };
+        name: {
+            type: StringConstructor;
+            default: string;
+        };
+        uuid: {
+            type: StringConstructor;
+            default: (<T extends ArrayLike<number>>(options: uuid.V4Options | null | undefined, buffer: T, offset?: number | undefined) => T) & ((options?: uuid.V4Options | undefined) => string);
+        };
+        departmentId: {
+            type: StringConstructor;
+            default: string;
+            required: boolean;
+            index: true;
+        };
+        modified_date: {
+            type: DateConstructor;
+            default: typeof currentDate;
+        };
+        when: {
+            type: DateConstructor;
+        };
+        agencyId: {
+            type: typeof import("mongoose").Schema.Types.ObjectId;
+            ref: string;
+            default: null;
+        };
+        managedAgencies: {
+            type: typeof import("mongoose").Schema.Types.ObjectId[];
+            ref: string;
+            default: never[];
+        };
+        active: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        admin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        superuser: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isPro: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        mobileAccess: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        webAccess: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        outsider: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        shareLocationEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        beaconEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        userContributionEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        syncLoggingExpireDate: {
+            type: DateConstructor;
+            default: null;
+        };
+        beacons: {
+            type: StringConstructor[];
+            default: never[];
+        };
+        salt: {
+            type: StringConstructor;
+            default: string;
+            select: boolean;
+        };
+        pass: {
+            type: StringConstructor;
+            default: string;
+            select: boolean;
+        };
+        mapHidden: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        mapId: {
+            type: StringConstructor;
+            default: string;
+        };
+        vehicle: {
+            type: import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    radioName: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    vehicleId: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            };
+            default: null;
+        };
+        sessionCountiPhone: {
+            type: NumberConstructor;
+            default: number;
+        };
+        sessionCountiPad: {
+            type: NumberConstructor;
+            default: number;
+        };
+        rtsAuthKey: {
+            type: StringConstructor;
+            default: string;
+        };
+        pubNubV2: {
+            type: import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    token: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    expireAt: {
+                        type: DateConstructor;
+                        default: typeof currentDate;
+                    };
+                    runAt: {
+                        type: DateConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            };
+            default: null;
+        };
+        pubNubV3: {
+            type: import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    token: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    expireAt: {
+                        type: DateConstructor;
+                        default: typeof currentDate;
+                    };
+                    runAt: {
+                        type: DateConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            };
+            default: null;
+        };
+        token: {
+            type: StringConstructor;
+            default: string;
+        };
+        tokenExpireAt: {
+            type: DateConstructor;
+            default: typeof currentDate;
+        };
+        shareLocationPhone: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        shareLocationTablet: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        offlineMapsEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        fireMapperProEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        arcGISAuth: {
+            type: import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    username: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    encrypted: {
+                        type: import("mongoose").Schema<any> & {
+                            _interface: import("../helpers").MongooseInterface<{
+                                iv: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                                encryptedData: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                            }>;
+                            _methods: unknown;
+                        };
+                        default: null;
+                    };
+                }>;
+                _methods: unknown;
+            };
+            default: null;
+        };
+        arcGISAuthError: {
+            type: import("mongoose").Schema<any> & {
+                _interface: import("../helpers").MongooseInterface<{
+                    code: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    error: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    error_description: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    message: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            };
+            default: null;
+        };
+        offDutyEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        webMapSettings: {
+            defaultZoomLevel: {
+                type: NumberConstructor;
+            };
+            defaultCenter: {
+                type: NumberConstructor[];
+                default: never[];
+            };
+            defaultMap: {
+                type: StringConstructor;
+            };
+        };
+        locationToCAD: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        logOffEnabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>;
+    _methods: unknown;
+};
 export declare function UserModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
     nick: string;
     email: string;

package/definitions/models/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/models/user.ts"],"names":[],"mappings":";AACA,OAAO,EAKL,cAAc,EAEd,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACtB,WAAW,EACZ,MAAM,YAAY,CAAC;AAKpB,wBAAsB,UAAU,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiPxD;AAED,MAAM,WAAW,IAAK,SAAQ,8BAA8B,CAAC,OAAO,UAAU,CAAC;CAAI;AACnF,MAAM,WAAW,SAAU,SAAQ,+BAA+B,CAAC,IAAI,CAAC;CAAI;;AAC5E,wBAAkF"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/models/user.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAKL,cAAc,EAEd,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACtB,WAAW,EACZ,MAAM,YAAY,CAAC;AAKpB,wBAAgB,UAAU,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiPlD;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGxD;AAED,MAAM,WAAW,IAAK,SAAQ,8BAA8B,CAAC,OAAO,UAAU,CAAC;CAAI;AACnF,MAAM,WAAW,SAAU,SAAQ,+BAA+B,CAAC,IAAI,CAAC;CAAI;;AAC5E,wBAAkF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabletcommand-backend-models",
-  "version": "5.17.41",
+  "version": "5.18.0",
   "description": "Tablet Command Backend Models",
   "scripts": {
     "test": "gulp",

package/src/models/agency.ts

@@ -9,7 +9,7 @@ import {
   ReplaceModelReturnType,
 } from "../helpers";
 
-export async function AgencyModule(mongoose: MongooseModule) {
+export function AgencySchema(mongoose: MongooseModule) {
   const { Schema, Types } = mongoose;
 
   const CrossStaffedUnit = createSchema(Schema, {
@@ -109,6 +109,11 @@ export async function AgencyModule(mongoose: MongooseModule) {
   });
   modelSchema.set("autoIndex", false);
 
+  return modelSchema;
+}
+
+export async function AgencyModule(mongoose: MongooseModule) {
+  const modelSchema = AgencySchema(mongoose);
   return createModel(mongoose, "Agency", modelSchema);
 }
 

package/src/models/arcgis-group.ts

@@ -160,11 +160,6 @@ export async function ArcGISGroupModule(mongoose: MongooseModule) {
       type: Date,
       default: currentDate,
     },
-    // Possible values: cron, user
-    createdBy: {
-      type: String,
-      default: "",
-    },
 
     // last time when cron updated groups
     // if date is in the past, we should refresh this

package/src/models/battalion.ts

@@ -15,7 +15,7 @@ import {
   retrieveCurrentUnixTime
 } from "../helpers";
 
-export async function BattalionModule(mongoose: MongooseModule) {
+export function BattalionSchema(mongoose: MongooseModule) {
   const { Schema, Types } = mongoose;
   const toJSONOpts = {
     virtuals: true,
@@ -175,7 +175,11 @@ export async function BattalionModule(mongoose: MongooseModule) {
       }
     });
   }
+  return modelSchema;
+}
 
+export async function BattalionModule(mongoose: MongooseModule) {
+  const modelSchema = BattalionSchema(mongoose);
   return createModel(mongoose, "Battalion", modelSchema);
 }
 

package/src/models/checklist.ts

@@ -16,7 +16,7 @@ import {
 
 import { ChecklistItemSchema } from "./checklist-item";
 
-export async function ChecklistModule(mongoose: MongooseModule) {
+export function ChecklistSchema(mongoose: MongooseModule) {
   const { Schema, Types } = mongoose;
 
   const ChecklistItem = ChecklistItemSchema(mongoose);
@@ -92,6 +92,11 @@ export async function ChecklistModule(mongoose: MongooseModule) {
     return this._id.toString();
   });
 
+  return modelSchema;
+}
+
+export async function ChecklistModule(mongoose: MongooseModule) {
+  const modelSchema = ChecklistSchema(mongoose);
   return createModel(mongoose, "Checklist", modelSchema);
 }
 

package/src/models/personnel-import.ts

@@ -9,7 +9,7 @@ import {
   ReplaceModelReturnType,
 } from "../helpers";
 
-export async function PersonnelImportModule(mongoose: MongooseModule) {
+export function PersonnelImportSchema(mongoose: MongooseModule) {
   const { Schema, Types } = mongoose;
 
   const modelSchema = createSchema(Schema, {
@@ -97,6 +97,11 @@ export async function PersonnelImportModule(mongoose: MongooseModule) {
   });
   modelSchema.set("autoIndex", false);
 
+  return modelSchema;
+}
+
+export async function PersonnelImportModule(mongoose: MongooseModule) {
+  const modelSchema = PersonnelImportSchema(mongoose);
   return createModel(mongoose, "PersonnelImport", modelSchema);
 }
 

package/src/models/template.ts

@@ -14,7 +14,7 @@ import {
   retrieveCurrentUnixTime
 } from "../helpers";
 
-export async function TemplateModule(mongoose: MongooseModule) {
+export function TemplateSchema(mongoose: MongooseModule) {
   const { Schema, Types } = mongoose;
 
   const ChecklistOption = createSchema(Schema, {
@@ -136,6 +136,11 @@ export async function TemplateModule(mongoose: MongooseModule) {
     });
   }
   // modelSchema.plugin(mongooseLeanVirtuals);
+  return modelSchema;
+}
+
+export async function TemplateModule(mongoose: MongooseModule) {
+  const modelSchema = TemplateSchema(mongoose);
   return createModel(mongoose, "Template", modelSchema);
 }
 

package/src/models/user.ts

@@ -15,7 +15,7 @@ import EsriAuthSchema from "./schema/esri-auth";
 import EsriErrorSchema from "./schema/esri-error";
 import PubNubTokenSchema from "./schema/pubnub-token";
 
-export async function UserModule(mongoose: MongooseModule) {
+export function UserSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const EsriAuth = EsriAuthSchema(mongoose);
   const EsriError = EsriErrorSchema(mongoose);
@@ -255,6 +255,11 @@ export async function UserModule(mongoose: MongooseModule) {
     return this._id.toHexString();
   });
 
+  return modelSchema;
+}
+
+export async function UserModule(mongoose: MongooseModule) {
+  const modelSchema = UserSchema(mongoose);
   return createModel(mongoose, "User", modelSchema);
 }