@dynamatix/gb-schemas 2.0.24 → 2.0.26

package/dist/applicants/applicant-credit-profile.model.js

@@ -1,20 +0,0 @@
-import mongoose from "mongoose";
-const creditProfileSchema = new mongoose.Schema({
-    anyVoluntaryEnforcedPossessionNo: {
-        type: String,
-        required: true
-    },
-    bankruptcyNo: {
-        type: String,
-        required: true
-    },
-    ccjInLastThreeYearNo: {
-        type: String,
-        required: true
-    },
-    defaultsInLastYearNo: {
-        type: String,
-        required: true
-    }
-});
-export default creditProfileSchema;

package/dist/applicants/applicant-direct-debit.model.js

@@ -1,17 +0,0 @@
-import mongoose from 'mongoose';
-const applicantDirectDebitSchema = new mongoose.Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Application' },
-    accountNumber: { type: String },
-    addressLine1: { type: String },
-    addressLine2: { type: String },
-    Applicants: { type: String },
-    branch: { type: String },
-    city: { type: String },
-    contactPostcode: { type: String },
-    institution: { type: String },
-    isConfirmDeclaration: { type: String, default: false },
-    nameOfAccountHolder: { type: String },
-    selectedPaymentDay: { type: String },
-    sortCode: { type: String }
-}, { timestamps: true });
-export default applicantDirectDebitSchema;

package/dist/applicants/applicant-employment.model.js

@@ -1,50 +0,0 @@
-import mongoose from "mongoose";
-import { Pound } from "../value-objects/pound";
-const applicantEmploymentSchema = new mongoose.Schema({
-    pageValidFlag: { type: Boolean, default: false },
-    acceptableIncomeLids: [{ type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }],
-    addressCity: { type: String, default: null },
-    addressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    addressLine1: { type: String, required: true },
-    addressLine2: { type: String, default: null },
-    addressLine3: { type: String, default: null },
-    addressPostCode: { type: String, required: true },
-    averageBonusPreviousTwoYears: { type: Pound, default: 0.00 },
-    basicGrossIncome: { type: Pound, default: 0.00 },
-    contractRemaining: { type: String },
-    dateJoined: { type: String, required: true },
-    disabilityLiving: { type: Pound, default: 0.00 },
-    employerName: { type: String, required: true },
-    employerTelephone: { type: String, default: null },
-    housingAllowance: { type: Pound, default: 0.00 },
-    industryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    isUnderTerminationNotice: {
-        type: Boolean,
-        default: false,
-    },
-    jobTitleLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    maintenance: { type: Pound, default: 0.00 },
-    maternityIncome: { type: Pound, default: 0.00 },
-    natureOfBusiness: { type: String, required: true },
-    pensionIncome: { type: Pound, default: 0.00 },
-    previousAddressCity: { type: String, default: null },
-    previousAddressCountry: { type: String, required: true },
-    previousAddressLine1: { type: String, required: true },
-    previousAddressLine2: { type: String, default: null },
-    previousAddressLine3: { type: String, default: null },
-    previousAddressPostCode: { type: String, required: true },
-    previousBasicGrossIncome: { type: Pound, default: 0.00, required: true },
-    previousDateJoined: { type: String, required: true },
-    previousDateLeft: { type: String, required: true },
-    previousEmployerName: { type: String, required: true },
-    previousEmployerTelephone: { type: String, default: null },
-    previousJobTitle: { type: String, required: true },
-    previousNatureOfBusiness: { type: String, required: true },
-    referenceContact: { type: String, default: null },
-    referenceContactEmail: { type: String, required: true },
-    underTerminationNoticeNote: { type: String, default: null }
-}, {
-    toJSON: { getters: true },
-    toObject: { getters: true }
-});
-export default applicantEmploymentSchema;

package/dist/applicants/applicant-expenditure.model.js

