@kipicore/dbcore 1.1.368 → 1.1.369

package/dist/models/psql/feeHistoryDetailsModel.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeeHistoryDetailsModel = void 0;
-const sequelize_1 = require("sequelize");
-const index_1 = require("./index");
-class FeeHistoryDetailsModel extends sequelize_1.Model {
-    static associate(models) {
-        const { UserModel, InstituteModel, SchoolFeeCollectionModel, UserFeeTypeByAccountModel, FeeHistoryModel, FeeTypeModel, } = models;
-        FeeHistoryDetailsModel.belongsTo(UserModel, {
-            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
-            as: 'createdByUser',
-        });
-        FeeHistoryDetailsModel.belongsTo(UserModel, {
-            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
-            as: 'updatedByUser',
-        });
-        FeeHistoryDetailsModel.belongsTo(UserModel, {
-            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
-            as: 'deletedByUser',
-        });
-        FeeHistoryDetailsModel.belongsTo(InstituteModel, {
-            foreignKey: 'instituteId',
-            as: 'feeHistoryDetailsInstitute',
-        });
-        InstituteModel.hasMany(FeeHistoryDetailsModel, {
-            foreignKey: 'instituteId',
-            as: 'instituteHasFeeHistoryDetails',
-        });
-        FeeHistoryDetailsModel.belongsTo(UserModel, {
-            foreignKey: 'userId',
-            as: 'feeHistoryDetailsUser',
-        });
-        UserModel.hasMany(FeeHistoryDetailsModel, {
-            foreignKey: 'userId',
-            as: 'userHasFeeHistoryDetails',
-        });
-        FeeHistoryDetailsModel.belongsTo(SchoolFeeCollectionModel, {
-            foreignKey: { name: 'schoolFeeCollectionId', field: 'school_fee_collection_id', allowNull: true },
-            as: 'feeHistoryDetailsSchool',
-        });
-        SchoolFeeCollectionModel.hasMany(FeeHistoryDetailsModel, {
-            foreignKey: { name: 'schoolFeeCollectionId', field: 'school_fee_collection_id', allowNull: true },
-            as: 'feeHistoryDetailsHasSchool',
-        });
-        FeeHistoryDetailsModel.belongsTo(UserFeeTypeByAccountModel, {
-            foreignKey: 'userFeeTypeByAccountId',
-            as: 'feeHistoryDetailsFeeType',
-        });
-        UserFeeTypeByAccountModel.hasMany(FeeHistoryDetailsModel, {
-            foreignKey: 'userFeeTypeByAccountId',
-            as: 'userFeeTypeFeeHistoryDetails',
-        });
-        FeeHistoryDetailsModel.belongsTo(FeeHistoryModel, {
-            foreignKey: { name: 'feeHistoryId', field: 'fee_history_id', allowNull: true },
-            as: 'detailsFeeHistory',
-        });
-        FeeHistoryModel.hasMany(FeeHistoryDetailsModel, {
-            foreignKey: { name: 'feeHistoryId', field: 'fee_history_id', allowNull: true },
-            as: 'feeHistoryHasDetails',
-        });
-        FeeHistoryDetailsModel.belongsTo(FeeTypeModel, {
-            foreignKey: { name: 'feeTypeId', field: 'fee_type_id', allowNull: true },
-            as: 'feeHistoryDetailsType',
-        });
-        FeeTypeModel.hasMany(FeeHistoryDetailsModel, {
-            foreignKey: { name: 'feeTypeId', field: 'fee_type_id', allowNull: true },
-            as: 'feeHistoryDetailsHasType',
-        });
-    }
-}
-exports.FeeHistoryDetailsModel = FeeHistoryDetailsModel;
-FeeHistoryDetailsModel.init({
-    id: {
-        type: sequelize_1.DataTypes.UUID,
-        defaultValue: sequelize_1.DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    instituteId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'institute_id',
-    },
-    userFeeTypeByAccountId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'user_fee_type_by_account_id',
-    },
-    schoolFeeCollectionId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'school_fee_collection_id',
-    },
-    userId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'user_id',
-    },
-    academicCalendarId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'academic_calendar_id',
-    },
-    feeHistoryId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'fee_history_id',
-    },
-    feeTypeId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-        field: 'fee_type_id',
-    },
-    paidFee: {
-        type: sequelize_1.DataTypes.INTEGER,
-        allowNull: true,
-        field: 'paid_fee',
-    },
-    upiId: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-        field: 'upi_id',
-    },
-    paymentType: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-        field: 'payment_type',
-    },
-    chequeNo: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-        field: 'cheque_no',
-    },
-    bankName: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: true,
-        field: 'bank_name',
-    },
-}, {
-    modelName: 'FeeHistoryDetailsModel',
-    tableName: 'fee_history_details',
-    timestamps: true,
-    sequelize: index_1.sequelize,
-});
-exports.default = FeeHistoryDetailsModel;

