gemcap-be-common 1.2.140 → 1.3.0

package/services/loan-statement-balance.service.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanStatementBalanceService = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const LoanPayment_model_1 = require("../models/LoanPayment.model");
+const LoanStatementTransaction_model_1 = require("../models/LoanStatementTransaction.model");
+const loan_charge_type_enum_1 = require("../enums/loan-charge-type.enum");
+class LoanStatementBalanceService {
+    loanChargesService;
+    getLoanStatementService;
+    loanTransactionsService;
+    constructor(loanChargesService, getLoanStatementService, loanTransactionsService) {
+        this.loanChargesService = loanChargesService;
+        this.getLoanStatementService = getLoanStatementService;
+        this.loanTransactionsService = loanTransactionsService;
+    }
+    async cleanDecreasePayment(payment, userId) {
+        if (!!payment.paid) {
+            let firstPaidStatement = null;
+            await Promise.all(payment.paid.map(async (paid) => {
+                const foundPayment = await LoanStatementTransaction_model_1.LoanStatementTransactionModel.findById(paid.statementId);
+                if (!foundPayment) {
+                    return;
+                }
+                if (!firstPaidStatement ||
+                    (foundPayment.date.getTime() < firstPaidStatement.date.getTime()) ||
+                    (firstPaidStatement.date.getTime() === foundPayment.date.getTime() && firstPaidStatement.order > foundPayment.order)) {
+                    firstPaidStatement = foundPayment;
+                }
+                await LoanStatementTransaction_model_1.LoanStatementTransactionModel.findByIdAndUpdate(paid.statementId, {
+                    amountPaid: new decimal_js_1.default(foundPayment.amountPaid).sub(paid.amount).toNumber(),
+                    settlementCode: null,
+                });
+            }));
+            if (firstPaidStatement) {
+                await this.calculateProductBalance(payment.productId.toString(), firstPaidStatement.date);
+            }
+        }
+        if (!!payment.loanTransactions) {
+            await Promise.all(payment.loanTransactions.map(async (t) => {
+                await this.loanTransactionsService.deleteLoanTransaction(t.transactionId.toString(), false, userId);
+            }));
+        }
+        await LoanPayment_model_1.LoanPaymentModel.findByIdAndUpdate(payment._id, { paid: [] });
+    }
+    async calculateProductBalance(productId, startDate) {
+        const loanStatementService = this.getLoanStatementService();
+        const statements = await loanStatementService.getTransactionsFromDate(productId, startDate);
+        for (const statement of statements) {
+            await this.updateBalance(statement);
+        }
+    }
+    async updateBalance(loanStatementTransaction) {
+        const loanStatementService = this.getLoanStatementService();
+        const previousTransaction = await loanStatementService.getPreviousTransaction(loanStatementTransaction);
+        const previousBalance = !previousTransaction ? 0 : previousTransaction.balance;
+        const newBalance = new decimal_js_1.default(previousBalance).add(loanStatementTransaction.amount).sub(loanStatementTransaction.amountPaid).toNumber();
+        await LoanStatementTransaction_model_1.LoanStatementTransactionModel.findByIdAndUpdate(loanStatementTransaction._id, { balance: newBalance });
+    }
+    async getLastStatementTransactionForDate(productId, startDate) {
+        const charges = await this.loanChargesService.getLoanChargeForProduct(productId);
+        const lastStatements = await LoanStatementTransaction_model_1.LoanStatementTransactionModel.aggregate([
+            {
+                $match: {
+                    'chargeId': { $in: charges.map((charge) => charge._id) },
+                    'date': { $lt: startDate },
+                },
+            }, {
+                $sort: {
+                    'date': -1,
+                    'order': -1,
+                },
+            }, {
+                $limit: 1,
+            },
+        ]);
+        if (lastStatements.length === 0) {
+            return null;
+        }
+        return lastStatements[0];
+    }
+    async getNextAdminTransactionForDate(productId, date) {
+        const charges = await this.loanChargesService.getLoanChargeForProduct(productId);
+        const adminCharge = charges.find((c) => c.chargeType === loan_charge_type_enum_1.ELoanChargeType.ADMIN_FEE);
+        if (adminCharge) {
+            const nextAdminFee = await LoanStatementTransaction_model_1.LoanStatementTransactionModel
+                .findOne({
+                chargeId: adminCharge._id,
+                date: { $gte: (0, dayjs_1.default)(date).startOf('month').toDate() },
+            })
+                .sort({ date: 1 })
+                .lean();
+            if (nextAdminFee) {
+                const totalDays = (0, dayjs_1.default)(date).daysInMonth();
+                const day = (0, dayjs_1.default)(date).date();
+                return new decimal_js_1.default(day).div(totalDays).mul(nextAdminFee.amount).toDP(2).toNumber();
+            }
+        }
+        return 0;
+    }
+}
+exports.LoanStatementBalanceService = LoanStatementBalanceService;