@@ -1,54 +0,0 @@
-import mongoose from "mongoose";
-import { Pound } from "../value-objects/pound";
-const applicantExpenditureSchema = new mongoose.Schema({
-    applicantId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Applicant",
-        required: true,
-        description: "Reference to the applicant this expenditure record belongs to.",
-    },
-    isFixed: {
-        type: Boolean,
-        default: false,
-        description: "True if all mandatory fields have been completed, otherwise false.",
-    },
-    expenditureTypeLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        default: null,
-        description: "Essential expenditure lookup",
-    },
-    declared: {
-        type: Pound,
-        description: "Declared monthly expenditure amount provided by the applicant.",
-    },
-    ons: {
-        type: Pound,
-        description: "Office for National Statistics (ONS) benchmark monthly expenditure.",
-    },
-    actual: {
-        type: Pound,
-        description: "Actual monthly expenditure verified based on applicant's evidence.",
-    },
-    rationale: {
-        type: String,
-        description: "Rationalized monthly expenditure used for affordability assessment.",
-    },
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true },
-});
-// Virtual property for essentialExpenditure
-const virtualEssentialExpenditure = applicantExpenditureSchema.virtual("ExpenditureType", {
-    ref: "Lookup",
-    localField: "expenditureTypeLid",
-    foreignField: "_id",
-    justOne: true,
-    options: {
-        select: "label",
-    },
-});
-virtualEssentialExpenditure.description = "Populated lookup value for essential expenditure.";
-const ApplicantExpenditureModel = mongoose.model("Applicant_Expenditure", applicantExpenditureSchema);
-export default ApplicantExpenditureModel;

package/dist/applicants/applicant-income-source.model.js

@@ -1,9 +0,0 @@
-import mongoose from "mongoose";
-const applicantIncomeSourceSchema = new mongoose.Schema({
-    employmentStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    incomeFromEmployment: { type: String },
-    incomeFromPension: { type: String },
-    incomeFromProperty: { type: String },
-    incomeFromSavings: { type: String }
-});
-export default applicantIncomeSourceSchema;

package/dist/applicants/applicant-income.model.js

