@kipicore/dbcore 1.1.614 → 1.1.615

package/dist/interfaces/accountLedgerOpeningInterface.d.ts

@@ -0,0 +1,12 @@
+import { AccountBalanceType } from '../constants/app';
+import { IDefaultAttributes } from './commonInterface';
+export interface IAccountLedgerOpeningModelAttributes extends IDefaultAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    ledgerId: string;
+    financialYearId: string;
+    openingBalance: number;
+    balanceType: AccountBalanceType;
+    openingDate: Date;
+}

package/dist/interfaces/accountLedgerOpeningInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/accountNumberSequenceInterface.d.ts

@@ -0,0 +1,11 @@
+import { IDefaultAttributes } from './commonInterface';
+export interface IAccountNumberSequenceModelAttributes extends IDefaultAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    financialYearId: string;
+    sequenceKey: string;
+    prefix: string;
+    currentNumber: number;
+    padding: number;
+}

package/dist/interfaces/accountNumberSequenceInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/accountPeriodLockInterface.d.ts

@@ -0,0 +1,11 @@
+import { IDefaultAttributes } from './commonInterface';
+export interface IAccountPeriodLockModelAttributes extends IDefaultAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    financialYearId: string;
+    periodStart: Date;
+    periodEnd: Date;
+    lockedBy: string;
+    reason: string;
+}

package/dist/interfaces/accountPeriodLockInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/accountVoucherTypeInterface.d.ts

@@ -0,0 +1,12 @@
+import { AccountVoucherTypeCode } from '../constants/app';
+import { IDefaultAttributes } from './commonInterface';
+export interface IAccountVoucherTypeModelAttributes extends IDefaultAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    code: AccountVoucherTypeCode;
+    name: string;
+    prefix: string | null;
+    numberingPattern: string | null;
+    requiresApproval: boolean;
+}

package/dist/interfaces/accountVoucherTypeInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -1,4 +1,6 @@
 export * from './academicCalendarInterface';
+export * from './accountFinancialYearInterface';
+export * from './accountPeriodLockInterface';
 export * from './accountHasReceiptDetailsInterface';
 export * from './announcementInterface';
 export * from './approvalRequestInterface';
@@ -241,3 +243,11 @@ export * from './rmsResourceDetailsInterface';
 export * from './userFinalResultInterface';
 export * from './refundInterface';
 export * from './kipiverseContactFormInterface';
+export * from './accountFinancialYearInterface';
+export * from './accountPeriodLockInterface';
+export * from './accountNumberSequenceInterface';
+export * from './accountGroupInterface';
+export * from './accountLedgerInterface';
+export * from './accountLedgerOpeningInterface';
+export * from './accountCostCenterInterface';
+export * from './accountVoucherTypeInterface';

package/dist/interfaces/index.js

@@ -15,6 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./academicCalendarInterface"), exports);
+__exportStar(require("./accountFinancialYearInterface"), exports);
+__exportStar(require("./accountPeriodLockInterface"), exports);
 __exportStar(require("./accountHasReceiptDetailsInterface"), exports);
 __exportStar(require("./announcementInterface"), exports);
 __exportStar(require("./approvalRequestInterface"), exports);
@@ -257,3 +259,11 @@ __exportStar(require("./rmsResourceDetailsInterface"), exports);
 __exportStar(require("./userFinalResultInterface"), exports);
 __exportStar(require("./refundInterface"), exports);
 __exportStar(require("./kipiverseContactFormInterface"), exports);
+__exportStar(require("./accountFinancialYearInterface"), exports);
+__exportStar(require("./accountPeriodLockInterface"), exports);
+__exportStar(require("./accountNumberSequenceInterface"), exports);
+__exportStar(require("./accountGroupInterface"), exports);
+__exportStar(require("./accountLedgerInterface"), exports);
+__exportStar(require("./accountLedgerOpeningInterface"), exports);
+__exportStar(require("./accountCostCenterInterface"), exports);
+__exportStar(require("./accountVoucherTypeInterface"), exports);

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountCostCenterModelAttributes } from '../../interfaces/accountCostCenterInterface';
+import { TAccountCostCenterModelCreationAttributes } from '../../types/accountCostCenterType';
+import { AccountCostCenterType } from '../../constants/app';
+declare class AccountCostCenterModel extends Model<IAccountCostCenterModelAttributes, TAccountCostCenterModelCreationAttributes> implements IAccountCostCenterModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    parentCostCenterId: string | null;
+    code: string;
+    name: string;
+    type: AccountCostCenterType;
+    refType: string | null;
+    refId: string | null;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountCostCenterModel;

