@kipicore/dbcore 1.1.30 → 1.1.33

package/dist/models/psql/courseModel.js

@@ -1,17 +1,51 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CourseModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const app_1 = require("../../constants/app");
-const userModel_1 = __importDefault(require("./userModel"));
-const instituteModel_1 = __importDefault(require("./instituteModel"));
-const typeManagementModel_1 = __importDefault(require("./typeManagementModel"));
-const instituteEntityModel_1 = __importDefault(require("./instituteEntityModel"));
 class CourseModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteModel, InstituteEntityModel, TypeManagementModel } = models;
+        CourseModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        CourseModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        CourseModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        CourseModel.belongsTo(InstituteModel, {
+            foreignKey: 'instituteId',
+            as: 'courseInstitute',
+        });
+        InstituteModel.hasMany(CourseModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasCourses',
+        });
+        CourseModel.belongsTo(InstituteEntityModel, {
+            foreignKey: 'subjectId',
+            as: 'courseSubject',
+        });
+        InstituteEntityModel.hasMany(CourseModel, {
+            foreignKey: 'subjectId',
+            as: 'subjectHasCourses',
+        });
+        CourseModel.belongsTo(TypeManagementModel, {
+            foreignKey: 'materialType',
+            as: 'courseMaterialType',
+        });
+        TypeManagementModel.hasMany(CourseModel, {
+            foreignKey: 'materialType',
+            as: 'materialTypeHasCourses',
+        });
+    }
 }
+exports.CourseModel = CourseModel;
 CourseModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -84,53 +118,4 @@ CourseModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-// Associations
-CourseModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-CourseModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-CourseModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-CourseModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'courseInstitute',
-});
-instituteModel_1.default.hasMany(CourseModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasCourses',
-});
-CourseModel.belongsTo(instituteEntityModel_1.default, {
-    foreignKey: 'subjectId',
-    as: 'courseSubject',
-});
-instituteEntityModel_1.default.hasMany(CourseModel, {
-    foreignKey: 'subjectId',
-    as: 'subjectHasCourses',
-});
-CourseModel.belongsTo(typeManagementModel_1.default, {
-    foreignKey: 'materialType',
-    as: 'courseMaterialType',
-});
-typeManagementModel_1.default.hasMany(CourseModel, {
-    foreignKey: 'materialType',
-    as: 'materialTypeHasCourses',
-});
 exports.default = CourseModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { IDriverModelAttributes } from '../../interfaces/driverInterface';
 import { TDriverModelCreationAttributes } from '../../types/driverType';
 import { APP_TYPE, COMMAN_STATUS } from '../../constants/app';
-declare class DriverModel extends Model<IDriverModelAttributes, TDriverModelCreationAttributes> {
+export declare class DriverModel extends Model<IDriverModelAttributes, TDriverModelCreationAttributes> {
     id: string;
     instituteId: string;
     firstName: string;
@@ -26,5 +26,7 @@ declare class DriverModel extends Model<IDriverModelAttributes, TDriverModelCrea
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt?: Date;
+    static associate(models: any): void;
+    static addHooks(): void;
 }
 export default DriverModel;

package/dist/models/psql/driverModel.js

@@ -3,18 +3,74 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriverModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const app_1 = require("../../constants/app");
-const userModel_1 = __importDefault(require("./userModel"));
 const instituteModel_1 = __importDefault(require("./instituteModel"));
 const errorMessages_1 = require("../../constants/errorMessages");
-const countryModel_1 = __importDefault(require("./countryModel"));
-const stateModel_1 = __importDefault(require("./stateModel"));
-const cityModel_1 = __importDefault(require("./cityModel"));
-const fileStorageModel_1 = __importDefault(require("./fileStorageModel"));
 class DriverModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteModel, CountryModel, StateModel, CityModel, FileStorageModel } = models;