package/dist/models/psql/feeHistoryModel.d.ts

@@ -1,33 +0,0 @@
-import { Model } from 'sequelize';
-import { IFeeHistoryModelAttributes } from '../../interfaces/feeHistoryInterface';
-import { TFeeHistoryModelCreationAttributes } from '../../types/feeHistoryType';
-import { FEE_HISTORY_STATUS, PAYMENT_TYPE } from '../../constants/app';
-export declare class FeeHistoryModel extends Model<IFeeHistoryModelAttributes, TFeeHistoryModelCreationAttributes> {
-    id: string;
-    instituteId: string;
-    userId: string;
-    feeCollectionId?: string;
-    paidFee: number;
-    paidDate: Date;
-    pdfId: string | null;
-    invoiceId: number | null;
-    status: FEE_HISTORY_STATUS;
-    upiId?: string | null;
-    paymentType?: PAYMENT_TYPE;
-    bankName?: string | null;
-    chequeNo?: string | null;
-    feeTypeId?: string[] | null;
-    bankAccountId?: string | null;
-    parentHistoryId?: string | null;
-    schoolFeeCollectionId?: string | null;
-    academicCalendarId: string;
-    createdBy: string;
-    updatedBy: string;
-    deletedBy: string;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readonly deletedAt: string;
-    static associate(models: any): void;
-    static addHooks(models: any): void;
-}
-export default FeeHistoryModel;

package/dist/models/psql/feeHistoryModel.js

