@dynamatix/gb-schemas 2.0.27 → 2.0.28

package/dist/applications/application.model.js

@@ -1,153 +0,0 @@
-import mongoose from "mongoose";
-import creditProfileSchema from "./application-credit-profile.model";
-const applicationSchema = new mongoose.Schema({
-    queueId: [{
-            type: mongoose.Schema.Types.ObjectId,
-            ref: "Queue",
-            required: true,
-        }],
-    assignedToUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
-    applicationId: { type: String, required: true },
-    isApplicationFeePaid: { type: String, required: true },
-    applicationNumber: { type: String, required: true },
-    applicationTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    bankSolicitor: { type: String, default: "" },
-    brokerId: { type: mongoose.Schema.Types.ObjectId, ref: "Broker", required: true },
-    caseManager: { type: String, default: "" },
-    caseManagerAccepted: { type: String, default: false },
-    completedReason: { type: String, default: "" },
-    isIntendToOccupy: { type: String, required: true },
-    introducer: { type: String, default: "" },
-    isIntroducerSubmission: { type: String, required: true },
-    isBrokerAssigned: { type: String, default: false },
-    isFinanceRecommendedToApplicant: { type: String, required: true },
-    isWorkflowTaskCreated: { type: String, required: true },
-    lastUpdated: { type: String },
-    lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    networkClubName: { type: String, default: "" },
-    isNetworkClubSubmission: { type: String, required: true },
-    newReason: { type: String, default: "" },
-    purchaseTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    rejectedReason: { type: String, default: "" },
-    repaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    selectedProduct: { type: String, required: false },
-    sourceOfWealthLids: [{ type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }],
-    sowBusiness: { type: String, default: "" },
-    sowInheritance: { type: String, default: "" },
-    sowOther: { type: String, default: "" },
-    sowProperty: { type: String, default: "" },
-    sowSalary: { type: String, default: "" },
-    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    submitReason: { type: String, default: "" },
-    submittedDate: { type: String },
-    underwriter: { type: String, default: "" },
-    isValuationFeePaid: { type: String, required: true },
-    withdrawalReason: { type: String, default: "" },
-    withdrawalReasonCode: { type: String, default: "" },
-    productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product", required: false },
-    product: { type: String },
-    securityId: { type: mongoose.Schema.Types.ObjectId, ref: "Security", required: true },
-    solicitorId: { type: mongoose.Schema.Types.ObjectId, ref: "Solicitor", required: true },
-    applicants: [
-        { type: mongoose.Schema.Types.ObjectId, ref: "Applicant" }
-    ],
-    isActive: { type: String, default: false },
-    isUkResident: { type: String, default: true },
-    riskRating: { type: String },
-    directDebitId: { type: mongoose.Schema.Types.ObjectId, ref: "Application_DirectDebit" },
-    creditProfile: creditProfileSchema,
-    mortgageId: { type: mongoose.Schema.Types.ObjectId, ref: "Mortgage" },
-    companyId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationCompany" },
-    rationaleId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationRationale" },
-    newAuditRecordsCount: { type: String, default: 0 }, // Ensure it is a Number
-    currentApprivoAuditId: Number,
-    propertyIds: [{ type: mongoose.Schema.Types.ObjectId, ref: "Property" }]
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-});
-// Virtual property 'noOfApplicants'
-applicationSchema.virtual('noOfApplicants').get(function () {
-    return this.applicants ? this.applicants.length : 0;
-});
-// Virtual property 'applicationTypeName'
-applicationSchema.virtual('applicationTypeName').get(function () {
-    return this.applicationTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationTypeLid?.name ?? null;
-});
-// Virtual property 'lendingType'
-applicationSchema.virtual('lendingType').get(function () {
-    return this.lendingTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.lendingTypeLid?.name ?? null;
-});
-// Virtual property 'purchaseType'
-applicationSchema.virtual('purchaseType').get(function () {
-    return this.purchaseTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.purchaseTypeLid?.text ?? null;
-});
-// Virtual property 'status'
-applicationSchema.virtual('status').get(function () {
-    return this.statusLid instanceof mongoose.Types.ObjectId ? null : this.statusLid?.name ?? null;
-});
-// Ensure the fields are populated when querying
-applicationSchema.pre('find', function () {
-    this.populate('applicationTypeLid').populate('lendingTypeLid').populate('statusLid');
-});
-applicationSchema.pre('findOne', function () {
-    this.populate('applicationTypeLid').populate('lendingTypeLid').populate('statusLid');
-});
-// Virtual property 'LTV %'
-applicationSchema.virtual('ltv').get(function () {
-    const purchasePrice = this.mortgageId?.purchasePrice;
-    const loanRequired = this.mortgageId?.loanRequired;
-    if (purchasePrice && loanRequired) {
-        const parseCurrency = (value) => {
-            if (typeof value === 'string') {
-                return parseFloat(value.replace(/[^0-9.-]+/g, ""));
-            }
-            return value;
-        };
-        const parsedPurchasePrice = parseCurrency(purchasePrice);
-        const parsedLoanRequired = parseCurrency(loanRequired);
-        const ltv = (parsedLoanRequired / parsedPurchasePrice) * 100;
-        return ltv.toFixed(2) + "%";
-    }
-    return null;
-});
-applicationSchema.virtual('submittedDateFormatted').get(function () {
-    if (!this.submittedDate)
-        return null;
-    const date = new Date(this.submittedDate);
-    const day = String(date.getDate()).padStart(2, '0');
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const year = date.getFullYear();
-    return `${day}-${month}-${year}`;
-});
-// Virtual property for broker name
-applicationSchema.virtual('brokerName').get(function () {
-    if (this.brokerId && typeof this.brokerId === 'object' && this.brokerId.firstName && this.brokerId.lastName) {
-        return this.brokerId.firstName + " " + this.brokerId.lastName;
-    }
-    return null;
-});
-applicationSchema.virtual('brokerEmail').get(function () {
-    return this.brokerId && typeof this.brokerId === 'object' ? this.brokerId.email : null;
-});
-applicationSchema.virtual('solicitorName').get(function () {
-    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.nameOfAccountHolder : null;
-});
-applicationSchema.virtual('solicitorEmail').get(function () {
-    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.email : null;
-});
-applicationSchema.virtual('brokerPhone').get(function () {
-    return this.brokerId && typeof this.brokerId === 'object' ? this.brokerId.mobileTelephone : null;
-});
-applicationSchema.virtual('solicitorPhone').get(function () {
-    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.telephone : null;
-});
-const ApplicationModel = mongoose.model("Application", applicationSchema);
-export default ApplicationModel;

