tabletcommand-backend-models 5.39.7 → 7.0.1

package/src/models/device-mapping.ts

@@ -1,20 +1,19 @@
 import * as  uuid from "uuid";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model } from "mongoose";
+import { DeviceMappingType } from "../types/device-mapping";
 
-export async function DeviceMappingModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface DeviceMapping extends DeviceMappingType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function DeviceMappingModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<DeviceMappingType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -74,13 +73,10 @@ export async function DeviceMappingModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_device_mapping",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "DeviceMapping", modelSchema);
+  return mongoose.model<DeviceMapping>("DeviceMapping", modelSchema, "massive_device_mapping", { overwriteModels: true });
 }
 
-export interface DeviceMapping extends ItemTypeFromTypeSchemaFunction<typeof DeviceMappingModule> { }
-export interface DeviceMappingModel extends ModelTypeFromTypeSchemaFunction<DeviceMapping> { }
-export default DeviceMappingModule as ReplaceModelReturnType<typeof DeviceMappingModule, DeviceMappingModel>;
+export interface DeviceMappingModel extends Model<DeviceMapping> { }

package/src/models/esri.ts

@@ -1,27 +1,24 @@
 // import * as uuid from "uuid";
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import EsriAuthModule from "./schema/esri-auth";
 import EsriErrorModule from "./schema/esri-error";
 import EsriMapModule from "./schema/esri-map";
 import FireMapperAuthModule from "./schema/firemapper-auth";
+import { EsriType, MapPropertiesType } from "../types/esri";
+
+export interface Esri extends EsriType { }
 
 export function EsriSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
   const EsriAuth = EsriAuthModule(mongoose);
   const EsriError = EsriErrorModule(mongoose);
   const EsriMap = EsriMapModule(mongoose);
   const FireMapperAuth = FireMapperAuthModule(mongoose);
 
-  const MapProperties = createSchema(Schema, {
+  const MapProperties = new Schema<MapPropertiesType>({
     // ArcGIS Item id
     itemId: {
       type: String,
@@ -36,9 +33,9 @@ export function EsriSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<EsriType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
 
@@ -48,7 +45,7 @@ export function EsriSchema(mongoose: MongooseModule) {
       default: new Date("1970-01-01T00:00:00.000Z"),
     },
     departmentId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Department",
       required: true
     },
@@ -111,31 +108,25 @@ export function EsriSchema(mongoose: MongooseModule) {
       default: new Date("1970-01-01T00:00:00.000Z"),
     },
   }, {
-    collection: "massive_esri",
   });
   modelSchema.set("autoIndex", false);
 
+  // Deprecated. Check which apps rely on .id instead of using ._id.
+  modelSchema.virtual("id").get(function(this: Esri) {
+    return this._id.toHexString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    // Deprecated. Check which apps rely on .id instead of using ._id.
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      ret.id = ret._id;
-    },
   });
 
-  // Deprecated. Check which apps rely on .id instead of using ._id.
-  modelSchema.virtual("id").get(function(this: DocumentTypeFromSchema<typeof modelSchema>) {
-    return this._id.toHexString();
-  });
   return modelSchema;
 }
 