@@ -1,189 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeeHistoryModel = void 0;
-const sequelize_1 = require("sequelize");
-const index_1 = require("./index");
-const app_1 = require("../../constants/app");
-const errorMessages_1 = require("../../constants/errorMessages");
-const userInstituteMetaModel_1 = __importDefault(require("../mongodb/userInstituteMetaModel"));
-class FeeHistoryModel extends sequelize_1.Model {
-    static associate(models) {
-        const { UserModel, InstituteModel, SchoolFeeCollectionModel, FeesCollectionModel, FileStorageModel, BankAccountDetailsModel, AcademicCalendarModel, } = models;
-        FeeHistoryModel.belongsTo(FeesCollectionModel, {
-            foreignKey: { name: 'feeCollectionId', field: 'fee_collection_id', allowNull: true },
-            as: 'feeHistoryFeeCollection',
-        });
-        FeesCollectionModel.hasMany(FeeHistoryModel, {
-            foreignKey: { name: 'feeCollectionId', field: 'fee_collection_id', allowNull: true },
-            as: 'feeCollectionHasFeeHistory',
-        });
-        FeeHistoryModel.belongsTo(FileStorageModel, {
-            foreignKey: { name: 'pdfId', field: 'pdf_id', allowNull: true },
-            as: 'feeHistoryFile',
-        });
-        FileStorageModel.hasMany(FeeHistoryModel, {
-            foreignKey: { name: 'pdfId', field: 'pdf_id', allowNull: true },
-            as: 'filesHasFeeHistory',
-        });
-        FeeHistoryModel.belongsTo(BankAccountDetailsModel, {
-            foreignKey: { name: 'bankAccountId', field: 'bank_account_id', allowNull: true },
-            as: 'feeHistoryAccount',
-        });
-        BankAccountDetailsModel.hasMany(FeeHistoryModel, {
-            foreignKey: { name: 'bankAccountId', field: 'bank_account_id', allowNull: true },
-            as: 'feeHistoryHasAccount',
-        });
-        FeeHistoryModel.belongsTo(FeeHistoryModel, {
-            foreignKey: { name: 'parentHistoryId', field: 'parent_history_id', allowNull: true },
-            as: 'feeHistory',
-        });
-        FeeHistoryModel.hasMany(FeeHistoryModel, {
-            foreignKey: { name: 'parentHistoryId', field: 'parent_history_id', allowNull: true },
-            as: 'feeHistoryHas',
-        });
-        FeeHistoryModel.belongsTo(SchoolFeeCollectionModel, {
-            foreignKey: { name: 'schoolFeeCollectionId', field: 'school_fee_collection_id', allowNull: true },
-            as: 'feeHistorySchool',
-        });
-        SchoolFeeCollectionModel.hasMany(FeeHistoryModel, {
-            foreignKey: { name: 'schoolFeeCollectionId', field: 'school_fee_collection_id', allowNull: true },
-            as: 'feeHistoryHasSchool',
-        });
-        FeeHistoryModel.belongsTo(InstituteModel, {
-            foreignKey: { name: 'instituteId', field: 'institute_id' },
-            as: 'feeHistoryInstitute',
-        });
-        InstituteModel.hasMany(FeeHistoryModel, {
-            foreignKey: 'instituteId',
-            as: 'instituteHasFeeHistory',
-        });
-        FeeHistoryModel.belongsTo(UserModel, {
-            foreignKey: { name: 'userId', field: 'user_id' },
-            as: 'feeHistoryUser',
-        });
-        UserModel.hasMany(FeeHistoryModel, {
-            foreignKey: 'userId',
-            as: 'userHasFeeHistory',
-        });
-        FeeHistoryModel.belongsTo(AcademicCalendarModel, {
-            foreignKey: { name: 'academicCalendarId', field: 'academic_calendar_id' },
-            as: 'feeHistoryAcaCal',
-        });
-        AcademicCalendarModel.hasMany(FeeHistoryModel, {
-            foreignKey: { name: 'academicCalendarId', field: 'academic_calendar_id' },
-            as: 'acaCalFeeHistory',
-        });
-        FeeHistoryModel.belongsTo(UserModel, {
-            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
-            as: 'createdByUser',
-        });
-        FeeHistoryModel.belongsTo(UserModel, {
-            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
-            as: 'updatedByUser',
-        });
-        FeeHistoryModel.belongsTo(UserModel, {
-            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
-            as: 'deletedByUser',
-        });
-    }
-    static addHooks(models) {
-        const { FileStorageModel } = models;
-        const subjectWiserFeePay = async (instituteId, feeCollectionId, paidFee, userId, academicCalendarId) => {
-            const { InstituteEntityModel, UserHasSubjectFeeModel, FeesCollectionModel, SubjectHasPayFeeHistory } = models;
-            const userInstituteMeta = await userInstituteMetaModel_1.default.findOne({
-                userId,
-                instituteId,
-                academicCalendarId,
-                status: app_1.USER_INSTITUTE_META_STATUS.ACCEPTED,
-            });
-            if (!userInstituteMeta)
-                throw new Error(errorMessages_1.USER_INSTITUTE_META_ERROR_MESSAGES.NOT_FOUND);
-            const subjects = await InstituteEntityModel.findAll({
-                where: { id: { [sequelize_1.Op.in]: userInstituteMeta.entities } },
-                include: [{ association: 'entityType', where: { sequence: app_1.INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST } }],
-            });
-            const subjectIds = subjects.map((subject) => subject.id);
-            const fees = await UserHasSubjectFeeModel.findAll({
-                where: { subjectId: { [sequelize_1.Op.in]: subjectIds }, instituteId, academicCalendarId },
-            });
-            const feeCollection = await FeesCollectionModel.findByPk(feeCollectionId);
-            if (!feeCollection)
-                throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.NOT_FOUND);
-            const feeDistribution = fees.map((fee) => ({
-                subjectId: fee.subjectId,
-                amount: parseFloat(((fee.fee / (feeCollection.feeAmount || 0)) * paidFee).toFixed(2)),
-            }));
-            return Promise.all(feeDistribution.map((distribution) => SubjectHasPayFeeHistory.create({
-                instituteId,
-                userId,
-                subjectId: distribution.subjectId,
-                feeCollectionId,
-                academicCalendarId,
-                amount: distribution.amount,
-            })));
-        };
-        FeeHistoryModel.beforeCreate(async (feeCollection) => {
-            if (feeCollection.paidFee) {
-                if (feeCollection.paymentType === app_1.PAYMENT_TYPE.CHEQUE) {
-                    feeCollection.upiId = null;
-                    if (!feeCollection.chequeNo || !feeCollection.bankName) {
-                        throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID_BY_CHQUE);
-                    }
-                }
-                else if (feeCollection.paymentType === app_1.PAYMENT_TYPE.UPI) {
-                    feeCollection.chequeNo = null;
-                    feeCollection.bankName = null;
-                    if (!feeCollection.upiId) {
-                        throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID_BY_UPI);
-                    }
-                }
-                else if (feeCollection.paymentType === app_1.PAYMENT_TYPE.CASH) {
-                    feeCollection.bankName = null;
-                    feeCollection.chequeNo = null;
-                    feeCollection.upiId = null;
-                }
-                else {
-                    throw new Error(errorMessages_1.FEESCOLLECTION_ERROR_MESSAGES.PAYMENT_TYPE_REQUIRED);
-                }
-                if (feeCollection.pdfId) {
-                    const pdfUrl = await FileStorageModel.findByPk(feeCollection.pdfId);
-                    if (!pdfUrl)
-                        throw new Error(errorMessages_1.FILE_STORAGE_ERROR_MESSAGES.NOT_FOUND);
-                }
-            }
-            if ((!feeCollection.feeTypeId || feeCollection.feeTypeId.length === 0) && !feeCollection.bankAccountId) {
-                await subjectWiserFeePay(feeCollection.instituteId, feeCollection.feeCollectionId, feeCollection.paidFee, feeCollection.userId, feeCollection.academicCalendarId);
-            }
-        });
-    }
-}
-exports.FeeHistoryModel = FeeHistoryModel;
-FeeHistoryModel.init({
-    id: { type: sequelize_1.DataTypes.UUID, defaultValue: sequelize_1.DataTypes.UUIDV4, allowNull: false, primaryKey: true },
-    instituteId: { type: sequelize_1.DataTypes.UUID, field: 'institute_id', allowNull: false },
-    pdfId: { type: sequelize_1.DataTypes.UUID, field: 'pdf_id', allowNull: true },
-    invoiceId: { type: sequelize_1.DataTypes.INTEGER, field: 'invoice_id', allowNull: true, defaultValue: null },
-    userId: { type: sequelize_1.DataTypes.UUID, field: 'user_id', allowNull: false },
-    feeCollectionId: { type: sequelize_1.DataTypes.UUID, field: 'fee_collection_id', allowNull: true },
-    parentHistoryId: { type: sequelize_1.DataTypes.UUID, field: 'parent_history_id', allowNull: true },
-    bankAccountId: { type: sequelize_1.DataTypes.UUID, field: 'bank_account_id', allowNull: true },
-    feeTypeId: { type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING), field: 'fee_type_id', allowNull: true, defaultValue: [] },
-    schoolFeeCollectionId: { type: sequelize_1.DataTypes.UUID, field: 'school_fee_collection_id', allowNull: true },
-    paidDate: { type: sequelize_1.DataTypes.DATE, defaultValue: sequelize_1.DataTypes.NOW, allowNull: false },
-    paidFee: { type: sequelize_1.DataTypes.INTEGER, allowNull: false },
-    paymentType: { type: sequelize_1.DataTypes.ENUM, values: Object.values(app_1.PAYMENT_TYPE), allowNull: true },
-    status: { type: sequelize_1.DataTypes.ENUM, values: Object.values(app_1.FEE_HISTORY_STATUS), allowNull: true, defaultValue: app_1.FEE_HISTORY_STATUS.PENDING },
-    bankName: { type: sequelize_1.DataTypes.STRING, allowNull: true },
-    chequeNo: { type: sequelize_1.DataTypes.STRING, allowNull: true },
-    upiId: { type: sequelize_1.DataTypes.STRING, allowNull: true },
-    academicCalendarId: { type: sequelize_1.DataTypes.UUID, field: 'academic_calendar_id', allowNull: true },
-}, {
-    modelName: 'FeeHistoryModel',
-    tableName: 'fee_history',
-    timestamps: true,
-    sequelize: index_1.sequelize,
-});
-exports.default = FeeHistoryModel;