package/dist/applications/broker.model.js

@@ -1,21 +0,0 @@
-import mongoose from "mongoose";
-const brokerSchema = new mongoose.Schema({
-    brokerId: { type: String },
-    landlinePhone: { type: String },
-    mobileTelephone: { type: String },
-    addressPostCode: { type: String },
-    addressLine1: { type: String },
-    addressLine2: { type: String },
-    addressLine3: { type: String },
-    addressCity: { type: String },
-    addressCountry: { type: String },
-    tradingName: { type: String },
-    fcaNumber: { type: String },
-    brokerType: { type: String },
-    email: { type: String },
-    network: { type: String },
-    firstName: { type: String },
-    lastName: { type: String }
-}, { timestamps: true });
-const BrokerModel = mongoose.model("Broker", brokerSchema);
-export default BrokerModel;

package/dist/applications/document.model.js

@@ -1,35 +0,0 @@
-import mongoose from "mongoose";
-const documentSchema = new mongoose.Schema({
-    applicationId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Application",
-        required: false,
-    },
-    documentId: { type: String, required: true },
-    owningEntityId: { type: String, required: false },
-    documentTypeLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        required: false,
-    },
-    documentTypeId: { type: mongoose.Schema.Types.ObjectId, ref: "DocumentType", required: false },
-    fileName: { type: String, required: false },
-    contentType: { type: String, required: false },
-    created: { type: String, required: false },
-    createdBy: { type: String, required: false },
-    isGenerated: { type: String, required: false },
-    data: { type: String, required: false },
-    envelopeId: { type: String, required: false },
-    signers: { type: Array, default: [] },
-    documentType: {
-        documentTypeId: { type: String, required: false },
-        displayName: { type: String, required: false },
-        value: { type: String, required: false },
-        data: { type: Object, required: false },
-    },
-    documentUrl: { type: String, required: false },
-}, {
-    timestamps: true
-});
-const DocumentModel = mongoose.model("Document", documentSchema);
-export default DocumentModel;