package/dist/models/psql/accountCostCenterModel.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountCostCenterModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel } = models;
+        AccountCostCenterModel.belongsTo(models.AccountCostCenterModel, {
+            foreignKey: 'parentCostCenterId',
+            as: 'parentCostCenter',
+        });
+        if (InstituteModel) {
+            AccountCostCenterModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountCostCenterModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountCostCenterModel.belongsTo(UserModel, {
+                foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+                as: 'createdByUser',
+            });
+            AccountCostCenterModel.belongsTo(UserModel, {
+                foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+                as: 'updatedByUser',
+            });
+            AccountCostCenterModel.belongsTo(UserModel, {
+                foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+                as: 'deletedByUser',
+            });
+        }
+    }
+}
+AccountCostCenterModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    parentCostCenterId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'parent_cost_center_id',
+    },
+    code: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    name: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    type: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    refType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ref_type',
+    },
+    refId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'ref_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountCostCenterModel',
+    tableName: 'account_cost_centers',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountCostCenterModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountFinancialYearModelAttributes } from '../../interfaces/accountFinancialYearInterface';
+import { TAccountFinancialYearModelCreationAttributes } from '../../types/accountFinancialYearType';
+import { COMMAN_STATUS } from '../../constants/app';
+declare class AccountFinancialYearModel extends Model<IAccountFinancialYearModelAttributes, TAccountFinancialYearModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    name: string;
+    startDate: Date;
+    endDate: Date;
+    isActive: boolean;
+    isClosed: boolean;
+    status: COMMAN_STATUS;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountFinancialYearModel;

package/dist/models/psql/accountFinancialYearModel.js

@@ -0,0 +1,81 @@
+"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 AccountFinancialYearModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountPeriodLockModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountPeriodLockModel) {
+            AccountFinancialYearModel.hasMany(AccountPeriodLockModel, { foreignKey: { name: 'financialYearId', field: 'financial_year_id' }, as: 'periodLocks' });
+        }
+        if (InstituteModel) {
+            AccountFinancialYearModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountFinancialYearModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountFinancialYearModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountFinancialYearModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountFinancialYearModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountFinancialYearModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    name: {
+        type: sequelize_1.DataTypes.STRING(255),
+        allowNull: true,
+    },
+    startDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'start_date',
+    },
+    endDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'end_date',
+    },
+    isActive: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: true,
+        field: 'is_active',
+    },
+    isClosed: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: false,
+        field: 'is_closed',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING(50),
+        allowNull: true,
+        defaultValue: app_1.COMMAN_STATUS.ACTIVE,
+    },
+}, {
+    modelName: 'AccountFinancialYearModel',
+    tableName: 'account_financial_years',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountFinancialYearModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountGroupModelAttributes } from '../../interfaces/accountGroupInterface';
+import { TAccountGroupModelCreationAttributes } from '../../types/accountGroupType';
+import { AccountNature, AccountNormalBalance } from '../../constants/app';
+declare class AccountGroupModel extends Model<IAccountGroupModelAttributes, TAccountGroupModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    parentGroupId: string | null;
+    groupCode: string;
+    groupName: string;
+    nature: AccountNature;
+    normalBalance: AccountNormalBalance;
+    isSystem: boolean;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountGroupModel;

