@dynamatix/gb-schemas 0.0.2

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,76 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  push:
+    branches:
+      - main
+    
+permissions:
+  contents: write
+  
+jobs:
+  version-bump:
+    name: Bump Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.get-version.outputs.version }}
+
+    steps:
+      # Checkout the repository
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      # Read and bump the version in package.json file
+      - name: Determine version
+        id: get-version
+        run: |
+          current_version=$(node -p "require('./package.json').version")
+          # Skip version bump for "docs" or "test" commits
+          if git log -1 --pretty=%B | grep -q -e "(docs):" -e "(test):"; then
+            echo "Skipping version bump for 'docs' or 'test' commit."
+            new_version=$current_version
+          else
+            major=$(echo "$current_version" | cut -d. -f1)
+            minor=$(echo "$current_version" | cut -d. -f2)
+            patch=$(echo "$current_version" | cut -d. -f3)
+            if git log -1 --pretty=%B | grep -q "(BREAKING CHANGE):"; then
+              new_version="$((major + 1)).0.0"
+            elif git log -1 --pretty=%B | grep -q "(feature):"; then
+              new_version="$major.$((minor + 1)).0"
+            elif git log -1 --pretty=%B | grep -q -e "(fix):" -e "(refactor):"; then
+              new_version="$major.$minor.$((patch + 1))"
+            else
+              echo "Error: Commit message does not match required patterns (docs:, test, feature:, fix:, refactor:)."
+              exit 1
+            fi
+            # Update package.json with the new version
+            jq --arg v "$new_version" '.version = $v' ./package.json > temp.json && mv temp.json ./package.json
+            # Commit the updated package.json
+            git config user.name "GitHub Actions"
+            git config user.email "actions@github.com"
+            git add ./package.json
+            git commit -m "Bump version to $new_version"
+            git push
+          fi
+          # Output the new or current version
+          echo "version=$new_version" >> $GITHUB_ENV
+          echo "::set-output name=version::$new_version"
+
+  build-and-publish:
+    runs-on: ubuntu-latest
+    needs: version-bump
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm i --f
+      - run: |
+          npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_ACCESS_TOKEN}}
+

package/applicants/applicant-commitment.model.js

@@ -0,0 +1,13 @@
+
+import mongoose from "mongoose";
+
+const applicantCommitmentSchema = new mongoose.Schema({
+    commitmentId: String,
+    doHaveSharedResponsibility: Boolean,
+    lenderName: String,
+    monthlyPayment: String,
+    commitmentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+});
+
+export default applicantCommitmentSchema;
+

package/applicants/applicant-credit-data.model.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+const applicantCreditDataSchema = new mongoose.Schema({
+    bankruptcy: { type: String },
+    countyCourtJudgment: { type: String },
+    creditDefaults: { type: String },
+    securedArrears: { type: String },
+    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    unsecuredArrears: { type: String },
+    valid: { type: Boolean}
+});
+
+export default applicantCreditDataSchema;

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

@@ -0,0 +1,22 @@
+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/applicants/applicant-direct-debit.model.js

@@ -0,0 +1,19 @@
+import mongoose from 'mongoose';
+
+const applicantDirectDebitSchema = new mongoose.Schema({
+    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: Boolean, default: false },
+    nameOfAccountHolder: { type: String },
+    selectedPaymentDay: { type: Number },
+    sortCode: { type: String }
+}, { timestamps: true });
+
+
+export default applicantDirectDebitSchema;

package/applicants/applicant-employment.model.js