package/dist/applications/index.js

@@ -1,20 +0,0 @@
-export { default as ApplicationModel } from './application.model';
-export { default as ApplicationAuditModel } from './application-audit.model';
-export { default as ApplicationCheckListModel } from './application-checklist-Item.model';
-export { default as ApplicationCompanyModel } from './application-company-model.js';
-export { default as ApplicationNoteModel } from './application-note.model';
-export { default as ApplicationCreditProfileModel } from './application-credit-profile.model';
-export { default as ApplicationDirectDebitModel } from './application-direct-debit.model';
-export { default as ApplicationMortgageModel } from './application-mortgage.model';
-export { default as ApplicationOnboardingModel } from './application-onboarding.model';
-export { default as ApplicationRationaleModel } from './application-rationale.model';
-export { default as ApplicationValuationModel } from './application-valuation.model';
-export { default as BrokerModel } from './broker.model';
-export { default as ProductModel } from './application-product.model';
-export { default as SolicitorModel } from './solicitor.model';
-export { default as ApplicationDocumentModel } from './application-document.model';
-export { default as ApplicationRiskNarrativeModel } from './application-risk-narrative.model';
-export { default as ApplicationFieldConfigModel } from './application-fieldconfig.model';
-export { default as DocumentModel } from './document.model';
-export { default as MortgageModel } from './application-mortgage.model';
-export { default as ApplicationProductFeaturesModel } from './application-productfeatures.model';

package/dist/applications/solicitor.model.js

@@ -1,114 +0,0 @@
-import mongoose from "mongoose";
-import { SortCode } from "../value-objects/sort-code";
-const Schema = mongoose.Schema;
-const solicitorSchema = new Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application",
-        required: true,
-        description: "Unique identifier for the application",
-    },
-    pageValidFlag: {
-        type: Boolean,
-        default: true,
-    },
-    accountNumber: {
-        type: Number,
-        description: "Account number associated with the solicitor"
-    },
-    addressCity: {
-        type: String,
-        maxLength: 30,
-        description: "City where the solicitor is located"
-    },
-    addressCountryLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        description: "Country ID from the lookup list"
-    },
-    addressLine1: {
-        type: String,
-        maxLength: 35,
-        description: "First line of the solicitor's address"
-    },
-    addressLine2: {
-        type: String,
-        maxLength: 35,
-        description: "Second line of the solicitor's address"
-    },
-    addressLine3: {
-        type: String,
-        maxLength: 35,
-        description: "Third line of the solicitor's address"
-    },
-    addressPostCode: {
-        type: String,
-        maxLength: 50,
-        description: "Postal code for the solicitor's address"
-    },
-    bankAddressLine1: {
-        type: String,
-        description: "First line of the solicitor's bank address"
-    },
-    bankAddressLine2: {
-        type: String,
-        description: "Second line of the solicitor's bank address"
-    },
-    bankBranch: {
-        type: String,
-        description: "Branch of the solicitor's bank"
-    },
-    bankCity: {
-        type: String,
-        description: "City where the solicitor's bank is located"
-    },
-    contactPostcode: {
-        type: String,
-        description: "Postal code for the solicitor's contact address"
-    },
-    email: {
-        type: String,
-        description: "Email address of the solicitor"
-    },
-    institution: {
-        type: String,
-        description: "Institution name where the solicitor works"
-    },
-    nameOfAccountHolder: {
-        type: String,
-        description: "Name of the account holder associated with the solicitor"
-    },
-    nameOfFirm: {
-        type: String,
-        description: "Name of the solicitor's firm"
-    },
-    signatory: {
-        type: String,
-        description: "Signatory name for the solicitor"
-    },
-    solicitorActing: {
-        type: String,
-        maxLength: 50,
-        description: "Indicates if the solicitor is acting in a particular capacity"
-    },
-    sortCode: {
-        type: SortCode,
-        description: "Sort code associated with the solicitor's account"
-    },
-    telephone: {
-        type: String,
-        maxLength: 15,
-        description: "Telephone number of the solicitor"
-    },
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-});
-const virtualCountry = solicitorSchema.virtual('addressCountry', {
-    ref: 'Lookup',
-    localField: 'addressCountryLid',
-    foreignField: '_id',
-    justOne: true
-});
-virtualCountry.description = 'Populated lookup value for the solicitor\'s address country';
-const SolicitorModel = mongoose.model("Solicitor", solicitorSchema);
-export default SolicitorModel;

package/dist/index.js

@@ -1,9 +0,0 @@
-export * from './applications/index.js';
-export * from './shared/index.js';
-export * from './properties/index.js';
-export * from './applicants/index.js';
-export * from './users/index.js';
-export * from './product-catalogues/index.js';
-export * from './underwriter/index.js';
-// Export Prisma/Postgres schemas
-export * from './entities/index.js';

package/dist/product-catalogues/index.js

@@ -1,3 +0,0 @@
-export { default as ProductCatalogueModel } from './product-catalogue.model';
-export { default as ProductDefinitionsModel } from './product-definitions.model';
-export { default as ProductVariantModel } from './product-variant.model';

package/dist/product-catalogues/product-catalogue.model.js

@@ -1,18 +0,0 @@
-import mongoose from "mongoose";
-const productCatalogueSchema = new mongoose.Schema({
-    productCatalogueId: { type: String, required: true },
-    name: { type: String, required: true },
-    description: { type: String },
-    applyFrom: { type: String, required: true },
-    applyUntil: { type: String, required: true },
-    submitUntil: { type: String, required: true },
-    status: { type: String, required: true },
-    lockedForEdit: { type: String, required: true },
-    baseRateName: { type: String },
-    baseRate: { type: String },
-    mapperName: { type: String }
-}, {
-    timestamps: true
-});
-const ProductCatalogueModel = mongoose.model('ProductCatalogue', productCatalogueSchema);
-export default ProductCatalogueModel;

package/dist/product-catalogues/product-definitions.model.js

@@ -1,26 +0,0 @@
-import mongoose from "mongoose";
-const ruleSchema = new mongoose.Schema({
-    ruleId: { type: String, required: true },
-    rule: { type: String, required: true }, // Storing as a string (JSON stringified)
-    name: { type: String, required: true },
-    description: { type: String },
-    scope: { type: String },
-    mandatory: { type: String, required: true },
-    overrideRuleType: { type: String },
-    overrideRuleMessage: { type: String },
-    inheritedFrom: { type: String },
-    anyPass: { type: String, required: true },
-    preCashflow: { type: String, required: true }
-});
-const productDefinitionsSchema = new mongoose.Schema({
-    productDefinitionId: { type: String, required: true },
-    productCatalogueId: { ref: "ProductCatalogue", type: mongoose.Schema.Types.ObjectId, required: true },
-    name: { type: String, required: true },
-    atLeastOnePass: { type: String, required: true },
-    elements: { type: [mongoose.Schema.Types.Mixed], default: [] },
-    rules: { type: [ruleSchema], default: [] } // Embedded array of RuleSchema
-}, {
-    timestamps: true
-});
-const ProductDefinitionsModel = mongoose.model('ProductDefinitions', productDefinitionsSchema);
-export default ProductDefinitionsModel;

package/dist/product-catalogues/product-variant.model.js

@@ -1,12 +0,0 @@
-import mongoose from "mongoose";
-const productVariantSchema = new mongoose.Schema({
-    productCatalogueId: { ref: "ProductCatalogue", type: mongoose.Schema.Types.ObjectId, required: true },
-    variantid: { type: String, required: true },
-    name: { type: String, required: true },
-    variantCode: { type: String, required: true },
-    label: { type: String },
-}, {
-    timestamps: true
-});
-const ProductVariantModel = mongoose.model('ProductVariant', productVariantSchema);
-export default ProductVariantModel;

package/dist/properties/index.js

@@ -1,2 +0,0 @@
-export { default as SecurityModel } from './security.model';
-export { default as PropertyModel } from './property.model';

package/dist/properties/property.model.js