package/dist/models/psql/accountGroupModel.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountGroupModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountLedgerModel, InstituteModel, AcademicCalendarModel } = models;
+        AccountGroupModel.belongsTo(models.AccountGroupModel, {
+            foreignKey: 'parentGroupId',
+            as: 'parentGroup',
+        });
+        if (AccountLedgerModel) {
+            AccountGroupModel.hasMany(AccountLedgerModel, { foreignKey: 'groupId', as: 'ledgers' });
+        }
+        if (InstituteModel) {
+            AccountGroupModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountGroupModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountGroupModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountGroupModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountGroupModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountGroupModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    parentGroupId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'parent_group_id',
+    },
+    groupCode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'group_code',
+    },
+    groupName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'group_name',
+    },
+    nature: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    normalBalance: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'normal_balance',
+    },
+    isSystem: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: false,
+        field: 'is_system',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountGroupModel',
+    tableName: 'account_groups',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountGroupModel;

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

@@ -0,0 +1,26 @@
+import { Model } from 'sequelize';
+import { IAccountLedgerModelAttributes } from '../../interfaces/accountLedgerInterface';
+import { TAccountLedgerModelCreationAttributes } from '../../types/accountLedgerType';
+import { AccountLedgerType, AccountNormalBalance } from '../../constants/app';
+declare class AccountLedgerModel extends Model<IAccountLedgerModelAttributes, TAccountLedgerModelCreationAttributes> implements IAccountLedgerModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    groupId: string;
+    ledgerCode: string;
+    ledgerName: string;
+    ledgerType: AccountLedgerType;
+    normalBalance: AccountNormalBalance;
+    entityType?: string | null;
+    entityId?: string | null;
+    bankAccountId?: string | null;
+    allowManualPosting: boolean;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountLedgerModel;

package/dist/models/psql/accountLedgerModel.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountLedgerModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountGroupModel, AccountLedgerOpeningModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountGroupModel) {
+            AccountLedgerModel.belongsTo(AccountGroupModel, { foreignKey: 'groupId', as: 'group' });
+        }
+        if (AccountLedgerOpeningModel) {
+            AccountLedgerModel.hasMany(AccountLedgerOpeningModel, { foreignKey: 'ledgerId', as: 'openings' });
+        }
+        if (InstituteModel) {
+            AccountLedgerModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountLedgerModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountLedgerModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountLedgerModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountLedgerModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountLedgerModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    groupId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'group_id',
+    },
+    ledgerCode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ledger_code',
+    },
+    ledgerName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ledger_name',
+    },
+    ledgerType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ledger_type',
+    },
+    normalBalance: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'normal_balance',
+    },
+    entityType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'entity_type',
+    },
+    entityId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'entity_id',
+    },
+    bankAccountId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'bank_account_id',
+    },
+    allowManualPosting: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: true,
+        field: 'allow_manual_posting',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountLedgerModel',
+    tableName: 'account_ledgers',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountLedgerModel;

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

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IAccountLedgerOpeningModelAttributes } from '../../interfaces/accountLedgerOpeningInterface';
+import { TAccountLedgerOpeningModelCreationAttributes } from '../../types/accountLedgerOpeningType';
+import { AccountBalanceType } from '../../constants/app';
+declare class AccountLedgerOpeningModel extends Model<IAccountLedgerOpeningModelAttributes, TAccountLedgerOpeningModelCreationAttributes> implements IAccountLedgerOpeningModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    ledgerId: string;
+    financialYearId: string;
+    openingBalance: number;
+    balanceType: AccountBalanceType;
+    openingDate: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountLedgerOpeningModel;

package/dist/models/psql/accountLedgerOpeningModel.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountLedgerOpeningModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountLedgerModel, InstituteModel, AcademicCalendarModel, AccountFinancialYearModel } = models;
+        if (AccountLedgerModel) {
+            AccountLedgerOpeningModel.belongsTo(AccountLedgerModel, { foreignKey: 'ledgerId', as: 'ledger' });
+        }
+        if (InstituteModel) {
+            AccountLedgerOpeningModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountLedgerOpeningModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountLedgerOpeningModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountLedgerOpeningModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountLedgerOpeningModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountLedgerOpeningModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountLedgerOpeningModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    ledgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'ledger_id',
+    },
+    financialYearId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'financial_year_id',
+    },
+    openingBalance: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'opening_balance',
+    },
+    balanceType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'balance_type',
+    },
+    openingDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'opening_date',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountLedgerOpeningModel',
+    tableName: 'account_ledger_openings',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountLedgerOpeningModel;