@dynamatix/gb-schemas 2.0.34 → 2.0.36

package/dist/shared/apprivo-sync-journey.model.d.ts

@@ -0,0 +1,86 @@
+import mongoose from "mongoose";
+declare const ApprivoSyncJourneyModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: string;
+    error: string;
+    milestoneLid: mongoose.Types.ObjectId;
+    mileStoneStatus: "Completed" | "Errored" | "Not Applicable";
+    isFirstPull: string;
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobRunId?: mongoose.Types.ObjectId | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: string;
+    error: string;
+    milestoneLid: mongoose.Types.ObjectId;
+    mileStoneStatus: "Completed" | "Errored" | "Not Applicable";
+    isFirstPull: string;
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobRunId?: mongoose.Types.ObjectId | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: string;
+    error: string;
+    milestoneLid: mongoose.Types.ObjectId;
+    mileStoneStatus: "Completed" | "Errored" | "Not Applicable";
+    isFirstPull: string;
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobRunId?: mongoose.Types.ObjectId | 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;
+} & {
+    applicationId: string;
+    error: string;
+    milestoneLid: mongoose.Types.ObjectId;
+    mileStoneStatus: "Completed" | "Errored" | "Not Applicable";
+    isFirstPull: string;
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobRunId?: mongoose.Types.ObjectId | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: string;
+    error: string;
+    milestoneLid: mongoose.Types.ObjectId;
+    mileStoneStatus: "Completed" | "Errored" | "Not Applicable";
+    isFirstPull: string;
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobRunId?: mongoose.Types.ObjectId | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: string;
+    error: string;
+    milestoneLid: mongoose.Types.ObjectId;
+    mileStoneStatus: "Completed" | "Errored" | "Not Applicable";
+    isFirstPull: string;
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobRunId?: mongoose.Types.ObjectId | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default ApprivoSyncJourneyModel;
+//# sourceMappingURL=apprivo-sync-journey.model.d.ts.map

package/dist/shared/apprivo-sync-journey.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apprivo-sync-journey.model.d.ts","sourceRoot":"","sources":["../../shared/apprivo-sync-journey.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiBhC,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiE,CAAC;AAC/F,eAAe,uBAAuB,CAAC"}

package/dist/shared/apprivo-sync-journey.model.js

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+const ApprivoSyncJourneySchema = new mongoose.Schema({
+    applicationId: { type: String, required: true },
+    milestoneLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    mileStoneStatus: {
+        type: String,
+        enum: ['Completed', 'Errored', 'Not Applicable'],
+        required: true
+    },
+    error: { type: String, default: null },
+    isFirstPull: { type: String, required: true },
+    jobRunId: { type: mongoose.Schema.Types.ObjectId, ref: "Job_Run" },
+    startTime: { type: Date, default: null },
+    endTime: { type: Date, default: null },
+}, { timestamps: true });
+const ApprivoSyncJourneyModel = mongoose.model('ApprivoSyncJourney', ApprivoSyncJourneySchema);
+export default ApprivoSyncJourneyModel;

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

@@ -0,0 +1,74 @@
+import mongoose from "mongoose";
+declare const CheckListModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    source: string;
+    checkTypeLid: mongoose.Types.ObjectId;
+    checkStatusLid: mongoose.Types.ObjectId;
+    sourceId?: mongoose.Types.ObjectId | null | undefined;
+    checkDescription?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    source: string;
+    checkTypeLid: mongoose.Types.ObjectId;
+    checkStatusLid: mongoose.Types.ObjectId;
+    sourceId?: mongoose.Types.ObjectId | null | undefined;
+    checkDescription?: string | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    source: string;
+    checkTypeLid: mongoose.Types.ObjectId;
+    checkStatusLid: mongoose.Types.ObjectId;
+    sourceId?: mongoose.Types.ObjectId | null | undefined;
+    checkDescription?: 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;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    source: string;
+    checkTypeLid: mongoose.Types.ObjectId;
+    checkStatusLid: mongoose.Types.ObjectId;
+    sourceId?: mongoose.Types.ObjectId | null | undefined;
+    checkDescription?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    source: string;
+    checkTypeLid: mongoose.Types.ObjectId;
+    checkStatusLid: mongoose.Types.ObjectId;
+    sourceId?: mongoose.Types.ObjectId | null | undefined;
+    checkDescription?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    source: string;
+    checkTypeLid: mongoose.Types.ObjectId;
+    checkStatusLid: mongoose.Types.ObjectId;
+    sourceId?: mongoose.Types.ObjectId | null | undefined;
+    checkDescription?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default CheckListModel;
+//# sourceMappingURL=checklist.model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checklist.model.d.ts","sourceRoot":"","sources":["../../shared/checklist.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiChC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AAEpE,eAAe,cAAc,CAAC"}

package/dist/shared/checklist.model.js

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+const checklistSchema = new mongoose.Schema({
+    checkTypeLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: true
+    },
+    source: {
+        type: String,
+        required: true
+    },
+    sourceId: {
+        type: mongoose.Schema.Types.ObjectId,
+        required: false
+    },
+    applicationId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Application",
+        required: true
+    },
+    checkDescription: { type: String },
+    checkStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: true
+    }
+}, { timestamps: true });
+checklistSchema.index({ checkDescription: 'text', source: 'text' });
+const CheckListModel = mongoose.model("CheckList", checklistSchema);
+export default CheckListModel;

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