@@ -1,81 +0,0 @@
-import mongoose from "mongoose";
-import { Pound } from "../value-objects/pound";
-const incomeSchema = new mongoose.Schema({
-    accountantsAddressLine1: { type: String, required: true },
-    accountantsAddressLine2: { type: String, required: true },
-    accountantsAddressLine3: { type: String, required: true },
-    accountantsCity: { type: String, default: '' },
-    accountantsCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    accountantsEmail: { type: String, required: true },
-    accountantsPostCode: { type: String, required: true },
-    accountantsPractice: { type: String, required: true },
-    accountantsTelephoneNumber: { type: String, required: true },
-    businessAddressLine1: { type: String, required: true },
-    businessAddressLine2: { type: String, required: true },
-    businessAddressLine3: { type: String, required: true },
-    businessCity: { type: String, default: '' },
-    businessCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    businessPostCode: { type: String, required: true },
-    businessTelephoneNumber: { type: String, required: true },
-    businessTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    charteredCertifiedOrOtherLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    contactName: { type: String, required: true },
-    currentYearEnd: { type: String, required: true },
-    dateEstablished: { type: String, required: true },
-    doYouHaveAccountant: {
-        type: Boolean,
-        required: true,
-    },
-    isBusinessAddressDifferent: {
-        type: Boolean,
-        required: true,
-    },
-    nameOfBusiness: { type: String, required: true },
-    natureOfBusiness: { type: String, required: true },
-    netAssets1: { type: Pound, default: 0.00 },
-    netAssets2: { type: Pound, default: 0.00 },
-    netAssets3: { type: Pound, default: 0.00 },
-    pageValidFlag: { type: String, default: true },
-    percentageOfShareholding: { type: Number, required: true, min: 0, max: 100 },
-    registeredAddressLine1: { type: String, required: true },
-    registeredAddressLine2: { type: String, required: true },
-    registeredAddressLine3: { type: String, required: true },
-    registeredCity: { type: String, default: '' },
-    registeredCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    registeredPostCode: { type: String, required: true },
-    registeredTelephone: { type: String, required: true },
-    selfEmployedDate: { type: String, required: true },
-    turnover1: { type: Pound, default: 0.00 },
-    turnover2: { type: Pound, default: 0.00 },
-    turnover3: { type: Pound, default: 0.00 },
-    year1: { type: Pound, default: 0.00 },
-    year2: { type: Pound, default: 0.00 },
-    year3: { type: Pound, default: 0.00 },
-    yearEnd1: { type: Number, default: '' },
-    yearEnd2: { type: Number, default: '' },
-    yearEnd3: { type: Number, default: '' },
-    totalEmploymentGrossIncome: { type: Pound, default: 0.00 },
-    totalEmploymentNetIncome: { type: Pound, default: 0.00 },
-    isEmploymentIncomeConfirmed: { type: Boolean, default: false },
-    employmentIncomeRationale: { type: String, default: null },
-    totalPensionGrossIncome: { type: Pound, default: 0.00 },
-    totalPensionNetIncome: { type: Pound, default: 0.00 },
-    isPensionIncomeConfirmed: { type: Boolean, default: false },
-    pensionIncomeRationale: { type: String, default: null },
-    totalAdditionalGrossIncome: { type: Pound, default: 0.00 },
-    totalAdditionalNetIncome: { type: Pound, default: 0.00 },
-    isAdditionalIncomeConfirmed: { type: Boolean, default: false },
-    additionalIncomeRationale: { type: String, default: null },
-    totalUKTaxCreditsGrossIncome: { type: Pound, default: 0.00 },
-    totalUKTaxCreditsNetIncome: { type: Pound, default: 0.00 },
-    isUKTaxCreditsIncomeConfirmed: { type: Boolean, default: false },
-    ukTaxCreditsIncomeRationale: { type: String, default: null },
-    totalPropertyGrossIncome: { type: Pound, default: 0.00 },
-    totalPropertyNetIncome: { type: Pound, default: 0.00 },
-    isPropertyIncomeConfirmed: { type: Boolean, default: false },
-    propertyIncomeRationale: { type: String, default: null },
-}, {
-    toJSON: { getters: true },
-    toObject: { getters: true }
-});
-export default incomeSchema;

package/dist/applicants/applicant-risk-narrative.model.js

@@ -1,13 +0,0 @@
-import mongoose from 'mongoose';
-const applicantRiskNarrativeSchema = new mongoose.Schema({
-    call2StatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    clientReference: { type: String },
-    docVerificationStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    isPoaTaskGenerated: { type: String },
-    link: { type: String },
-    riskLevel: { type: String },
-    riskRating: { type: String },
-    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    verificationLinkSentOn: { type: String }
-});
-export default applicantRiskNarrativeSchema;

package/dist/applicants/applicant.model.js

