@dynamatix/gb-schemas 0.21.6 → 0.21.8

package/applicants/applicant-commitment.model.js

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

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

@@ -7,7 +7,7 @@ const applicantCreditDataSchema = new mongoose.Schema({
     securedArrears: { type: String },
     statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
     unsecuredArrears: { type: String },
-    valid: { type: Boolean}
+    valid: { type: String}
 });
 
 export default applicantCreditDataSchema;

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

@@ -9,9 +9,9 @@ const applicantDirectDebitSchema = new mongoose.Schema({
     city: { type: String },
     contactPostcode: { type: String },
     institution: { type: String },
-    isConfirmDeclaration: { type: Boolean, default: false },
+    isConfirmDeclaration: { type: String, default: false },
     nameOfAccountHolder: { type: String },
-    selectedPaymentDay: { type: Number },
+    selectedPaymentDay: { type: String },
     sortCode: { type: String }
 }, { timestamps: true });
 

package/applicants/applicant-employment.model.js

@@ -24,7 +24,7 @@ const applicantEmploymentSchema = new mongoose.Schema({
     employerTelephone: { type: String },
     housingAllowance: { type: String },
     industryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    isUnderTerminationNotice: { type: Boolean, default: null  },
+    isUnderTerminationNotice: { type: String, default: null  },
     jobTitle: { type: String },
     maintenance: { type: String },
     maternityIncome: { type: String },

package/applicants/applicant-expenditure.model.js

@@ -1,12 +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 }
+    childCareForDependents: { type: String },
+    insurance: { type: String },
+    other: { type: String },
+    totalMonthlyExpenditure: { type: String },
+    transport: { type: String },
+    utilities: { type: String }
 });
 
 export default applicantExpenditureSchema;

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

@@ -2,10 +2,10 @@ 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 }
+    incomeFromEmployment: { type: String },
+    incomeFromPension: { type: String },
+    incomeFromProperty: { type: String },
+    incomeFromSavings: { type: String }
 });
 
 export default applicantIncomeSourceSchema;

package/applicants/applicant-income.model.js

