@dynamatix/gb-schemas 1.2.115 → 1.2.117

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

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

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

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

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

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

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

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

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

@@ -7,8 +7,9 @@ declare const ApplicantExpenditureModel: mongoose.Model<{
     applicantId: mongoose.Types.ObjectId;
     isFixed: boolean;
     expenditureTypeLid: mongoose.Types.ObjectId;
+    sectionName?: "essentialExpenditure" | "basicCostOfLivingExpenditure" | null | undefined;
     declared?: Pound | null | undefined;
-    ons?: Pound | null | undefined;
+    expected?: Pound | null | undefined;
     actual?: Pound | null | undefined;
     rationale?: string | null | undefined;
 }, {}, {}, {}, mongoose.Document<unknown, {}, {
@@ -18,8 +19,9 @@ declare const ApplicantExpenditureModel: mongoose.Model<{
     applicantId: mongoose.Types.ObjectId;
     isFixed: boolean;
     expenditureTypeLid: mongoose.Types.ObjectId;
+    sectionName?: "essentialExpenditure" | "basicCostOfLivingExpenditure" | null | undefined;
     declared?: Pound | null | undefined;
-    ons?: Pound | null | undefined;
+    expected?: Pound | null | undefined;
     actual?: Pound | null | undefined;
     rationale?: string | null | undefined;
 }> & {
@@ -29,8 +31,9 @@ declare const ApplicantExpenditureModel: mongoose.Model<{
     applicantId: mongoose.Types.ObjectId;
     isFixed: boolean;
     expenditureTypeLid: mongoose.Types.ObjectId;
+    sectionName?: "essentialExpenditure" | "basicCostOfLivingExpenditure" | null | undefined;
     declared?: Pound | null | undefined;
-    ons?: Pound | null | undefined;
+    expected?: Pound | null | undefined;
     actual?: Pound | null | undefined;
     rationale?: string | null | undefined;
 } & {
@@ -52,8 +55,9 @@ declare const ApplicantExpenditureModel: mongoose.Model<{
     applicantId: mongoose.Types.ObjectId;
     isFixed: boolean;
     expenditureTypeLid: mongoose.Types.ObjectId;
+    sectionName?: "essentialExpenditure" | "basicCostOfLivingExpenditure" | null | undefined;
     declared?: Pound | null | undefined;
-    ons?: Pound | null | undefined;
+    expected?: Pound | null | undefined;
     actual?: Pound | null | undefined;
     rationale?: string | null | undefined;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
@@ -63,8 +67,9 @@ declare const ApplicantExpenditureModel: mongoose.Model<{
     applicantId: mongoose.Types.ObjectId;
     isFixed: boolean;
     expenditureTypeLid: mongoose.Types.ObjectId;
+    sectionName?: "essentialExpenditure" | "basicCostOfLivingExpenditure" | null | undefined;
     declared?: Pound | null | undefined;
-    ons?: Pound | null | undefined;
+    expected?: Pound | null | undefined;
     actual?: Pound | null | undefined;
     rationale?: string | null | undefined;
 }>> & mongoose.FlatRecord<{
@@ -74,8 +79,9 @@ declare const ApplicantExpenditureModel: mongoose.Model<{
     applicantId: mongoose.Types.ObjectId;
     isFixed: boolean;
     expenditureTypeLid: mongoose.Types.ObjectId;
+    sectionName?: "essentialExpenditure" | "basicCostOfLivingExpenditure" | null | undefined;
     declared?: Pound | null | undefined;
-    ons?: Pound | null | undefined;
+    expected?: Pound | null | undefined;
     actual?: Pound | null | undefined;
     rationale?: string | null | undefined;
 }> & {

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;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAmE/C,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuE,CAAC;AACvG,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;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AA2E/C,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuE,CAAC;AACvG,eAAe,yBAAyB,CAAC"}

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

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

package/dist/applicants/applicant-income-source.model.d.ts

@@ -1,17 +1,45 @@
 import mongoose from "mongoose";
-declare const applicantIncomeSourceSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+declare const ApplicantIncomeSourceModel: mongoose.Model<{
+    applicantId: mongoose.Types.ObjectId;
+    employmentStatusLid: mongoose.Types.ObjectId;
+    incomeFromEmployment: boolean;
+    incomeFromPension: boolean;
+    incomeFromProperty: boolean;
+    incomeFromSavings: boolean;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    applicantId: mongoose.Types.ObjectId;
+    employmentStatusLid: mongoose.Types.ObjectId;
+    incomeFromEmployment: boolean;
+    incomeFromPension: boolean;
+    incomeFromProperty: boolean;
+    incomeFromSavings: boolean;
+}> & {
+    applicantId: mongoose.Types.ObjectId;
+    employmentStatusLid: mongoose.Types.ObjectId;
+    incomeFromEmployment: boolean;
+    incomeFromPension: boolean;
+    incomeFromProperty: boolean;
+    incomeFromSavings: boolean;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    applicantId: mongoose.Types.ObjectId;
     employmentStatusLid: mongoose.Types.ObjectId;
     incomeFromEmployment: boolean;
     incomeFromPension: boolean;
     incomeFromProperty: boolean;
     incomeFromSavings: boolean;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    applicantId: mongoose.Types.ObjectId;
     employmentStatusLid: mongoose.Types.ObjectId;
     incomeFromEmployment: boolean;
     incomeFromPension: boolean;
     incomeFromProperty: boolean;
     incomeFromSavings: boolean;
 }>> & mongoose.FlatRecord<{
+    applicantId: mongoose.Types.ObjectId;
     employmentStatusLid: mongoose.Types.ObjectId;
     incomeFromEmployment: boolean;
     incomeFromPension: boolean;
@@ -21,6 +49,6 @@ declare const applicantIncomeSourceSchema: mongoose.Schema<any, mongoose.Model<a
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
-}>;
-export default applicantIncomeSourceSchema;
+}>>;
+export default ApplicantIncomeSourceModel;
 //# sourceMappingURL=applicant-income-source.model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"applicant-income-source.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income-source.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AAGH,eAAe,2BAA2B,CAAC"}
+{"version":3,"file":"applicant-income-source.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income-source.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAahC,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyE,CAAC;AAE1G,eAAe,0BAA0B,CAAC"}

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

@@ -1,9 +1,12 @@
 import mongoose from "mongoose";
 const applicantIncomeSourceSchema = new mongoose.Schema({
+    applicantId: { type: mongoose.Schema.Types.ObjectId, ref: "Applicant", required: true },
     employmentStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
     incomeFromEmployment: { type: Boolean, default: false },
     incomeFromPension: { type: Boolean, default: false },
     incomeFromProperty: { type: Boolean, default: false },
     incomeFromSavings: { type: Boolean, default: false }
 });
-export default applicantIncomeSourceSchema;
+const ApplicantIncomeSourceModel = mongoose.model("Applicant_IncomeSource", applicantIncomeSourceSchema);
+export default ApplicantIncomeSourceModel;
+;

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

@@ -1,78 +1,78 @@
-import mongoose from "mongoose";
-import { Pound } from "../value-objects/pound";
-const incomeSchema = new mongoose.Schema({
-    applicantId: { type: mongoose.Schema.Types.ObjectId, ref: "Applicant", required: true },
-    accountantsAddressLine1: { type: String, required: true },
-    accountantsAddressLine2: { type: String, required: true },
-    accountantsAddressLine3: { type: String, required: true },
-    accountantsCity: { type: String, default: '' },
-    accountantsCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    accountantsEmail: { type: String, required: true },
-    accountantsPostCode: { type: String, required: true },
-    accountantsPractice: { type: String, required: true },
-    accountantsTelephoneNumber: { type: String, required: true },
-    businessAddressLine1: { type: String, required: true },
-    businessAddressLine2: { type: String, required: true },
-    businessAddressLine3: { type: String, required: true },
-    businessCity: { type: String, default: '' },
-    businessCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    businessPostCode: { type: String, required: true },
-    businessTelephoneNumber: { type: String, required: true },
-    businessTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    charteredCertifiedOrOtherLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    contactName: { type: String, required: true },
-    currentYearEnd: { type: String, required: true },
-    dateEstablished: { type: String, required: true },
-    doYouHaveAccountant: {
-        type: Boolean,
-        required: true,
-    },
-    isBusinessAddressDifferent: {
-        type: Boolean,
-        required: true,
-    },
-    nameOfBusiness: { type: String, required: true },
-    natureOfBusiness: { type: String, required: true },
-    netAssets1: { type: Pound, default: 0.00 },
-    netAssets2: { type: Pound, default: 0.00 },
-    netAssets3: { type: Pound, default: 0.00 },
-    pageValidFlag: { type: String, default: true },
-    percentageOfShareholding: { type: Number, required: true, min: 0, max: 100 },
-    registeredAddressLine1: { type: String, required: true },
-    registeredAddressLine2: { type: String, required: true },
-    registeredAddressLine3: { type: String, required: true },
-    registeredCity: { type: String, default: '' },
-    registeredCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    registeredPostCode: { type: String, required: true },
-    registeredTelephone: { type: String, required: true },
-    selfEmployedDate: { type: String, required: true },
-    totalEmploymentGrossIncome: { type: Pound, default: 0.00 },
-    totalEmploymentNetIncome: { type: Pound, default: 0.00 },
-    isEmploymentIncomeConfirmed: { type: Boolean, default: false },
-    employmentIncomeRationale: { type: String, default: null },
-    isPensionIncomeConfirmed: { type: Boolean, default: false },
-    pensionIncomeRationale: { type: String, default: null },
-    totalAdditionalGrossIncome: { type: Pound, default: 0.00 },
-    totalAdditionalNetIncome: { type: Pound, default: 0.00 },
-    isAdditionalIncomeConfirmed: { type: Boolean, default: false },
-    additionalIncomeRationale: { type: String, default: null },
-    isUKTaxCreditsIncomeConfirmed: { type: Boolean, default: false },
-    ukTaxCreditsIncomeRationale: { type: String, default: null },
-    totalPropertyGrossIncome: { type: Pound, default: 0.00 },
-    totalPropertyNetIncome: { type: Pound, default: 0.00 },
-    isPropertyIncomeConfirmed: { type: Boolean, default: false },
-    propertyIncomeRationale: { type: String, default: null },
-    selfEmployedIncomeRationale: { type: String, default: null },
-    isSelfEmployedIncomeConfirmed: { type: Boolean, default: false },
-    totalSelfEmployedGrossIncome: { type: Pound, default: 0.00 },
-    totalSelfEmployedNetIncome: { type: Pound, default: 0.00 },
-    soleTraderIncomeRationale: { type: String, default: null },
-    soleTraderIncomeConfirmed: { type: Boolean, default: false },
-    soleTraderGrossIncome: { type: Pound, default: 0.00 },
-    soleTraderNetIncome: { type: Pound, default: 0.00 },
-}, {
-    toJSON: { getters: true },
-    toObject: { getters: true }
-});
-const ApplicantIncomeModel = mongoose.model("Applicant_Income", incomeSchema);
-export default ApplicantIncomeModel;
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+const incomeSchema = new mongoose.Schema({
+    applicantId: { type: mongoose.Schema.Types.ObjectId, ref: "Applicant", required: true },
+    accountantsAddressLine1: { type: String, required: true },
+    accountantsAddressLine2: { type: String, required: true },
+    accountantsAddressLine3: { type: String, required: true },
+    accountantsCity: { type: String, default: '' },
+    accountantsCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    accountantsEmail: { type: String, required: true },
+    accountantsPostCode: { type: String, required: true },
+    accountantsPractice: { type: String, required: true },
+    accountantsTelephoneNumber: { type: String, required: true },
+    businessAddressLine1: { type: String, required: true },
+    businessAddressLine2: { type: String, required: true },
+    businessAddressLine3: { type: String, required: true },
+    businessCity: { type: String, default: '' },
+    businessCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    businessPostCode: { type: String, required: true },
+    businessTelephoneNumber: { type: String, required: true },
+    businessTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    charteredCertifiedOrOtherLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    contactName: { type: String, required: true },
+    currentYearEnd: { type: String, required: true },
+    dateEstablished: { type: String, required: true },
+    doYouHaveAccountant: {
+        type: Boolean,
+        required: true,
+    },
+    isBusinessAddressDifferent: {
+        type: Boolean,
+        required: true,
+    },
+    nameOfBusiness: { type: String, required: true },
+    natureOfBusiness: { type: String, required: true },
+    netAssets1: { type: Pound, default: 0.00 },
+    netAssets2: { type: Pound, default: 0.00 },
+    netAssets3: { type: Pound, default: 0.00 },
+    pageValidFlag: { type: String, default: true },
+    percentageOfShareholding: { type: Number, required: true, min: 0, max: 100 },
+    registeredAddressLine1: { type: String, required: true },
+    registeredAddressLine2: { type: String, required: true },
+    registeredAddressLine3: { type: String, required: true },
+    registeredCity: { type: String, default: '' },
+    registeredCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    registeredPostCode: { type: String, required: true },
+    registeredTelephone: { type: String, required: true },
+    selfEmployedDate: { type: String, required: true },
+    totalEmploymentGrossIncome: { type: Pound, default: 0.00 },
+    totalEmploymentNetIncome: { type: Pound, default: 0.00 },
+    isEmploymentIncomeConfirmed: { type: Boolean, default: false },
+    employmentIncomeRationale: { type: String, default: null },
+    isPensionIncomeConfirmed: { type: Boolean, default: false },
+    pensionIncomeRationale: { type: String, default: null },
+    totalAdditionalGrossIncome: { type: Pound, default: 0.00 },
+    totalAdditionalNetIncome: { type: Pound, default: 0.00 },
+    isAdditionalIncomeConfirmed: { type: Boolean, default: false },
+    additionalIncomeRationale: { type: String, default: null },
+    isUKTaxCreditsIncomeConfirmed: { type: Boolean, default: false },
+    ukTaxCreditsIncomeRationale: { type: String, default: null },
+    totalPropertyGrossIncome: { type: Pound, default: 0.00 },
+    totalPropertyNetIncome: { type: Pound, default: 0.00 },
+    isPropertyIncomeConfirmed: { type: Boolean, default: false },
+    propertyIncomeRationale: { type: String, default: null },
+    selfEmployedIncomeRationale: { type: String, default: null },
+    isSelfEmployedIncomeConfirmed: { type: Boolean, default: false },
+    totalSelfEmployedGrossIncome: { type: Pound, default: 0.00 },
+    totalSelfEmployedNetIncome: { type: Pound, default: 0.00 },
+    soleTraderIncomeRationale: { type: String, default: null },
+    soleTraderIncomeConfirmed: { type: Boolean, default: false },
+    soleTraderGrossIncome: { type: Pound, default: 0.00 },
+    soleTraderNetIncome: { type: Pound, default: 0.00 },
+}, {
+    toJSON: { getters: true },
+    toObject: { getters: true }
+});
+const ApplicantIncomeModel = mongoose.model("Applicant_Income", incomeSchema);
+export default ApplicantIncomeModel;