tabletcommand-backend-models 5.39.7 → 7.0.1

package/src/models/mark43-incident-retry.ts

@@ -1,17 +1,16 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Mark43IncidentRetryType, RelatedEventType, RetryPayloadType } from "../types/mark43-incident-retry";
 
-export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
+export interface Mark43IncidentRetry extends Mark43IncidentRetryType { }
+
+export default async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
-  
-  const RelatedEvent = createSchema(Schema, {
+
+  const RelatedEvent = new Schema<RelatedEventType>({
     mark43Id: {
       type: Number,
       default: 0,
@@ -25,7 +24,7 @@ export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const RetryPayload = createSchema(Schema, {
+  const RetryPayload = new Schema<RetryPayloadType>({
     departmentId: {
       type: Number,
       default: 0,
@@ -42,7 +41,7 @@ export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Mark43IncidentRetryType>({
     departmentId: {
       type: String,
       default: "",
@@ -84,13 +83,10 @@ export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
       type: String,
     },
   }, {
-    collection: "massive_mark43_incident_retry",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "Mark43IncidentRetry", modelSchema);
+  return mongoose.model<Mark43IncidentRetry>("Mark43IncidentRetry", modelSchema, "massive_mark43_incident_retry", { overwriteModels: true });
 }
 
-export interface Mark43IncidentRetry extends ItemTypeFromTypeSchemaFunction<typeof Mark43IncidentRetryModule> { }
-export interface Mark43IncidentRetryModel extends ModelTypeFromTypeSchemaFunction<Mark43IncidentRetry> { }
-export default Mark43IncidentRetryModule as ReplaceModelReturnType<typeof Mark43IncidentRetryModule, Mark43IncidentRetryModel>;
+export interface Mark43IncidentRetryModel extends Model<Mark43IncidentRetry> { }

package/src/models/message.ts

@@ -1,20 +1,19 @@
 import * as uuid from "uuid";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
 import ColorModule from "./schema/color";
+import { Model } from "mongoose";
+import { MessageType, TypeSchemaType } from "../types/message";
 
-export async function MessageModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface Message extends MessageType, Record<string, unknown> { }
+
+export default async function MessageModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
 
-  const TypeSchema = createSchema(Schema, {
+  const TypeSchema = new Schema<TypeSchemaType>({
     type: {
       type: String,
       default: "", // generic, support, requestLogs, requestCADLogs, upgradeApp, upgradeOS
@@ -28,9 +27,9 @@ export async function MessageModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<MessageType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -96,13 +95,10 @@ export async function MessageModule(mongoose: MongooseModule) {
       default: {},
     },
   }, {
-    collection: "massive_message",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "Message", modelSchema);
+  return mongoose.model<Message>("Message", modelSchema, "massive_message", { overwriteModels: true });
 }
 
-export interface Message extends ItemTypeFromTypeSchemaFunction<typeof MessageModule> { }
-export interface MessageModel extends ModelTypeFromTypeSchemaFunction<Message> { }
-export default MessageModule as ReplaceModelReturnType<typeof MessageModule, MessageModel>;
+export interface MessageModel extends Model<Message> { }

package/src/models/monitor.ts

@@ -1,21 +1,20 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { MonitorType } from "../types/monitor";
 
-export async function MonitorModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface Monitor extends MonitorType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function MonitorModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<MonitorType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -57,7 +56,6 @@ export async function MonitorModule(mongoose: MongooseModule) {
       default: 1,
     },
   }, {
-    collection: "massive_monitor",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
@@ -67,9 +65,7 @@ export async function MonitorModule(mongoose: MongooseModule) {
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "Monitor", modelSchema);
+  return mongoose.model<Monitor>("Monitor", modelSchema, "massive_monitor", { overwriteModels: true });
 }
 
-export interface Monitor extends ItemTypeFromTypeSchemaFunction<typeof MonitorModule> { }
-export interface MonitorModel extends ModelTypeFromTypeSchemaFunction<Monitor> { }
-export default MonitorModule as ReplaceModelReturnType<typeof MonitorModule, MonitorModel>;
+export interface MonitorModel extends Model<Monitor> { }

package/src/models/personnel-import.ts

@@ -1,18 +1,17 @@
+import { Model } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { PersonnelImportType, RadioType } from "../types/personnel";
+
+export interface PersonnelImport extends PersonnelImportType { }
 
 export function PersonnelImportSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const Radio = createSchema(Schema, {
+  const Radio = new Schema<RadioType>({
     radioName: {
       type: String,
     },
@@ -29,9 +28,9 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<PersonnelImportType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     PersonnelID: {
@@ -75,11 +74,11 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: 0,
     },
     shiftStart: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
     shiftEnd: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
 
@@ -105,7 +104,7 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: ""
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -114,18 +113,15 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_personnel_import",
   });
   modelSchema.set("autoIndex", false);
 
   return modelSchema;
 }
 
-export async function PersonnelImportModule(mongoose: MongooseModule) {
+export default async function PersonnelImportModule(mongoose: MongooseModule) {
   const modelSchema = PersonnelImportSchema(mongoose);
-  return createModel(mongoose, "PersonnelImport", modelSchema);
+  return mongoose.model<PersonnelImport>("PersonnelImport", modelSchema, "massive_personnel_import", { overwriteModels: true });
 }
 
-export interface PersonnelImport extends ItemTypeFromTypeSchemaFunction<typeof PersonnelImportModule> { }
-export interface PersonnelImportModel extends ModelTypeFromTypeSchemaFunction<PersonnelImport> { }
-export default PersonnelImportModule as ReplaceModelReturnType<typeof PersonnelImportModule, PersonnelImportModel>;
+export interface PersonnelImportModel extends Model<PersonnelImport> { }

package/src/models/personnel-known.ts

@@ -1,19 +1,18 @@
 import * as uuid from "uuid";
 
 import {
-  createSchema,
-  createModel,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
+import { Model } from "mongoose";
+import { PersonnelKnownType, RadioType } from "../types/personnel";
+
+export interface PersonnelKnown extends PersonnelKnownType, Record<string, unknown> { }
 
 export function PersonnelKnownSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const Radio = createSchema(Schema, {
+  const Radio = new Schema<RadioType>({
     radioName: {
       type: String,
     },
@@ -26,9 +25,9 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<PersonnelKnownType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     PersonnelID: {
@@ -74,7 +73,7 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
       default: ""
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -83,7 +82,6 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
       default: ""
     },
   }, {
-    collection: "massive_personnel_known",
     timestamps: true,
     autoIndex: false,
   });
@@ -91,11 +89,9 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function PersonnelKnownModule(mongoose: MongooseModule) {
+export default async function PersonnelKnownModule(mongoose: MongooseModule) {
   const modelSchema = PersonnelKnownSchema(mongoose);
-  return createModel(mongoose, "PersonnelKnown", modelSchema);
+  return mongoose.model<PersonnelKnown>("PersonnelKnown", modelSchema, "massive_personnel_known", { overwriteModels: true });
 }
 
-export interface PersonnelKnown extends ItemTypeFromTypeSchemaFunction<typeof PersonnelKnownModule> { }
-export interface PersonnelKnownModel extends ModelTypeFromTypeSchemaFunction<PersonnelKnown> { }
-export default PersonnelKnownModule as ReplaceModelReturnType<typeof PersonnelKnownModule, PersonnelKnownModel>;
+export interface PersonnelKnownModel extends Model<PersonnelKnown> { }

package/src/models/personnel-roster.ts

@@ -1,19 +1,18 @@
+import { Model } from "mongoose";
 import {
-  createSchema,
-  createModel,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
+import { PersonnelRosterType } from "../types/personnel";
+
+export interface PersonnelRoster extends PersonnelRosterType { }
 
 export function PersonnelRosterSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<PersonnelRosterType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     PersonnelID: {
@@ -67,7 +66,6 @@ export function PersonnelRosterSchema(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_personnel_roster",
     autoIndex: false,
     timestamps: true,
   });
@@ -75,11 +73,9 @@ export function PersonnelRosterSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function PersonnelRosterModule(mongoose: MongooseModule) {
+export default async function PersonnelRosterModule(mongoose: MongooseModule) {
   const modelSchema = PersonnelRosterSchema(mongoose);
-  return createModel(mongoose, "PersonnelRoster", modelSchema);
+  return mongoose.model<PersonnelRoster>("PersonnelRoster", modelSchema, "massive_personnel_roster", { overwriteModels: true });
 }
 
-export interface PersonnelRoster extends ItemTypeFromTypeSchemaFunction<typeof PersonnelRosterModule> { }
-export interface PersonnelRosterModel extends ModelTypeFromTypeSchemaFunction<PersonnelRoster> { }
-export default PersonnelRosterModule as ReplaceModelReturnType<typeof PersonnelRosterModule, PersonnelRosterModel>;
+export interface PersonnelRosterModel extends Model<PersonnelRoster> { }

package/src/models/rate-limit.ts

@@ -1,19 +1,18 @@
+import { Model } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { RateLimitType } from "../types/rate-limit";
 
-export async function RateLimitModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface RateLimit extends RateLimitType { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function RateLimitModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<RateLimitType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     username: String,
@@ -34,13 +33,10 @@ export async function RateLimitModule(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_rate_limit",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "RateLimit", modelSchema);
+  return mongoose.model<RateLimit>("RateLimit", modelSchema, "massive_rate_limit", { overwriteModels: true });
 }
 
-export interface RateLimit extends ItemTypeFromTypeSchemaFunction<typeof RateLimitModule> { }
-export interface RateLimitModel extends ModelTypeFromTypeSchemaFunction<RateLimit> { }
-export default RateLimitModule as ReplaceModelReturnType<typeof RateLimitModule, RateLimitModel>;
+export interface RateLimitModel extends Model<RateLimit> { }

package/src/models/release-note.ts

@@ -1,19 +1,18 @@
+import { Model } from "mongoose";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
-  ModelTypeFromTypeSchemaFunction,
-  ItemTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { ReleaseNoteType } from "../types/release-note";
 
-export async function ReleaseNoteModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ReleaseNote extends ReleaseNoteType, Record<string, unknown> { }
 
-  const modelSchema = createSchema(Schema, {
+export default async function ReleaseNoteModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<ReleaseNoteType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     title: {
@@ -39,13 +38,8 @@ export async function ReleaseNoteModule(mongoose: MongooseModule) {
       type: Date,
       default: currentDate,
     },
-  }, {
-    collection: "massive_release_note",
-  });
-  modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "ReleaseNote", modelSchema);
+  }, { autoIndex: false });
+  return mongoose.model<ReleaseNote>("ReleaseNote", modelSchema, "massive_release_note", { overwriteModels: true });
 }
 
-export interface ReleaseNote extends ItemTypeFromTypeSchemaFunction<typeof ReleaseNoteModule> { }
-export interface ReleaseNoteModel extends ModelTypeFromTypeSchemaFunction<ReleaseNote> { }
-export default ReleaseNoteModule as ReplaceModelReturnType<typeof ReleaseNoteModule, ReleaseNoteModel>;
+export interface ReleaseNoteModel extends Model<ReleaseNote> { }

package/src/models/remote-log-stream.ts

@@ -1,25 +1,22 @@
 import * as uuid from "uuid";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
-
+import { Model } from "mongoose";
 import RemoteFileSchema from "./schema/remote-file";
+import { RemoteLogStreamType } from "../types/remote-log";
+
+export interface RemoteLogStream extends RemoteLogStreamType, Record<string, unknown> { }
 
-export async function RemoteLogStreamModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function RemoteLogStreamModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
   const RemoteFile = RemoteFileSchema(mongoose);
 
-  // This is almost identical to RemoteLog
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<RemoteLogStreamType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -101,13 +98,10 @@ export async function RemoteLogStreamModule(mongoose: MongooseModule) {
     },
   }, {
     autoIndex: false,
-    collection: "massive_remote_log_stream",
     timestamps: true,
   });
 
-  return createModel(mongoose, "RemoteLogStream", modelSchema);
+  return mongoose.model<RemoteLogStream>("RemoteLogStream", modelSchema, "massive_remote_log_stream", { overwriteModels: true });
 }
 
-export interface RemoteLogStream extends ItemTypeFromTypeSchemaFunction<typeof RemoteLogStreamModule> { }
-export interface RemoteLogStreamModel extends ModelTypeFromTypeSchemaFunction<RemoteLogStream> { }
-export default RemoteLogStreamModule as ReplaceModelReturnType<typeof RemoteLogStreamModule, RemoteLogStreamModel>;
+export interface RemoteLogStreamModel extends Model<RemoteLogStream> { }

package/src/models/remote-log.ts

@@ -1,25 +1,22 @@
 import * as uuid from "uuid";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
-
+import { Model } from "mongoose";
 import RemoteFileSchema from "./schema/remote-file";
+import { RemoteLogType } from "../types/remote-log";
+
+export interface RemoteLog extends RemoteLogType { }
 
-export async function RemoteLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function RemoteLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
   const RemoteFile = RemoteFileSchema(mongoose);
 
-  // This is almost identical to RemoteLogStream
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<RemoteLogType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -99,13 +96,10 @@ export async function RemoteLogModule(mongoose: MongooseModule) {
     },
   }, {
     autoIndex: false,
-    collection: "massive_remote_log_stream",
     timestamps: true,
   });
 
-  return createModel(mongoose, "RemoteLog", modelSchema);
+  return mongoose.model<RemoteLog>("RemoteLog", modelSchema, "massive_remote_log_stream", { overwriteModels: true });
 }
 
-export interface RemoteLog extends ItemTypeFromTypeSchemaFunction<typeof RemoteLogModule> { }
-export interface RemoteLogModel extends ModelTypeFromTypeSchemaFunction<RemoteLog> { }
-export default RemoteLogModule as ReplaceModelReturnType<typeof RemoteLogModule, RemoteLogModel>;
+export interface RemoteLogModel extends Model<RemoteLog> { }

package/src/models/schema/agency-cron-config.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { EncryptedDataType, CronConfigSourceType, CronConfigAuthType, CronConfigCSVFieldMapType, ReconcileTimeOptionsType, AgencyCronConfigType } from "../../types/agency";
 
 export default function AgencyCronSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const EncryptedData = createSchema(Schema, {
+  const EncryptedData = new Schema<EncryptedDataType>({
     iv: {
       type: String,
       default: "",
@@ -20,7 +20,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const CronConfigSource = createSchema(Schema, {
+  const CronConfigSource = new Schema<CronConfigSourceType>({
     protocol: {
       type: String,
       default: "",
@@ -49,7 +49,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     filePath: "",
   };
 
-  const CronConfigAuth = createSchema(Schema, {
+  const CronConfigAuth = new Schema<CronConfigAuthType>({
     password: {
       type: EncryptedData,
       default: null,
@@ -79,7 +79,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     useSSHKey: false,
   };
 
-  const CronConfigCSVFieldMap = createSchema(Schema, {
+  const CronConfigCSVFieldMap = new Schema<CronConfigCSVFieldMapType>({
     PersonnelID: {
       type: String,
     },
@@ -126,7 +126,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     TimeFormat: "YYYY-MM-DD HH:mm",
   };
 
-  const ReconcileTimeOptions = createSchema(Schema, {
+  const ReconcileTimeOptions = new Schema<ReconcileTimeOptionsType>({
     enabled: {
       type: Boolean,
     },
@@ -147,7 +147,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     endTime: "08:00",
   };
 
-  const AgencyCronConfig = createSchema(Schema, {
+  const AgencyCronConfig = new Schema<AgencyCronConfigType>({
     enabled: {
       type: Boolean,
       default: false,

package/src/models/schema/agency-saml.ts

@@ -1,12 +1,12 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
+import { AgencySAMLSchemaType } from "../../types/agency";
 
 export default function AgencySAMLSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const AgencySAML = createSchema(Schema, {
+  const AgencySAML = new Schema<AgencySAMLSchemaType>({
     selector: {
       type: String,
       required: true,