package/services/loan-statement-balance.service.ts

@@ -0,0 +1,113 @@
+import Decimal from 'decimal.js';
+import dayjs from 'dayjs';
+
+import { ILoanPaymentWithId, LoanPaymentModel } from '../models/LoanPayment.model';
+import {
+  LoanStatementTransactionModel,
+  ILoanStatementTransactionDoc,
+} from '../models/LoanStatementTransaction.model';
+import { ELoanChargeType } from '../enums/loan-charge-type.enum';
+
+import { LoanChargesService } from './loan-charges.service';
+import { LoanStatementService } from './loan-statement.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+
+export class LoanStatementBalanceService {
+
+  constructor(
+    private readonly loanChargesService: LoanChargesService,
+    private readonly getLoanStatementService: () => LoanStatementService,
+    private readonly loanTransactionsService: LoanTransactionsService,
+  ) {
+  }
+
+  async cleanDecreasePayment(payment: ILoanPaymentWithId, userId: string) {
+    if (!!payment.paid) {
+      let firstPaidStatement: any = null;
+      await Promise.all(payment.paid.map(async (paid) => {
+        const foundPayment = await LoanStatementTransactionModel.findById(paid.statementId);
+        if (!foundPayment) {
+          return;
+        }
+        if (!firstPaidStatement ||
+          (foundPayment.date.getTime() < firstPaidStatement.date.getTime()) ||
+          (firstPaidStatement.date.getTime() === foundPayment.date.getTime() && firstPaidStatement.order > foundPayment.order)
+        ) {
+          firstPaidStatement = foundPayment;
+        }
+        await LoanStatementTransactionModel.findByIdAndUpdate(paid.statementId, {
+          amountPaid: new Decimal(foundPayment.amountPaid).sub(paid.amount).toNumber(),
+          settlementCode: null,
+        });
+      }));
+      if (firstPaidStatement) {
+        await this.calculateProductBalance(payment.productId.toString(), firstPaidStatement.date);
+      }
+    }
+    if (!!payment.loanTransactions) {
+      await Promise.all(payment.loanTransactions.map(async (t) => {
+        await this.loanTransactionsService.deleteLoanTransaction(t.transactionId.toString(), false, userId);
+      }));
+    }
+    await LoanPaymentModel.findByIdAndUpdate(payment._id, { paid: [] });
+  }
+
+  async calculateProductBalance(productId: string, startDate: Date) {
+    const loanStatementService = this.getLoanStatementService();
+    const statements = await loanStatementService.getTransactionsFromDate(productId, startDate);
+    for (const statement of statements) {
+      await this.updateBalance(statement);
+    }
+  }
+
+  async updateBalance(loanStatementTransaction: ILoanStatementTransactionDoc) {
+    const loanStatementService = this.getLoanStatementService();
+    const previousTransaction = await loanStatementService.getPreviousTransaction(loanStatementTransaction);
+    const previousBalance = !previousTransaction ? 0 : previousTransaction.balance;
+    const newBalance = new Decimal(previousBalance).add(loanStatementTransaction.amount).sub(loanStatementTransaction.amountPaid).toNumber();
+    await LoanStatementTransactionModel.findByIdAndUpdate(loanStatementTransaction._id, { balance: newBalance });
+  }
+
+  async getLastStatementTransactionForDate(productId: string, startDate: Date) {
+    const charges = await this.loanChargesService.getLoanChargeForProduct(productId);
+    const lastStatements = await LoanStatementTransactionModel.aggregate<ILoanStatementTransactionDoc>([
+      {
+        $match: {
+          'chargeId': { $in: charges.map((charge) => charge._id) },
+          'date': { $lt: startDate },
+        },
+      }, {
+        $sort: {
+          'date': -1,
+          'order': -1,
+        },
+      }, {
+        $limit: 1,
+      },
+    ]);
+    if (lastStatements.length === 0) {
+      return null;
+    }
+    return lastStatements[0];
+  }
+
+  async getNextAdminTransactionForDate(productId: string, date: Date) {
+    const charges = await this.loanChargesService.getLoanChargeForProduct(productId);
+    const adminCharge = charges.find((c) => c.chargeType === ELoanChargeType.ADMIN_FEE);
+    if (adminCharge) {
+      const nextAdminFee = await LoanStatementTransactionModel
+        .findOne({
+          chargeId: adminCharge._id,
+          date: { $gte: dayjs(date).startOf('month').toDate() },
+        })
+        .sort({ date: 1 })
+        .lean();
+      if (nextAdminFee) {
+        const totalDays = dayjs(date).daysInMonth();
+        const day = dayjs(date).date();
+        return new Decimal(day).div(totalDays).mul(nextAdminFee.amount).toDP(2).toNumber();
+      }
+    }
+    return 0;
+  }
+}