package/dist/models/psql/feeTypeHasTermsModel.d.ts

@@ -1,22 +0,0 @@
-import { Model } from 'sequelize';
-import { IFeeTypeHasTermsModelAttributes } from '../../interfaces/feeTypeHasTermsInterface';
-import { TFeeTypeHasTermsModelCreationAttributes } from '../../types/feeTypeHasTermsType';
-import { PAYMENT_TERMS_TYPE } from '../../constants/app';
-declare class FeeTypeHasTermsModel extends Model<IFeeTypeHasTermsModelAttributes, TFeeTypeHasTermsModelCreationAttributes> {
-    id: string;
-    stdId: string;
-    feeTypeId: string;
-    frequency: PAYMENT_TERMS_TYPE;
-    amount: number;
-    date: Date;
-    instituteId: string;
-    academicCalendarId: string;
-    createdBy: string;
-    updatedBy: string;
-    deletedBy: string;
-    readonly createdAt: Date;
-    readonly deletedAt: string;
-    readonly updatedAt: Date;
-    static associate(models: any): void;
-}
-export default FeeTypeHasTermsModel;

package/dist/models/psql/feeTypeHasTermsModel.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-const index_1 = require("./index");
-const app_1 = require("../../constants/app");
-class FeeTypeHasTermsModel extends sequelize_1.Model {
-    static associate(models) {
-        const { FeeTypeModel, InstituteModel, UserModel } = models;
-        FeeTypeHasTermsModel.belongsTo(FeeTypeModel, {
-            foreignKey: {
-                name: 'feeTypeId',
-            },
-            as: 'termsFeeType',
-        });
-        FeeTypeModel.hasMany(FeeTypeHasTermsModel, {
-            foreignKey: 'feeTypeId',
-            as: 'feeTypeHasTerms',
-        });
-        FeeTypeHasTermsModel.belongsTo(InstituteModel, {
-            foreignKey: {
-                name: 'instituteId',
-                field: 'institute_id',
-            },
-            as: 'instituteFeeTypeTerms',
-        });
-        InstituteModel.hasMany(FeeTypeHasTermsModel, {
-            foreignKey: 'instituteId',
-            as: 'feeTypeHasTermsInstitute',
-        });
-        FeeTypeHasTermsModel.belongsTo(UserModel, {
-            foreignKey: {
-                name: 'createdBy',
-                allowNull: true,
-                field: 'created_by',
-            },
-            as: 'createdByUser',
-        });
-        FeeTypeHasTermsModel.belongsTo(UserModel, {
-            foreignKey: {
-                name: 'updatedBy',
-                allowNull: true,
-                field: 'updated_by',
-            },
-            as: 'updatedByUser',
-        });
-        FeeTypeHasTermsModel.belongsTo(UserModel, {
-            foreignKey: {
-                name: 'deletedBy',
-                allowNull: true,
-                field: 'deleted_by',
-            },
-            as: 'deletedByUser',
-        });
-    }
-}
-FeeTypeHasTermsModel.init({
-    id: {
-        type: sequelize_1.DataTypes.UUID,
-        defaultValue: sequelize_1.DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    instituteId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'institute_id',
-        allowNull: false,
-    },
-    stdId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: false,
-    },
-    feeTypeId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: false,
-    },
-    academicCalendarId: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: true,
-    },
-    amount: {
-        type: sequelize_1.DataTypes.INTEGER,
-        allowNull: false,
-    },
-    date: {
-        type: sequelize_1.DataTypes.DATE,
-        allowNull: false,
-    },
-    frequency: {
-        type: sequelize_1.DataTypes.ENUM,
-        values: Object.values(app_1.PAYMENT_TERMS_TYPE),
-        allowNull: false,
-    },
-}, {
-    modelName: 'FeeTypeHasTermsModel',
-    tableName: 'fee_type_has_terms',
-    timestamps: true,
-    sequelize: index_1.sequelize,
-});
-exports.default = FeeTypeHasTermsModel;