-export async function EsriModule(mongoose: MongooseModule) {
+export default async function EsriModule(mongoose: MongooseModule) {
   const modelSchema = EsriSchema(mongoose);
-  return createModel(mongoose, "Esri", modelSchema);
+  return mongoose.model<Esri>("Esri", modelSchema, "massive_esri", { overwriteModels: true });
 }
 
-export interface Esri extends ItemTypeFromTypeSchemaFunction<typeof EsriModule> { }
-export interface EsriModel extends ModelTypeFromTypeSchemaFunction<Esri> { }
-export default EsriModule as ReplaceModelReturnType<typeof EsriModule, EsriModel>;
+export interface EsriModel extends Model<Esri> { }

package/src/models/gst-mapping.ts

@@ -1,21 +1,20 @@
 import * as  uuid from "uuid";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
+import { Model } from "mongoose";
+import { GSTMappingType } from "../types/gst-mapping";
 
-export async function GSTMappingModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface GSTMapping extends GSTMappingType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function GSTMappingModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<GSTMappingType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -36,10 +35,10 @@ export async function GSTMappingModule(mongoose: MongooseModule) {
     },
     location: {
       longitude: {
-          type: Number,
+        type: Number,
       },
       latitude: {
-          type: Number,
+        type: Number,
       },
     },
     modified_unix_date: {
@@ -71,13 +70,10 @@ export async function GSTMappingModule(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_gst_mapping",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "GSTMapping", modelSchema);
+  return mongoose.model<GSTMapping>("GSTMapping", modelSchema, "massive_gst_mapping", { overwriteModels: true });
 }
 
-export interface GSTMapping extends ItemTypeFromTypeSchemaFunction<typeof GSTMappingModule> { }
-export interface GSTMappingModel extends ModelTypeFromTypeSchemaFunction<GSTMapping> { }
-export default GSTMappingModule as ReplaceModelReturnType<typeof GSTMappingModule, GSTMappingModel>;
+export interface GSTMappingModel extends Model<GSTMapping> { }

package/src/models/incident-event.ts

@@ -1,25 +1,19 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { EventUserType, IncidentEventType } from "../types/incident-events";
 
-export async function IncidentEventModule(mongoose: MongooseModule) {
-  const modelSchema = IncidentEventSchema(mongoose);
-  return createModel(mongoose, "IncidentEvent", modelSchema);
-}
+export interface IncidentEvent extends IncidentEventType { }
 
 export function IncidentEventSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const EventUser = createSchema(Schema, {
+  const EventUser = new Schema<EventUserType>({
     username: {
       type: String,
       default: "",
@@ -41,9 +35,9 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<IncidentEventType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -118,7 +112,6 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_incident_event",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
@@ -135,6 +128,9 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export interface IncidentEvent extends ItemTypeFromTypeSchemaFunction<typeof IncidentEventModule> { }
-export interface IncidentEventModel extends ModelTypeFromTypeSchemaFunction<IncidentEvent> { }
-export default IncidentEventModule as ReplaceModelReturnType<typeof IncidentEventModule, IncidentEventModel>;
+export default async function IncidentEventModule(mongoose: MongooseModule) {
+  const modelSchema = IncidentEventSchema(mongoose);
+  return mongoose.model<IncidentEvent>("IncidentEvent", modelSchema, "massive_incident_event", { overwriteModels: true });
+}
+
+export interface IncidentEventModel extends Model<IncidentEvent> { }

package/src/models/incident-notified.ts

@@ -1,17 +1,16 @@
+import { Model } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { IncidentNotifiedType, SentItemType, UnitType } from "../types/incident-events";
 
-export async function IncidentNotifiedModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
-  
-  const SentItem = createSchema(Schema, {
+export interface IncidentNotified extends IncidentNotifiedType { }
+
+export default async function IncidentNotifiedModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const SentItem = new Schema<SentItemType>({
     name: {
       type: String,
       default: "",
@@ -29,7 +28,7 @@ export async function IncidentNotifiedModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const Unit = createSchema(Schema, {
+  const Unit = new Schema<UnitType>({
     UnitID: {
       type: String,
       default: "",
@@ -43,9 +42,9 @@ export async function IncidentNotifiedModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<IncidentNotifiedType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -79,13 +78,10 @@ export async function IncidentNotifiedModule(mongoose: MongooseModule) {
       default: currentDate,
     },
   }, {
-    collection: "massive_incident_notified",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "IncidentNotified", modelSchema);
+  return mongoose.model<IncidentNotified>("IncidentNotified", modelSchema, "massive_incident_notified", { overwriteModels: true });
 }
 
-export interface IncidentNotified extends ItemTypeFromTypeSchemaFunction<typeof IncidentNotifiedModule> { }
-export interface IncidentNotifiedModel extends ModelTypeFromTypeSchemaFunction<IncidentNotified> { }
-export default IncidentNotifiedModule as ReplaceModelReturnType<typeof IncidentNotifiedModule, IncidentNotifiedModel>;
+export interface IncidentNotifiedModel extends Model<IncidentNotified> { }

package/src/models/incident-takeover.ts

@@ -1,19 +1,18 @@
 import * as uuid from "uuid";
 import {
-  createSchema,
-  createModel,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model } from "mongoose";
+import { IncidentTakeoverType } from "../types/incident-events";
 
-export async function IncidentTakeoverModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface IncidentTakeover extends IncidentTakeoverType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function IncidentTakeoverModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<IncidentTakeoverType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -72,13 +71,10 @@ export async function IncidentTakeoverModule(mongoose: MongooseModule) {
       default: 0,
     },
   }, {
-    collection: "massive_incident_takeover",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "IncidentTakeover", modelSchema);
+  return mongoose.model<IncidentTakeover>("IncidentTakeover", modelSchema, "massive_incident_takeover", { overwriteModels: true });
 }
 
-export interface IncidentTakeover extends ItemTypeFromTypeSchemaFunction<typeof IncidentTakeoverModule> { }
-export interface IncidentTakeoverModel extends ModelTypeFromTypeSchemaFunction<IncidentTakeover> { }
-export default IncidentTakeoverModule as ReplaceModelReturnType<typeof IncidentTakeoverModule, IncidentTakeoverModel>;
+export interface IncidentTakeoverModel extends Model<IncidentTakeover> { }

package/src/models/job-log.ts

@@ -1,21 +1,20 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { JobLogType } from "../types/job-log";
 
-export async function JobLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface JobLog extends JobLogType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function JobLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<JobLogType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     jobName: {
@@ -44,7 +43,6 @@ export async function JobLogModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_job_log",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
@@ -58,9 +56,7 @@ export async function JobLogModule(mongoose: MongooseModule) {
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "JobLog", modelSchema);
+  return mongoose.model<JobLog>("JobLog", modelSchema, "massive_job_log", { overwriteModels: true });
 }
 
-export interface JobLog extends ItemTypeFromTypeSchemaFunction<typeof JobLogModule> { }
-export interface JobLogModel extends ModelTypeFromTypeSchemaFunction<JobLog> { }
-export default JobLogModule as ReplaceModelReturnType<typeof JobLogModule, JobLogModel>;
+export interface JobLogModel extends Model<JobLog> { }

package/src/models/location.ts

@@ -1,27 +1,26 @@
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
-  createSchemaDefinition,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 import ColorModule from "./schema/color";
 import GeoJSONPointModule from "./schema/geojson-point";
+import { Model } from "mongoose";
+import { LocationType } from "../types/location";
 
-export async function LocationModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface Location extends LocationType, Record<string, unknown> { }
+
+export default async function LocationModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
   const GeoJSONPoint = GeoJSONPointModule(mongoose);
 
-  const modelSchemaDefinition = createSchemaDefinition({
+
+  const modelSchema = new Schema<LocationType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -173,10 +172,7 @@ export async function LocationModule(mongoose: MongooseModule) {
       type: Date,
       default: currentDate,
     },
-  });
-
-  const modelSchema = createSchema(Schema, modelSchemaDefinition, {
-    collection: "massive_location",
+  }, {
   });
 
   modelSchema.set("toJSON", {
@@ -216,9 +212,7 @@ export async function LocationModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "Location", modelSchema);
+  return mongoose.model<Location>("Location", modelSchema, "massive_location", { overwriteModels: true });
 }
 
-export interface Location extends ItemTypeFromTypeSchemaFunction<typeof LocationModule> { }
-export interface LocationModel extends ModelTypeFromTypeSchemaFunction<Location> { }
-export default LocationModule as ReplaceModelReturnType<typeof LocationModule, LocationModel>;
+export interface LocationModel extends Model<Location> { }

package/src/models/mail-log.ts

@@ -1,20 +1,19 @@
+import { Model } from "mongoose";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { MailLogType } from "../types/mail-log";
 
-export async function MailLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface MailLog extends MailLogType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function MailLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<MailLogType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     mailId: {
@@ -77,13 +76,10 @@ export async function MailLogModule(mongoose: MongooseModule) {
       default: currentDate,
     },
   }, {
-    collection: "massive_mail_log",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "MailLog", modelSchema);
+  return mongoose.model<MailLog>("MailLog", modelSchema, "massive_mail_log", { overwriteModels: true });
 }
 
-export interface MailLog extends ItemTypeFromTypeSchemaFunction<typeof MailLogModule> { }
-export interface MailLogModel extends ModelTypeFromTypeSchemaFunction<MailLog> { }
-export default MailLogModule as ReplaceModelReturnType<typeof MailLogModule, MailLogModel>;
+export interface MailLogModel extends Model<MailLog> { }

package/src/models/managed-incident.ts

@@ -1,16 +1,8 @@
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ModelFromSchema,
-  MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import {
   CADPersonSchema,
@@ -20,9 +12,22 @@ import {
   SharedSourceSchema,
   SharedToSchema,
 } from "./schema/shared-incident";
+import { Model } from "mongoose";
+import {
+  HistoryItemType,
+  AssignmentItemType,
+  IncidentUnitType,
+  IncidentGroupType,
+  IncidentHazardType,
+  IncidentChecklistItemType,
+  IncidentChecklistType,
+  ManagedIncidentType,
+} from "../types/managed-incident";
+
+export interface ManagedIncident extends ManagedIncidentType, Record<string, unknown> { }
 
-export async function ManagedIncidentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function ManagedIncidentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
   const CADPerson = CADPersonSchema(mongoose);
   const RadioChannel = RadioChannelSchema(mongoose);
@@ -31,7 +36,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
   const SharedSource = SharedSourceSchema(mongoose);
   const SharedTo = SharedToSchema(mongoose);
 
-  const HistoryItem = createSchema(Schema, {
+  const HistoryItem = new Schema<HistoryItemType>({
     message: {
       type: String,
       default: "",
@@ -57,7 +62,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const AssignmentItem = createSchema(Schema, {
+  const AssignmentItem = new Schema<AssignmentItemType>({
     name: {
       type: String,
       default: "",
@@ -99,7 +104,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentUnit = createSchema(Schema, {
+  const IncidentUnit = new Schema<IncidentUnitType>({
     UnitID: {
       type: String,
       required: true,
@@ -209,7 +214,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentGroup = createSchema(Schema, {
+  const IncidentGroup = new Schema<IncidentGroupType>({
     location_on_map: {
       type: String,
       default: "",
@@ -251,7 +256,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentHazard = createSchema(Schema, {
+  const IncidentHazard = new Schema<IncidentHazardType>({
     location_on_scene: {
       type: String,
       default: "",
@@ -293,7 +298,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentChecklistItem = createSchema(Schema, {
+  const IncidentChecklistItem = new Schema<IncidentChecklistItemType>({
     active: {
       type: Boolean,
       default: true
@@ -338,7 +343,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentChecklist = createSchema(Schema, {
+  const IncidentChecklist = new Schema<IncidentChecklistType>({
     active: {
       type: Boolean,
       default: true
@@ -383,9 +388,9 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ManagedIncidentType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -555,29 +560,22 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     sharedSource: {
       type: SharedSource,
     },
-
   }, {
-    collection: "massive_incident_managed",
   });
   modelSchema.set("autoIndex", false);
 
+  modelSchema.virtual("id").get(function(this: ManagedIncident) {
+    return this._id.toHexString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
   modelSchema.plugin(mongooseLeanVirtuals);
-  return createModel(mongoose, "ManagedIncident", modelSchema);
+  return mongoose.model<ManagedIncident>("ManagedIncident", modelSchema, "massive_incident_managed", { overwriteModels: true });
 }
 
-export interface ManagedIncident extends ItemTypeFromTypeSchemaFunction<typeof ManagedIncidentModule> { }
-export interface ManagedIncidentModel extends ModelTypeFromTypeSchemaFunction<ManagedIncident> { }
-export default ManagedIncidentModule as ReplaceModelReturnType<typeof ManagedIncidentModule, ManagedIncidentModel>;
+export interface ManagedIncidentModel extends Model<ManagedIncident> { }