@dynamatix/gb-schemas 1.2.13 → 1.2.15

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

@@ -1,16 +1,23 @@
 import mongoose from "mongoose";
-declare const incomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
-    businessType: string;
+import { Pound } from "../value-objects/pound";
+declare const incomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    toJSON: {
+        getters: true;
+    };
+    toObject: {
+        getters: true;
+    };
+}, {
     natureOfBusiness: string;
-    yearEnd1: string;
-    yearEnd2: string;
-    yearEnd3: string;
+    yearEnd1: number;
+    yearEnd2: number;
+    yearEnd3: number;
     pageValidFlag: string;
     accountantsAddressLine1: string;
     accountantsAddressLine2: string;
     accountantsAddressLine3: string;
     accountantsCity: string;
-    accountantsCountry: string;
+    accountantsCountryLid: mongoose.Types.ObjectId;
     accountantsEmail: string;
     accountantsPostCode: string;
     accountantsPractice: string;
@@ -19,46 +26,46 @@ declare const incomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     businessAddressLine2: string;
     businessAddressLine3: string;
     businessCity: string;
-    businessCountry: string;
+    businessCountryLid: mongoose.Types.ObjectId;
     businessPostCode: string;
     businessTelephoneNumber: string;
-    charteredCertifiedOrOther: string;
+    businessTypeLid: mongoose.Types.ObjectId;
+    charteredCertifiedOrOtherLid: mongoose.Types.ObjectId;
     contactName: string;
     currentYearEnd: string;
     dateEstablished: string;
-    doYouHaveAccountant: string;
-    isBusinessAddressDifferent: string;
+    doYouHaveAccountant: boolean;
+    isBusinessAddressDifferent: boolean;
     nameOfBusiness: string;
-    netAssets1: string;
-    netAssets2: string;
-    netAssets3: string;
-    percentageOfShareholding: string;
+    netAssets1: Pound;
+    netAssets2: Pound;
+    netAssets3: Pound;
+    percentageOfShareholding: number;
     registeredAddressLine1: string;
     registeredAddressLine2: string;
     registeredAddressLine3: string;
     registeredCity: string;
-    registeredCountry: string;
+    registeredCountryLid: mongoose.Types.ObjectId;
     registeredPostCode: string;
     registeredTelephone: string;
     selfEmployedDate: string;
-    turnover1: string;
-    turnover2: string;
-    turnover3: string;
-    year1: string;
-    year2: string;
-    year3: string;
+    turnover1: Pound;
+    turnover2: Pound;
+    turnover3: Pound;
+    year1: Pound;
+    year2: Pound;
+    year3: Pound;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    businessType: string;
     natureOfBusiness: string;
-    yearEnd1: string;
-    yearEnd2: string;
-    yearEnd3: string;
+    yearEnd1: number;
+    yearEnd2: number;
+    yearEnd3: number;
     pageValidFlag: string;
     accountantsAddressLine1: string;
     accountantsAddressLine2: string;
     accountantsAddressLine3: string;
     accountantsCity: string;
-    accountantsCountry: string;
+    accountantsCountryLid: mongoose.Types.ObjectId;
     accountantsEmail: string;
     accountantsPostCode: string;
     accountantsPractice: string;
@@ -67,46 +74,46 @@ declare const incomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     businessAddressLine2: string;
     businessAddressLine3: string;
     businessCity: string;
-    businessCountry: string;
+    businessCountryLid: mongoose.Types.ObjectId;
     businessPostCode: string;
     businessTelephoneNumber: string;
-    charteredCertifiedOrOther: string;
+    businessTypeLid: mongoose.Types.ObjectId;
+    charteredCertifiedOrOtherLid: mongoose.Types.ObjectId;
     contactName: string;
     currentYearEnd: string;
     dateEstablished: string;
-    doYouHaveAccountant: string;
-    isBusinessAddressDifferent: string;
+    doYouHaveAccountant: boolean;
+    isBusinessAddressDifferent: boolean;
     nameOfBusiness: string;
-    netAssets1: string;
-    netAssets2: string;
-    netAssets3: string;
-    percentageOfShareholding: string;
+    netAssets1: Pound;
+    netAssets2: Pound;
+    netAssets3: Pound;
+    percentageOfShareholding: number;
     registeredAddressLine1: string;
     registeredAddressLine2: string;
     registeredAddressLine3: string;
     registeredCity: string;
-    registeredCountry: string;
+    registeredCountryLid: mongoose.Types.ObjectId;
     registeredPostCode: string;
     registeredTelephone: string;
     selfEmployedDate: string;
-    turnover1: string;
-    turnover2: string;
-    turnover3: string;
-    year1: string;
-    year2: string;
-    year3: string;
+    turnover1: Pound;
+    turnover2: Pound;
+    turnover3: Pound;
+    year1: Pound;
+    year2: Pound;
+    year3: Pound;
 }>> & mongoose.FlatRecord<{
-    businessType: string;
     natureOfBusiness: string;
-    yearEnd1: string;
-    yearEnd2: string;
-    yearEnd3: string;
+    yearEnd1: number;
+    yearEnd2: number;
+    yearEnd3: number;
     pageValidFlag: string;
     accountantsAddressLine1: string;
     accountantsAddressLine2: string;
     accountantsAddressLine3: string;
     accountantsCity: string;
-    accountantsCountry: string;
+    accountantsCountryLid: mongoose.Types.ObjectId;
     accountantsEmail: string;
     accountantsPostCode: string;
     accountantsPractice: string;
@@ -115,34 +122,35 @@ declare const incomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     businessAddressLine2: string;
     businessAddressLine3: string;
     businessCity: string;
-    businessCountry: string;
+    businessCountryLid: mongoose.Types.ObjectId;
     businessPostCode: string;
     businessTelephoneNumber: string;
-    charteredCertifiedOrOther: string;
+    businessTypeLid: mongoose.Types.ObjectId;
+    charteredCertifiedOrOtherLid: mongoose.Types.ObjectId;
     contactName: string;
     currentYearEnd: string;
     dateEstablished: string;
-    doYouHaveAccountant: string;
-    isBusinessAddressDifferent: string;
+    doYouHaveAccountant: boolean;
+    isBusinessAddressDifferent: boolean;
     nameOfBusiness: string;
-    netAssets1: string;
-    netAssets2: string;
-    netAssets3: string;
-    percentageOfShareholding: string;
+    netAssets1: Pound;
+    netAssets2: Pound;
+    netAssets3: Pound;
+    percentageOfShareholding: number;
     registeredAddressLine1: string;
     registeredAddressLine2: string;
     registeredAddressLine3: string;
     registeredCity: string;
-    registeredCountry: string;
+    registeredCountryLid: mongoose.Types.ObjectId;
     registeredPostCode: string;
     registeredTelephone: string;
     selfEmployedDate: string;
-    turnover1: string;
-    turnover2: string;
-    turnover3: string;
-    year1: string;
-    year2: string;
-    year3: string;
+    turnover1: Pound;
+    turnover2: Pound;
+    turnover3: Pound;
+    year1: Pound;
+    year2: Pound;
+    year3: Pound;
 }> & {
     _id: mongoose.Types.ObjectId;
 } & {

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

@@ -1 +1 @@
-{"version":3,"file":"applicant-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDhB,CAAC;AAEH,eAAe,YAAY,CAAC"}
+{"version":3,"file":"applicant-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-income.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DhB,CAAC;AAEH,eAAe,YAAY,CAAC"}

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

@@ -1,51 +1,63 @@
 import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
 const incomeSchema = new mongoose.Schema({
-    accountantsAddressLine1: { type: String, default: '' },
-    accountantsAddressLine2: { type: String, default: '' },
-    accountantsAddressLine3: { type: String, default: '' },
+    accountantsAddressLine1: { type: String, required: true },
+    accountantsAddressLine2: { type: String, required: true },
+    accountantsAddressLine3: { type: String, required: true },
     accountantsCity: { type: String, default: '' },
-    accountantsCountry: { type: String, default: 'GBR' },
-    accountantsEmail: { type: String, default: '' },
-    accountantsPostCode: { type: String, default: '' },
-    accountantsPractice: { type: String, default: '' },
-    accountantsTelephoneNumber: { type: String, default: '' },
-    businessAddressLine1: { type: String, default: '' },
-    businessAddressLine2: { type: String, default: '' },
-    businessAddressLine3: { type: String, default: '' },
+    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: '' },
-    businessCountry: { type: String, default: 'GBR' },
-    businessPostCode: { type: String, default: '' },
-    businessTelephoneNumber: { type: String, default: '' },
-    businessType: { type: String, default: '4' },
-    charteredCertifiedOrOther: { type: String, default: '' },
-    contactName: { type: String, default: '' },
-    currentYearEnd: { type: String, default: null },
-    dateEstablished: { type: String, default: null },
-    doYouHaveAccountant: { type: String, default: false },
-    isBusinessAddressDifferent: { type: String, default: false },
-    nameOfBusiness: { type: String, default: '' },
-    natureOfBusiness: { type: String, default: '' },
-    netAssets1: { type: String, default: 0.0 },
-    netAssets2: { type: String, default: 0.0 },
-    netAssets3: { type: String, default: 0.0 },
+    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,
+        get: (v) => v ? "Yes" : "No"
+    },
+    isBusinessAddressDifferent: {
+        type: Boolean,
+        required: true,
+        get: (v) => v ? "Yes" : "No"
+    },
+    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: String, default: 100 },
-    registeredAddressLine1: { type: String, default: '' },
-    registeredAddressLine2: { type: String, default: '' },
-    registeredAddressLine3: { type: String, default: '' },
+    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: '' },
-    registeredCountry: { type: String, default: 'GBR' },
-    registeredPostCode: { type: String, default: '' },
-    registeredTelephone: { type: String, default: '' },
-    selfEmployedDate: { type: String, default: null },
-    turnover1: { type: String, default: 0.0 },
-    turnover2: { type: String, default: 0.0 },
-    turnover3: { type: String, default: 0.0 },
-    year1: { type: String, default: 0.0 },
-    year2: { type: String, default: 0.0 },
-    year3: { type: String, default: 0.0 },
-    yearEnd1: { type: String, default: '' },
-    yearEnd2: { type: String, default: '' },
-    yearEnd3: { type: String, default: '' }
+    registeredCountryLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    registeredPostCode: { type: String, required: true },
+    registeredTelephone: { type: String, required: true },
+    selfEmployedDate: { type: String, required: true },
+    turnover1: { type: Pound, default: '£0.00' },
+    turnover2: { type: Pound, default: '£0.00' },
+    turnover3: { type: Pound, default: '£0.00' },
+    year1: { type: Pound, default: '£0.00' },
+    year2: { type: Pound, default: '£0.00' },
+    year3: { type: Pound, default: '£0.00' },
+    yearEnd1: { type: Number, default: '' },
+    yearEnd2: { type: Number, default: '' },
+    yearEnd3: { type: Number, default: '' }
+}, {
+    toJSON: { getters: true },
+    toObject: { getters: true }
 });
 export default incomeSchema;

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