@@ -1,223 +0,0 @@
-import mongoose from "mongoose";
-import applicantCreditDataSchema from "./applicant-credit-data.model";
-import applicantRiskNarrativeSchema from "./applicant-risk-narrative.model";
-import applicantIncomeSourceSchema from "./applicant-income-source.model";
-import applicantEmploymentSchema from "./applicant-employment.model";
-import applicantDirectDebitSchema from "./applicant-direct-debit.model";
-import creditProfileSchema from "./applicant-credit-profile.model";
-import incomeSchema from "./applicant-income.model";
-const applicantSchema = new mongoose.Schema({
-    applicantId: { type: String, required: true },
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
-    addressCity: { type: String, default: null },
-    addressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    addressLine1: { type: String, default: null },
-    addressLine2: { type: String, default: null },
-    addressLine3: { type: String, default: null },
-    addressMovedDate: { type: String, default: null },
-    addressPostCode: { type: String, default: null },
-    correspondenceAddressCity: { type: String, default: null },
-    correspondenceAddressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    correspondenceAddressLine1: { type: String, default: null },
-    correspondenceAddressLine2: { type: String, default: null },
-    correspondenceAddressLine3: { type: String, default: null },
-    correspondenceAddressPostCode: { type: String, default: null },
-    countryOfResidenceLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    dateOfBirth: { type: String, required: true },
-    dependant10Age: { type: Number, default: 0 },
-    dependant1Age: { type: Number, default: 0 },
-    dependant2Age: { type: Number, default: 0 },
-    dependant3Age: { type: Number, default: 0 },
-    dependant4Age: { type: Number, default: 0 },
-    dependant5Age: { type: Number, default: 0 },
-    dependant6Age: { type: Number, default: 0 },
-    dependant7Age: { type: Number, default: 0 },
-    dependant8Age: { type: Number, default: 0 },
-    dependant9Age: { type: Number, default: 0 },
-    email: { type: String, required: true },
-    employmentStatusDetails: { type: String, default: null },
-    firstName: { type: String, required: true },
-    isFirstTimelandlord: {
-        type: Boolean,
-        default: false,
-    },
-    foreignIdForNationals: { type: String, default: null },
-    gdprEmail: {
-        type: Boolean,
-        default: false,
-    },
-    gdprPost: {
-        type: Boolean,
-        default: false,
-    },
-    gdprTelephone: {
-        type: Boolean,
-        default: false,
-    },
-    gdprTextMessage: {
-        type: Boolean,
-        default: false,
-    },
-    gender: { type: String, required: true },
-    hasBrokerGivenConsentForVulnerabilities: {
-        type: Boolean,
-        required: true,
-    },
-    hasLinkedJurisdiction: {
-        type: Boolean,
-        default: false,
-    },
-    isCorrespondence: {
-        type: Boolean,
-        default: true,
-    },
-    isCreditCardCommitmentConfirmed: { type: Boolean, default: false, },
-    isLoanCommitmentConfirmed: { type: Boolean, default: false, },
-    isMortgageHPPCommitmentConfirmed: { type: Boolean, default: false, },
-    isCurrentContract: { type: Boolean, default: false, },
-    isCustomerVulnerable: {
-        type: Boolean,
-        default: false,
-    },
-    isExpat: {
-        type: Boolean,
-        default: false,
-    },
-    isFirstApplicant: {
-        type: Boolean,
-        default: false,
-    },
-    isUkPassport: {
-        type: Boolean,
-        default: false,
-    },
-    isUkResident: {
-        type: Boolean,
-        required: true,
-    },
-    classLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    pageValidFlag: { type: Boolean, default: false },
-    lastName: { type: String, required: true },
-    linkedJurisdictionCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    linkedJurisdictionDetails: { type: String, default: null },
-    maidenName: { type: String, default: null },
-    maritalStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    mobileNumber: { type: String, default: null },
-    nationalityLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    netIncome: { type: Number, default: 0.00 },
-    niNumber: { type: String, required: true },
-    numberOfDependants: { type: Number, default: 0 },
-    isOneYearPrior: {
-        type: Boolean,
-        default: false,
-    },
-    phoneNumber: { type: String, default: null },
-    previous1AddressCity: { type: String, default: null },
-    previous1AddressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    previous1AddressLine1: { type: String, default: null },
-    previous1AddressLine2: { type: String, default: null },
-    previous1AddressLine3: { type: String, default: null },
-    previous1AddressMovedDate: { type: String, default: null },
-    previous1AddressPostCode: { type: String, default: null },
-    previous1AddressPropertyOwnedBy: { type: String, default: null },
-    previous2AddressCity: { type: String, default: null },
-    previous2AddressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    previous2AddressLine1: { type: String, default: null },
-    previous2AddressLine2: { type: String, default: null },
-    previous2AddressLine3: { type: String, default: null },
-    previous2AddressMovedDate: { type: String, default: null },
-    previous2AddressPostCode: { type: String, default: null },
-    previous2AddressPropertyOwnedBy: { type: String, default: null },
-    relationshipToOthers: { type: String, required: true },
-    residentialStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    retirementAge: { type: String, required: true },
-    taxJurisdictionLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    taxPayerLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    timeResidedAtCountryOfResidence: { type: Number, required: true },
-    title: { type: String, required: true },
-    isTwoYearPrior: {
-        type: Boolean,
-        default: false,
-    },
-    understandEnglish: {
-        type: Boolean,
-        required: true,
-    },
-    vulnerabilityNotes: { type: String, default: null },
-    vulnerabilityTypeLids: [{ type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }],
-    ukPassportProfession: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        required: function () {
-            return this.isUkResident;
-        }
-    },
-    creditData: applicantCreditDataSchema,
-    riskNarrative: applicantRiskNarrativeSchema,
-    incomeSource: applicantIncomeSourceSchema,
-    employment: applicantEmploymentSchema,
-    directDebit: applicantDirectDebitSchema,
-    creditProfile: creditProfileSchema,
-    income: incomeSchema
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true, getters: true },
-    toObject: { virtuals: true, getters: true }
-});
-applicantSchema.virtual('nationality').get(function () {
-    return this.nationalityLid?.name ?? null;
-});
-applicantSchema.virtual('residence').get(function () {
-    return this.countryOfResidenceLid?.name ?? null;
-});
-applicantSchema.virtual('industry').get(function () {
-    return this.employment?.industryLid?.name ?? null;
-});
-applicantSchema.virtual('employmentClass').get(function () {
-    return this.classLid?.name ?? null;
-});
-applicantSchema.virtual('addressCountry').get(function () {
-    return this.addressCountryLid?.name ?? null;
-});
-applicantSchema.virtual('previous1AddressCountry').get(function () {
-    return this.previous1AddressCountryLid?.name ?? null;
-});
-applicantSchema.virtual('previous2AddressCountry').get(function () {
-    return this.previous2AddressCountryLid?.name ?? null;
-});
-applicantSchema.virtual('maritalStatus').get(function () {
-    return this.maritalStatusLid?.name ?? null;
-});
-applicantSchema.virtual('residentialStatus').get(function () {
-    return this.residentialStatusLid?.name ?? null;
-});
-applicantSchema.virtual('taxPayer').get(function () {
-    return this.taxPayerLid?.name ?? null;
-});
-applicantSchema.virtual('vulnerabilityType').get(function () {
-    return this.vulnerabilityTypeLids?.map((v) => v.name);
-});
-applicantSchema.virtual('fullName').get(function () {
-    return `${this.firstName ?? ''} ${this.lastName ?? ''}`.trim();
-});
-// virtual property 'applicationType'
-applicantSchema.virtual('applicationType').get(function () {
-    return this.applicationId?.applicationTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationId?.applicationTypeLid?.name || null;
-});
-// virtual property 'lendingType'
-applicantSchema.virtual('lendingType').get(function () {
-    return this.applicationId?.lendingTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationId?.lendingTypeLid?.name || null;
-});
-// numberOfApplicants – how many applicants are on the associated Application
-applicantSchema.virtual('numberOfApplicants').get(function () {
-    // `this.applicationId` must be populated (with its `applicants` field) 
-    const app = this.applicationId;
-    // if it's populated and has an applicants array, return its length, otherwise 0
-    return Array.isArray(app?.applicants) ? app.applicants.length : 0;
-});
-const ApplicantModel = mongoose.model("Applicant", applicantSchema);
-export default ApplicantModel;