package/dist/models/psql/feeTypeModel.d.ts

@@ -1,24 +0,0 @@
-import { Model } from 'sequelize';
-import { IFeeTypeModelAttributes } from '../../interfaces/feeTypeInterface';
-import { TFeeTypeModelCreationAttributes } from '../../types/feeTypeType';
-import { BOOLEAN_STATUS, COMMAN_STATUS, FEE_TYPE, FEE_TYPE_FREQUENCY } from '../../constants/app';
-declare class FeeTypeModel extends Model<IFeeTypeModelAttributes, TFeeTypeModelCreationAttributes> {
-    id: string;
-    instituteId: string;
-    typeManagementId: string;
-    frequency: FEE_TYPE_FREQUENCY;
-    feeType: FEE_TYPE;
-    module: COMMAN_STATUS;
-    status: COMMAN_STATUS;
-    account: string;
-    isDefault: BOOLEAN_STATUS;
-    academicCalendarId: string;
-    createdBy: string;
-    updatedBy: string;
-    deletedBy: string;
-    readonly createdAt: Date;
-    readonly deletedAt: string;
-    readonly updatedAt: Date;
-    static associate(models: any): void;
-}
-export default FeeTypeModel;

package/dist/models/psql/feeTypeModel.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-const index_1 = require("./index");
-const app_1 = require("../../constants/app");
-class FeeTypeModel extends sequelize_1.Model {
-    static associate(models) {
-        const { BankAccountDetailsModel, TypeManagementModel, InstituteModel, UserModel, AcademicCalendarModel } = models;
-        FeeTypeModel.belongsTo(BankAccountDetailsModel, {
-            foreignKey: { name: 'account' },
-            as: 'accountFeeType',
-        });
-        BankAccountDetailsModel.hasMany(FeeTypeModel, {
-            foreignKey: 'account',
-            as: 'feeTypeHasAccount',
-        });
-        TypeManagementModel.hasMany(FeeTypeModel, {
-            foreignKey: 'typeManagementId',
-            as: 'feeTypeTypeManagement',
-        });
-        FeeTypeModel.belongsTo(TypeManagementModel, {
-            foreignKey: { name: 'typeManagementId' },
-            as: 'typeManagementType',
-        });
-        FeeTypeModel.belongsTo(InstituteModel, {
-            foreignKey: { name: 'instituteId', field: 'institute_id' },
-            as: 'instituteFeeType',
-        });
-        InstituteModel.hasMany(FeeTypeModel, {
-            foreignKey: 'instituteId',
-            as: 'feeTypeInstitute',
-        });
-        FeeTypeModel.belongsTo(UserModel, {
-            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
-            as: 'createdByUser',
-        });
-        FeeTypeModel.belongsTo(UserModel, {
-            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
-            as: 'updatedByUser',
-        });
-        FeeTypeModel.belongsTo(UserModel, {
-            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
-            as: 'deletedByUser',
-        });
-        FeeTypeModel.belongsTo(AcademicCalendarModel, {
-            foreignKey: { name: 'academicCalendarId', field: 'academic_calendar_id' },
-            as: 'feeTypeAcademicCalendar',
-        });
-        AcademicCalendarModel.hasMany(FeeTypeModel, {
-            foreignKey: { name: 'academicCalendarId', field: 'academic_calendar_id' },
-            as: 'academicCalendarFeeType',
-        });
-    }
-}
-FeeTypeModel.init({
-    id: {
-        type: sequelize_1.DataTypes.UUID,
-        defaultValue: sequelize_1.DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    typeManagementId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'type_management_id',
-        allowNull: false,
-    },
-    instituteId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'institute_id',
-        allowNull: false,
-    },
-    account: {
-        type: sequelize_1.DataTypes.UUID,
-        allowNull: false,
-    },
-    status: {
-        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.COMMAN_STATUS)),
-        defaultValue: app_1.COMMAN_STATUS.ACTIVE,
-        allowNull: false,
-    },
-    module: {
-        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.COMMAN_STATUS)),
-        defaultValue: app_1.COMMAN_STATUS.INACTIVE,
-        allowNull: false,
-    },
-    isDefault: {
-        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.BOOLEAN_STATUS)),
-        allowNull: false,
-        defaultValue: app_1.BOOLEAN_STATUS.NO,
-    },
-    feeType: {
-        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.FEE_TYPE)),
-        allowNull: false,
-    },
-    frequency: {
-        type: sequelize_1.DataTypes.ENUM(...Object.values(app_1.FEE_TYPE_FREQUENCY)),
-        allowNull: false,
-    },
-    academicCalendarId: {
-        type: sequelize_1.DataTypes.UUID,
-        field: 'academic_calendar_id',
-        allowNull: true,
-    },
-}, {
-    modelName: 'FeeTypeModel',
-    tableName: 'fee_type',
-    timestamps: true,
-    sequelize: index_1.sequelize,
-});
-exports.default = FeeTypeModel;

