@dynamatix/gb-schemas 2.0.34 → 2.0.35

package/dist/shared/system-parameter.model.d.ts

@@ -0,0 +1,60 @@
+import mongoose from "mongoose";
+declare const SystemParameterModel: mongoose.Model<{
+    createdOn: NativeDate;
+    createdByUserId: mongoose.Types.ObjectId;
+    parameterName: string;
+    parameterValue: any;
+    notes?: string | null | undefined;
+    updatedByUserId?: mongoose.Types.ObjectId | null | undefined;
+    updatedOn?: NativeDate | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdOn: NativeDate;
+    createdByUserId: mongoose.Types.ObjectId;
+    parameterName: string;
+    parameterValue: any;
+    notes?: string | null | undefined;
+    updatedByUserId?: mongoose.Types.ObjectId | null | undefined;
+    updatedOn?: NativeDate | null | undefined;
+}> & {
+    createdOn: NativeDate;
+    createdByUserId: mongoose.Types.ObjectId;
+    parameterName: string;
+    parameterValue: any;
+    notes?: string | null | undefined;
+    updatedByUserId?: mongoose.Types.ObjectId | null | undefined;
+    updatedOn?: NativeDate | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    createdOn: NativeDate;
+    createdByUserId: mongoose.Types.ObjectId;
+    parameterName: string;
+    parameterValue: any;
+    notes?: string | null | undefined;
+    updatedByUserId?: mongoose.Types.ObjectId | null | undefined;
+    updatedOn?: NativeDate | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdOn: NativeDate;
+    createdByUserId: mongoose.Types.ObjectId;
+    parameterName: string;
+    parameterValue: any;
+    notes?: string | null | undefined;
+    updatedByUserId?: mongoose.Types.ObjectId | null | undefined;
+    updatedOn?: NativeDate | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdOn: NativeDate;
+    createdByUserId: mongoose.Types.ObjectId;
+    parameterName: string;
+    parameterValue: any;
+    notes?: string | null | undefined;
+    updatedByUserId?: mongoose.Types.ObjectId | null | undefined;
+    updatedOn?: NativeDate | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default SystemParameterModel;
+//# sourceMappingURL=system-parameter.model.d.ts.map

package/dist/shared/system-parameter.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-parameter.model.d.ts","sourceRoot":"","sources":["../../shared/system-parameter.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAgChC,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2D,CAAC;AACtF,eAAe,oBAAoB,CAAC"}

package/dist/shared/system-parameter.model.js

@@ -0,0 +1,32 @@
+import mongoose from "mongoose";
+const systemParameterSchema = new mongoose.Schema({
+    parameterName: {
+        type: String,
+        required: true,
+    },
+    parameterValue: {
+        type: mongoose.Schema.Types.Mixed,
+        required: true,
+    },
+    notes: {
+        type: String,
+    },
+    createdByUserId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+    },
+    createdOn: {
+        type: Date,
+        default: Date.now,
+    },
+    updatedByUserId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+    },
+    updatedOn: {
+        type: Date,
+    },
+});
+const SystemParameterModel = mongoose.model('SystemParameter', systemParameterSchema);
+export default SystemParameterModel;

package/dist/shared/task-document.model.d.ts

@@ -0,0 +1,42 @@
+import mongoose from 'mongoose';
+declare const TaskDocumentTypeModel: mongoose.Model<{
+    name: string;
+    source: "applicant" | "application";
+    value: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    name: string;
+    source: "applicant" | "application";
+    value: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+}> & {
+    name: string;
+    source: "applicant" | "application";
+    value: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    name: string;
+    source: "applicant" | "application";
+    value: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    name: string;
+    source: "applicant" | "application";
+    value: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+}>> & mongoose.FlatRecord<{
+    name: string;
+    source: "applicant" | "application";
+    value: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default TaskDocumentTypeModel;
+//# sourceMappingURL=task-document.model.d.ts.map

package/dist/shared/task-document.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-document.model.d.ts","sourceRoot":"","sources":["../../shared/task-document.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAuBhC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AAEzF,eAAe,qBAAqB,CAAC"}

package/dist/shared/task-document.model.js

@@ -0,0 +1,23 @@
+import mongoose from 'mongoose';
+// Define the schema for TaskDocumentType
+const taskDocumentTypeSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true,
+    },
+    value: {
+        type: String,
+        required: true,
+    },
+    parentDocumentTypeId: {
+        type: mongoose.Schema.Types.ObjectId,
+        default: null, // Null for parent categories
+    },
+    source: {
+        type: String,
+        required: true,
+        enum: ['applicant', 'application'], // Only allow these two values
+    },
+});
+const TaskDocumentTypeModel = mongoose.model('TaskDocumentType', taskDocumentTypeSchema);
+export default TaskDocumentTypeModel;