@@ -0,0 +1,53 @@
+import mongoose from "mongoose";
+
+const applicantEmploymentSchema = new mongoose.Schema({
+    acceptableIncome: { type: String },
+    addressCity: { type: String },
+    addressCountryLID: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    addressLine1: { type: String },
+    addressLine2: { type: String },
+    addressLine3: { type: String },
+    addressPostCode: { type: String },
+
+    averageBonusPreviousTwoYears: { type: String },
+    basicGrossIncome: { type: String },
+    basicPay: { type: String },
+    carAllowance: { type: String },
+    childBenefit: { type: String },
+    childBenefitOrSchoolAllowance: { type: String },
+
+    classLID: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    contractRemaining: { type: String },
+    dateJoined: { type: Date },
+    disabilityLiving: { type: String },
+    employerName: { type: String },
+    employerTelephone: { type: String },
+    housingAllowance: { type: String },
+    industryLID: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    isUnderTerminationNotice: { type: Boolean, default: null  },
+    jobTitle: { type: String },
+    maintenance: { type: String },
+    maternityIncome: { type: String },
+    natureOfBusiness: { type: String },
+    pensionIncome: { type: String },
+    previousAddressCity: { type: String },
+    previousAddressCountry: { type: String },
+    previousAddressLine1: { type: String },
+    previousAddressLine2: { type: String },
+    previousAddressLine3: { type: String },
+    previousAddressPostCode: { type: String },
+    previousBasicGrossIncome: { type: String },
+    previousDateJoined: { type: Date },
+    previousDateLeft: { type: Date },
+    previousEmployerName: { type: String },
+    previousEmployerTelephone: { type: String },
+    previousJobTitle: { type: String },
+    previousNatureOfBusiness: { type: String },
+    referenceContact: { type: String },
+    referenceContactEmail: { type: String },
+    secondJob: { type: String },
+    travelAllowance: { type: String },
+    underTerminationNoticeNote: { type: String }
+});
+
+export default applicantEmploymentSchema;

package/applicants/applicant-expenditure.model.js

@@ -0,0 +1,12 @@
+import mongoose from "mongoose";
+
+const applicantExpenditureSchema = new mongoose.Schema({
+    childCareForDependents: { type: Number },
+    insurance: { type: Number },
+    other: { type: Number },
+    totalMonthlyExpenditure: { type: Number },
+    transport: { type: Number },
+    utilities: { type: Number }
+});
+
+export default applicantExpenditureSchema;

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

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

package/applicants/applicant-income.model.js

@@ -0,0 +1,53 @@
+import mongoose from "mongoose";
+
+const incomeSchema = new mongoose.Schema({
+    accountantsAddressLine1: { type: String, default: '' },
+    accountantsAddressLine2: { type: String, default: '' },
+    accountantsAddressLine3: { type: String, default: '' },
+    accountantsCity: { type: String, default: '' },
+    accountantsCountry: { type: String, default: 'GBR' },
+    accountantsEmail: { type: String, default: '' },
+    accountantsPostCode: { type: String, default: '' },
+    accountantsPractice: { type: String, default: '' },
+    accountantsTelephoneNumber: { type: String, default: '' },
+    businessAddressLine1: { type: String, default: '' },
+    businessAddressLine2: { type: String, default: '' },
+    businessAddressLine3: { type: String, default: '' },
+    businessCity: { type: String, default: '' },
+    businessCountry: { type: String, default: 'GBR' },
+    businessPostCode: { type: String, default: '' },
+    businessTelephoneNumber: { type: String, default: '' },
+    businessType: { type: String, default: '4' },
+    charteredCertifiedOrOther: { type: String, default: '' },
+    contactName: { type: String, default: '' },
+    currentYearEnd: { type: Date, default: null },
+    dateEstablished: { type: Date, default: null },
+    doYouHaveAccountant: { type: Boolean, default: false },
+    isBusinessAddressDifferent: { type: Boolean, default: false },
+    nameOfBusiness: { type: String, default: '' },
+    natureOfBusiness: { type: String, default: '' },
+    netAssets1: { type: Number, default: 0.0 },
+    netAssets2: { type: Number, default: 0.0 },
+    netAssets3: { type: Number, default: 0.0 },
+    pageValidFlag: { type: Boolean, default: true },
+    percentageOfShareholding: { type: Number, default: 100 },
+    registeredAddressLine1: { type: String, default: '' },
+    registeredAddressLine2: { type: String, default: '' },
+    registeredAddressLine3: { type: String, default: '' },
+    registeredCity: { type: String, default: '' },
+    registeredCountry: { type: String, default: 'GBR' },
+    registeredPostCode: { type: String, default: '' },
+    registeredTelephone: { type: String, default: '' },
+    selfEmployedDate: { type: Date, default: null },
+    turnover1: { type: Number, default: 0.0 },
+    turnover2: { type: Number, default: 0.0 },
+    turnover3: { type: Number, default: 0.0 },
+    year1: { type: Number, default: 0.0 },
+    year2: { type: Number, default: 0.0 },
+    year3: { type: Number, default: 0.0 },
+    yearEnd1: { type: String, default: '' },
+    yearEnd2: { type: String, default: '' },
+    yearEnd3: { type: String, default: '' }
+});
+
+export default incomeSchema;

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

