@dynamatix/gb-schemas 2.3.271 → 2.3.273

package/dist/applicants/applicant-additional-income.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-additional-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-additional-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAgC5D,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiF,CAAC;AAEtH,eAAe,8BAA8B,CAAC"}
+{"version":3,"file":"applicant-additional-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-additional-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAoC5D,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiF,CAAC;AAEtH,eAAe,8BAA8B,CAAC"}

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

@@ -28,5 +28,8 @@ const applicantAdditionalIncomeSchema = new mongoose.Schema({
 applyAuditMiddleware(applicantAdditionalIncomeSchema, "Applicant_Additional_Income");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantAdditionalIncomeSchema, 'applicant_additional_income');
+// Add indexes that exist in database but missing from model
+applicantAdditionalIncomeSchema.index({ applicantId: 1 }); // Filter by applicant
+applicantAdditionalIncomeSchema.index({ applicantId: 1, apprivoSoucrceNumberLid: 1 }); // Compound: applicant + source number
 const ApplicantAdditionalIncomeModel = mongoose.model("Applicant_Additional_Income", applicantAdditionalIncomeSchema);
 export default ApplicantAdditionalIncomeModel;

package/dist/applicants/applicant-commitment-creditCard.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-commitment-creditCard.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-creditCard.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAuC/C,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqE,CAAC;AACrG,eAAe,yBAAyB,CAAC"}
+{"version":3,"file":"applicant-commitment-creditCard.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-creditCard.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AA2C/C,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqE,CAAC;AACrG,eAAe,yBAAyB,CAAC"}

package/dist/applicants/applicant-commitment-creditCard.model.js

@@ -33,5 +33,8 @@ creditCardCommitmentSchema.virtual('ApplicationId', {
 applyAuditMiddleware(creditCardCommitmentSchema, "CreditCardCommitment");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(creditCardCommitmentSchema, 'creditcardcommitment');
+// Indexes for query optimization
+creditCardCommitmentSchema.index({ applicantId: 1 });
+creditCardCommitmentSchema.index({ applicantId: 1, isSelected: 1 });
 const CreditCardCommitmentModel = mongoose.model("CreditCardCommitment", creditCardCommitmentSchema);
 export default CreditCardCommitmentModel;

package/dist/applicants/applicant-commitment-loan.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-commitment-loan.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-loan.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAwD5D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"applicant-commitment-loan.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-loan.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA0D5D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}

package/dist/applicants/applicant-commitment-loan.model.js

@@ -45,5 +45,7 @@ loanCommitmentSchema.virtual('lendingType').get(function () {
 applyAuditMiddleware(loanCommitmentSchema, "LoanCommitment");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(loanCommitmentSchema, 'loancommitment');
+// Indexes for query optimization
+loanCommitmentSchema.index({ applicantId: 1 });
 const LoanCommitmentModel = mongoose.model("LoanCommitment", loanCommitmentSchema);
 export default LoanCommitmentModel;

package/dist/applicants/applicant-commitment-mortgage.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-commitment-mortgage.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-mortgage.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA0E5D,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiE,CAAC;AAC/F,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"applicant-commitment-mortgage.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-mortgage.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA6E5D,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiE,CAAC;AAC/F,eAAe,uBAAuB,CAAC"}

package/dist/applicants/applicant-commitment-mortgage.model.js

@@ -62,5 +62,8 @@ mortgageCommitmentSchema.virtual('applicationType').get(function () {
 applyAuditMiddleware(mortgageCommitmentSchema, "MortgageCommitment");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(mortgageCommitmentSchema, 'mortgagecommitment');
+// Indexes for query optimization
+mortgageCommitmentSchema.index({ applicantId: 1 });
+mortgageCommitmentSchema.index({ applicantId: 1, isSelected: 1 });
 const MortgageCommitmentModel = mongoose.model("MortgageCommitment", mortgageCommitmentSchema);
 export default MortgageCommitmentModel;

package/dist/applicants/applicant-commitment-residence.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-commitment-residence.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-residence.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA2D5D,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmE,CAAC;AAClG,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"applicant-commitment-residence.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-residence.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA6D5D,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmE,CAAC;AAClG,eAAe,wBAAwB,CAAC"}

package/dist/applicants/applicant-commitment-residence.model.js

@@ -51,5 +51,7 @@ const residenceCommitmentSchema = new mongoose.Schema({
 applyAuditMiddleware(residenceCommitmentSchema, "ResidenceCommitment");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(residenceCommitmentSchema, 'residencecommitment');
+// Indexes for query optimization
+residenceCommitmentSchema.index({ applicantId: 1 });
 const ResidenceCommitmentModel = mongoose.model("ResidenceCommitment", residenceCommitmentSchema);
 export default ResidenceCommitmentModel;

package/dist/applicants/applicant-commitment-secureLoan.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-commitment-secureLoan.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-secureLoan.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA4C5D,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuE,CAAC;AACxG,eAAe,0BAA0B,CAAC"}
+{"version":3,"file":"applicant-commitment-secureLoan.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-secureLoan.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAgD5D,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuE,CAAC;AACxG,eAAe,0BAA0B,CAAC"}

package/dist/applicants/applicant-commitment-secureLoan.model.js

@@ -36,5 +36,8 @@ securedLoanCommitmentSchema.virtual('lendingType').get(function () {
 applyAuditMiddleware(securedLoanCommitmentSchema, "SecuredLoanCommitment");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(securedLoanCommitmentSchema, 'securedloancommitment');
+// Indexes for query optimization
+securedLoanCommitmentSchema.index({ applicantId: 1 });
+securedLoanCommitmentSchema.index({ applicantId: 1, isSelected: 1 });
 const SecuredLoanCommitmentModel = mongoose.model("SecuredLoanCommitment", securedLoanCommitmentSchema);
 export default SecuredLoanCommitmentModel;

package/dist/applicants/applicant-commitment-unsecuredLoan.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-commitment-unsecuredLoan.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-unsecuredLoan.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA4C5D,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2E,CAAC;AAC9G,eAAe,4BAA4B,CAAC"}
+{"version":3,"file":"applicant-commitment-unsecuredLoan.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-commitment-unsecuredLoan.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAgD5D,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2E,CAAC;AAC9G,eAAe,4BAA4B,CAAC"}

package/dist/applicants/applicant-commitment-unsecuredLoan.model.js

@@ -36,5 +36,8 @@ unsecuredLoanCommitmentSchema.virtual('lendingType').get(function () {
 applyAuditMiddleware(unsecuredLoanCommitmentSchema, "UnsecuredLoanCommitment");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(unsecuredLoanCommitmentSchema, 'unsecuredloancommitment');
+// Indexes for query optimization
+unsecuredLoanCommitmentSchema.index({ applicantId: 1 });
+unsecuredLoanCommitmentSchema.index({ applicantId: 1, isSelected: 1 });
 const UnsecuredLoanCommitmentModel = mongoose.model("UnsecuredLoanCommitment", unsecuredLoanCommitmentSchema);
 export default UnsecuredLoanCommitmentModel;

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

@@ -111,6 +111,7 @@ const applicantCreditReportSchema = new Schema({
     noticeofCorrection: [noticeofCorrectionSchema],
 });
 // Apply workflow plugin to the schema
+applicantCreditReportSchema.index({ applicantId: 1 });
 applyWorkflowPlugin(applicantCreditReportSchema, 'applicantcreditreport');
 const ApplicantCreditReportModel = mongoose.model("ApplicantCreditReport", applicantCreditReportSchema);
 export default ApplicantCreditReportModel;

package/dist/applicants/applicant-employment-income.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-employment-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-employment-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAiB5D,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAgF,CAAC;AAErH,eAAe,8BAA8B,CAAC"}
+{"version":3,"file":"applicant-employment-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-employment-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAqB5D,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAgF,CAAC;AAErH,eAAe,8BAA8B,CAAC"}

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

@@ -13,5 +13,8 @@ applicantEmploymentIncomeSchema.virtual('incomeSourceId').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantEmploymentIncomeSchema, 'applicantemploymentincome');
+// Add indexes that exist in database but missing from model
+applicantEmploymentIncomeSchema.index({ applicantId: 1 }); // Filter by applicant
+applicantEmploymentIncomeSchema.index({ applicantId: 1, incomeTypeLid: 1 }); // Compound: applicant + income type
 const ApplicantEmploymentIncomeModel = mongoose.model("Applicant_EmploymentIncome", applicantEmploymentIncomeSchema);
 export default ApplicantEmploymentIncomeModel;

package/dist/applicants/applicant-expenditure.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-expenditure.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-expenditure.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA0K5D,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAsE,CAAC;AACtG,eAAe,yBAAyB,CAAC"}
+{"version":3,"file":"applicant-expenditure.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-expenditure.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA6K5D,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAsE,CAAC;AACtG,eAAe,yBAAyB,CAAC"}

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

@@ -138,6 +138,9 @@ const virtualEssentialExpenditure = applicantExpenditureSchema.virtual("Expendit
 virtualEssentialExpenditure.description = "Populated lookup value for essential expenditure.";
 applyAuditMiddleware(applicantExpenditureSchema, "Applicant_Expenditure");
 // Apply workflow plugin to the schema
+applicantExpenditureSchema.index({ applicantId: 1 });
+applicantExpenditureSchema.index({ applicantId: 1, sectionName: 1 });
+applicantExpenditureSchema.index({ expenditureTypeLid: 1 });
 applyWorkflowPlugin(applicantExpenditureSchema, 'applicant_expenditure');
 const ApplicantExpenditureModel = mongoose.model("Applicant_Expenditure", applicantExpenditureSchema);
 export default ApplicantExpenditureModel;

package/dist/applicants/applicant-income-settings.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-income-settings.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income-settings.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAwBhC,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4E,CAAC;AAE/G,eAAe,4BAA4B,CAAC"}
+{"version":3,"file":"applicant-income-settings.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income-settings.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA0BhC,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4E,CAAC;AAE/G,eAAe,4BAA4B,CAAC"}

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

@@ -17,5 +17,6 @@ applicantIncomeSettingsSchema.virtual('lendingType').get(function () {
 applyAuditMiddleware(applicantIncomeSettingsSchema, "Applicant_IncomeSettings");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantIncomeSettingsSchema, 'applicant_incomesettings');
+applicantIncomeSettingsSchema.index({ applicantId: 1 });
 const ApplicantIncomeSettingsModel = mongoose.model("Applicant_IncomeSettings", applicantIncomeSettingsSchema);
 export default ApplicantIncomeSettingsModel;

package/dist/applicants/applicant-income-summary.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-income-summary.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income-summary.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA6C5D,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2E,CAAC;AAE7G,eAAe,2BAA2B,CAAC"}
+{"version":3,"file":"applicant-income-summary.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income-summary.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAgD5D,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2E,CAAC;AAE7G,eAAe,2BAA2B,CAAC"}

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

@@ -37,5 +37,7 @@ const applicantIncomeSummarySchema = new mongoose.Schema({
 applyAuditMiddleware(applicantIncomeSummarySchema, "Applicant_Income_Summary");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantIncomeSummarySchema, 'applicant_income_summary');
+// Add indexes that exist in database but missing from model
+applicantIncomeSummarySchema.index({ applicantId: 1 }, { unique: true }); // Filter by applicant - unique constraint
 const ApplicantIncomeSummaryModel = mongoose.model("Applicant_Income_Summary", applicantIncomeSummarySchema);
 export default ApplicantIncomeSummaryModel;

package/dist/applicants/applicant-pension-income.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-pension-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-pension-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAuC5D,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E,CAAC;AAE7G,eAAe,4BAA4B,CAAC"}
+{"version":3,"file":"applicant-pension-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-pension-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AA0C5D,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E,CAAC;AAE7G,eAAe,4BAA4B,CAAC"}

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

@@ -29,5 +29,7 @@ applicantPensionIncomSchema.virtual('incomeSourceId').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantPensionIncomSchema, 'applicant_pension_income');
+// Add indexes that exist in database but missing from model
+applicantPensionIncomSchema.index({ applicantId: 1 }); // Filter by applicant
 const EmploymentPensionIncomeModel = mongoose.model("Applicant_Pension_Income", applicantPensionIncomSchema);
 export default EmploymentPensionIncomeModel;

package/dist/applicants/applicant-property-income.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-property-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-property-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAqC5D,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAoE,CAAC;AAEvG,eAAe,4BAA4B,CAAC"}
+{"version":3,"file":"applicant-property-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-property-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAuC5D,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAoE,CAAC;AAEvG,eAAe,4BAA4B,CAAC"}

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

@@ -29,5 +29,6 @@ propertyIncomeSchema.virtual('incomeSourceId').get(function () {
 applyAuditMiddleware(propertyIncomeSchema, "Applicant_Property_Income");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(propertyIncomeSchema, 'applicant_property_income');
+propertyIncomeSchema.index({ applicantId: 1 });
 const ApplicantPropertyIncomeModel = mongoose.model("Applicant_Property_Income", propertyIncomeSchema);
 export default ApplicantPropertyIncomeModel;

package/dist/applicants/applicant-self-employed-income.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-self-employed-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-self-employed-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAuB5D,QAAA,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6E,CAAC;AAEpH,eAAe,gCAAgC,CAAC"}
+{"version":3,"file":"applicant-self-employed-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-self-employed-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAwB5D,QAAA,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6E,CAAC;AAEpH,eAAe,gCAAgC,CAAC"}

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

@@ -17,6 +17,7 @@ selfEmployedIncomeSchema.virtual('incomeSourceId').get(function () {
 });
 applyAuditMiddleware(selfEmployedIncomeSchema, "Applicant_Self_Employed_Income");
 // Apply workflow plugin to the schema
+selfEmployedIncomeSchema.index({ applicantId: 1 }); // Filter by applicant
 applyWorkflowPlugin(selfEmployedIncomeSchema, 'applicant_self_employed_income');
 const ApplicantSelfEmployedIncomeModel = mongoose.model("Applicant_Self_Employed_Income", selfEmployedIncomeSchema);
 export default ApplicantSelfEmployedIncomeModel;

package/dist/applicants/applicant-self-employment.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-self-employment.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-self-employment.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA2DhC,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6E,CAAC;AAEhH,eAAe,4BAA4B,CAAC"}
+{"version":3,"file":"applicant-self-employment.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-self-employment.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA8DhC,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6E,CAAC;AAEhH,eAAe,4BAA4B,CAAC"}

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

@@ -49,5 +49,7 @@ const applicantSelfEmploymentSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantSelfEmploymentSchema, 'applicant_self_employment');
+// Add indexes that exist in database but missing from model
+applicantSelfEmploymentSchema.index({ applicantId: 1 }); // Filter by applicant
 const ApplicantSelfEmploymentModel = mongoose.model("Applicant_Self_Employment", applicantSelfEmploymentSchema);
 export default ApplicantSelfEmploymentModel;

package/dist/applicants/applicant-sole-trader-income.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-sole-trader-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-sole-trader-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAsB5D,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyE,CAAC;AAE9G,eAAe,8BAA8B,CAAC"}
+{"version":3,"file":"applicant-sole-trader-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-sole-trader-income.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAwB5D,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyE,CAAC;AAE9G,eAAe,8BAA8B,CAAC"}

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

@@ -16,5 +16,6 @@ soleTraderIncomeSchema.virtual('incomeSourceId').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(soleTraderIncomeSchema, 'applicant_sole_trader_income');
+soleTraderIncomeSchema.index({ applicantId: 1 });
 const ApplicantSoleTraderIncomeModel = mongoose.model("Applicant_Sole_Trader_Income", soleTraderIncomeSchema);
 export default ApplicantSoleTraderIncomeModel;

package/dist/applicants/applicant-uk-tax-credits.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-uk-tax-credits.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-uk-tax-credits.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAoB5D,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E,CAAC;AAE3G,eAAe,0BAA0B,CAAC"}
+{"version":3,"file":"applicant-uk-tax-credits.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-uk-tax-credits.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAuB5D,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E,CAAC;AAE3G,eAAe,0BAA0B,CAAC"}

package/dist/applicants/applicant-uk-tax-credits.model.js

@@ -15,5 +15,7 @@ applicantUkTaxCreditsSchema.virtual('incomeSourceId').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantUkTaxCreditsSchema, 'applicant_uk_tax_credits');
+// Add indexes that exist in database but missing from model
+applicantUkTaxCreditsSchema.index({ applicantId: 1 }); // Filter by applicant
 const ApplicantUkTaxCreditsModel = mongoose.model("Applicant_Uk_Tax_Credits", applicantUkTaxCreditsSchema);
 export default ApplicantUkTaxCreditsModel;

package/dist/applicants/applicant-welcome-call.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-welcome-call.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-welcome-call.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqtBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4D,CAAC;AAEnF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"applicant-welcome-call.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-welcome-call.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAulBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4D,CAAC;AAEnF,eAAe,gBAAgB,CAAC"}

package/dist/applicants/applicant-welcome-call.model.js

@@ -288,12 +288,6 @@ welcomeCallSchema.virtual('applicantEmployerBusinessName').get(function () {
                 console.log('No employment status found');
             }
         }
-        else {
-            console.log('No income settings found');
-        }
-    }
-    else {
-        console.log('No applicant found');
     }
     return 'N/A';
 });
@@ -314,143 +308,46 @@ welcomeCallSchema.virtual('customerContactNumbers').get(function () {
     }
     return null;
 });
-// Virtual property for all applicants name/DOB when there are multiple applicants
-welcomeCallSchema.virtual('allApplicantsNameAndDOB').get(function () {
-    // Get application and its applicants
-    if (this.applicationId && typeof this.applicationId === 'object') {
-        const application = this.applicationId;
-        // Get all applicants from the application (field name is 'applicants')
-        if (application.applicants && Array.isArray(application.applicants) && application.applicants.length > 0) {
-            // Get current applicant ID for comparison
-            const currentApplicantId = this.applicantId?._id || this.applicantId;
-            // Filter out the current applicant to get only OTHER applicants
-            const otherApplicants = application.applicants.filter((applicant) => {
-                const applicantId = applicant._id || applicant;
-                return applicantId.toString() !== currentApplicantId.toString();
-            });
-            // If no other applicants, return "N/A" (single applicant case)
-            if (otherApplicants.length === 0) {
-                return 'N/A';
-            }
-            // Format each other applicant as: firstName,middleName,lastName,dd/mm/yyyy
-            const formattedApplicants = otherApplicants.map((applicant) => {
-                // Check if applicant is an ObjectId (not populated)
-                if (typeof applicant === 'string' || (applicant.constructor && applicant.constructor.name === 'ObjectId')) {
-                    return null; // Skip unpopulated references
-                }
-                const firstName = applicant.firstName || '';
-                const middleName = applicant.middleName || '';
-                const lastName = applicant.lastName || '';
-                // Combine first and middle names
-                const fullFirstName = middleName ? `${firstName},${middleName}` : firstName;
-                // Format date of birth to dd/mm/yyyy
-                let formattedDOB = '';
-                if (applicant.dateOfBirth) {
-                    // Check if dateOfBirth is already a formatted string (DD/MM/YYYY)
-                    if (typeof applicant.dateOfBirth === 'string' && /^\d{2}\/\d{2}\/\d{4}$/.test(applicant.dateOfBirth)) {
-                        // Already in DD/MM/YYYY format
-                        formattedDOB = applicant.dateOfBirth;
-                    }
-                    else {
-                        // Try to parse as Date object or ISO string
-                        try {
-                            const date = new Date(applicant.dateOfBirth);
-                            // Check if date is valid
-                            if (!isNaN(date.getTime())) {
-                                const day = String(date.getDate()).padStart(2, '0');
-                                const month = String(date.getMonth() + 1).padStart(2, '0');
-                                const year = date.getFullYear();
-                                formattedDOB = `${day}/${month}/${year}`;
-                            }
-                        }
-                        catch (e) {
-                            // Date parsing failed, try to use as-is if it's a string
-                            if (typeof applicant.dateOfBirth === 'string') {
-                                formattedDOB = applicant.dateOfBirth;
-                            }
-                        }
-                    }
-                }
-                return `${fullFirstName},${lastName},${formattedDOB}`;
-            }).filter((line) => line && line.trim() !== ',,' && line.trim() !== '');
-            // Join all applicants with newline
-            return formattedApplicants.join('\n');
-        }
-    }
-    // If application not populated or no applicants, return "N/A"
-    return 'N/A';
-});
 // Virtual property for other applicants name and DOB in the requested format
 welcomeCallSchema.virtual('otherApplicantsNameAndDOB').get(function () {
-    console.log('=== DEBUG otherApplicantsNameAndDOB ===');
-    console.log('this.applicationId:', this.applicationId);
-    console.log('this.applicantId:', this.applicantId);
-    console.log('typeof this.applicationId:', typeof this.applicationId);
-    console.log('typeof this.applicantId:', typeof this.applicantId);
-    // Try to get application from applicantId first, then from applicationId
     let application = null;
-    if (this.applicantId &&
-        typeof this.applicantId === 'object' &&
-        !(typeof this.applicantId.toHexString === 'function') && // not ObjectId
-        this.applicantId.applicationId) {
+    if (this.applicantId && typeof this.applicantId === 'object' && !(typeof this.applicantId.toHexString === 'function') && this.applicantId.applicationId) {
         application = this.applicantId.applicationId;
-        console.log('Got application from applicantId.applicationId');
     }
     else if (this.applicationId && typeof this.applicationId === 'object') {
         application = this.applicationId;
-        console.log('Got application from this.applicationId');
     }
     else {
-        console.log('No application found in either applicantId.applicationId or this.applicationId');
         return 'N/A';
     }
     if (application) {
-        console.log('application object:', application);
-        console.log('application.applicants:', application.applicants);
-        console.log('Array.isArray(application.applicants):', Array.isArray(application.applicants));
-        console.log('application.applicants.length:', application.applicants?.length);
-        // Additional debug: Check if applicants is populated
-        if (application.applicants && application.applicants.length > 0) {
-            console.log('First applicant sample:', application.applicants[0]);
-            console.log('First applicant type:', typeof application.applicants[0]);
-            console.log('First applicant has firstName:', !!application.applicants[0]?.firstName);
-        }
         // Get all applicants from the application (field name is 'applicants')
         if (application.applicants && Array.isArray(application.applicants) && application.applicants.length > 0) {
-            console.log('Found applicants array with length:', application.applicants.length);
             // Get current applicant ID for comparison
             const currentApplicantId = this.applicantId?._id || this.applicantId;
-            console.log('currentApplicantId:', currentApplicantId);
             // Filter out the current applicant to get only OTHER applicants
             const otherApplicants = application.applicants.filter((applicant) => {
                 const applicantId = applicant._id || applicant;
-                console.log('Comparing applicantId:', applicantId, 'with currentApplicantId:', currentApplicantId);
                 return applicantId.toString() !== currentApplicantId.toString();
             });
-            console.log('otherApplicants after filtering:', otherApplicants.length);
             // If no other applicants, return "N/A" (single applicant case)
             if (otherApplicants.length === 0) {
-                console.log('No other applicants found, returning N/A');
                 return 'N/A';
             }
             // Format each other applicant as: "First and middle names, last name, Date of birth"
             const formattedApplicants = otherApplicants.map((applicant) => {
-                console.log('Processing applicant:', applicant);
                 // Check if applicant is an ObjectId (not populated)
                 if (typeof applicant === 'string' || (applicant.constructor && applicant.constructor.name === 'ObjectId')) {
-                    console.log('Applicant is not populated, skipping');
                     return null; // Skip unpopulated references
                 }
                 const firstName = applicant.firstName || '';
                 const middleName = applicant.middleName || '';
                 const lastName = applicant.lastName || '';
-                console.log('Applicant names:', { firstName, middleName, lastName });
                 // Combine first and middle names with space
                 const fullFirstName = middleName ? `${firstName} ${middleName}` : firstName;
                 // Format date of birth to dd/mm/yyyy
                 let formattedDOB = '';
                 if (applicant.dateOfBirth) {
-                    console.log('Applicant dateOfBirth:', applicant.dateOfBirth);
                     // Check if dateOfBirth is already a formatted string (DD/MM/YYYY)
                     if (typeof applicant.dateOfBirth === 'string' && /^\d{2}\/\d{2}\/\d{4}$/.test(applicant.dateOfBirth)) {
                         // Already in DD/MM/YYYY format
@@ -477,24 +374,13 @@ welcomeCallSchema.virtual('otherApplicantsNameAndDOB').get(function () {
                     }
                 }
                 // Format as "First and middle names, last name, Date of birth"
-                const result = `${fullFirstName}, ${lastName}, ${formattedDOB}`;
-                console.log('Formatted applicant result:', result);
-                return result;
+                return `${fullFirstName}, ${lastName}, ${formattedDOB}`;
             }).filter((line) => line && line.trim() !== ', ,' && line.trim() !== '');
-            console.log('Final formattedApplicants:', formattedApplicants);
             // Join all applicants with newline
-            const finalResult = formattedApplicants.join('\n');
-            console.log('Final result:', finalResult);
-            return finalResult;
-        }
-        else {
-            console.log('No applicants array found or empty array');
-            console.log('This means you need to populate the applicationId with applicants when querying');
-            console.log('Use: .populate({ path: "applicationId", populate: { path: "applicants" } })');
+            return formattedApplicants.join('\n');
         }
     }
     // If application not populated or no applicants, return "N/A"
-    console.log('Returning N/A - no application or applicants found');
     return 'N/A';
 });
 // Virtual property for broker name and firm 
@@ -670,5 +556,7 @@ welcomeCallSchema.virtual('initialRatePercentage').get(function () {
 applyAuditMiddleware(welcomeCallSchema, "ApplicantWelcomeCall");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(welcomeCallSchema, 'applicantwelcomecall');
+// Index for query optimization
+welcomeCallSchema.index({ applicantId: 1, isActive: 1 }); // Compound index for getWelcomeCallByApplicantId and softDeleteByApplicantId queries
 const WelcomeCallModel = mongoose.model('ApplicantWelcomeCall', welcomeCallSchema);
 export default WelcomeCallModel;

package/dist/applicants/applicant.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAOhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAuQ5D,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}
+{"version":3,"file":"applicant.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAOhC,OAAO,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAwR5D,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}

package/dist/applicants/applicant.model.js

@@ -236,5 +236,19 @@ applicantSchema.virtual('numberOfApplicants').get(function () {
 applyAuditMiddleware(applicantSchema, "Applicant");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicantSchema, 'applicant');
+// Database indexes for performance optimization
+// Single field indexes
+applicantSchema.index({ applicationId: 1 });
+applicantSchema.index({ applicantId: 1 });
+// Compound indexes
+applicantSchema.index({ applicationId: 1, isExpenseOwner: 1 }); // For expense owner queries
+applicantSchema.index({ applicationId: 1, _id: 1 }); // For application-scoped queries
+// Indexes for lookup operations
+applicantSchema.index({ nationalityLid: 1 });
+applicantSchema.index({ countryOfResidenceLid: 1 });
+applicantSchema.index({ maritalStatusLid: 1 });
+applicantSchema.index({ residentialStatusLid: 1 });
+applicantSchema.index({ addressCountryLid: 1 });
+applicantSchema.index({ incomeSummaryId: 1 });
 const ApplicantModel = mongoose.model("Applicant", applicantSchema);
 export default ApplicantModel;

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

@@ -90,6 +90,8 @@ const virtualApplicants = applicationDirectDebitSchema.virtual('applicants', {
     }
 });
 virtualApplicants.description = 'Full Name of the applicant';
+// Index for applicationId queries
+applicationDirectDebitSchema.index({ applicationId: 1 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicationDirectDebitSchema, 'application_directdebit');
 const ApplicationDirectDebitModel = mongoose.model("Application_DirectDebit", applicationDirectDebitSchema);

package/dist/applications/application-euc.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-euc.model.d.ts","sourceRoot":"","sources":["../../applications/application-euc.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiBhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"application-euc.model.d.ts","sourceRoot":"","sources":["../../applications/application-euc.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}

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

@@ -8,5 +8,7 @@ const applicationEucSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicationEucSchema, 'applicationeuc');
+// Add indexes that exist in database but missing from model
+applicationEucSchema.index({ applicationId: 1 }, { unique: true }); // Unique index for applicationId
 const ApplicationEucModel = mongoose.model("ApplicationEUC", applicationEucSchema);
 export default ApplicationEucModel;

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

@@ -262,5 +262,7 @@ mortgageSchema.virtual("sourceOfWealth").get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(mortgageSchema, 'mortgage');
+// Index for query optimization
+mortgageSchema.index({ applicationId: 1 }); // Index for getByApplicationId queries
 const MortgageModel = mongoose.model("Mortgage", mortgageSchema);
 export default MortgageModel;

package/dist/applications/application-note.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-note.model.d.ts","sourceRoot":"","sources":["../../applications/application-note.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6FhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACzE,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"application-note.model.d.ts","sourceRoot":"","sources":["../../applications/application-note.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiHhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACzE,eAAe,mBAAmB,CAAC"}

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

@@ -83,5 +83,23 @@ const noteSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(noteSchema, 'applictionnote');
+// Database indexes for performance optimization
+// Existing indexes
+noteSchema.index({ applicationId: 1 });
+noteSchema.index({ noteId: 1 });
+noteSchema.index({ createdByUserId: 1 });
+noteSchema.index({ noteTypeLid: 1 });
+noteSchema.index({ noteSubTypeLid: 1 });
+noteSchema.index({
+    applicationId: 1,
+    noteId: 1
+});
+// Additional recommended indexes for query patterns
+// Compound indexes for primary query patterns
+noteSchema.index({ applicationId: 1, createdOn: -1 }); // Primary query pattern with sort
+noteSchema.index({ applicationId: 1, noteTypeLid: 1 }); // For filtering by type
+noteSchema.index({ applicationId: 1, createdBy: 1 }); // For filtering by creator
+// Single field indexes for distinct and filter operations
+noteSchema.index({ createdBy: 1 }); // For distinct operations and creator filtering
 const ApplictionNoteModel = mongoose.model("ApplictionNote", noteSchema);
 export default ApplictionNoteModel;

package/dist/applications/application-product.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-product.model.d.ts","sourceRoot":"","sources":["../../applications/application-product.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA4FhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAC9D,eAAe,YAAY,CAAC"}
+{"version":3,"file":"application-product.model.d.ts","sourceRoot":"","sources":["../../applications/application-product.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6FhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAC9D,eAAe,YAAY,CAAC"}

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

@@ -77,5 +77,8 @@ productSchema.virtual('productFeePaymentType').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(productSchema, 'product');
+// Indexes for query optimization
+productSchema.index({ applicationId: 1 }); // Index for updateByApplicationId and getByApplicationIdWithRepaymentType queries
+productSchema.index({ repaymentTypeLid: 1 }); // Index for populate operations on repaymentTypeLid
 const ProductModel = mongoose.model("Product", productSchema);
 export default ProductModel;

package/dist/applications/application.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application.model.d.ts","sourceRoot":"","sources":["../../applications/application.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAwOhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"application.model.d.ts","sourceRoot":"","sources":["../../applications/application.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAsPhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}

package/dist/applications/application.model.js

@@ -206,5 +206,16 @@ applicationSchema.virtual('taskCompletionPercent').get(function () {
     // Calculate (lender/total)*100
     return Number(((lender / total) * 100).toFixed(2));
 });
+// Database indexes for performance optimization
+// Single field indexes
+applicationSchema.index({ applicationId: 1 });
+applicationSchema.index({ assignedToUserId: 1 });
+applicationSchema.index({ brokerId: 1 });
+applicationSchema.index({ applicants: 1 }); // For array membership queries
+// Compound indexes for common query combinations
+applicationSchema.index({ applicants: 1, _id: 1 }); // For finding application by applicant
+applicationSchema.index({ assignedToUserId: 1, statusLid: 1 }); // For filtering by assignee and status
+// Text index for search functionality
+applicationSchema.index({ applicationNumber: "text" });
 const ApplicationModel = mongoose.model("Application", applicationSchema);
 export default ApplicationModel;

package/dist/applications/applications-task.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applications-task.model.d.ts","sourceRoot":"","sources":["../../applications/applications-task.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA4ChC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"applications-task.model.d.ts","sourceRoot":"","sources":["../../applications/applications-task.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA+ChC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}

package/dist/applications/applications-task.model.js

@@ -38,5 +38,8 @@ const applicationsTaskSchema = new mongoose.Schema({
 applyAuditMiddleware(applicationsTaskSchema, "ApplicationsTask");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicationsTaskSchema, 'applicationstask');
+// Indexes for query optimization
+applicationsTaskSchema.index({ applicationId: 1, instanceId: 1 }); // Compound index for findByApplicationIdAndInstanceId queries
+applicationsTaskSchema.index({ applicationId: 1, createdOn: -1 }); // Compound index for findAll with sort by createdOn descending
 const ApplicationsTaskModel = mongoose.model("ApplicationsTask", applicationsTaskSchema);
 export default ApplicationsTaskModel;

package/dist/product-catalogues/product-catalogue.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"product-catalogue.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-catalogue.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAuBhC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"product-catalogue.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-catalogue.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAyBhC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}

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

@@ -17,5 +17,6 @@ const productCatalogueSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(productCatalogueSchema, 'productcatalogue');
+productCatalogueSchema.index({ productCatalogueId: 1 });
 const ProductCatalogueModel = mongoose.model('ProductCatalogue', productCatalogueSchema);
 export default ProductCatalogueModel;

package/dist/product-catalogues/product-variant.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"product-variant.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-variant.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAkBhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"product-variant.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-variant.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}

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

@@ -9,6 +9,7 @@ const productVariantSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+productVariantSchema.index({ productCatalogueId: 1, variantid: 1 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(productVariantSchema, 'productvariant');
 const ProductVariantModel = mongoose.model('ProductVariant', productVariantSchema);

package/dist/properties/security.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"security.model.d.ts","sourceRoot":"","sources":["../../properties/security.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiKhC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}
+{"version":3,"file":"security.model.d.ts","sourceRoot":"","sources":["../../properties/security.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAsKhC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}

package/dist/properties/security.model.js

@@ -145,5 +145,9 @@ securitySchema.virtual('lendingType').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(securitySchema, 'security');
+// Indexes for query optimization
+securitySchema.index({ applicationId: 1 });
+securitySchema.index({ propertyTypeLid: 1 });
+securitySchema.index({ propertyTenureLid: 1 });
 const SecurityModel = mongoose.model("Security", securitySchema);
 export default SecurityModel;

package/dist/shared/api-log.model.d.ts

@@ -40,6 +40,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -52,6 +53,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -64,6 +66,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -82,6 +85,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -94,6 +98,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -106,6 +111,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;

package/dist/shared/api-log.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-log.model.d.ts","sourceRoot":"","sources":["../../shared/api-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAC;AAE5D,eAAe,WAAW,CAAC"}
+{"version":3,"file":"api-log.model.d.ts","sourceRoot":"","sources":["../../shared/api-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAyBhC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAC;AAE5D,eAAe,WAAW,CAAC"}

package/dist/shared/api-log.model.js

@@ -7,12 +7,16 @@ const apiLogSchema = new mongoose.Schema({
     route: { type: String, required: true },
     createdByUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, },
     statusCode: { type: Number, required: true },
+    status: { type: String }, // For future filtering by status
     errorMessage: { type: String },
     loggedAt: { type: Date, default: Date.now },
     stackTrace: [{ type: String }],
     requestData: { type: mongoose.Schema.Types.Mixed }, // to store request payload
     responseData: { type: mongoose.Schema.Types.Mixed }, // to store response payload
 }, { timestamps: true });
+// Indexes for date and status filtering
+apiLogSchema.index({ createdAt: -1 }); // For date-based queries (newest first)
+apiLogSchema.index({ status: 1, createdAt: -1 }); // Compound index for status + date queries
 /**
  * Mongoose model for API logs.
  * @constant {Model}

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

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

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

@@ -13,5 +13,7 @@ const ApprivoSyncJourneySchema = new mongoose.Schema({
     startTime: { type: Date, default: null },
     endTime: { type: Date, default: null },
 }, { timestamps: true });
+// Add indexes that exist in database but missing from model
+ApprivoSyncJourneySchema.index({ milestoneLid: 1, applicationId: 1 }); // Compound: milestone + application
 const ApprivoSyncJourneyModel = mongoose.model('ApprivoSyncJourney', ApprivoSyncJourneySchema);
 export default ApprivoSyncJourneyModel;

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

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

package/dist/shared/checklist.model.js

@@ -26,5 +26,10 @@ const checklistSchema = new mongoose.Schema({
     }
 }, { timestamps: true });
 checklistSchema.index({ checkDescription: 'text', source: 'text' });
+// Add recommended indexes for query optimization
+checklistSchema.index({ applicationId: 1 }); // Filter by application
+checklistSchema.index({ checkTypeLid: 1 }); // Filter by check type
+checklistSchema.index({ checkStatusLid: 1 }); // Filter by check status
+checklistSchema.index({ sourceId: 1 }); // Filter by source (applicant/property/application)
 const CheckListModel = mongoose.model("CheckList", checklistSchema);
 export default CheckListModel;

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

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

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

@@ -15,5 +15,8 @@ const lookupGroupSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(lookupGroupSchema, 'lookupgroup');
+// Database indexes for performance optimization
+// Single field indexes
+lookupGroupSchema.index({ name: 1 }, { unique: true });
 const LookupGroupModel = mongoose.model('LookupGroup', lookupGroupSchema);
 export default LookupGroupModel;

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

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

package/dist/shared/lookup.model.js

@@ -16,5 +16,11 @@ const lookupSchema = new mongoose.Schema({
         type: String
     }
 });
+lookupSchema.index({ lookupGroupId: 1 });
+lookupSchema.index({ value: 1 });
+// Case-insensitive index for name queries
+lookupSchema.index({ name: 1 }, { collation: { locale: "en", strength: 2 } });
+// Compound index for lookupGroupId + name queries
+lookupSchema.index({ lookupGroupId: 1, name: 1 }, { collation: { locale: "en", strength: 2 } });
 const LookupModel = mongoose.model('Lookup', lookupSchema);
 export default LookupModel;

package/dist/shared/webhook-event.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhook-event.model.d.ts","sourceRoot":"","sources":["../../shared/webhook-event.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAoB,MAAM,UAAU,CAAC;AAC5C,OAAO,aAAa,MAAM,sBAAsB,CAAC;;;;;;AAuDjD,wBAAiF"}
+{"version":3,"file":"webhook-event.model.d.ts","sourceRoot":"","sources":["../../shared/webhook-event.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAoB,MAAM,UAAU,CAAC;AAC5C,OAAO,aAAa,MAAM,sBAAsB,CAAC;;;;;;AA4DjD,wBAAiF"}

package/dist/shared/webhook-event.model.js

@@ -50,4 +50,8 @@ const webhookEventSchema = new Schema({
 // Index for efficient querying
 webhookEventSchema.index({ createdAt: -1 });
 webhookEventSchema.index({ status: 1, retryCount: 1 });
+// Recommended compound indexes for webhook event queries
+webhookEventSchema.index({ status: 1, createdAt: 1 }); // For findByStatus() with sort
+webhookEventSchema.index({ status: 1, retryCount: 1, createdAt: 1 }); // Enhanced pending events query
+webhookEventSchema.index({ applicationId: 1, createdAt: -1 }); // For findByApplicationId() with sort
 export default mongoose.model('WebhookEvent', webhookEventSchema);

package/dist/users/auth-log.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-log.model.d.ts","sourceRoot":"","sources":["../../users/auth-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqBhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAE9D,eAAe,YAAY,CAAC"}
+{"version":3,"file":"auth-log.model.d.ts","sourceRoot":"","sources":["../../users/auth-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAyBhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA2C,CAAC;AAE9D,eAAe,YAAY,CAAC"}

package/dist/users/auth-log.model.js

@@ -17,5 +17,8 @@ const AuthLogSchema = new mongoose.Schema({
         enum: ["LOGIN", "LOGOUT", "PASSWORD_RESET"]
     }
 });
+// Indexes for query optimization
+AuthLogSchema.index({ userEmail: 1, loggedInTimestamp: -1 }); // Compound index for getByEmail queries with timestamp sort
+AuthLogSchema.index({ loggedInTimestamp: -1 }); // Index for getAll queries sorted by timestamp descending
 const AuthLogModel = mongoose.model("AuthLog", AuthLogSchema);
 export default AuthLogModel;

package/dist/users/permission.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permission.model.d.ts","sourceRoot":"","sources":["../../users/permission.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAWhC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiD,CAAC;AAEvE,eAAe,eAAe,CAAC"}
+{"version":3,"file":"permission.model.d.ts","sourceRoot":"","sources":["../../users/permission.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAchC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiD,CAAC;AAEvE,eAAe,eAAe,CAAC"}

package/dist/users/permission.model.js

@@ -6,5 +6,7 @@ const permissionSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+// Add recommended indexes for query optimization
+permissionSchema.index({ name: 1 }); // Filter by permission name
 const PermissionModel = mongoose.model('Permission', permissionSchema);
 export default PermissionModel;

package/dist/users/role-group.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"role-group.model.d.ts","sourceRoot":"","sources":["../../users/role-group.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAehC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}
+{"version":3,"file":"role-group.model.d.ts","sourceRoot":"","sources":["../../users/role-group.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAmBhC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}

package/dist/users/role-group.model.js

@@ -10,5 +10,8 @@ const RoleGroupSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+// Indexes for query optimization
+RoleGroupSchema.index({ name: 1 });
+RoleGroupSchema.index({ roles: 1 });
 const RoleGroupModel = mongoose.model('RoleGroup', RoleGroupSchema);
 export default RoleGroupModel;

package/dist/users/role.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"role.model.d.ts","sourceRoot":"","sources":["../../users/role.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAchC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAErD,eAAe,SAAS,CAAC"}
+{"version":3,"file":"role.model.d.ts","sourceRoot":"","sources":["../../users/role.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAkBhC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAErD,eAAe,SAAS,CAAC"}

package/dist/users/role.model.js

@@ -9,5 +9,8 @@ const RoleSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+// Add recommended indexes for query optimization
+RoleSchema.index({ name: 1 }); // Filter by role name
+RoleSchema.index({ permissions: 1 }); // Filter by permissions
 const RoleModel = mongoose.model('Role', RoleSchema);
 export default RoleModel;

package/dist/users/user.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.model.d.ts","sourceRoot":"","sources":["../../users/user.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAgChC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAErD,eAAe,SAAS,CAAC"}
+{"version":3,"file":"user.model.d.ts","sourceRoot":"","sources":["../../users/user.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6ChC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAErD,eAAe,SAAS,CAAC"}

package/dist/users/user.model.js

@@ -26,5 +26,15 @@ const userSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+// Database indexes for performance optimization
+// Single field indexes
+userSchema.index({ accountId: 1 }, { unique: true });
+userSchema.index({ email: 1 });
+userSchema.index({ token: 1 });
+userSchema.index({ groups: 1 }); // For population
+// Text index for name search
+userSchema.index({ fullName: "text" });
+// Regular index for prefix matching (alternative to text search)
+userSchema.index({ fullName: 1 });
 const UserModel = mongoose.model('User', userSchema);
 export default UserModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "2.3.271",
+  "version": "2.3.273",
   "description": "All the schemas for gatehouse bank back-end",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",