tabletcommand-backend-models 5.39.7 → 7.0.1

package/definitions/models/managed-incident.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"managed-incident.d.ts","sourceRoot":"","sources":["../../src/models/managed-incident.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAGL,WAAW,EAEX,8BAA8B,EAC9B,+BAA+B,EAG/B,cAAc,EACd,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAUpB,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2iBnE;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":"managed-incident.d.ts","sourceRoot":"","sources":["../../src/models/managed-incident.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,EAEL,cAAc,EACf,MAAM,YAAY,CAAC;AASpB,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAQL,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,eAAgB,SAAQ,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAI;AAEzF,wBAA8B,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;UAsiB3E;AAED,MAAM,WAAW,oBAAqB,SAAQ,KAAK,CAAC,eAAe,CAAC;CAAI"}

package/definitions/models/mark43-incident-retry.d.ts

@@ -1,47 +1,35 @@
-/// <reference types="mongoose" />
-import { ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, MongooseModule, ReplaceModelReturnType } from "../helpers";
-export declare function Mark43IncidentRetryModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
-    departmentId: string;
-    created: string;
-    modified: string;
-    active: boolean;
-    attempts: number;
-    retries: number;
-    notificationSent: boolean;
-    retryPayload: import("../helpers").MongooseInterface<{
-        departmentId: {
-            type: NumberConstructor;
-            default: number;
-        };
-        activityType: {
-            type: StringConstructor;
-            default: string;
-        };
-        relatedEvent: {
-            type: import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    mark43Id: {
-                        type: NumberConstructor;
-                        default: number;
-                    };
-                    cadAgencyEventNumber: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                }>;
-                _methods: unknown;
-            };
-        };
-    }>;
-    mark43IncidentId: number;
-    incidentNumber: string;
-}, {}> & {
-    __methods?: unknown;
-}>;
-export interface Mark43IncidentRetry extends ItemTypeFromTypeSchemaFunction<typeof Mark43IncidentRetryModule> {
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Model } from "mongoose";
+import { MongooseModule } from "../helpers";
+import { Mark43IncidentRetryType } from "../types/mark43-incident-retry";
+export interface Mark43IncidentRetry extends Mark43IncidentRetryType {
 }