package/dist/applicants/index.js

@@ -1,13 +0,0 @@
-export { default as ApplicantModel } from './applicant.model';
-export { default as ApplicantEmploymentIncomeModel } from './applicant-employment-income.model';
-export { default as CreditCardCommitmentModel } from './applicant-commitment-creditCard.model';
-export { default as LoanCommitmentModel } from './applicant-commitment-loan.model';
-export { default as MortgageCommitmentModel } from './applicant-commitment-mortgage.model';
-export { default as ResidenceCommitmentModel } from './applicant-commitment-residence.model';
-export { default as SecuredLoanCommitmentModel } from './applicant-commitment-secureLoan.model';
-export { default as UnsecuredLoanCommitmentModel } from './applicant-commitment-unsecuredLoan.model';
-export { default as ApplicantExpenditureModel } from './applicant-expenditure.model';
-export { default as ApplicantPensionIncomeModel } from './applicant-pension-income.model';
-export { default as ApplicantAdditionalIncomeModel } from './applicant-additional-income.model';
-export { default as ApplicantUKTaxCreditsModel } from './applicant-uk-tax-credits.model';
-export { default as ApplicantPropertyIncomeModel } from './applicant-property-income.model';

package/dist/applications/application-audit.model.js

@@ -1,42 +0,0 @@
-import mongoose from "mongoose";
-const applicationAuditSchema = new mongoose.Schema({
-    auditId: {
-        type: String,
-        required: true
-    },
-    accountId: {
-        type: String,
-        required: true
-    },
-    auditCorrelationId: {
-        type: String,
-        required: true
-    },
-    auditDate: {
-        type: Date,
-        required: true
-    },
-    changeType: {
-        type: String,
-        required: true
-    },
-    applicationId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Application',
-        required: true
-    },
-    name: {
-        type: String,
-        required: true
-    },
-    oldValue: {
-        type: String,
-        required: true
-    },
-    newValue: {
-        type: String,
-        required: true
-    }
-}, { timestamps: true });
-const ApplicationAuditModel = mongoose.model('ApplicationAudit', applicationAuditSchema);
-export default ApplicationAuditModel;