@@ -0,0 +1,48 @@
+import mongoose from "mongoose";
+declare const DocumentTypeModel: mongoose.Model<{
+    name: string;
+    source: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+    label?: string | null | undefined;
+    matchRules?: any;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    name: string;
+    source: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+    label?: string | null | undefined;
+    matchRules?: any;
+}> & {
+    name: string;
+    source: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+    label?: string | null | undefined;
+    matchRules?: any;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    name: string;
+    source: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+    label?: string | null | undefined;
+    matchRules?: any;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    name: string;
+    source: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+    label?: string | null | undefined;
+    matchRules?: any;
+}>> & mongoose.FlatRecord<{
+    name: string;
+    source: string;
+    parentDocumentTypeId: mongoose.Types.ObjectId;
+    label?: string | null | undefined;
+    matchRules?: any;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default DocumentTypeModel;
+//# sourceMappingURL=document-type-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document-type-model.d.ts","sourceRoot":"","sources":["../../shared/document-type-model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAUhC,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqD,CAAC;AAE7E,eAAe,iBAAiB,CAAC"}

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

@@ -0,0 +1,10 @@
+import mongoose from "mongoose";
+const DocumentTypeSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    label: { type: String },
+    source: { type: String, default: null },
+    parentDocumentTypeId: { type: mongoose.Schema.Types.ObjectId, ref: 'DocumentType', default: null },
+    matchRules: { type: mongoose.Schema.Types.Mixed }
+});
+const DocumentTypeModel = mongoose.model('DocumentType', DocumentTypeSchema);
+export default DocumentTypeModel;

package/dist/shared/index.d.ts

@@ -0,0 +1,13 @@
+export { default as LookupGroupModel } from './lookup-group.model';
+export { default as LookupModel } from './lookup.model';
+export { default as SystemParameterModel } from './system-parameter.model';
+export { default as AlertModel } from './alert.model';
+export { default as CheckListModel } from './checklist.model';
+export { default as JobSettingModel } from './job-setting.model';
+export { default as TaskModel } from './task.model';
+export { default as ApprivoSyncJourneyModel } from './apprivo-sync-journey.model';
+export { default as JobRunModel } from './job-run.model';
+export { default as TaskDocumentTypeModel } from './task-document.model';
+export { default as DocumentTypeModel } from './document-type-model';
+export { default as SchemaDocModel } from './schema-doc.model';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../shared/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAC,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAC,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAC,MAAM,uBAAuB,CAAA;AACvE,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/shared/index.js

@@ -0,0 +1,12 @@
+export { default as LookupGroupModel } from './lookup-group.model';
+export { default as LookupModel } from './lookup.model';
+export { default as SystemParameterModel } from './system-parameter.model';
+export { default as AlertModel } from './alert.model';
+export { default as CheckListModel } from './checklist.model';
+export { default as JobSettingModel } from './job-setting.model';
+export { default as TaskModel } from './task.model';
+export { default as ApprivoSyncJourneyModel } from './apprivo-sync-journey.model';
+export { default as JobRunModel } from './job-run.model';
+export { default as TaskDocumentTypeModel } from './task-document.model';
+export { default as DocumentTypeModel } from './document-type-model';
+export { default as SchemaDocModel } from './schema-doc.model';