@@ -1,64 +1,81 @@
 import mongoose from "mongoose";
-declare const applicantOtherIncomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
-    maintenance?: string | null | undefined;
-    amount1?: string | null | undefined;
-    amount2?: string | null | undefined;
-    amount3?: string | null | undefined;
-    amount4?: string | null | undefined;
-    guaranteed1?: string | null | undefined;
-    guaranteed2?: string | null | undefined;
-    guaranteed3?: string | null | undefined;
-    guaranteed4?: string | null | undefined;
-    otherBenefits?: string | null | undefined;
-    payFrequency1?: string | null | undefined;
-    payFrequency2?: string | null | undefined;
-    payFrequency3?: string | null | undefined;
-    payFrequency4?: string | null | undefined;
-    sourceDetails1?: string | null | undefined;
-    sourceDetails2?: string | null | undefined;
-    sourceDetails3?: string | null | undefined;
-    sourceDetails4?: string | null | undefined;
-    taxCredits?: string | null | undefined;
+import { Pound } from "../value-objects/pound";
+declare const applicantOtherIncomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    toJSON: {
+        getters: true;
+    };
+    toObject: {
+        getters: true;
+    };
+}, {
+    maintenance: Pound;
+    sourceDetails1: string;
+    amount1: Pound;
+    payFrequency1Lid: mongoose.Types.ObjectId;
+    guaranteed1: boolean;
+    sourceDetails2: string;
+    amount2: Pound;
+    payFrequency2Lid: mongoose.Types.ObjectId;
+    guaranteed2: boolean;
+    sourceDetails3: string;
+    amount3: Pound;
+    payFrequency3Lid: mongoose.Types.ObjectId;
+    guaranteed3: boolean;
+    sourceDetails4: string;
+    amount4: Pound;
+    payFrequency4Lid: mongoose.Types.ObjectId;
+    guaranteed4: boolean;
+    taxCredits: Pound;
+    otherBenefits: Pound;
+    grossPensionIncome: Pound;
+    privatePensionIncome: Pound;
+    statePensionIncome: Pound;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    maintenance?: string | null | undefined;
-    amount1?: string | null | undefined;
-    amount2?: string | null | undefined;
-    amount3?: string | null | undefined;
-    amount4?: string | null | undefined;
-    guaranteed1?: string | null | undefined;
-    guaranteed2?: string | null | undefined;
-    guaranteed3?: string | null | undefined;
-    guaranteed4?: string | null | undefined;
-    otherBenefits?: string | null | undefined;
-    payFrequency1?: string | null | undefined;
-    payFrequency2?: string | null | undefined;
-    payFrequency3?: string | null | undefined;
-    payFrequency4?: string | null | undefined;
-    sourceDetails1?: string | null | undefined;
-    sourceDetails2?: string | null | undefined;
-    sourceDetails3?: string | null | undefined;
-    sourceDetails4?: string | null | undefined;
-    taxCredits?: string | null | undefined;
+    maintenance: Pound;
+    sourceDetails1: string;
+    amount1: Pound;
+    payFrequency1Lid: mongoose.Types.ObjectId;
+    guaranteed1: boolean;
+    sourceDetails2: string;
+    amount2: Pound;
+    payFrequency2Lid: mongoose.Types.ObjectId;
+    guaranteed2: boolean;
+    sourceDetails3: string;
+    amount3: Pound;
+    payFrequency3Lid: mongoose.Types.ObjectId;
+    guaranteed3: boolean;
+    sourceDetails4: string;
+    amount4: Pound;
+    payFrequency4Lid: mongoose.Types.ObjectId;
+    guaranteed4: boolean;
+    taxCredits: Pound;
+    otherBenefits: Pound;
+    grossPensionIncome: Pound;
+    privatePensionIncome: Pound;
+    statePensionIncome: Pound;
 }>> & mongoose.FlatRecord<{
-    maintenance?: string | null | undefined;
-    amount1?: string | null | undefined;
-    amount2?: string | null | undefined;
-    amount3?: string | null | undefined;
-    amount4?: string | null | undefined;
-    guaranteed1?: string | null | undefined;
-    guaranteed2?: string | null | undefined;
-    guaranteed3?: string | null | undefined;
-    guaranteed4?: string | null | undefined;
-    otherBenefits?: string | null | undefined;
-    payFrequency1?: string | null | undefined;
-    payFrequency2?: string | null | undefined;
-    payFrequency3?: string | null | undefined;
-    payFrequency4?: string | null | undefined;
-    sourceDetails1?: string | null | undefined;
-    sourceDetails2?: string | null | undefined;
-    sourceDetails3?: string | null | undefined;
-    sourceDetails4?: string | null | undefined;
-    taxCredits?: string | null | undefined;
+    maintenance: Pound;
+    sourceDetails1: string;
+    amount1: Pound;
+    payFrequency1Lid: mongoose.Types.ObjectId;
+    guaranteed1: boolean;
+    sourceDetails2: string;
+    amount2: Pound;
+    payFrequency2Lid: mongoose.Types.ObjectId;
+    guaranteed2: boolean;
+    sourceDetails3: string;
+    amount3: Pound;
+    payFrequency3Lid: mongoose.Types.ObjectId;
+    guaranteed3: boolean;
+    sourceDetails4: string;
+    amount4: Pound;
+    payFrequency4Lid: mongoose.Types.ObjectId;
+    guaranteed4: boolean;
+    taxCredits: Pound;
+    otherBenefits: Pound;
+    grossPensionIncome: Pound;
+    privatePensionIncome: Pound;
+    statePensionIncome: Pound;
 }> & {
     _id: mongoose.Types.ObjectId;
 } & {

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

@@ -1 +1 @@
-{"version":3,"file":"applicant-other-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-other-income.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB9B,CAAC;AAEH,eAAe,0BAA0B,CAAC"}
+{"version":3,"file":"applicant-other-income.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-other-income.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiD9B,CAAC;AAEH,eAAe,0BAA0B,CAAC"}

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

@@ -1,23 +1,50 @@
 import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
 const applicantOtherIncomeSchema = new mongoose.Schema({
-    amount1: { type: String },
-    amount2: { type: String },
-    amount3: { type: String },
-    amount4: { type: String },
-    guaranteed1: { type: String },
-    guaranteed2: { type: String },
-    guaranteed3: { type: String },
-    guaranteed4: { type: String },
-    maintenance: { type: String },
-    otherBenefits: { type: String },
-    payFrequency1: { type: String },
-    payFrequency2: { type: String },
-    payFrequency3: { type: String },
-    payFrequency4: { type: String },
-    sourceDetails1: { type: String },
-    sourceDetails2: { type: String },
-    sourceDetails3: { type: String },
-    sourceDetails4: { type: String },
-    taxCredits: { type: String }
+    // Income Source 1
+    sourceDetails1: { type: String, default: null },
+    amount1: { type: Pound, default: '£0.00' },
+    payFrequency1Lid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    guaranteed1: {
+        type: Boolean,
+        default: false,
+        get: (v) => v ? "Yes" : "No"
+    },
+    // Income Source 2
+    sourceDetails2: { type: String, default: null },
+    amount2: { type: Pound, default: '£0.00' },
+    payFrequency2Lid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    guaranteed2: {
+        type: Boolean,
+        default: false,
+        get: (v) => v ? "Yes" : "No"
+    },
+    // Income Source 3
+    sourceDetails3: { type: String, default: null },
+    amount3: { type: Pound, default: '£0.00' },
+    payFrequency3Lid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    guaranteed3: {
+        type: Boolean,
+        default: false,
+        get: (v) => v ? "Yes" : "No"
+    },
+    // Income Source 4
+    sourceDetails4: { type: String, default: null },
+    amount4: { type: Pound, default: '£0.00' },
+    payFrequency4Lid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    guaranteed4: {
+        type: Boolean,
+        default: false,
+        get: (v) => v ? "Yes" : "No"
+    },
+    taxCredits: { type: Pound, default: '£0.00' },
+    maintenance: { type: Pound, default: '£0.00' },
+    otherBenefits: { type: Pound, default: '£0.00' },
+    grossPensionIncome: { type: Pound, default: '£0.00' },
+    privatePensionIncome: { type: Pound, default: '£0.00' },
+    statePensionIncome: { type: Pound, default: '£0.00' },
+}, {
+    toJSON: { getters: true },
+    toObject: { getters: true }
 });
 export default applicantOtherIncomeSchema;

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

@@ -0,0 +1,49 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+declare const propertyIncomeSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    toJSON: {
+        getters: true;
+    };
+    toObject: {
+        getters: true;
+    };
+}, {
+    yearEnd1: number;
+    yearEnd2: number;
+    yearEnd3: number;
+    pageValidFlag: boolean;
+    rentalIncome1: Pound;
+    netProfit1: Pound;
+    rentalIncome2: Pound;
+    netProfit2: Pound;
+    rentalIncome3: Pound;
+    netProfit3: Pound;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    yearEnd1: number;
+    yearEnd2: number;
+    yearEnd3: number;
+    pageValidFlag: boolean;
+    rentalIncome1: Pound;
+    netProfit1: Pound;
+    rentalIncome2: Pound;
+    netProfit2: Pound;
+    rentalIncome3: Pound;
+    netProfit3: Pound;
+}>> & mongoose.FlatRecord<{
+    yearEnd1: number;
+    yearEnd2: number;
+    yearEnd3: number;
+    pageValidFlag: boolean;
+    rentalIncome1: Pound;
+    netProfit1: Pound;
+    rentalIncome2: Pound;
+    netProfit2: Pound;
+    rentalIncome3: Pound;
+    netProfit3: Pound;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default propertyIncomeSchema;
+//# sourceMappingURL=applicant-property-income.model.d.ts.map

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

@@ -0,0 +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;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBxB,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

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

@@ -0,0 +1,21 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+const propertyIncomeSchema = new mongoose.Schema({
+    pageValidFlag: { type: Boolean, default: false },
+    // Latest tax year
+    yearEnd1: { type: Number, required: true },
+    rentalIncome1: { type: Pound, required: true },
+    netProfit1: { type: Pound, required: true },
+    // Previous tax year
+    yearEnd2: { type: Number, required: true },
+    rentalIncome2: { type: Pound, required: true },
+    netProfit2: { type: Pound, required: true },
+    // Previous tax year
+    yearEnd3: { type: Number, required: true },
+    rentalIncome3: { type: Pound, required: true },
+    netProfit3: { type: Pound, required: true }
+}, {
+    toJSON: { getters: true },
+    toObject: { getters: true }
+});
+export default propertyIncomeSchema;