+        DriverModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        DriverModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        DriverModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        DriverModel.belongsTo(CountryModel, {
+            foreignKey: 'country',
+            as: 'countryDetails',
+        });
+        DriverModel.belongsTo(StateModel, {
+            foreignKey: 'state',
+            as: 'stateDetails',
+        });
+        DriverModel.belongsTo(CityModel, {
+            foreignKey: 'city',
+            as: 'cityDetails',
+        });
+        DriverModel.belongsTo(FileStorageModel, {
+            foreignKey: 'drivingLicense',
+            as: 'drivingLicenseDetails',
+        });
+        DriverModel.belongsTo(FileStorageModel, {
+            foreignKey: 'aadharCard',
+            as: 'aadharCardDetails',
+        });
+        DriverModel.belongsTo(InstituteModel, {
+            foreignKey: 'instituteId',
+            as: 'driverInstitute',
+        });
+        InstituteModel.hasMany(DriverModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasDrivers',
+        });
+    }
+    static addHooks() {
+        const beforeCreateOrUpdateHook = async (driver) => {
+            if (driver.instituteId) {
+                const institute = await instituteModel_1.default.findByPk(driver.instituteId);
+                if (!institute) {
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+                }
+            }
+        };
+        DriverModel.beforeCreate(beforeCreateOrUpdateHook);
+        DriverModel.beforeBulkUpdate(async (options) => {
+            if (options.attributes) {
+                await beforeCreateOrUpdateHook(options.attributes);
+            }
+        });
+    }
 }
+exports.DriverModel = DriverModel;
 DriverModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -87,7 +143,6 @@ DriverModel.init({
         values: Object.values(app_1.APP_TYPE),
         allowNull: true,
         field: 'app_type',
-        // defaultValue: APP_TYPE.SCHOOL_APP,
     },
     status: {
         type: sequelize_1.DataTypes.ENUM,
@@ -101,63 +156,4 @@ DriverModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-// Associations
-DriverModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-DriverModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-DriverModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-DriverModel.belongsTo(countryModel_1.default, {
-    foreignKey: 'country',
-    as: 'countryDetails',
-});
-DriverModel.belongsTo(stateModel_1.default, { foreignKey: 'state', as: 'stateDetails' });
-DriverModel.belongsTo(cityModel_1.default, { foreignKey: 'city', as: 'cityDetails' });
-DriverModel.belongsTo(fileStorageModel_1.default, {
-    foreignKey: 'drivingLicense',
-    as: 'drivingLicenseDetails',
-});
-DriverModel.belongsTo(fileStorageModel_1.default, {
-    foreignKey: 'aadharCard',
-    as: 'aadharCardDetails',
-});
-DriverModel.belongsTo(instituteModel_1.default, {
-    foreignKey: 'instituteId',
-    as: 'driverInstitute',
-});
-instituteModel_1.default.hasMany(DriverModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasDrivers',
-});
-const beforeCreateOrUpdateHook = async (driver) => {
-    if (driver.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(driver.instituteId);
-        if (!institute) {
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-        }
-    }
-};
-DriverModel.beforeCreate(beforeCreateOrUpdateHook);
-DriverModel.beforeBulkUpdate(async (options) => {
-    await beforeCreateOrUpdateHook(options.attributes);
-});
 exports.default = DriverModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { IEntityGroupModelAttributes } from '../../interfaces/entityGroupInterface';
 import { TEntityGroupModelCreationAttributes } from '../../types/entityGroupType';
 import { COMMAN_STATUS } from '../../constants/app';
-declare class EntityGroupModel extends Model<IEntityGroupModelAttributes, TEntityGroupModelCreationAttributes> {
+export declare class EntityGroupModel extends Model<IEntityGroupModelAttributes, TEntityGroupModelCreationAttributes> {
     id: string;
     title: string;
     isDefault: boolean;
@@ -17,5 +17,6 @@ declare class EntityGroupModel extends Model<IEntityGroupModelAttributes, TEntit
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt: string;
+    static associate(models: any): void;
 }
 export default EntityGroupModel;

package/dist/models/psql/entityGroupModel.js

@@ -1,15 +1,35 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityGroupModel = void 0;
 const sequelize_1 = require("sequelize");
-const instituteEntityModel_1 = __importDefault(require("./instituteEntityModel"));
 const app_1 = require("../../constants/app");
 const index_1 = require("./index");
-const userModel_1 = __importDefault(require("./userModel"));
 class EntityGroupModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, InstituteEntityModel } = models;
+        EntityGroupModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        EntityGroupModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        EntityGroupModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        EntityGroupModel.belongsTo(InstituteEntityModel, {
+            foreignKey: { name: 'standardId', allowNull: true, field: 'standard_id' },
+            as: 'standardEntityGroup',
+        });
+        InstituteEntityModel.hasMany(EntityGroupModel, {
+            foreignKey: { name: 'standardId', allowNull: true, field: 'standard_id' },
+            as: 'entityGroupStandard',
+        });
+    }
 }