package/dist/shared/task.model.d.ts

@@ -0,0 +1,206 @@
+import mongoose from "mongoose";
+declare const TaskModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    description: string;
+    actionsOnFailure: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+    actionsOnSuccess: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    description: string;
+    actionsOnFailure: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+    actionsOnSuccess: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    description: string;
+    actionsOnFailure: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+    actionsOnSuccess: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    description: string;
+    actionsOnFailure: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+    actionsOnSuccess: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    description: string;
+    actionsOnFailure: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+    actionsOnSuccess: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    description: string;
+    actionsOnFailure: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+    actionsOnSuccess: mongoose.Types.DocumentArray<{
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }> & {
+        type: string;
+        message?: string | null | undefined;
+        target?: string | null | undefined;
+    }>;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default TaskModel;
+//# sourceMappingURL=task.model.d.ts.map

package/dist/shared/task.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.model.d.ts","sourceRoot":"","sources":["../../shared/task.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAmBhC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AACrD,eAAe,SAAS,CAAC"}

package/dist/shared/task.model.js

@@ -0,0 +1,15 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+const actionSchema = new Schema({
+    type: { type: String, required: true }, // Type of the action
+    message: { type: String, required: false },
+    target: { type: String, required: false },
+});
+const taskSchema = new Schema({
+    name: { type: String, required: true },
+    description: { type: String, required: true },
+    actionsOnFailure: { type: [actionSchema], default: [] },
+    actionsOnSuccess: { type: [actionSchema], default: [] },
+}, { timestamps: true });
+const TaskModel = mongoose.model("Task", taskSchema);
+export default TaskModel;

package/dist/underwriter/index.d.ts

@@ -0,0 +1,2 @@
+export { default as UnderwriterModel } from './underwriter.model';
+//# sourceMappingURL=index.d.ts.map

package/dist/underwriter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../underwriter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAC,MAAM,qBAAqB,CAAC"}

package/dist/underwriter/index.js

@@ -0,0 +1 @@
+export { default as UnderwriterModel } from './underwriter.model';

package/dist/underwriter/underwriter.model.d.ts

@@ -0,0 +1,98 @@
+import mongoose from "mongoose";
+declare const UnderwriterModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    fullName: string;
+    mandateLevel: number;
+    underwriterId: number;
+    totalBTLCaseCount: number;
+    btlPreOfferCaseCount: number;
+    btlPostOfferCaseCount: number;
+    totalBridgingCaseCount: number;
+    bridgingPreOfferCaseCount: number;
+    bridgingPostOfferCaseCount: number;
+    bridgingMandateLevel: number;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    fullName: string;
+    mandateLevel: number;
+    underwriterId: number;
+    totalBTLCaseCount: number;
+    btlPreOfferCaseCount: number;
+    btlPostOfferCaseCount: number;
+    totalBridgingCaseCount: number;
+    bridgingPreOfferCaseCount: number;
+    bridgingPostOfferCaseCount: number;
+    bridgingMandateLevel: number;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    fullName: string;
+    mandateLevel: number;
+    underwriterId: number;
+    totalBTLCaseCount: number;
+    btlPreOfferCaseCount: number;
+    btlPostOfferCaseCount: number;
+    totalBridgingCaseCount: number;
+    bridgingPreOfferCaseCount: number;
+    bridgingPostOfferCaseCount: number;
+    bridgingMandateLevel: number;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    fullName: string;
+    mandateLevel: number;
+    underwriterId: number;
+    totalBTLCaseCount: number;
+    btlPreOfferCaseCount: number;
+    btlPostOfferCaseCount: number;
+    totalBridgingCaseCount: number;
+    bridgingPreOfferCaseCount: number;
+    bridgingPostOfferCaseCount: number;
+    bridgingMandateLevel: number;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    fullName: string;
+    mandateLevel: number;
+    underwriterId: number;
+    totalBTLCaseCount: number;
+    btlPreOfferCaseCount: number;
+    btlPostOfferCaseCount: number;
+    totalBridgingCaseCount: number;
+    bridgingPreOfferCaseCount: number;
+    bridgingPostOfferCaseCount: number;
+    bridgingMandateLevel: number;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    fullName: string;
+    mandateLevel: number;
+    underwriterId: number;
+    totalBTLCaseCount: number;
+    btlPreOfferCaseCount: number;
+    btlPostOfferCaseCount: number;
+    totalBridgingCaseCount: number;
+    bridgingPreOfferCaseCount: number;
+    bridgingPostOfferCaseCount: number;
+    bridgingMandateLevel: number;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default UnderwriterModel;
+//# sourceMappingURL=underwriter.model.d.ts.map