package/dist/applications/application-checklist-Item.model.js

@@ -1,45 +0,0 @@
-import mongoose from "mongoose";
-const checkListItemSchema = new mongoose.Schema({
-    additionalOfferConditions: { type: String, default: "" },
-    appFormSignedNotes: { type: String, default: "" },
-    applicationCompletionDate: { type: String },
-    buildingInsuranceInsurerName: { type: String, default: "" },
-    buildingInsurancePolicyNumber: { type: String, default: "" },
-    buildingInsuranceReceived: { type: String, default: "" },
-    buildingInsuranceRenewalDate: { type: String },
-    dateOfValuationReceived: { type: String },
-    feePaidDocumentsDownloaded: { type: String, default: "" },
-    feePaidNotes: { type: String, default: "" },
-    fundsNotes: { type: String, default: "" },
-    fundsReleasedDate: { type: String },
-    hasAllDocsReviewedAndAccepted: { type: String, default: "" },
-    idnPorReceived: { type: String, default: "" },
-    legalCompletionDate: { type: String },
-    legalDocsReceived: { type: String, default: "" },
-    legalNotes: { type: String, default: "" },
-    ninetyDaysValuationAmount: { type: String, default: "" },
-    offerConditionsItems: { type: String, default: "" },
-    offerConditionsMet: { type: String, default: "" },
-    offerNotes: { type: String, default: "" },
-    offerOfferPrepared: { type: String, default: "" },
-    offerOfferReviewed: { type: String, default: "" },
-    offerSignedNotes: { type: String, default: "" },
-    offerSolicitorInstructedDate: { type: String },
-    packagingNotes: { type: String, default: "" },
-    preOfferNotes: { type: String, default: "" },
-    reinstatementAmount: { type: String, default: "" },
-    rotReceived: { type: String, default: "" },
-    rotReceivedDate: { type: String },
-    salesContractReceived: { type: String, default: "" },
-    underwritingNotes: { type: String, default: "" },
-    underwritingValuationNotes: { type: String, default: "" },
-    valuationAccepted: { type: String },
-    valuationFurtherConditions: { type: String, default: "" },
-    valuationNotes: { type: String, default: "" },
-    valuationReceived: { type: String },
-    valuationRequestedDate: { type: String },
-    valuationScheduledDate: { type: String },
-    valuationSurveyorDetails: { type: String, default: "" }
-});
-const ApplicationCheckListModel = mongoose.model("ApplicationCheckList", checkListItemSchema);
-export default ApplicationCheckListModel;