@@ -1,144 +0,0 @@
-import mongoose from 'mongoose';
-import { Pound } from '../value-objects/pound';
-const propertySchema = new mongoose.Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application",
-        description: "Unique identifier for the application",
-        required: true
-    },
-    pageValidFlag: {
-        type: Boolean,
-        default: true,
-        description: "Flag indicating if the page is valid",
-    },
-    propertyId: {
-        type: String,
-        required: true,
-        unique: true,
-        description: "Unique identifier for the property"
-    },
-    addressLine1: {
-        type: String,
-        required: true,
-        maxLength: 35,
-        description: "First line of the property address"
-    },
-    addressLine2: {
-        type: String,
-        required: false,
-        maxLength: 35,
-        description: "Second line of the property address"
-    },
-    addressLine3: {
-        type: String,
-        required: false,
-        maxLength: 35,
-        description: "Third line of the property address"
-    },
-    associatedLoanPartiesIds: {
-        type: [mongoose.Schema.Types.ObjectId],
-        required: false,
-        description: "List of associated loan parties (either applicant or company)"
-    },
-    city: {
-        type: String,
-        required: false,
-        maxLength: 30,
-        description: "City where the property is located"
-    },
-    countryLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Lookup',
-        required: true,
-        description: "Country where the property is located",
-    },
-    lender: {
-        type: String,
-        required: true,
-        maxLength: 35,
-        description: "Lender providing the loan for the property"
-    },
-    marketValue: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The market value of the property",
-    },
-    monthlyRent: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The monthly rent value of the property"
-    },
-    monthlyRepayment: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The monthly repayment value for the property"
-    },
-    originalLoanBalance: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The original loan balance for the property"
-    },
-    outstandingBalance: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The remaining outstanding balance of the property loan"
-    },
-    otherOwnershipParties: {
-        type: String,
-        required: false,
-        maxLength: 500,
-        description: "Other parties that own the property"
-    },
-    postCode: {
-        type: String,
-        required: true,
-        maxLength: 50,
-        description: "The postCode for the property"
-    },
-    remainingTerm: {
-        type: Number,
-        required: true,
-        max: 4,
-        description: "The remaining term of the loan in years"
-    },
-    portfolioFile: {
-        type: String,
-        required: false,
-        description: "File containing the portfolio details"
-    }
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-});
-propertySchema.virtual('country').get(function () {
-    return this.countryLid instanceof mongoose.Types.ObjectId ? null : this.countryLid?.name || null;
-});
-propertySchema.virtual('stressedRCR').get(function () {
-    const monthlyRentValue = this.monthlyRent ? parseFloat(this.monthlyRent.toString()) : 0.00;
-    const monthlyRepaymentValue = this.monthlyRepayment ? parseFloat(this.monthlyRepayment.toString()) : 0.00;
-    // Avoid division by zero
-    if (monthlyRepaymentValue === 0) {
-        return '0.00'; // Return 0.00 if monthlyRepayment is zero
-    }
-    const stressedRCR = (monthlyRentValue / monthlyRepaymentValue) * 100;
-    return stressedRCR.toFixed(2);
-});
-// virtual property 'applicationType'
-propertySchema.virtual('applicationType').get(function () {
-    return this.applicationId?.applicationTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationId?.applicationTypeLid?.name || null;
-});
-// virtual property 'lendingType'
-propertySchema.virtual('lendingType').get(function () {
-    return this.applicationId?.lendingTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationId?.lendingTypeLid?.name || null;
-});
-const PropertyModel = mongoose.model('Property', propertySchema);
-export default PropertyModel;

package/dist/shared/alert.model.js

@@ -1,24 +0,0 @@
-import mongoose from "mongoose";
-const alertSchema = new mongoose.Schema({
-    alertTypeLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup"
-    },
-    applicationId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Application",
-        required: true
-    },
-    alertMessage: { type: String },
-    documentId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Document",
-    },
-    statusLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup"
-    },
-    isActive: { type: String, default: true },
-}, { timestamps: true });
-const AlertModel = mongoose.model("Alert", alertSchema);
-export default AlertModel;

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

@@ -1,17 +0,0 @@
-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.js

@@ -1,30 +0,0 @@
-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.js

@@ -1,10 +0,0 @@
-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.js

@@ -1,12 +0,0 @@
-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';