@@ -0,0 +1,25 @@
+import mongoose from "mongoose";
+
+const applicantOtherIncomeSchema = new mongoose.Schema({
+    amount1: { type: Number },
+    amount2: { type: Number },
+    amount3: { type: Number },
+    amount4: { type: Number },
+    guaranteed1: { type: Boolean },
+    guaranteed2: { type: Boolean },
+    guaranteed3: { type: Boolean },
+    guaranteed4: { type: Boolean },
+    maintenance: { type: String },
+    otherBenefits: { type: String },
+    payFrequency1: { type: String },
+    payFrequency2: { type: String },
+    payFrequency3: { type: String },
+    payFrequency4: { type: String },
+    sourceDetails1: { type: String },
+    sourceDetails2: { type: String },
+    sourceDetails3: { type: String },
+    sourceDetails4: { type: String },
+    taxCredits: { type: String }
+});
+
+export default applicantOtherIncomeSchema;

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

@@ -0,0 +1,15 @@
+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: Boolean },
+    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/applicants/applicant.model.js

@@ -0,0 +1,110 @@
+import mongoose from "mongoose";
+import applicantCreditDataSchema from "./applicant-credit-data.model.js";
+import applicantRiskNarrativeSchema from "./applicant-risk-narrative.model.js";
+import applicantOtherIncomeSchema from "./applicant-other-income.model.js";
+import applicantIncomeSourceSchema from "./applicant-income-source.model.js";
+import applicantExpenditureSchema from "./applicant-expenditure.model.js";
+import applicantEmploymentSchema from "./applicant-employment.model.js";
+import applicantCommitmentSchema from "./applicant-commitment.model.js";
+import applicantDirectDebitSchema from "./applicant-direct-debit.model.js";
+import creditProfileSchema from "./applicant-credit-profile.model.js";
+import incomeSchema from "./applicant-income.model.js";
+
+const applicantSchema = new mongoose.Schema({
+    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: Date, default: null },
+    addressPostCode: { type: String, default: null },
+    correspondenceAddressCity: { type: String, default: null },
+    correspondenceAddressCountry: { type: String, 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", default: null },
+    dateOfBirth: { type: Date, default: null },
+    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, default: null },
+    employmentStatusDetails: { type: String, default: null },
+    firstName: { type: String, default: null },
+    isFirstTimelandlord: { type: Boolean, default: false },
+    foreignNationalsId: { 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, default: null },
+    hasBrokerGivenConsentForVulnerabilities: { type: String, default: null },
+    hasLinkedJurisdiction: { type: Boolean, default: false },
+    isCorrespondence: { type: Boolean, default: true },
+    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, default: true },
+    lastName: { type: String, default: null },
+    linkedJurisdictionCountry: { type: String, default: null },
+    linkedJurisdictionDetails: { type: String, default: null },
+    maidenName: { type: String, default: null },
+    maritalStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    mobileNumber: { type: String, default: null },
+    nationalityLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    netIncome: { type: String },
+    niNumber: { type: String, default: null },
+    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: Date, 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: Date, default: null },
+    previous2AddressPostCode: { type: String, default: null },
+    previous2AddressPropertyOwnedBy: { type: String, default: null },
+    relationshipToOthersLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    residentialStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    retirementAge: { type: Number, default: 0 },
+    taxJurisdiction: { type: String, default: null },
+    taxPayerLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    timeResidedAtCountryOfResidence: { type: String, default: null },
+    title: { type: String, default: null },
+    isTwoYearPrior: { type: Boolean, default: false },
+    understandEnglish: { type: Boolean, default: true },
+    vulnerabilityNotes: { type: String, default: null },
+    VulnerabilityTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    creditData: applicantCreditDataSchema,
+    riskNarrative: applicantRiskNarrativeSchema,
+    otherIncome: applicantOtherIncomeSchema,
+    incomeSource: applicantIncomeSourceSchema,
+    expenditure: applicantExpenditureSchema,
+    employment: applicantEmploymentSchema,
+    commitments:[applicantCommitmentSchema],
+    directDebit: applicantDirectDebitSchema,
+    creditProfile: creditProfileSchema,
+    income: incomeSchema
+});
+
+const ApplicantModel = mongoose.model("Applicant", applicantSchema);
+export default ApplicantModel;