@@ -22,15 +22,15 @@ const incomeSchema = new mongoose.Schema({
     contactName: { type: String, default: '' },
     currentYearEnd: { type: Date, default: null },
     dateEstablished: { type: Date, default: null },
-    doYouHaveAccountant: { type: Boolean, default: false },
-    isBusinessAddressDifferent: { type: Boolean, default: false },
+    doYouHaveAccountant: { type: String, default: false },
+    isBusinessAddressDifferent: { type: String, 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 },
+    netAssets1: { type: String, default: 0.0 },
+    netAssets2: { type: String, default: 0.0 },
+    netAssets3: { type: String, default: 0.0 },
+    pageValidFlag: { type: String, default: true },
+    percentageOfShareholding: { type: String, default: 100 },
     registeredAddressLine1: { type: String, default: '' },
     registeredAddressLine2: { type: String, default: '' },
     registeredAddressLine3: { type: String, default: '' },
@@ -39,12 +39,12 @@ const incomeSchema = new mongoose.Schema({
     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 },
+    turnover1: { type: String, default: 0.0 },
+    turnover2: { type: String, default: 0.0 },
+    turnover3: { type: String, default: 0.0 },
+    year1: { type: String, default: 0.0 },
+    year2: { type: String, default: 0.0 },
+    year3: { type: String, default: 0.0 },
     yearEnd1: { type: String, default: '' },
     yearEnd2: { type: String, default: '' },
     yearEnd3: { type: String, default: '' }

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

@@ -1,14 +1,14 @@
 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 },
+    amount1: { type: String },
+    amount2: { type: String },
+    amount3: { type: String },
+    amount4: { type: String },
+    guaranteed1: { type: String },
+    guaranteed2: { type: String },
+    guaranteed3: { type: String },
+    guaranteed4: { type: String },
     maintenance: { type: String },
     otherBenefits: { type: String },
     payFrequency1: { type: String },

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

@@ -4,7 +4,7 @@ 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 },
+    isPoaTaskGenerated: { type: String },
     link: { type: String },
     riskLevel: { type: String },
     riskRating: { type: String },

package/applicants/applicant.model.js

@@ -28,35 +28,35 @@ const applicantSchema = new mongoose.Schema({
     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 },
+    dependant10Age: { type: String, default: 0 },
+    dependant1Age: { type: String, default: 0 },
+    dependant2Age: { type: String, default: 0 },
+    dependant3Age: { type: String, default: 0 },
+    dependant4Age: { type: String, default: 0 },
+    dependant5Age: { type: String, default: 0 },
+    dependant6Age: { type: String, default: 0 },
+    dependant7Age: { type: String, default: 0 },
+    dependant8Age: { type: String, default: 0 },
+    dependant9Age: { type: String, default: 0 },
     email: { type: String, default: null },
     employmentStatusDetails: { type: String, default: null },
     firstName: { type: String, default: null },
-    isFirstTimelandlord: { type: Boolean, default: false },
+    isFirstTimelandlord: { type: String, 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 },
+    gdprEmail: { type: String, default: false },
+    gdprPost: { type: String, default: false },
+    gdprTelephone: { type: String, default: false },
+    gdprTextMessage: { type: String, 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 },
+    hasLinkedJurisdiction: { type: String, default: false },
+    isCorrespondence: { type: String, default: true },
+    isCurrentContract: { type: String, default: false },
+    isCustomerVulnerable: { type: String, default: false },
+    isExpat: { type: String, default: false },
+    isFirstApplicant: { type: String, default: false },
+    isUkPassport: { type: String, default: false },
+    isUkResident: { type: String, default: true },
     lastName: { type: String, default: null },
     linkedJurisdictionCountry: { type: String, default: null },
     linkedJurisdictionDetails: { type: String, default: null },
@@ -66,8 +66,8 @@ const applicantSchema = new mongoose.Schema({
     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 },
+    numberOfDependants: { type: String, default: 0 },
+    isOneYearPrior: { type: String, default: false },
     phoneNumber: { type: String, default: null },
     previous1AddressCity: { type: String, default: null },
     previous1AddressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
@@ -87,13 +87,13 @@ const applicantSchema = new mongoose.Schema({
     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 },
+    retirementAge: { type: String, 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 },
+    isTwoYearPrior: { type: String, default: false },
+    understandEnglish: { type: String, default: true },
     vulnerabilityNotes: { type: String, default: null },
     VulnerabilityTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
     creditData: applicantCreditDataSchema,

package/applications/application-audit.model.js

@@ -3,11 +3,11 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const applicationAuditSchema = new mongoose.Schema({
     auditId: {
-        type: Number,
+        type: String,
         required: true
     },
     accountId: {
-        type: Number,
+        type: String,
         required: true
     },
     auditCorrelationId: {
@@ -19,7 +19,7 @@ const applicationAuditSchema = new mongoose.Schema({
         required: true
     },
     changeType: {
-        type: Number,
+        type: String,
         required: true
     },
     applicationId: {

package/applications/application-company-model.js

@@ -9,28 +9,28 @@ const companySchema = new mongoose.Schema({
   addressLine3: { type: String, default: "" },
   addressPostCode: { type: String, default: "" },
   businessType: { type: String, default: "" },
-  doYouKnowRegisteredNumber: { type: Boolean, default: false }, // e.g., true or false
+  doYouKnowRegisteredNumber: { type: String, 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
+  netProfitYear1: { type: String, }, // e.g., 50000
+  netProfitYear2: { type: String, }, // e.g., 75000
+  netProfitYear3: { type: String, }, // 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
+  turnoverYear1: { type: String }, // e.g., 100000
+  turnoverYear2: { type: String }, // e.g., 150000
+  turnoverYear3: { type: String }, // 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
+  yearEnd1: { type: String }, // e.g., 2021
+  yearEnd2: { type: String }, // e.g., 2022
+  yearEnd3: { type: String }, // e.g., 2023
   sicCodes: [{ type: String, default: "" }], // e.g., "12345"
   epc: { type: String, default: "" }, // e.g., "A"
   tenure: { type: String, default: "" }, // e.g., "Leasehold"
   remainingLease: { type: String, default: "" }, // e.g., "85 years"
   dateOfIncorporation: { type: Date }, // e.g., "2010-06-15"
-  existingMortgage: {type: Number } // e.g., "2"
+  existingMortgage: {type: String } // e.g., "2"
 });
 
 companySchema.plugin(mongooseEncryption);

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

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

package/applications/application-direct-debit.model.js

@@ -9,9 +9,9 @@ const directDebitSchema = new mongoose.Schema({
   city: { type: String, default: "" }, 
   contactPostcode: { type: String, default: "" }, 
   institution: { type: String, default: "" }, 
-  isConfirmDeclaration: { type: Boolean, default: false }, 
+  isConfirmDeclaration: { type: String, default: false }, 
   nameOfAccountHolder: { type: String, default: "" }, 
-  selectedPaymentDay: { type: Number, default: null }, 
+  selectedPaymentDay: { type: String, default: null }, 
   sortCode: { type: String, default: "" }, 
   
 });

package/applications/application-document.model.js

@@ -14,17 +14,17 @@ const documentSchema = new mongoose.Schema({
         ref: "Lookup",
         required: false,
     },
-    documentTypeId: { type: Number, required: false },
+    documentTypeId: { type: String, required: false },
     fileName: { type: String, required: false },
     contentType: { type: String, required: false },
     created: { type: Date, required: false },
-    createdBy: { type: Number, required: false },
-    isGenerated: { type: Boolean, 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: Number, required: false },
+        documentTypeId: { type: String, required: false },
         displayName: { type: String, required: false },
         value: { type: String, required: false },
         data: { type: Object, required: false },

package/applications/application-fieldconfig.model.js

@@ -3,7 +3,7 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const fieldConfigSchema = new mongoose.Schema({
     fieldName: { type: String, required: true, unique: true },
-    validateProductOnChange: { type: Boolean, default: true }
+    validateProductOnChange: { type: String, default: true }
 });
 
 

package/applications/application-mortgage.model.js

@@ -8,18 +8,18 @@ const mortgageSchema = new mongoose.Schema({
     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 },          
+    isDistressedSale: { type: String, default: false },            
+    isGovernmentInitiative: { type: String, default: false },      
+    isPurchasedAsSale: { type: String, default: false },           
+    isPurchasedBelowMarketValue: { type: String, default: false }, 
+    isReadyToSell: { type: String, default: true },                
+    isTheIntentionToLet: { type: String, default: true },          
     leaseTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    loanRequired: { type: Number, required: true },                
-    monthlyRentalIncome: { type: Number, required: true },          
+    loanRequired: { type: String, required: true },                
+    monthlyRentalIncome: { type: String, required: true },          
     propertyValuationDetails: { type: String, default: "" },
     proposedTenants: { type: String },
-    purchasePrice: { type: Number, required: true },              
+    purchasePrice: { type: String, required: true },              
     repaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
     repaymentVehicle: { type: String, default: "" },
     saleMade: { type: String, default: "" },

package/applications/application-note.model.js

@@ -12,7 +12,7 @@ const noteSchema = new mongoose.Schema({
         default: null
     },
     createdBy: {
-        type: Number,
+        type: String,
         default: null
     },
     createdByUserId: {
@@ -41,7 +41,7 @@ const noteSchema = new mongoose.Schema({
         default: ''
     },
     autoCreated: {
-        type: Boolean,
+        type: String,
         default: false
     },
     additionalData: {
@@ -57,7 +57,7 @@ const noteSchema = new mongoose.Schema({
         default: ''
     },
     assignedBy: {
-        type: Number,
+        type: String,
         default: null
     },
     assignedByUserId: {

package/applications/application-product.model.js

@@ -1,7 +1,7 @@
 import mongoose from "mongoose";
 
 const productSchema = new mongoose.Schema({
-  numberOfYearsToRepay: { type: Number, default: 0 }, 
+  numberOfYearsToRepay: { type: String, default: 0 }, 
   productFeePaymentType: { type: String, default: "" }, 
   selectedProduct: { type: String, default: "" } 
 });

package/applications/application-valuation.model.js

@@ -1,15 +1,15 @@
 import mongoose from "mongoose";
 
 const valuationSchema = new mongoose.Schema({
-  amount: { type: Number }, 
+  amount: { type: String }, 
   epcRating: { type: String, default: "" },
-  epcScore: { type: Number }, 
-  estimatedRentalValue: { type: Number }, 
+  epcScore: { type: String }, 
+  estimatedRentalValue: { type: String }, 
   instructionId: { type: String, default: "" }, 
   instructionStatus: { type: String, default: "" },
   instructionStatusComment: { type: String, default: "" },
-  isManual: { type: Boolean, default: false },
-  squareMetres: { type: Number }, 
+  isManual: { type: String, default: false },
+  squareMetres: { type: String }, 
   valuerNotes: { type: String, default: "" }, 
   version: { type: String, default: "" } 
 });

package/applications/application.model.js

@@ -13,24 +13,24 @@ const applicationSchema = new mongoose.Schema(
     }],
     assignedToUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
     applicationId: { type: String, required: true },
-    isApplicationFeePaid: { type: Boolean, 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: Boolean, default: false },
+    caseManagerAccepted: { type: String, default: false },
     completedReason: { type: String, default: "" },
-    isIntendToOccupy: { type: Boolean, required: true },
+    isIntendToOccupy: { type: String, required: true },
     introducer: { type: String, default: "" },
-    isIntroducerSubmission: { type: Boolean, required: true },
-    isBrokerAssigned: { type: Boolean, default: false },
-    isFinanceRecommendedToApplicant: { type: Boolean, required: true },
-    isWorkflowTaskCreated: { type: Boolean, required: true },
+    isIntroducerSubmission: { type: String, required: true },
+    isBrokerAssigned: { type: String, default: false },
+    isFinanceRecommendedToApplicant: { type: String, required: true },
+    isWorkflowTaskCreated: { type: String, required: true },
     lastUpdated: { type: Date },
     lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
     networkClubName: { type: String, default: "" },
-    isNetworkClubSubmission: { type: Boolean, required: true },
+    isNetworkClubSubmission: { type: String, required: true },
     newReason: { type: String, default: "" },
     purchaseTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
     rejectedReason: { type: String, default: "" },
@@ -46,7 +46,7 @@ const applicationSchema = new mongoose.Schema(
     submitReason: { type: String, default: "" },
     submittedDate: { type: Date },
     underwriter: { type: String, default: "" },
-    isValuationFeePaid: { type: Boolean, required: true },
+    isValuationFeePaid: { type: String, required: true },
     withdrawalReason: { type: String, default: "" },
     withdrawalReasonCode: { type: String, default: "" },
     productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product", required: false },
@@ -58,16 +58,16 @@ const applicationSchema = new mongoose.Schema(
     ],
     statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
     submittedDate: { type: Date },
-    isValuationFeePaid: { type: Boolean, required: true },
-    isActive: { type: Boolean, default: false },
-    isUkResident: { type: Boolean, default: true },
+    isValuationFeePaid: { type: String, required: true },
+    isActive: { type: String, default: false },
+    isUkResident: { type: String, default: true },
     riskRating: { type: String },
     directDebit: directDebitSchema,
     creditProfile: creditProfileSchema,
     mortgage: mortgageSchema,
     companyId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationCompany" },
     rationaleId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationRationale" },
-    newAuditRecordsCount: { type: Number, default: 0 } // Ensure it is a Number
+    newAuditRecordsCount: { type: String, default: 0 } // Ensure it is a Number
   },
   {
     timestamps: true,

package/applications/broker.model.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose";
 import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const brokerSchema = new mongoose.Schema({
-    brokerId: { type: Number },
+    brokerId: { type: String },
     landlinePhone: { type: String },
     mobileTelephone: { type: String },
     addressPostCode: { type: String },

package/applications/document.model.js

@@ -18,13 +18,13 @@ const documentSchema = new mongoose.Schema({
     fileName: { type: String, required: false },
     contentType: { type: String, required: false },
     created: { type: Date, required: false },
-    createdBy: { type: Number, required: false },
-    isGenerated: { type: Boolean, 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: Number, required: false },
+        documentTypeId: { type: String, required: false },
         displayName: { type: String, required: false },
         value: { type: String, required: false },
         data: { type: Object, required: false },

package/applications/productfeatures.model.js

@@ -4,87 +4,87 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 const feeSchema = new mongoose.Schema({
     feeType: { type: String, required: true },
     description: { type: String, required: true },
-    feeAmount: { type: Number, required: true },
-    rate: { type: Number, default: 0 },
-    addedToLoan: { type: Boolean, default: false },
-    allowOverride: { type: Boolean, default: false },
+    feeAmount: { type: String, required: true },
+    rate: { type: String, default: 0 },
+    addedToLoan: { type: String, default: false },
+    allowOverride: { type: String, default: false },
     additionalData: { type: mongoose.Schema.Types.Mixed, default: null }
 });
 
 const cashflowPeriodSchema = new mongoose.Schema({
-    from: { type: Number, default: null },
-    to: { type: Number, default: null },
-    instalmentAmount: { type: Number, default: null },
-    instalmentInterest: { type: Number, default: null },
-    instalmentCapitalRepaid: { type: Number, default: null },
-    otherCosts: { type: Number, default: 0 },
-    outstandingCapital: { type: Number, default: null }
+    from: { type: String, default: null },
+    to: { type: String, default: null },
+    instalmentAmount: { type: String, default: null },
+    instalmentInterest: { type: String, default: null },
+    instalmentCapitalRepaid: { type: String, default: null },
+    otherCosts: { type: String, default: 0 },
+    outstandingCapital: { type: String, default: null }
 });
 
 const calculationsSchema = new mongoose.Schema({
-    ltv: { type: Number, default: null },
-    rentalCoverageRatioRate: { type: Number, default: null },
-    bankContributionRate: { type: Number, default: null },
-    bankInitialShareRate: { type: Number, default: null },
-    totalAmountPayable: { type: Number, default: null },
-    fixedMonthlyPayment: { type: Number, default: null },
-    fixedMonthlyCapital: { type: Number, default: null },
-    fixedMonthlyInterest: { type: Number, default: null },
-    variableMonthlyPayment: { type: Number, default: null },
-    summaryTotal: { type: Number, default: null },
-    reimbursementPerPound: { type: Number, default: null },
-    stressedPayment: { type: Number, default: null },
-    stressedPaymentRate: { type: Number, default: null },
-    rentalCoverage: { type: Number, default: null },
-    rentalCoverageWithoutTopUp: { type: Number, default: null }
+    ltv: { type: String, default: null },
+    rentalCoverageRatioRate: { type: String, default: null },
+    bankContributionRate: { type: String, default: null },
+    bankInitialShareRate: { type: String, default: null },
+    totalAmountPayable: { type: String, default: null },
+    fixedMonthlyPayment: { type: String, default: null },
+    fixedMonthlyCapital: { type: String, default: null },
+    fixedMonthlyInterest: { type: String, default: null },
+    variableMonthlyPayment: { type: String, default: null },
+    summaryTotal: { type: String, default: null },
+    reimbursementPerPound: { type: String, default: null },
+    stressedPayment: { type: String, default: null },
+    stressedPaymentRate: { type: String, default: null },
+    rentalCoverage: { type: String, default: null },
+    rentalCoverageWithoutTopUp: { type: String, default: null }
 });
 
 const productFeaturesSchema = new mongoose.Schema({
     name: { type: String, required: true },
-    clientAdvance: { type: Number, required: true },
-    ltv: { type: Number, required: true },
-    repayment: { type: Number, required: true },
-    variableRepayment: { type: Number, required: true },
-    reversionRateWithoutBaseRate: { type: Number, default: null },
-    totalReversionRate: { type: Number, default: null },
-    initialRate: { type: Number, required: true },
-    fixedTerm: { type: Number, required: true },
+    clientAdvance: { type: String, required: true },
+    ltv: { type: String, required: true },
+    repayment: { type: String, required: true },
+    variableRepayment: { type: String, required: true },
+    reversionRateWithoutBaseRate: { type: String, default: null },
+    totalReversionRate: { type: String, default: null },
+    initialRate: { type: String, required: true },
+    fixedTerm: { type: String, required: true },
     fixedTermEndDate: { type: Date, default: null },
-    baseRate: { type: Number, default: null },
-    productRate: { type: Number, default: null },
-    apr: { type: Number, default: null },
-    rentalCoverage: { type: Number, default: null },
+    baseRate: { type: String, default: null },
+    productRate: { type: String, default: null },
+    apr: { type: String, default: null },
+    rentalCoverage: { type: String, default: null },
     repaymentType: { type: String, default: null },
     applicationCategory: { type: String, default: null },
     securityType: { type: String, default: null },
     erc: { type: String, default: null },
     loanType: { type: String, default: null },
     maxLtvLimit: { type: String, default: null },
-    reimbursement: { type: Number, default: null },
-    reimbursementPerPound: { type: Number, default: null },
-    stressedApr: { type: Number, default: null },
-    stressedRate: { type: Number, default: null },
-    stressedRepayment: { type: Number, default: null },
+    reimbursement: { type: String, default: null },
+    reimbursementPerPound: { type: String, default: null },
+    stressedApr: { type: String, default: null },
+    stressedRate: { type: String, default: null },
+    stressedRepayment: { type: String, default: null },
     liborFloorRate: { type: String, default: null },
-    totalTermInMonths: { type: Number, default: null },
+    totalTermInMonths: { type: String, default: null },
     chargeType: { type: String, default: '' },
     productCategory: { type: String, default: '' },
     ercCode: { type: String, default: '' },
-    variableTerm: { type: Number, default: null },
-    totalFeePayable: { type: Number, default: null },
+    variableTerm: { type: String, default: null },
+    totalFeePayable: { type: String, default: null },
     dipIssueDate: { type: Date, default: null },
     estimatedCompletionDate: { type: Date, default: null },
     dipExpiryDate: { type: Date, default: null },
     fixedRepaymentUntillDate: { type: Date, default: null },
     rentalReviewDate: { type: Date, default: null },
-    totalReimbursementWithFee: { type: Number, default: null },
-    finalRentPayment: { type: Number, default: null },
-    clientDeposit: { type: Number, default: null },
-    firstRentPayment: { type: Number, default: null },
+    totalReimbursementWithFee: { type: String, default: null },
+    finalRentPayment: { type: String, default: null },
+    clientDeposit: { type: String, default: null },
+    firstRentPayment: { type: String, default: null },
     fees: [feeSchema],
     ercFeatures: { type: mongoose.Schema.Types.Mixed, default: null },
     cashflowPeriods: {
-        totalNoOfPayments: { type: Number, default: null },
+        totalNoOfPayments: { type: String, default: null },
         fixed: cashflowPeriodSchema,
         variable: cashflowPeriodSchema,
         total: cashflowPeriodSchema
@@ -92,8 +92,8 @@ const productFeaturesSchema = new mongoose.Schema({
     icr: { type: String, default: null },
     ufssProductCode: { type: String, default: null },
     ufssInterestRateCode: { type: String, default: null },
-    stressedPayment: { type: Number, default: null },
-    stressedPaymentRate: { type: Number, default: null },
+    stressedPayment: { type: String, default: null },
+    stressedPaymentRate: { type: String, default: null },
     calculations: calculationsSchema
 });
 

package/applications/solicitor.model.js

@@ -4,11 +4,11 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 const Schema = mongoose.Schema;
 
 const solicitorSchema = new Schema({
-    dualRep: { type: Boolean, default: false },
-    isSraApprovedManagers: { type: Boolean, default: true },
-    pageValidFlag: { type: Boolean, default: true },
+    dualRep: { type: String, default: false },
+    isSraApprovedManagers: { type: String, default: true },
+    pageValidFlag: { type: String, default: true },
     solicitorsList: { type: String},
-    useExistingSolicitor: { type: Boolean, default: true },
+    useExistingSolicitor: { type: String, default: true },
     accountNumber: { type: String},
     addressCity: { type: String},
     addressCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
@@ -23,7 +23,7 @@ const solicitorSchema = new Schema({
     contactPostcode: { type: String,  },
     email: { type: String },
     institution: { type: String },
-    isActive: { type: Boolean, default: true },
+    isActive: { type: String, default: true },
     nameOfAccountHolder: { type: String },
     nameOfFirm: { type: String},
     signatory: { type: String},

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "0.21.6",
-  "description": "All the schemas for gatehouse bank back-end.",
+  "version": "0.21.8",
+  "description": "All the schemas for gatehouse bank back-end",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

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

@@ -8,10 +8,10 @@ const productCatalogueSchema = new mongoose.Schema({
     applyFrom: { type: Date, required: true },
     applyUntil: { type: Date, required: true },
     submitUntil: { type: Date, required: true },
-    status: { type: Number, required: true },
-    lockedForEdit: { type: Boolean, required: true },
+    status: { type: String, required: true },
+    lockedForEdit: { type: String, required: true },
     baseRateName: { type: String },
-    baseRate: { type: Number },
+    baseRate: { type: String },
     mapperName: { type: String }
 }, {
     timestamps: true

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

@@ -7,19 +7,19 @@ const ruleSchema = new mongoose.Schema({
     name: { type: String, required: true },
     description: { type: String },
     scope: { type: String },
-    mandatory: { type: Boolean, required: true },
+    mandatory: { type: String, required: true },
     overrideRuleType: { type: String },
     overrideRuleMessage: { type: String },
     inheritedFrom: { type: String },
-    anyPass: { type: Boolean, required: true },
-    preCashflow: { type: Boolean, required: true }
+    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: Boolean, required: true },
+    atLeastOnePass: { type: String, required: true },
     elements: { type: [mongoose.Schema.Types.Mixed], default: [] }, 
     rules: { type: [ruleSchema], default: [] } // Embedded array of RuleSchema
 }, {

package/properties/property.model.js

@@ -4,23 +4,23 @@ import mongooseEncryption from "../utils/encryption.middleware.js";
 const dataStreetSchema = new mongoose.Schema({
     floorArea: { type: String, default: '' },
     propertyType: { type: String, default: '' },
-    noOfBedrooms: { type: Number, default: 0 },
-    noOfBathrooms: { type: Number, default: 0 },
+    noOfBedrooms: { type: String, default: 0 },
+    noOfBathrooms: { type: String, default: 0 },
     lats: { type: String, },
     longs: { type: String,  },
     lmkKey: { type: String, default: '' },
-    matchConfidence: { type: Number, default: 0 },
+    matchConfidence: { type: String, default: 0 },
     transactions:[{
         transactionDate: String,
         epc: String,
         price: String,
-        isNewBuild: Boolean,
+        isNewBuild: String,
     }],
     nearByListings: [{
         listedDate: String,
-        price: Number,
-        noOfBedrooms: Number,
-        noOfBathrooms: Number,
+        price: String,
+        noOfBedrooms: String,
+        noOfBathrooms: String,
         internalArea: String,
         distance: String,
         address: String,
@@ -28,9 +28,9 @@ const dataStreetSchema = new mongoose.Schema({
     }],
     nearByCompletedTransactions:[{
         transactionDate: String,
-        price: Number,
-        noOfBedrooms: Number,
-        noOfBathrooms: Number,
+        price: String,
+        noOfBedrooms: String,
+        noOfBathrooms: String,
         internalArea: String,
         distance: String,
         address: String,
@@ -52,30 +52,30 @@ const dataStreetSchema = new mongoose.Schema({
 });
 
 const propertySchema = new mongoose.Schema({
-    haveAnyBuyToLetProperties: { type: Boolean, required: true },
-    isPropertyInEnglandOrWales: { type: Boolean, required: true },
+    haveAnyBuyToLetProperties: { type: String, required: true },
+    isPropertyInEnglandOrWales: { type: String, required: true },
     price: { type: String, default: '' },
-    noOfBuyToLetProperties: { type: Number },
+    noOfBuyToLetProperties: { type: String },
     totalMonthlyRentalIncome: { type: String, default: '' },
     totalMonthlyRepayment: { type: String, default: '' },
     totalOutstandingBalance: { type: String, default: '' },
-    areAllBedRoomsOver10sqm: { type: Boolean, required: true },
-    isBrickTileConstruction: { type: Boolean, required: true },
+    areAllBedRoomsOver10sqm: { type: String, required: true },
+    isBrickTileConstruction: { type: String, required: true },
     constructionDetails: { type: String, default: '' },
-    isExLAExclusion: { type: Boolean, required: true },
-    isFlatLift: { type: Boolean, required: true },
-    flatNumberOfBedrooms: { type: Number},
-    isGreenEPC: { type: Boolean, required: true },
+    isExLAExclusion: { type: String, required: true },
+    isFlatLift: { type: String, required: true },
+    flatNumberOfBedrooms: { type: String},
+    isGreenEPC: { type: String, required: true },
     isGroundRent: { type: String, default: '' },
-    isHouseLicensed: { type: Boolean, required: true },
-    houseNumberOfFloors: { type: Number },
-    houseNumberOfKitchens: { type: Number },
-    houseNumberOfLivingRooms: { type: Number },
-    houseNumberOfBathrooms: { type: Number },
-    houseNumberOfTenancies: { type: Number },
-    hasHousePlanningPermission: { type: Boolean, required: true },
-    isGarage: { type: Boolean, required: true },
-    isNewBuild: { type: Boolean, required: true },
+    isHouseLicensed: { type: String, required: true },
+    houseNumberOfFloors: { type: String },
+    houseNumberOfKitchens: { type: String },
+    houseNumberOfLivingRooms: { type: String },
+    houseNumberOfBathrooms: { type: String },
+    houseNumberOfTenancies: { type: String },
+    hasHousePlanningPermission: { type: String, required: true },
+    isGarage: { type: String, required: true },
+    isNewBuild: { type: String, required: true },
     propertyAddressCity: { type: String, required: true },
     propertyAddressCountry: { type: String, required: true },
     propertyAddressLine1: { type: String, required: true },
@@ -84,15 +84,15 @@ const propertySchema = new mongoose.Schema({
     propertyAddressPostCode: { type: String, required: true },
     propertyTenureLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
     propertyTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    propertyYearBuilt: { type: Number },
-    receiptOfAnyDiscount: { type: Boolean, },
+    propertyYearBuilt: { type: String },
+    receiptOfAnyDiscount: { type: String, },
     receiptOfDiscountDetails: { type: String, default: '' },
     sectorExperience: { type: String, required: true },
     serviceCharge: { type: String, default: '' },
     unexpiredRemainingLease: { type: String, default: '' },
     yearLeaseExpires: { type: String, default: '' },
     energyEfficiencyRating: { type: String},
-    energyEfficiencyRatingValue: { type: Number },
+    energyEfficiencyRatingValue: { type: String },
     dataStreetSchema: dataStreetSchema,
 }, { 
     toJSON: { virtuals: true }, 

package/shared/alert.model.js

@@ -20,7 +20,7 @@ const alertSchema = new mongoose.Schema({
         type: mongoose.Schema.Types.ObjectId,
         ref: "Lookup"
     },
-    isActive: { type: Boolean, default: true },
+    isActive: { type: String, default: true },
 }, { timestamps: true });
 
 alertSchema.plugin(mongooseEncryption);

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

@@ -9,7 +9,7 @@ const ApprivoSyncJourneySchema = new mongoose.Schema({
     required: true 
   },
   error: { type: String, default: null },
-  isFirstPull: { type: Boolean, required: true },
+  isFirstPull: { type: String, required: true },
   jobRunId: { type: mongoose.Schema.Types.ObjectId, ref: "Job_Run"},
   startTime: {type: Date, default: null},
   endTime: {type: Date, default: null},

package/shared/job-setting.model.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose";
 
 const jobSettingSchema = new mongoose.Schema({
     name: { type: String, required: true },
-    isActive: { type: Boolean, default: true },
+    isActive: { type: String, default: true },
     frequency: {
         type: String, default: '2 hours'
     },

package/users/role-group.model.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose";
 import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const RoleGroupSchema = new mongoose.Schema({
-    groupId: { type: Number, required: true },
+    groupId: { type: String, required: true },
     name: { type: String, required: true },
     description: { type: String },
     roles: [{

package/users/role.model.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose";
 import mongooseEncryption from "../utils/encryption.middleware.js";
 
 const RoleSchema = new mongoose.Schema({
-    roleId: { type: Number, required: true },
+    roleId: { type: String, required: true },
     name: { type: String, required: true },
     description: { type: String },
     permissions: [{

package/users/user.model.js

@@ -7,12 +7,12 @@ const ClaimSchema = new mongoose.Schema({
 });
 
 const userSchema = new mongoose.Schema({
-    accountId: { type: Number, required: true },
+    accountId: { type: String, required: true },
     email: { type: String, required: true },
     fullName: { type: String, required: true },
     password: { type: String, required: true },
     organisationId: { type: mongoose.Schema.Types.Mixed },
-    status: { type: Number, required: true },
+    status: { type: String, required: true },
     groups: [{
         type: mongoose.Schema.Types.ObjectId,
         ref: 'RoleGroup'

package/utils/encryption.middleware.js

@@ -39,10 +39,10 @@ export default function mongooseEncryption(schema, options) {
 
     // Decrypt after bulkWrite operations
     schema.post("bulkWrite", function (result) {
-        result.result.insertedDocs.forEach(doc => {
+        result.result.insertedIds.forEach(doc => {
             doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt document fields
         });
-        result.result.modifiedDocs.forEach(doc => {
+        result.result.upserted.forEach(doc => {
             doc.set(decryptObject(doc.toObject(), collectionName)); // Decrypt document fields
         });
     });