@dynamatix/gb-schemas 2.0.22 → 2.0.24

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

@@ -0,0 +1,175 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+declare const ApplicantEmploymentIncomeModel: mongoose.Model<{
+    applicantId?: mongoose.Types.ObjectId | null | undefined;
+    amount?: {
+        validators: mongoose.Types.DocumentArray<{
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }> & {
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }>;
+        get?: {} | null | undefined;
+        schema?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        set?: {} | null | undefined;
+        validate?: {} | null | undefined;
+        default?: {} | null | undefined;
+        text?: {} | null | undefined;
+        unique?: {} | null | undefined;
+        index?: {} | null | undefined;
+        sparse?: {} | null | undefined;
+        required?: {} | null | undefined;
+        ref?: {} | null | undefined;
+        cast?: {} | null | undefined;
+        select?: {} | null | undefined;
+        immutable?: {} | null | undefined;
+        transform?: {} | null | undefined;
+        options?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        OptionsConstructor?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        getEmbeddedSchemaType?: {} | null | undefined;
+        instance?: unknown;
+        isRequired?: unknown;
+        path?: unknown;
+        validateAll?: {} | null | undefined;
+        defaultOptions?: unknown;
+    } | null | undefined;
+    incomeTypeLid?: mongoose.Types.ObjectId | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    applicantId?: mongoose.Types.ObjectId | null | undefined;
+    amount?: {
+        validators: mongoose.Types.DocumentArray<{
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }> & {
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }>;
+        get?: {} | null | undefined;
+        schema?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        set?: {} | null | undefined;
+        validate?: {} | null | undefined;
+        default?: {} | null | undefined;
+        text?: {} | null | undefined;
+        unique?: {} | null | undefined;
+        index?: {} | null | undefined;
+        sparse?: {} | null | undefined;
+        required?: {} | null | undefined;
+        ref?: {} | null | undefined;
+        cast?: {} | null | undefined;
+        select?: {} | null | undefined;
+        immutable?: {} | null | undefined;
+        transform?: {} | null | undefined;
+        options?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        OptionsConstructor?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        getEmbeddedSchemaType?: {} | null | undefined;
+        instance?: unknown;
+        isRequired?: unknown;
+        path?: unknown;
+        validateAll?: {} | null | undefined;
+        defaultOptions?: unknown;
+    } | null | undefined;
+    incomeTypeLid?: mongoose.Types.ObjectId | null | undefined;
+}> & {
+    applicantId?: mongoose.Types.ObjectId | null | undefined;
+    amount?: {
+        validators: mongoose.Types.DocumentArray<{
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }> & {
+            type?: unknown;
+            message?: unknown;
+            validator?: unknown;
+            reason?: unknown;
+        }>;
+        get?: {} | null | undefined;
+        schema?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        set?: {} | null | undefined;
+        validate?: {} | null | undefined;
+        default?: {} | null | undefined;
+        text?: {} | null | undefined;
+        unique?: {} | null | undefined;
+        index?: {} | null | undefined;
+        sparse?: {} | null | undefined;
+        required?: {} | null | undefined;
+        ref?: {} | null | undefined;
+        cast?: {} | null | undefined;
+        select?: {} | null | undefined;
+        immutable?: {} | null | undefined;
+        transform?: {} | null | undefined;
+        options?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        OptionsConstructor?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        getEmbeddedSchemaType?: {} | null | undefined;
+        instance?: unknown;
+        isRequired?: unknown;
+        path?: unknown;
+        validateAll?: {} | null | undefined;
+        defaultOptions?: unknown;
+    } | null | undefined;
+    incomeTypeLid?: mongoose.Types.ObjectId | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    applicantId: mongoose.Types.ObjectId;
+    amount: Pound;
+    incomeTypeLid: mongoose.Types.ObjectId;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    applicantId: mongoose.Types.ObjectId;
+    amount: Pound;
+    incomeTypeLid: mongoose.Types.ObjectId;
+}>> & mongoose.FlatRecord<{
+    applicantId: mongoose.Types.ObjectId;
+    amount: Pound;
+    incomeTypeLid: mongoose.Types.ObjectId;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default ApplicantEmploymentIncomeModel;
+//# sourceMappingURL=applicant-employment-income.model.d.ts.map

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

@@ -0,0 +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;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAS/C,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAgF,CAAC;AAErH,eAAe,8BAA8B,CAAC"}

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

@@ -0,0 +1,9 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+const applicantEmploymentIncomeSchema = new mongoose.Schema({
+    applicantId: { type: mongoose.Schema.Types.ObjectId, ref: "Applicant", required: true },
+    incomeTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    amount: { type: Pound, required: true },
+});
+const ApplicantEmploymentIncomeModel = mongoose.model("Applicant_EmploymentIncome", applicantEmploymentIncomeSchema);
+export default ApplicantEmploymentIncomeModel;

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

@@ -0,0 +1,136 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+declare const applicantEmploymentSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    toJSON: {
+        getters: true;
+    };
+    toObject: {
+        getters: true;
+    };
+}, {
+    pageValidFlag: boolean;
+    natureOfBusiness: string;
+    addressPostCode: string;
+    addressLine1: string;
+    addressLine2: string;
+    addressLine3: string;
+    addressCity: string;
+    addressCountryLid: mongoose.Types.ObjectId;
+    acceptableIncomeLids: mongoose.Types.ObjectId[];
+    averageBonusPreviousTwoYears: Pound;
+    basicGrossIncome: Pound;
+    dateJoined: string;
+    disabilityLiving: Pound;
+    employerName: string;
+    employerTelephone: string;
+    housingAllowance: Pound;
+    industryLid: mongoose.Types.ObjectId;
+    isUnderTerminationNotice: boolean;
+    jobTitleLid: mongoose.Types.ObjectId;
+    maintenance: Pound;
+    maternityIncome: Pound;
+    pensionIncome: Pound;
+    previousAddressCity: string;
+    previousAddressCountry: string;
+    previousAddressLine1: string;
+    previousAddressLine2: string;
+    previousAddressLine3: string;
+    previousAddressPostCode: string;
+    previousBasicGrossIncome: Pound;
+    previousDateJoined: string;
+    previousDateLeft: string;
+    previousEmployerName: string;
+    previousEmployerTelephone: string;
+    previousJobTitle: string;
+    previousNatureOfBusiness: string;
+    referenceContact: string;
+    referenceContactEmail: string;
+    underTerminationNoticeNote: string;
+    contractRemaining?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    pageValidFlag: boolean;
+    natureOfBusiness: string;
+    addressPostCode: string;
+    addressLine1: string;
+    addressLine2: string;
+    addressLine3: string;
+    addressCity: string;
+    addressCountryLid: mongoose.Types.ObjectId;
+    acceptableIncomeLids: mongoose.Types.ObjectId[];
+    averageBonusPreviousTwoYears: Pound;
+    basicGrossIncome: Pound;
+    dateJoined: string;
+    disabilityLiving: Pound;
+    employerName: string;
+    employerTelephone: string;
+    housingAllowance: Pound;
+    industryLid: mongoose.Types.ObjectId;
+    isUnderTerminationNotice: boolean;
+    jobTitleLid: mongoose.Types.ObjectId;
+    maintenance: Pound;
+    maternityIncome: Pound;
+    pensionIncome: Pound;
+    previousAddressCity: string;
+    previousAddressCountry: string;
+    previousAddressLine1: string;
+    previousAddressLine2: string;
+    previousAddressLine3: string;
+    previousAddressPostCode: string;
+    previousBasicGrossIncome: Pound;
+    previousDateJoined: string;
+    previousDateLeft: string;
+    previousEmployerName: string;
+    previousEmployerTelephone: string;
+    previousJobTitle: string;
+    previousNatureOfBusiness: string;
+    referenceContact: string;
+    referenceContactEmail: string;
+    underTerminationNoticeNote: string;
+    contractRemaining?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    pageValidFlag: boolean;
+    natureOfBusiness: string;
+    addressPostCode: string;
+    addressLine1: string;
+    addressLine2: string;
+    addressLine3: string;
+    addressCity: string;
+    addressCountryLid: mongoose.Types.ObjectId;
+    acceptableIncomeLids: mongoose.Types.ObjectId[];
+    averageBonusPreviousTwoYears: Pound;
+    basicGrossIncome: Pound;
+    dateJoined: string;
+    disabilityLiving: Pound;
+    employerName: string;
+    employerTelephone: string;
+    housingAllowance: Pound;
+    industryLid: mongoose.Types.ObjectId;
+    isUnderTerminationNotice: boolean;
+    jobTitleLid: mongoose.Types.ObjectId;
+    maintenance: Pound;
+    maternityIncome: Pound;
+    pensionIncome: Pound;
+    previousAddressCity: string;
+    previousAddressCountry: string;
+    previousAddressLine1: string;
+    previousAddressLine2: string;
+    previousAddressLine3: string;
+    previousAddressPostCode: string;
+    previousBasicGrossIncome: Pound;
+    previousDateJoined: string;
+    previousDateLeft: string;
+    previousEmployerName: string;
+    previousEmployerTelephone: string;
+    previousJobTitle: string;
+    previousNatureOfBusiness: string;
+    referenceContact: string;
+    referenceContactEmail: string;
+    underTerminationNoticeNote: string;
+    contractRemaining?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default applicantEmploymentSchema;
+//# sourceMappingURL=applicant-employment.model.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+const applicantEmploymentSchema = new mongoose.Schema({
+    pageValidFlag: { type: Boolean, default: false },
+    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 }
+});
+export default applicantEmploymentSchema;

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