package/dist/models/psql/feesCollectionModel.d.ts

@@ -1,30 +0,0 @@
-import { Model } from 'sequelize';
-import { IFeesCollectionModelAttributes } from '../../interfaces/feesCollectionInterface';
-import { TFeesCollectionModelCreationAttributes } from '../../types/feesCollectionType';
-import { FEE_PAYMENT_STATUS, PAYMENT_TYPE } from '../../constants/app';
-declare class FeesCollectionModel extends Model<IFeesCollectionModelAttributes, TFeesCollectionModelCreationAttributes> {
-    id: string;
-    date: Date;
-    dueDate?: Date;
-    feeAmount?: number;
-    paidFee?: number;
-    discount?: number;
-    paymentType?: PAYMENT_TYPE;
-    bankName?: string | null;
-    chequeNo?: string | null;
-    userId: string;
-    instituteId: string;
-    upiId?: string | null;
-    status: FEE_PAYMENT_STATUS;
-    academicCalendarId: string;
-    isLeft?: boolean;
-    createdBy: string;
-    updatedBy: string;
-    deletedBy: string;
-    readonly createdAt: Date;
-    readonly deletedAt: string;
-    readonly updatedAt: Date;
-    static addHooks(models: any): void;
-    static associate(models: any): void;
-}
-export default FeesCollectionModel;