+exports.EntityGroupModel = EntityGroupModel;
 EntityGroupModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -57,44 +77,4 @@ EntityGroupModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-EntityGroupModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-EntityGroupModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-EntityGroupModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-EntityGroupModel.belongsTo(instituteEntityModel_1.default, {
-    foreignKey: {
-        name: 'standardId',
-        allowNull: true,
-        field: 'standard_id',
-    },
-    as: 'standardEntityGroup',
-});
-instituteEntityModel_1.default.hasMany(EntityGroupModel, {
-    foreignKey: {
-        name: 'standardId',
-        allowNull: true,
-        field: 'standard_id',
-    },
-    as: 'entityGroupStandard',
-});
 exports.default = EntityGroupModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { IFacilityAttributes } from '../../interfaces/facilityInterface';
 import { TFacilityCreationAttributes } from '../../types/facilityType';
 import { FACILITY_TYPE } from '../../constants/app';
-declare class FacilityModel extends Model<IFacilityAttributes, TFacilityCreationAttributes> {
+export declare class FacilityModel extends Model<IFacilityAttributes, TFacilityCreationAttributes> {
     id: string;
     typeManagementId: string;
     type: FACILITY_TYPE;
@@ -14,5 +14,7 @@ declare class FacilityModel extends Model<IFacilityAttributes, TFacilityCreation
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt: string;
+    static associate(models: any): void;
+    static addHooks(): void;
 }
 export default FacilityModel;

package/dist/models/psql/facilityModel.js

@@ -3,15 +3,77 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FacilityModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const instituteModel_1 = __importDefault(require("./instituteModel"));
-const userModel_1 = __importDefault(require("./userModel"));
 const errorMessages_1 = require("../../constants/errorMessages");
 const typeManagementModel_1 = __importDefault(require("./typeManagementModel"));
 const app_1 = require("../../constants/app");
 class FacilityModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, TypeManagementModel, UserModel } = models;
+        FacilityModel.belongsTo(InstituteModel, {
+            foreignKey: { name: 'instituteId', field: 'institute_id' },
+            as: 'facilityInstitute',
+        });
+        InstituteModel.hasMany(FacilityModel, {
+            foreignKey: 'instituteId',
+            as: 'instituteHasFacilities',
+        });
+        FacilityModel.belongsTo(TypeManagementModel, {
+            foreignKey: { name: 'typeManagementId', field: 'type_management_id' },
+            as: 'facilityType',
+        });
+        TypeManagementModel.hasMany(FacilityModel, {
+            foreignKey: 'typeManagementId',
+            as: 'instituteHasFacilitiesType',
+        });
+        FacilityModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FacilityModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FacilityModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+    }
+    static addHooks() {
+        const beforeCreateOrUpdateHook = async (facility) => {
+            if (facility.instituteId) {
+                const institute = await instituteModel_1.default.findByPk(facility.instituteId);
+                if (!institute)
+                    throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+            }
+            if (facility.typeManagementId) {
+                const type = await typeManagementModel_1.default.findOne({
+                    where: {
+                        id: facility.typeManagementId,
+                        type: app_1.TYPE_MANAGEMENT_TYPE.FACILITY,
+                    },
+                });
+                if (!type)
+                    throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
+            }
+        };
+        FacilityModel.beforeCreate(beforeCreateOrUpdateHook);
+        FacilityModel.beforeBulkUpdate(async (options) => {
+            if (options.attributes) {
+                await beforeCreateOrUpdateHook(options.attributes);
+            }
+        });
+        FacilityModel.beforeBulkCreate(async (instances) => {
+            for (const instance of instances) {
+                await beforeCreateOrUpdateHook(instance);
+            }
+        });
+    }
 }