package/applications/application-audit.model.js

@@ -0,0 +1,47 @@
+import mongoose from "mongoose";
+
+const applicationAuditSchema = new mongoose.Schema({
+    auditId: {
+        type: Number,
+        required: true
+    },
+    accountId: {
+        type: Number,
+        required: true
+    },
+    auditCorrelationId: {
+        type: String,
+        required: true
+    },
+    auditDate: {
+        type: Date,
+        required: true
+    },
+    changeType: {
+        type: Number,
+        required: true
+    },
+    formEntityId: {
+        type: String,
+        required: false
+    },
+    formEntityDescription: {
+        type: String,
+        required: false
+    },
+    name: {
+        type: String,
+        required: true
+    },
+    oldValue: {
+        type: String,
+        required: true
+    },
+    newValue: {
+        type: String,
+        required: true
+    }
+});
+
+const ApplicationAuditModel = mongoose.model('ApplicationAudit', applicationAuditSchema);
+export default ApplicationAuditModel;

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

@@ -0,0 +1,47 @@
+import mongoose from "mongoose";
+
+const checkListItemSchema = new mongoose.Schema({
+  additionalOfferConditions: { type: String, default: "" },
+  appFormSignedNotes: { type: String, default: "" },
+  applicationCompletionDate: { type: Date },
+  buildingInsuranceInsurerName: { type: String, default: "" },
+  buildingInsurancePolicyNumber: { type: String, default: "" },
+  buildingInsuranceReceived: { type: String, default: "" },
+  buildingInsuranceRenewalDate: { type: Date },
+  dateOfValuationReceived: { type: Date },
+  feePaidDocumentsDownloaded: { type: String, default: "" },
+  feePaidNotes: { type: String, default: "" },
+  fundsNotes: { type: String, default: "" },
+  fundsReleasedDate: { type: Date },
+  hasAllDocsReviewedAndAccepted: { type: String, default: "" },
+  idnPorReceived: { type: String, default: "" },
+  legalCompletionDate: { type: Date },
+  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: Date },
+  packagingNotes: { type: String, default: "" },
+  preOfferNotes: { type: String, default: "" },
+  reinstatementAmount: { type: String, default: "" },
+  rotReceived: { type: String, default: "" },
+  rotReceivedDate: { type: Date },
+  salesContractReceived: { type: String, default: "" },
+  underwritingNotes: { type: String, default: "" },
+  underwritingValuationNotes: { type: String, default: "" },
+  valuationAccepted: { type: Date },
+  valuationFurtherConditions: { type: String, default: "" },
+  valuationNotes: { type: String, default: "" },
+  valuationReceived: { type: Date },
+  valuationRequestedDate: { type: Date },
+  valuationScheduledDate: { type: Date },
+  valuationSurveyorDetails: { type: String, default: "" }
+});
+
+const CheckListModel = mongoose.model("CheckList", checkListItemSchema);
+export default CheckListModel;

package/applications/application-company-model.js