@@ -0,0 +1,87 @@
+import mongoose from "mongoose";
+import { Pound } from "../value-objects/pound";
+declare const ApplicantExpenditureModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicantId: mongoose.Types.ObjectId;
+    isFixed: boolean;
+    expenditureTypeLid: mongoose.Types.ObjectId;
+    declared?: Pound | null | undefined;
+    ons?: Pound | null | undefined;
+    actual?: Pound | null | undefined;
+    rationale?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicantId: mongoose.Types.ObjectId;
+    isFixed: boolean;
+    expenditureTypeLid: mongoose.Types.ObjectId;
+    declared?: Pound | null | undefined;
+    ons?: Pound | null | undefined;
+    actual?: Pound | null | undefined;
+    rationale?: string | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicantId: mongoose.Types.ObjectId;
+    isFixed: boolean;
+    expenditureTypeLid: mongoose.Types.ObjectId;
+    declared?: Pound | null | undefined;
+    ons?: Pound | null | undefined;
+    actual?: Pound | null | undefined;
+    rationale?: string | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    toJSON: {
+        virtuals: true;
+    };
+    toObject: {
+        virtuals: true;
+    };
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicantId: mongoose.Types.ObjectId;
+    isFixed: boolean;
+    expenditureTypeLid: mongoose.Types.ObjectId;
+    declared?: Pound | null | undefined;
+    ons?: Pound | null | undefined;
+    actual?: Pound | null | undefined;
+    rationale?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicantId: mongoose.Types.ObjectId;
+    isFixed: boolean;
+    expenditureTypeLid: mongoose.Types.ObjectId;
+    declared?: Pound | null | undefined;
+    ons?: Pound | null | undefined;
+    actual?: Pound | null | undefined;
+    rationale?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicantId: mongoose.Types.ObjectId;
+    isFixed: boolean;
+    expenditureTypeLid: mongoose.Types.ObjectId;
+    declared?: Pound | null | undefined;
+    ons?: Pound | null | undefined;
+    actual?: Pound | null | undefined;
+    rationale?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default ApplicantExpenditureModel;
+//# sourceMappingURL=applicant-expenditure.model.d.ts.map

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

@@ -0,0 +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;AAoE/C,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuE,CAAC;AACvG,eAAe,yBAAyB,CAAC"}

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

@@ -0,0 +1,54 @@
+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.",
+    },
+}, {
+    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

@@ -0,0 +1,26 @@
+import mongoose from "mongoose";
+declare const applicantIncomeSourceSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    employmentStatusLid: mongoose.Types.ObjectId;
+    incomeFromEmployment?: string | null | undefined;
+    incomeFromPension?: string | null | undefined;
+    incomeFromProperty?: string | null | undefined;
+    incomeFromSavings?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    employmentStatusLid: mongoose.Types.ObjectId;
+    incomeFromEmployment?: string | null | undefined;
+    incomeFromPension?: string | null | undefined;
+    incomeFromProperty?: string | null | undefined;
+    incomeFromSavings?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    employmentStatusLid: mongoose.Types.ObjectId;
+    incomeFromEmployment?: string | null | undefined;
+    incomeFromPension?: string | null | undefined;
+    incomeFromProperty?: string | null | undefined;
+    incomeFromSavings?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default applicantIncomeSourceSchema;
+//# sourceMappingURL=applicant-income-source.model.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AAEH,eAAe,2BAA2B,CAAC"}

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

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