+exports.FacilityModel = FacilityModel;
 FacilityModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -45,76 +107,4 @@ FacilityModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-const beforeCreateOrUpdateHook = async (facilities) => {
-    if (facilities.instituteId) {
-        const institute = await instituteModel_1.default.findByPk(facilities.instituteId);
-        if (!institute)
-            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
-    }
-    if (facilities.typeManagementId) {
-        const type = await typeManagementModel_1.default.findOne({
-            where: {
-                id: facilities.typeManagementId,
-                type: app_1.TYPE_MANAGEMENT_TYPE.FACILITY,
-            },
-        });
-        if (!type)
-            throw new Error(errorMessages_1.TYPE_MANAGEMENT_ERROR_MESSAGES.NOT_FOUND);
-    }
-};
-FacilityModel.beforeCreate(beforeCreateOrUpdateHook);
-FacilityModel.beforeBulkUpdate(async (options) => {
-    await beforeCreateOrUpdateHook(options.attributes);
-});
-FacilityModel.beforeBulkCreate(async (instances) => {
-    for (const instance of instances) {
-        await beforeCreateOrUpdateHook(instance);
-    }
-});
-FacilityModel.belongsTo(instituteModel_1.default, {
-    foreignKey: {
-        name: 'instituteId',
-        field: 'institute_id',
-    },
-    as: 'facilityInstitute',
-});
-instituteModel_1.default.hasMany(FacilityModel, {
-    foreignKey: 'instituteId',
-    as: 'instituteHasFacilities',
-});
-FacilityModel.belongsTo(typeManagementModel_1.default, {
-    foreignKey: {
-        name: 'typeManagementId',
-        field: 'type_management_id',
-    },
-    as: 'facilityType',
-});
-typeManagementModel_1.default.hasMany(FacilityModel, {
-    foreignKey: 'typeManagementId',
-    as: 'instituteHasFacilitiesType',
-});
-FacilityModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-FacilityModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-FacilityModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
 exports.default = FacilityModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { APP_TYPE, COMMAN_STATUS } from '../../constants/app';
 import { IFeatureActionAttributes } from '../../interfaces/featureActionInterface';
 import { TFeatureActionCreationAttributes } from '../../types/featureActionType';
-declare class FeatureActionModel extends Model<IFeatureActionAttributes, TFeatureActionCreationAttributes> {
+export declare class FeatureActionModel extends Model<IFeatureActionAttributes, TFeatureActionCreationAttributes> {
     id: string;
     name: string;
     status: COMMAN_STATUS;
@@ -16,7 +16,8 @@ declare class FeatureActionModel extends Model<IFeatureActionAttributes, TFeatur
     updatedBy: string;
     deletedBy: string;
     readonly createdAt: Date;
-    readonly deletedAt: string;
     readonly updatedAt: Date;
+    readonly deletedAt: string;
+    static associate(models: any): void;
 }
 export default FeatureActionModel;

package/dist/models/psql/featureActionModel.js

@@ -1,15 +1,31 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureActionModel = void 0;
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
 const app_1 = require("../../constants/app");
-const userModel_1 = __importDefault(require("./userModel"));
-const roleModel_1 = __importDefault(require("./roleModel"));
 class FeatureActionModel extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, RoleModel } = models;
+        FeatureActionModel.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        FeatureActionModel.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        FeatureActionModel.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        FeatureActionModel.belongsTo(RoleModel, {
+            foreignKey: { name: 'roleId', field: 'role_id' },
+            as: 'role',
+        });
+    }
 }
+exports.FeatureActionModel = FeatureActionModel;
 FeatureActionModel.init({
     id: {
         type: sequelize_1.DataTypes.UUID,
@@ -61,35 +77,4 @@ FeatureActionModel.init({
     timestamps: true,
     sequelize: index_1.sequelize,
 });
-FeatureActionModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-FeatureActionModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-FeatureActionModel.belongsTo(userModel_1.default, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-FeatureActionModel.belongsTo(roleModel_1.default, {
-    foreignKey: {
-        name: 'roleId',
-        field: 'roleId',
-    },
-    as: 'role',
-});
 exports.default = FeatureActionModel;

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

@@ -2,7 +2,7 @@ import { Model } from 'sequelize';
 import { IFeeHistoryDetailsModelAttributes } from '../../interfaces/feeHistoryDetailsInterface';
 import { TFeeHistoryDetailsModelCreationAttributes } from '../../types/feeHistoryDetailsType';
 import { PAYMENT_TYPE } from '../../constants/app';
-declare class FeeHistoryDetailsModel extends Model<IFeeHistoryDetailsModelAttributes, TFeeHistoryDetailsModelCreationAttributes> {
+export declare class FeeHistoryDetailsModel extends Model<IFeeHistoryDetailsModelAttributes, TFeeHistoryDetailsModelCreationAttributes> {
     id: string;
     instituteId: string;
     userFeeTypeByAccountId: string;
@@ -22,5 +22,6 @@ declare class FeeHistoryDetailsModel extends Model<IFeeHistoryDetailsModelAttrib
     readonly createdAt: Date;
     readonly updatedAt: Date;
     readonly deletedAt?: Date;
+    static associate(models: any): void;
 }
 export default FeeHistoryDetailsModel;