@@ -0,0 +1,29 @@
+import mongoose from "mongoose";
+
+const companySchema = new mongoose.Schema({
+  addressCity: { type: String, default: "" },
+  addressCountry: { type: String, default: "" },
+  addressLine1: { type: String, default: "" },
+  addressLine2: { type: String, default: "" },
+  addressLine3: { type: String, default: "" },
+  addressPostCode: { type: String, default: "" },
+  businessType: { type: String, default: "" },
+  doYouKnowRegisteredNumber: { type: Boolean, default: false }, // e.g., true or false
+  natureOfBusiness: { type: String, default: "" },
+  netProfitYear1: { type: Number }, // e.g., 50000
+  netProfitYear2: { type: Number }, // e.g., 75000
+  netProfitYear3: { type: Number }, // e.g., 100000
+  registeredName: { type: String, default: "" },
+  registeredNumber: { type: String, default: "" },
+  taxJurisdiction: { type: String, default: "" },
+  tradingSince: { type: Date }, // e.g., "2020-01-01"
+  turnoverYear1: { type: Number }, // e.g., 100000
+  turnoverYear2: { type: Number }, // e.g., 150000
+  turnoverYear3: { type: Number }, // e.g., 200000
+  yearEnd: { type: Date }, // e.g., "2023-12-31"
+  yearEnd1: { type: Number }, // e.g., 2021
+  yearEnd2: { type: Number }, // e.g., 2022
+  yearEnd3: { type: Number } // e.g., 2023
+});
+const CompanyModel = mongoose.model("Company", companySchema);
+export default CompanyModel;

package/applications/application-credit-profile.model.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+
+const creditProfileSchema = new mongoose.Schema({
+  companyAnyVoluntaryEnforcedPossessionNo: { type: Boolean, default: false }, 
+  companyAnyVoluntaryEnforcedPossessionYes: { type: String, default: "" },   
+  companyBankruptcyNo: { type: Boolean, default: false },                    
+  companyBankruptcyYes: { type: String, default: "" },                      
+  companyCCJInLastThreeYearNo: { type: Boolean, default: false },            
+  companyCCJInLastThreeYearYes: { type: String, default: "" },               
+  companyDefaultsInLastYearNo: { type: Boolean, default: false },           
+  companyDefaultsInLastYearYes: { type: String, default: "" }           
+});
+const CreditProfileModel = mongoose.model("CreditProfile", creditProfileSchema);
+export default CreditProfileModel;

package/applications/application-illustration-model.js

@@ -0,0 +1,8 @@
+import mongoose from "mongoose";
+
+const illustrationSchema = new mongoose.Schema({
+  date: { type: Date } // e.g., the date of illustration
+});
+
+const IllustrationModel = mongoose.model("Illustration", illustrationSchema);
+export default IllustrationModel;

package/applications/application-legal.model.js

@@ -0,0 +1,8 @@
+import mongoose from "mongoose";
+
+const legalSchema = new mongoose.Schema({
+  assignedSolicitor: { type: String, default: "" }, 
+  solicitorsReference: { type: String, default: "" } 
+});
+const LegalModel = mongoose.model("Legal", legalSchema);
+export default LegalModel;

package/applications/application-mortgage.model.js

@@ -0,0 +1,31 @@
+import mongoose from "mongoose";
+
+const mortgageSchema = new mongoose.Schema({
+    depositComeFrom: { type: String, required: true },          
+    estimatedValue: { type: String, default: "" },
+    exitStrategy: { type: String, required: true },             
+    fundRaisedFor: { type: String, default: "" },
+    giftDetails: { type: String, default: "" },
+    ifOtherDetails: { type: String, default: "" },
+    isDistressedSale: { type: Boolean, default: false },            
+    isGovernmentInitiative: { type: Boolean, default: false },      
+    isPurchasedAsSale: { type: Boolean, default: false },           
+    isPurchasedBelowMarketValue: { type: Boolean, default: false }, 
+    isReadyToSell: { type: Boolean, default: true },                
+    isTheIntentionToLet: { type: Boolean, default: true },          
+    leaseTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    loanRequired: { type: Number, required: true },                
+    monthlyRentalIncome: { type: Number, required: true },          
+    propertyValuationDetails: { type: String, default: "" },
+    proposedTenants: { type: String },
+    purchasePrice: { type: Number, required: true },              
+    repaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    repaymentVehicle: { type: String, default: "" },
+    saleMade: { type: String, default: "" },
+    sourceOfFundDetails: { type: String, default: "" },
+    sourceOfFundsLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    telephoneNumber: { type: String, required: true },              
+    vendorsName: { type: String, default: "" }
+});
+
+export default mortgageSchema;