package/dist/underwriter/underwriter.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"underwriter.model.d.ts","sourceRoot":"","sources":["../../underwriter/underwriter.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}

package/dist/underwriter/underwriter.model.js

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+const underwriterSchema = new mongoose.Schema({
+    fullName: { type: String, required: true },
+    mandateLevel: { type: Number, required: true },
+    underwriterId: { type: Number, required: true },
+    totalBTLCaseCount: { type: Number, required: true },
+    btlPreOfferCaseCount: { type: Number, required: true },
+    btlPostOfferCaseCount: { type: Number, required: true },
+    totalBridgingCaseCount: { type: Number, required: true },
+    bridgingPreOfferCaseCount: { type: Number, required: true },
+    bridgingPostOfferCaseCount: { type: Number, required: true },
+    bridgingMandateLevel: { type: Number, required: true }
+}, {
+    timestamps: true
+});
+const UnderwriterModel = mongoose.model('Underwriter', underwriterSchema);
+export default UnderwriterModel;

package/dist/users/auth-log.model.d.ts

@@ -0,0 +1,42 @@
+import mongoose from "mongoose";
+declare const AuthLogModel: mongoose.Model<{
+    userEmail: string;
+    loggedInTimestamp: NativeDate;
+    isSuccess: boolean;
+    activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    userEmail: string;
+    loggedInTimestamp: NativeDate;
+    isSuccess: boolean;
+    activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
+}> & {
+    userEmail: string;
+    loggedInTimestamp: NativeDate;
+    isSuccess: boolean;
+    activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    userEmail: string;
+    loggedInTimestamp: NativeDate;
+    isSuccess: boolean;
+    activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    userEmail: string;
+    loggedInTimestamp: NativeDate;
+    isSuccess: boolean;
+    activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
+}>> & mongoose.FlatRecord<{
+    userEmail: string;
+    loggedInTimestamp: NativeDate;
+    isSuccess: boolean;
+    activity?: "LOGIN" | "LOGOUT" | "PASSWORD_RESET" | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default AuthLogModel;
+//# sourceMappingURL=auth-log.model.d.ts.map

package/dist/users/auth-log.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-log.model.d.ts","sourceRoot":"","sources":["../../users/auth-log.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqBhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAE9D,eAAe,YAAY,CAAC"}

package/dist/users/auth-log.model.js

@@ -0,0 +1,21 @@
+import mongoose from "mongoose";
+const AuthLogSchema = new mongoose.Schema({
+    userEmail: {
+        type: String,
+        required: true
+    },
+    loggedInTimestamp: {
+        type: Date,
+        default: Date.now
+    },
+    isSuccess: {
+        type: Boolean,
+        required: true
+    },
+    activity: {
+        type: String,
+        enum: ["LOGIN", "LOGOUT", "PASSWORD_RESET"]
+    }
+});
+const AuthLogModel = mongoose.model("AuthLog", AuthLogSchema);
+export default AuthLogModel;

package/dist/users/index.d.ts

@@ -0,0 +1,7 @@
+export { default as UserModel } from './user.model';
+export { default as RoleModel } from './role.model';
+export { default as RoleGroupModel } from './role-group.model';
+export { default as PermissionModel } from './permission.model';
+export { default as TasksModel } from './tasks.model';
+export { default as AuthLogModel } from './auth-log.model';
+//# sourceMappingURL=index.d.ts.map

package/dist/users/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../users/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAC,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/users/index.js

@@ -0,0 +1,6 @@
+export { default as UserModel } from './user.model';
+export { default as RoleModel } from './role.model';
+export { default as RoleGroupModel } from './role-group.model';
+export { default as PermissionModel } from './permission.model';
+export { default as TasksModel } from './tasks.model';
+export { default as AuthLogModel } from './auth-log.model';

package/dist/users/permission.model.d.ts

@@ -0,0 +1,56 @@
+import mongoose from "mongoose";
+declare const PermissionModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    controllerName: string;
+    methodName: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    controllerName: string;
+    methodName: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    controllerName: string;
+    methodName: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    controllerName: string;
+    methodName: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    controllerName: string;
+    methodName: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    controllerName: string;
+    methodName: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default PermissionModel;
+//# sourceMappingURL=permission.model.d.ts.map

package/dist/users/permission.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.model.d.ts","sourceRoot":"","sources":["../../users/permission.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAWhC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiD,CAAC;AAEvE,eAAe,eAAe,CAAC"}