package/services/loan-statement-effects.service.d.ts

@@ -0,0 +1,8 @@
+import { LoanStatementBalanceService } from './loan-statement-balance.service';
+import { MonthEndDataService } from './month-end-data.service';
+export declare class LoanStatementEffectsService {
+    private readonly loanStatementBalanceService;
+    private readonly monthEndDataService;
+    constructor(loanStatementBalanceService: LoanStatementBalanceService, monthEndDataService: MonthEndDataService);
+    saveMonthData(productId: string, statementDate: Date): Promise<void>;
+}

package/services/loan-statement-effects.service.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanStatementEffectsService = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const loan_products_db_1 = require("../db/loan-products.db");
+const MonthEndData_Model_1 = require("../models/MonthEndData.Model");
+class LoanStatementEffectsService {
+    loanStatementBalanceService;
+    monthEndDataService;
+    constructor(loanStatementBalanceService, monthEndDataService) {
+        this.loanStatementBalanceService = loanStatementBalanceService;
+        this.monthEndDataService = monthEndDataService;
+    }
+    async saveMonthData(productId, statementDate) {
+        if ((0, dayjs_1.default)(statementDate).date() !== 1) {
+            return;
+        }
+        const balance = await (0, loan_products_db_1.getLoanProductBalance)(productId, statementDate);
+        const lastTransaction = await this.loanStatementBalanceService.getLastStatementTransactionForDate(productId, statementDate);
+        const month = (0, dayjs_1.default)(statementDate).subtract(1, 'd').month() + 1;
+        const year = (0, dayjs_1.default)(statementDate).subtract(1, 'd').year();
+        const keptData = {
+            [MonthEndData_Model_1.EMonthEndDataType.BALANCE]: balance?.balance ?? 0,
+            [MonthEndData_Model_1.EMonthEndDataType.FLOATED_BALANCE]: balance?.floatedBalance ?? 0,
+            [MonthEndData_Model_1.EMonthEndDataType.STATEMENT_BALANCE]: lastTransaction?.balance ?? 0,
+        };
+        await Promise.all(Object.entries(keptData).map(async ([dataType, dataValue]) => {
+            await this.monthEndDataService.upsertMonthEndData({
+                productId: new mongoose_1.default.Types.ObjectId(productId),
+                year,
+                month,
+                dataType: dataType,
+                dataValue,
+            });
+        }));
+    }
+}
+exports.LoanStatementEffectsService = LoanStatementEffectsService;