package/dist/shared/job-run.model.d.ts

@@ -0,0 +1,48 @@
+import mongoose from "mongoose";
+declare const JobRunModel: mongoose.Model<{
+    error: string;
+    status: "Completed" | "Errored" | "Running";
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobName: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    error: string;
+    status: "Completed" | "Errored" | "Running";
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobName: string;
+}> & {
+    error: string;
+    status: "Completed" | "Errored" | "Running";
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobName: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    error: string;
+    status: "Completed" | "Errored" | "Running";
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobName: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    error: string;
+    status: "Completed" | "Errored" | "Running";
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobName: string;
+}>> & mongoose.FlatRecord<{
+    error: string;
+    status: "Completed" | "Errored" | "Running";
+    startTime: NativeDate;
+    endTime: NativeDate;
+    jobName: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default JobRunModel;
+//# sourceMappingURL=job-run.model.d.ts.map

package/dist/shared/job-run.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-run.model.d.ts","sourceRoot":"","sources":["../../shared/job-run.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAoB,MAAM,UAAU,CAAC;AAc5C,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAC;AAC5D,eAAe,WAAW,CAAC"}

package/dist/shared/job-run.model.js

@@ -0,0 +1,14 @@
+import mongoose, { Schema } from "mongoose";
+const jobRunSchema = new Schema({
+    jobName: { type: String, required: true },
+    status: {
+        type: String,
+        enum: ['Running', 'Completed', 'Errored'],
+        required: true
+    },
+    error: { type: String, default: null },
+    startTime: { type: Date, default: null },
+    endTime: { type: Date, default: null }
+});
+const JobRunModel = mongoose.model('Job_Run', jobRunSchema);
+export default JobRunModel;

package/dist/shared/job-setting.model.d.ts

@@ -0,0 +1,42 @@
+import mongoose from "mongoose";
+declare const JobSettingModel: mongoose.Model<{
+    name: string;
+    isActive: string;
+    frequency: string;
+    jobParams: any[];
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    name: string;
+    isActive: string;
+    frequency: string;
+    jobParams: any[];
+}> & {
+    name: string;
+    isActive: string;
+    frequency: string;
+    jobParams: any[];
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    name: string;
+    isActive: string;
+    frequency: string;
+    jobParams: any[];
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    name: string;
+    isActive: string;
+    frequency: string;
+    jobParams: any[];
+}>> & mongoose.FlatRecord<{
+    name: string;
+    isActive: string;
+    frequency: string;
+    jobParams: any[];
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default JobSettingModel;
+//# sourceMappingURL=job-setting.model.d.ts.map

package/dist/shared/job-setting.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-setting.model.d.ts","sourceRoot":"","sources":["../../shared/job-setting.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAWhC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAkD,CAAC;AAExE,eAAe,eAAe,CAAC"}

package/dist/shared/job-setting.model.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+const jobSettingSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    isActive: { type: String, default: true },
+    frequency: {
+        type: String, default: '2 hours'
+    },
+    jobParams: { type: [mongoose.Schema.Types.Mixed] }
+});
+const JobSettingModel = mongoose.model("Job_Setting", jobSettingSchema);
+export default JobSettingModel;

package/dist/shared/lookup-group.model.d.ts

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+declare const LookupGroupModel: mongoose.Model<{
+    name: string;
+    lookups: mongoose.Types.ObjectId[];
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    name: string;
+    lookups: mongoose.Types.ObjectId[];
+}> & {
+    name: string;
+    lookups: mongoose.Types.ObjectId[];
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    name: string;
+    lookups: mongoose.Types.ObjectId[];
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    name: string;
+    lookups: mongoose.Types.ObjectId[];
+}>> & mongoose.FlatRecord<{
+    name: string;
+    lookups: mongoose.Types.ObjectId[];
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default LookupGroupModel;
+//# sourceMappingURL=lookup-group.model.d.ts.map

package/dist/shared/lookup-group.model.d.ts.map

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

package/dist/shared/lookup-group.model.js

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+const lookupGroupSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    lookups: [
+        {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "Lookup", // References the Lookup collection
+        },
+    ],
+});
+const LookupGroupModel = mongoose.model('LookupGroup', lookupGroupSchema);
+export default LookupGroupModel;

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