-export interface Mark43IncidentRetryModel extends ModelTypeFromTypeSchemaFunction<Mark43IncidentRetry> {
+export default function Mark43IncidentRetryModule(mongoose: MongooseModule): Promise<Model<Mark43IncidentRetry, {}, {}, {}, import("mongoose").Document<unknown, {}, Mark43IncidentRetry> & Mark43IncidentRetry & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>>;
+export interface Mark43IncidentRetryModel extends Model<Mark43IncidentRetry> {
 }
-declare const _default: ReplaceModelReturnType<typeof Mark43IncidentRetryModule, Mark43IncidentRetryModel>;
-export default _default;
 //# sourceMappingURL=mark43-incident-retry.d.ts.map

package/definitions/models/mark43-incident-retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mark43-incident-retry.d.ts","sourceRoot":"","sources":["../../src/models/mark43-incident-retry.ts"],"names":[],"mappings":";AAAA,OAAO,EAIL,8BAA8B,EAC9B,+BAA+B,EAC/B,cAAc,EACd,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFvE;AAED,MAAM,WAAW,mBAAoB,SAAQ,8BAA8B,CAAC,OAAO,yBAAyB,CAAC;CAAI;AACjH,MAAM,WAAW,wBAAyB,SAAQ,+BAA+B,CAAC,mBAAmB,CAAC;CAAI;;AAC1G,wBAA+H"}
+{"version":3,"file":"mark43-incident-retry.d.ts","sourceRoot":"","sources":["../../src/models/mark43-incident-retry.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAEL,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,uBAAuB,EAAsC,MAAM,gCAAgC,CAAC;AAE7G,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;CAAI;AAExE,wBAA8B,yBAAyB,CAAC,QAAQ,EAAE,cAAc;;SAgF/E;AAED,MAAM,WAAW,wBAAyB,SAAQ,KAAK,CAAC,mBAAmB,CAAC;CAAI"}

package/definitions/models/message.d.ts

@@ -1,47 +1,35 @@
-/// <reference types="mongoose" />
-import { MongooseModule, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, ReplaceModelReturnType } from "../helpers";
-export declare function MessageModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
-    _id: import("mongoose").Types.ObjectId;
-    departmentId: string;
-    userId: string;
-    session: string;
-    active: boolean;
-    uuid: string;
-    requestId: string;
-    title: string;
-    body: string;
-    actionTitle: string;
-    created: string;
-    updated: string;
-    color: import("../helpers").MongooseInterface<{
-        background: {
-            type: StringConstructor;
-            default: string;
-        };
-        text: {
-            type: StringConstructor;
-            default: string;
-        };
-    }>;
-    url: string;
-    priority: number;
-    type: import("../helpers").MongooseInterface<{
-        type: {
-            type: StringConstructor;
-            default: string;
-        };
-        typeOpts: {
-            type: ObjectConstructor;
-            default: {};
-        };
-    }>;
-}, {}> & {
-    __methods?: unknown;
-}>;
-export interface Message extends ItemTypeFromTypeSchemaFunction<typeof MessageModule> {
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { MongooseModule } from "../helpers";
+import { Model } from "mongoose";
+import { MessageType } from "../types/message";
+export interface Message extends MessageType, Record<string, unknown> {
 }
-export interface MessageModel extends ModelTypeFromTypeSchemaFunction<Message> {
+export default function MessageModule(mongoose: MongooseModule): Promise<Model<Message, {}, {}, {}, import("mongoose").Document<unknown, {}, Message> & Message & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>, any>>;
+export interface MessageModel extends Model<Message> {
 }
-declare const _default: ReplaceModelReturnType<typeof MessageModule, MessageModel>;
-export default _default;
 //# sourceMappingURL=message.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/models/message.ts"],"names":[],"mappings":";AACA,OAAO,EACL,cAAc,EAGd,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EAEvB,MAAM,YAAY,CAAC;AAGpB,wBAAsB,aAAa,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2F3D;AAED,MAAM,WAAW,OAAQ,SAAQ,8BAA8B,CAAC,OAAO,aAAa,CAAC;CAAI;AACzF,MAAM,WAAW,YAAa,SAAQ,+BAA+B,CAAC,OAAO,CAAC;CAAI;;AAClF,wBAA2F"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/models/message.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EACL,cAAc,EAEf,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,WAAW,EAAkB,MAAM,kBAAkB,CAAC;AAE/D,MAAM,WAAW,OAAQ,SAAQ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAI;AAEzE,wBAA8B,aAAa,CAAC,QAAQ,EAAE,cAAc;;UA0FnE;AAED,MAAM,WAAW,YAAa,SAAQ,KAAK,CAAC,OAAO,CAAC;CAAI"}

package/definitions/models/monitor.d.ts

@@ -1,22 +1,35 @@
-/// <reference types="mongoose" />
-import { ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, MongooseModule, ReplaceModelReturnType } from "../helpers";
-export declare function MonitorModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
-    _id: import("mongoose").Types.ObjectId;
-    departmentId: string;
-    agencyId: string;
-    notificationType: string;
-    status: string;
-    sentUnixDate: number;
-    sentAt: string;
-    ticketId: string;
-    count: number;
-}, {}> & {
-    __methods?: unknown;
-}>;
-export interface Monitor extends ItemTypeFromTypeSchemaFunction<typeof MonitorModule> {
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Model } from "mongoose";
+import { MongooseModule } from "../helpers";
+import { MonitorType } from "../types/monitor";
+export interface Monitor extends MonitorType {
 }
-export interface MonitorModel extends ModelTypeFromTypeSchemaFunction<Monitor> {
+export default function MonitorModule(mongoose: MongooseModule): Promise<Model<Monitor, {}, {}, {}, import("mongoose").Document<unknown, {}, Monitor> & Monitor & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>, any>>;
+export interface MonitorModel extends Model<Monitor> {
 }
-declare const _default: ReplaceModelReturnType<typeof MonitorModule, MonitorModel>;
-export default _default;
 //# sourceMappingURL=monitor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"monitor.d.ts","sourceRoot":"","sources":["../../src/models/monitor.ts"],"names":[],"mappings":";AAAA,OAAO,EAIL,8BAA8B,EAC9B,+BAA+B,EAC/B,cAAc,EACd,sBAAsB,EAEvB,MAAM,YAAY,CAAC;AAGpB,wBAAsB,aAAa,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;GA0D3D;AAED,MAAM,WAAW,OAAQ,SAAQ,8BAA8B,CAAC,OAAO,aAAa,CAAC;CAAI;AACzF,MAAM,WAAW,YAAa,SAAQ,+BAA+B,CAAC,OAAO,CAAC;CAAI;;AAClF,wBAA2F"}
+{"version":3,"file":"monitor.d.ts","sourceRoot":"","sources":["../../src/models/monitor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAEL,cAAc,EAEf,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,WAAW,OAAQ,SAAQ,WAAW;CAAI;AAEhD,wBAA8B,aAAa,CAAC,QAAQ,EAAE,cAAc;;UAyDnE;AAED,MAAM,WAAW,YAAa,SAAQ,KAAK,CAAC,OAAO,CAAC;CAAI"}

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

@@ -1,145 +1,40 @@
-/// <reference types="mongoose" />
-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[];
-        };
-        radios: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    radioName: {
-                        type: StringConstructor;
-                    };
-                    active: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    source: {
-                        type: StringConstructor;
-                        default: string;
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            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: import("mongoose").Types.ObjectIdConstructor;
-            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("mongoose").Types.ObjectId;
-    PersonnelID: string;
-    PersonnelName: string;
-    PersonnelRank: string;
-    PersonnelWorkCode: string;
-    PersonnelNote: string;
-    departmentId: string;
-    radioNames: string[];
-    radios: import("../helpers").MongooseInterface<{
-        radioName: {
-            type: StringConstructor;
-        };
-        active: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        source: {
-            type: StringConstructor;
-            default: string;
-        };
-    }>[];
-    shiftStartTime: number;
-    shiftEndTime: number;
-    shiftStart: string;
-    shiftEnd: string;
-    modified_unix_date: number;
-    modified: string;
-    active: boolean;
-    agencyName: string;
-    agencyCode: string;
-    agencyId: import("mongoose").Types.ObjectId;
-    importNotes: string;
-}, {}> & {
-    __methods?: unknown;
-}>;
-export interface PersonnelImport extends ItemTypeFromTypeSchemaFunction<typeof PersonnelImportModule> {
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Model } from "mongoose";
+import { MongooseModule } from "../helpers";
+import { PersonnelImportType } from "../types/personnel";
+export interface PersonnelImport extends PersonnelImportType {
 }
-export interface PersonnelImportModel extends ModelTypeFromTypeSchemaFunction<PersonnelImport> {
+export declare function PersonnelImportSchema(mongoose: MongooseModule): import("mongoose").Schema<PersonnelImportType, Model<PersonnelImportType, any, any, any, import("mongoose").Document<unknown, any, PersonnelImportType> & PersonnelImportType & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, PersonnelImportType, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<PersonnelImportType>> & import("mongoose").FlatRecord<PersonnelImportType> & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>>;
+export default function PersonnelImportModule(mongoose: MongooseModule): Promise<Model<PersonnelImport, {}, {}, {}, import("mongoose").Document<unknown, {}, PersonnelImport> & PersonnelImport & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>, any>>;
+export interface PersonnelImportModel extends Model<PersonnelImport> {
 }
-declare const _default: ReplaceModelReturnType<typeof PersonnelImportModule, PersonnelImportModel>;
-export default _default;
 //# sourceMappingURL=personnel-import.d.ts.map

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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8G7D;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"}
+{"version":3,"file":"personnel-import.d.ts","sourceRoot":"","sources":["../../src/models/personnel-import.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAEL,cAAc,EAEf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,mBAAmB,EAAa,MAAM,oBAAoB,CAAC;AAEpE,MAAM,WAAW,eAAgB,SAAQ,mBAAmB;CAAI;AAEhE,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;;;IA6G7D;AAED,wBAA8B,qBAAqB,CAAC,QAAQ,EAAE,cAAc;;UAG3E;AAED,MAAM,WAAW,oBAAqB,SAAQ,KAAK,CAAC,eAAe,CAAC;CAAI"}

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

@@ -1,103 +1,40 @@
-/// <reference types="mongoose" />
-import * as uuid from "uuid";
-import { MongooseModule, ItemTypeFromTypeSchemaFunction, ModelTypeFromTypeSchemaFunction, ReplaceModelReturnType, currentDate } from "../helpers";
-export declare function PersonnelKnownSchema(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;
-        };
-        modified: {
-            type: DateConstructor;
-            default: typeof currentDate;
-        };
-        departmentId: {
-            type: 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);
-        };
-        radios: {
-            type: (import("mongoose").Schema<any> & {
-                _interface: import("../helpers").MongooseInterface<{
-                    radioName: {
-                        type: StringConstructor;
-                    };
-                    active: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                }>;
-                _methods: unknown;
-            })[];
-            default: never[];
-        };
-        active: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        jurisdiction: {
-            type: StringConstructor;
-            default: string;
-        };
-        agencyId: {
-            type: import("mongoose").Types.ObjectIdConstructor;
-            ref: string;
-            default: null;
-        };
-        source: {
-            type: StringConstructor;
-            default: string;
-        };
-    }>;
-    _methods: unknown;
-};
-export declare function PersonnelKnownModule(mongoose: MongooseModule): Promise<import("mongoose").Model<import("mongoose").Document & Record<string, unknown> & {
-    _id: import("mongoose").Types.ObjectId;
-    PersonnelID: string;
-    PersonnelName: string;
-    PersonnelRank: string;
-    PersonnelWorkCode: string;
-    modified: string;
-    departmentId: string;
-    uuid: string;
-    radios: import("../helpers").MongooseInterface<{
-        radioName: {
-            type: StringConstructor;
-        };
-        active: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>[];
-    active: boolean;
-    jurisdiction: string;
-    agencyId: import("mongoose").Types.ObjectId;
-    source: string;
-}, {}> & {
-    __methods?: unknown;
-}>;
-export interface PersonnelKnown extends ItemTypeFromTypeSchemaFunction<typeof PersonnelKnownModule> {
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { MongooseModule } from "../helpers";
+import { Model } from "mongoose";
+import { PersonnelKnownType } from "../types/personnel";
+export interface PersonnelKnown extends PersonnelKnownType, Record<string, unknown> {
 }
-export interface PersonnelKnownModel extends ModelTypeFromTypeSchemaFunction<PersonnelKnown> {
+export declare function PersonnelKnownSchema(mongoose: MongooseModule): import("mongoose").Schema<PersonnelKnownType, Model<PersonnelKnownType, any, any, any, import("mongoose").Document<unknown, any, PersonnelKnownType> & PersonnelKnownType & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, PersonnelKnownType, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<PersonnelKnownType>> & import("mongoose").FlatRecord<PersonnelKnownType> & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>>;
+export default function PersonnelKnownModule(mongoose: MongooseModule): Promise<Model<PersonnelKnown, {}, {}, {}, import("mongoose").Document<unknown, {}, PersonnelKnown> & PersonnelKnown & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}>, any>>;
+export interface PersonnelKnownModel extends Model<PersonnelKnown> {
 }
-declare const _default: ReplaceModelReturnType<typeof PersonnelKnownModule, PersonnelKnownModel>;
-export default _default;
 //# sourceMappingURL=personnel-known.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"personnel-known.d.ts","sourceRoot":"","sources":["../../src/models/personnel-known.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,EAGL,cAAc,EACd,8BAA8B,EAC9B,+BAA+B,EAC/B,sBAAsB,EACtB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+E5D;AAED,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;GAGlE;AAED,MAAM,WAAW,cAAe,SAAQ,8BAA8B,CAAC,OAAO,oBAAoB,CAAC;CAAI;AACvG,MAAM,WAAW,mBAAoB,SAAQ,+BAA+B,CAAC,cAAc,CAAC;CAAI;;AAChG,wBAAgH"}
+{"version":3,"file":"personnel-known.d.ts","sourceRoot":"","sources":["../../src/models/personnel-known.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,EACL,cAAc,EAEf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAa,MAAM,oBAAoB,CAAC;AAEnE,MAAM,WAAW,cAAe,SAAQ,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAI;AAEvF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,cAAc;;;;IA8E5D;AAED,wBAA8B,oBAAoB,CAAC,QAAQ,EAAE,cAAc;;UAG1E;AAED,MAAM,WAAW,mBAAoB,SAAQ,KAAK,CAAC,cAAc,CAAC;CAAI"}