package/services/loan-statement-effects.service.ts

@@ -0,0 +1,41 @@
+import dayjs from 'dayjs';
+import mongoose from 'mongoose';
+
+import { getLoanProductBalance as getLoanProductBalanceDB } from '../db/loan-products.db';
+
+import { LoanStatementBalanceService } from './loan-statement-balance.service';
+import { EMonthEndDataType } from '../models/MonthEndData.Model';
+import { MonthEndDataService } from './month-end-data.service';
+
+export class LoanStatementEffectsService {
+  constructor(
+    private readonly loanStatementBalanceService: LoanStatementBalanceService,
+    private readonly monthEndDataService: MonthEndDataService,
+  ) {
+  }
+
+  async saveMonthData(productId: string, statementDate: Date) {
+    if (dayjs(statementDate).date() !== 1) {
+      return;
+    }
+    const balance = await getLoanProductBalanceDB(productId, statementDate);
+    const lastTransaction = await this.loanStatementBalanceService.getLastStatementTransactionForDate(productId, statementDate);
+    const month = dayjs(statementDate).subtract(1, 'd').month() + 1;
+    const year = dayjs(statementDate).subtract(1, 'd').year();
+
+    const keptData = {
+      [EMonthEndDataType.BALANCE]: balance?.balance ?? 0,
+      [EMonthEndDataType.FLOATED_BALANCE]: balance?.floatedBalance ?? 0,
+      [EMonthEndDataType.STATEMENT_BALANCE]: lastTransaction?.balance ?? 0,
+    };
+    await Promise.all(Object.entries(keptData).map(async ([dataType, dataValue]) => {
+      await this.monthEndDataService.upsertMonthEndData({
+        productId: new mongoose.Types.ObjectId(productId),
+        year,
+        month,
+        dataType: dataType as EMonthEndDataType,
+        dataValue,
+      });
+    }));
+  }
+}

package/services/loan-statement-status.service.d.ts