@@ -0,0 +1,42 @@
+import mongoose from "mongoose";
+declare const LookupModel: mongoose.Model<{
+    text: string;
+    name: string;
+    value?: string | null | undefined;
+    lookupGroupId?: mongoose.Types.ObjectId | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    text: string;
+    name: string;
+    value?: string | null | undefined;
+    lookupGroupId?: mongoose.Types.ObjectId | null | undefined;
+}> & {
+    text: string;
+    name: string;
+    value?: string | null | undefined;
+    lookupGroupId?: mongoose.Types.ObjectId | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    text: string;
+    name: string;
+    value?: string | null | undefined;
+    lookupGroupId?: mongoose.Types.ObjectId | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    text: string;
+    name: string;
+    value?: string | null | undefined;
+    lookupGroupId?: mongoose.Types.ObjectId | null | undefined;
+}>> & mongoose.FlatRecord<{
+    text: string;
+    name: string;
+    value?: string | null | undefined;
+    lookupGroupId?: mongoose.Types.ObjectId | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default LookupModel;
+//# sourceMappingURL=lookup.model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.model.d.ts","sourceRoot":"","sources":["../../shared/lookup.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqBhC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAC;AAC3D,eAAe,WAAW,CAAC"}

package/dist/shared/lookup.model.js

@@ -0,0 +1,20 @@
+import mongoose from "mongoose";
+const lookupSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    text: {
+        type: String,
+        required: true
+    },
+    lookupGroupId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "LookupGroup", // References the LookupGroup collection
+    },
+    value: {
+        type: String
+    }
+});
+const LookupModel = mongoose.model('Lookup', lookupSchema);
+export default LookupModel;

package/dist/shared/schema-doc.model.d.ts

@@ -0,0 +1,48 @@
+import { Schema } from 'mongoose';
+declare const SchemaDocModel: import("mongoose").Model<{
+    type?: string | null | undefined;
+    schemaName?: string | null | undefined;
+    description?: string | null | undefined;
+    field?: string | null | undefined;
+    isVirtual?: boolean | null | undefined;
+}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
+    type?: string | null | undefined;
+    schemaName?: string | null | undefined;
+    description?: string | null | undefined;
+    field?: string | null | undefined;
+    isVirtual?: boolean | null | undefined;
+}> & {
+    type?: string | null | undefined;
+    schemaName?: string | null | undefined;
+    description?: string | null | undefined;
+    field?: string | null | undefined;
+    isVirtual?: boolean | null | undefined;
+} & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+    type?: string | null | undefined;
+    schemaName?: string | null | undefined;
+    description?: string | null | undefined;
+    field?: string | null | undefined;
+    isVirtual?: boolean | null | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    type?: string | null | undefined;
+    schemaName?: string | null | undefined;
+    description?: string | null | undefined;
+    field?: string | null | undefined;
+    isVirtual?: boolean | null | undefined;
+}>> & import("mongoose").FlatRecord<{
+    type?: string | null | undefined;
+    schemaName?: string | null | undefined;
+    description?: string | null | undefined;
+    field?: string | null | undefined;
+    isVirtual?: boolean | null | undefined;
+}> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default SchemaDocModel;
+//# sourceMappingURL=schema-doc.model.d.ts.map

package/dist/shared/schema-doc.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-doc.model.d.ts","sourceRoot":"","sources":["../../shared/schema-doc.model.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAS,MAAM,UAAU,CAAC;AAWzC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAsC,CAAC;AAE3D,eAAe,cAAc,CAAC"}

package/dist/shared/schema-doc.model.js

@@ -0,0 +1,11 @@
+import { Schema, model } from 'mongoose';
+// Schema to store documentation
+const schemaDocSchema = new Schema({
+    schemaName: String,
+    field: String,
+    type: String,
+    description: String,
+    isVirtual: Boolean
+});
+const SchemaDocModel = model('SchemaDoc', schemaDocSchema);
+export default SchemaDocModel;