@@ -0,0 +1,208 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose from 'mongoose';
+import { ISelectedMonth } from '../helpers/date.helper';
+import { IStatementPeriod } from './loan-statement.service';
+import { LoanChargesService } from './loan-charges.service';
+import { TermLoanService } from './term-loan.service';
+export type SelectablePeriod = 'LAST_MONTH' | 'CURRENT_MONTH' | 'ENTIRE_LOAN' | 'SELECTED_PERIOD';
+export declare class LoanStatementStatusService {
+    private readonly getLoanChargesService;
+    private readonly termLoanService;
+    constructor(getLoanChargesService: () => LoanChargesService, termLoanService: TermLoanService);
+    initStatementStatuses(): Promise<void>;
+    getStatementDateFromStringPeriod(period: SelectablePeriod): ISelectedMonth;
+    getStatementDateForDate(date: Date): ISelectedMonth;
+    getStatementDateFromPeriod(period: IStatementPeriod): ISelectedMonth;
+    getDateFromStatementDate(statementDate: ISelectedMonth): Date;
+    getPeriodsFromStatementDate(statementDate: ISelectedMonth): IStatementPeriod[];
+    toggleStatementLock(productId: string, statementDate: ISelectedMonth): Promise<void>;
+    updateStatementStatus(productId: string, statementDate: ISelectedMonth, actual: boolean): Promise<void>;
+    getAllStatementsStatus(statementDate: ISelectedMonth): Promise<{
+        product: import("../models/LoanProducts.model").ILoanProductDoc;
+        productId: mongoose.Types.ObjectId;
+        actual: boolean;
+        locked: boolean;
+        lastCalculated: Date;
+        year: number;
+        month: number;
+        _id: any;
+        __v?: any;
+        $assertPopulated: <Paths = {}>(path: string | string[], values?: Partial<Paths>) => Omit<import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, keyof Paths> & Paths;
+        $clone: () => import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        $getAllSubdocs: () => mongoose.Document<any, any, any>[];
+        $ignore: (path: string) => void;
+        $isDefault: (path: string) => boolean;
+        $isDeleted: (val?: boolean) => boolean;
+        $getPopulatedDocs: () => mongoose.Document<any, any, any>[];
+        $inc: (path: string | string[], val?: number) => import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        $isEmpty: (path: string) => boolean;
+        $isValid: (path: string) => boolean;
+        $locals: mongoose.FlattenMaps<Record<string, unknown>>;
+        $markValid: (path: string) => void;
+        $model: {
+            <ModelType = mongoose.Model<unknown, {}, {}, {}, mongoose.Document<unknown, {}, unknown> & Required<{
+                _id: unknown;
+            }>, any>>(name: string): ModelType;
+            <ModelType_1 = mongoose.Model<any, {}, {}, {}, any, any>>(): ModelType_1;
+        };
+        $op: "save" | "validate" | "remove";
+        $session: (session?: mongoose.mongo.ClientSession) => mongoose.mongo.ClientSession;
+        $set: {
+            (path: string | Record<string, any>, val: any, type: any, options?: mongoose.DocumentSetOptions): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+            (path: string | Record<string, any>, val: any, options?: mongoose.DocumentSetOptions): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+            (value: string | Record<string, any>): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        };
+        $where: mongoose.FlattenMaps<Record<string, unknown>>;
+        baseModelName?: string;
+        collection: mongoose.Collection<mongoose.mongo.BSON.Document>;
+        db: mongoose.FlattenMaps<mongoose.Connection>;
+        deleteOne: (options?: mongoose.QueryOptions<unknown>) => any;
+        depopulate: (path?: string | string[]) => import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        directModifiedPaths: () => string[];
+        equals: (doc: mongoose.Document<any, any, any>) => boolean;
+        errors?: mongoose.Error.ValidationError;
+        get: {
+            <T extends string | number | symbol>(path: T, type?: any, options?: any): any;
+            (path: string, type?: any, options?: any): any;
+        };
+        getChanges: () => mongoose.UpdateQuery<import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc>;
+        id?: any;
+        increment: () => import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        init: (obj: mongoose.AnyObject, opts?: mongoose.AnyObject) => import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        invalidate: {
+            <T_1 extends string | number | symbol>(path: T_1, errorMsg: string | NativeError, value?: any, kind?: string): NativeError;
+            (path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError;
+        };
+        isDirectModified: {
+            <T_2 extends string | number | symbol>(path: T_2 | T_2[]): boolean;
+            (path: string | string[]): boolean;
+        };
+        isDirectSelected: {
+            <T_3 extends string | number | symbol>(path: T_3): boolean;
+            (path: string): boolean;
+        };
+        isInit: {
+            <T_4 extends string | number | symbol>(path: T_4): boolean;
+            (path: string): boolean;
+        };
+        isModified: {
+            <T_5 extends string | number | symbol>(path?: T_5 | T_5[], options?: {
+                ignoreAtomics?: boolean;
+            }): boolean;
+            (path?: string | string[], options?: {
+                ignoreAtomics?: boolean;
+            }): boolean;
+        };
+        isNew: boolean;
+        isSelected: {
+            <T_6 extends string | number | symbol>(path: T_6): boolean;
+            (path: string): boolean;
+        };
+        markModified: {
+            <T_7 extends string | number | symbol>(path: T_7, scope?: any): void;
+            (path: string, scope?: any): void;
+        };
+        model: {
+            <ModelType_2 = mongoose.Model<unknown, {}, {}, {}, mongoose.Document<unknown, {}, unknown> & Required<{
+                _id: unknown;
+            }>, any>>(name: string): ModelType_2;
+            <ModelType_3 = mongoose.Model<any, {}, {}, {}, any, any>>(): ModelType_3;
+        };
+        modifiedPaths: (options?: {
+            includeChildren?: boolean;
+        }) => string[];
+        overwrite: (obj: mongoose.AnyObject) => import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        $parent: () => mongoose.Document<any, any, any>;
+        populate: {
+            <Paths_1 = {}>(path: string | mongoose.PopulateOptions | (string | mongoose.PopulateOptions)[]): Promise<mongoose.MergeType<import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, Paths_1>>;
+            <Paths_2 = {}>(path: string, select?: string | mongoose.AnyObject, model?: mongoose.Model<any, {}, {}, {}, any, any>, match?: mongoose.AnyObject, options?: mongoose.PopulateOptions): Promise<mongoose.MergeType<import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, Paths_2>>;
+        };
+        populated: (path: string) => any;
+        replaceOne: (replacement?: mongoose.AnyObject, options?: mongoose.QueryOptions<unknown>) => mongoose.Query<any, import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, {}, import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, "find">;
+        save: (options?: mongoose.SaveOptions) => Promise<import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc>;
+        schema: mongoose.FlattenMaps<mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+            [x: string]: unknown;
+        }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+            [x: string]: unknown;
+        }>> & mongoose.FlatRecord<{
+            [x: string]: unknown;
+        }> & Required<{
+            _id: unknown;
+        }>>>;
+        set: {
+            <T_8 extends string | number | symbol>(path: T_8, val: any, type: any, options?: mongoose.DocumentSetOptions): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+            (path: string | Record<string, any>, val: any, type: any, options?: mongoose.DocumentSetOptions): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+            (path: string | Record<string, any>, val: any, options?: mongoose.DocumentSetOptions): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+            (value: string | Record<string, any>): import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc;
+        };
+        toJSON: {
+            <T_9 = any>(options?: mongoose.ToObjectOptions<mongoose.Document<unknown, {}, unknown> & Required<{
+                _id: unknown;
+            }>> & {
+                flattenMaps?: true;
+            }): mongoose.FlattenMaps<T_9>;
+            <T_10 = any>(options: mongoose.ToObjectOptions<mongoose.Document<unknown, {}, unknown> & Required<{
+                _id: unknown;
+            }>> & {
+                flattenMaps: false;
+            }): T_10;
+        };
+        toObject: <T_11 = any>(options?: mongoose.ToObjectOptions<mongoose.Document<unknown, {}, unknown> & Required<{
+            _id: unknown;
+        }>>) => mongoose.Require_id<T_11>;
+        unmarkModified: {
+            <T_12 extends string | number | symbol>(path: T_12): void;
+            (path: string): void;
+        };
+        updateOne: (update?: mongoose.UpdateWithAggregationPipeline | mongoose.UpdateQuery<import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc>, options?: mongoose.QueryOptions<unknown>) => mongoose.Query<any, import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, {}, import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc, "find">;
+        validate: {
+            <T_13 extends string | number | symbol>(pathsToValidate?: T_13 | T_13[], options?: mongoose.AnyObject): Promise<void>;
+            (pathsToValidate?: mongoose.PathsToValidate, options?: mongoose.AnyObject): Promise<void>;
+            (options: {
+                pathsToSkip?: mongoose.pathsToSkip;
+            }): Promise<void>;
+        };
+        validateSync: {
+            (options: {
+                [k: string]: any;
+                pathsToSkip?: mongoose.pathsToSkip;
+            }): mongoose.Error.ValidationError;
+            <T_14 extends string | number | symbol>(pathsToValidate?: T_14 | T_14[], options?: mongoose.AnyObject): mongoose.Error.ValidationError;
+            (pathsToValidate?: mongoose.PathsToValidate, options?: mongoose.AnyObject): mongoose.Error.ValidationError;
+        };
+    }[]>;
+    getStatementStatus(productId: string, date: Date): Promise<mongoose.Document<unknown, {}, import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc> & import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    getCreateStatementStatus(productId: string, statementDate: ISelectedMonth): Promise<mongoose.Document<unknown, {}, import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc> & import("../models/LoanStatementStatus.model").ILoanStatementStatusDoc & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    validateDate(productId: string, date: Date): Promise<"Statement is locked!" | "Internal Server Error">;
+    getBorrowerStatement(borrowerId: string): Promise<{
+        [K in SelectablePeriod | 'TERM_LOAN']?: boolean;
+    }>;
+    getBorrowerMonthStatus(borrowerId: string, statementDate: ISelectedMonth): Promise<boolean>;
+}