@kipicore/dbcore 1.1.619 → 1.1.620

package/dist/models/psql/accountIntegrationMappingModel.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountIntegrationMappingModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountIntegrationConnectionModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountIntegrationMappingModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountIntegrationMappingModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountIntegrationConnectionModel) {
+            AccountIntegrationMappingModel.belongsTo(AccountIntegrationConnectionModel, { foreignKey: 'connectionId', as: 'connection' });
+        }
+        if (UserModel) {
+            AccountIntegrationMappingModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountIntegrationMappingModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountIntegrationMappingModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountIntegrationMappingModel.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',
+    },
+    connectionId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'connection_id',
+    },
+    provider: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'provider',
+    },
+    mappingType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'mapping_type',
+    },
+    kipiObjectType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'kipi_object_type',
+    },
+    kipiObjectId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'kipi_object_id',
+    },
+    externalId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'external_id',
+    },
+    externalName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'external_name',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountIntegrationMappingModel',
+    tableName: 'account_integration_mappings',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountIntegrationMappingModel;

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

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IAccountInventoryPostingModelAttributes } from '../../interfaces/accountInventoryPostingInterface';
+import { TAccountInventoryPostingModelCreationAttributes } from '../../types/accountInventoryPostingType';
+import { AccountSourceModule, AccountInventoryMovementType } from '../../constants/app';
+declare class AccountInventoryPostingModel extends Model<IAccountInventoryPostingModelAttributes, TAccountInventoryPostingModelCreationAttributes> implements IAccountInventoryPostingModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    sourceModule: AccountSourceModule;
+    sourceId: string;
+    movementType: AccountInventoryMovementType;
+    amount: number;
+    journalEntryId: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountInventoryPostingModel;

package/dist/models/psql/accountInventoryPostingModel.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountInventoryPostingModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountJournalEntryModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountInventoryPostingModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountInventoryPostingModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountInventoryPostingModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (UserModel) {
+            AccountInventoryPostingModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountInventoryPostingModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountInventoryPostingModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountInventoryPostingModel.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',
+    },
+    sourceModule: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_module',
+    },
+    sourceId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'source_id',
+    },
+    movementType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'movement_type',
+    },
+    amount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'amount',
+        defaultValue: 0.00,
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountInventoryPostingModel',
+    tableName: 'account_inventory_postings',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountInventoryPostingModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountInventoryValuationModelAttributes } from '../../interfaces/accountInventoryValuationInterface';
+import { TAccountInventoryValuationModelCreationAttributes } from '../../types/accountInventoryValuationType';
+import { AccountInventoryValuationMethod } from '../../constants/app';
+declare class AccountInventoryValuationModel extends Model<IAccountInventoryValuationModelAttributes, TAccountInventoryValuationModelCreationAttributes> implements IAccountInventoryValuationModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    resourceId: string;
+    financialYearId: string;
+    valuationMethod: AccountInventoryValuationMethod;
+    quantity: number;
+    unitCost: number;
+    currentValue: number;
+    journalEntryId: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountInventoryValuationModel;

package/dist/models/psql/accountInventoryValuationModel.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountInventoryValuationModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountFinancialYearModel, AccountJournalEntryModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountInventoryValuationModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountInventoryValuationModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountInventoryValuationModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountInventoryValuationModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (UserModel) {
+            AccountInventoryValuationModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountInventoryValuationModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountInventoryValuationModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountInventoryValuationModel.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',
+    },
+    resourceId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'resource_id',
+    },
+    financialYearId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'financial_year_id',
+    },
+    valuationMethod: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'valuation_method',
+    },
+    quantity: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'quantity',
+        defaultValue: 0.00,
+    },
+    unitCost: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'unit_cost',
+        defaultValue: 0.00,
+    },
+    currentValue: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'current_value',
+        defaultValue: 0.00,
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountInventoryValuationModel',
+    tableName: 'account_inventory_valuations',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountInventoryValuationModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountJournalEntryModelAttributes } from '../../interfaces/accountJournalEntryInterface';
+import { TAccountJournalEntryModelCreationAttributes } from '../../types/accountJournalEntryType';
+import { AccountSourceModule } from '../../constants/app';
+declare class AccountJournalEntryModel extends Model<IAccountJournalEntryModelAttributes, TAccountJournalEntryModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    voucherId: string;
+    postingDate: Date;
+    financialYearId: string;
+    eventId?: string;
+    sourceModule?: AccountSourceModule;
+    sourceType?: string;
+    sourceId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountJournalEntryModel;

package/dist/models/psql/accountJournalEntryModel.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountJournalEntryModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountVoucherModel, AccountFinancialYearModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountVoucherModel) {
+            AccountJournalEntryModel.belongsTo(AccountVoucherModel, { foreignKey: 'voucherId', as: 'voucher' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountJournalEntryModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        if (InstituteModel) {
+            AccountJournalEntryModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountJournalEntryModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountJournalEntryModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountJournalEntryModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountJournalEntryModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountJournalEntryModel.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',
+    },
+    voucherId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'voucher_id',
+    },
+    postingDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'posting_date',
+    },
+    financialYearId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'financial_year_id',
+    },
+    eventId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'event_id',
+    },
+    sourceModule: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_module',
+    },
+    sourceType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_type',
+    },
+    sourceId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_id',
+    },
+}, {
+    modelName: 'AccountJournalEntryModel',
+    tableName: 'account_journal_entries',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountJournalEntryModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountJournalLineModelAttributes } from '../../interfaces/accountJournalLineInterface';
+import { TAccountJournalLineModelCreationAttributes } from '../../types/accountJournalLineType';
+declare class AccountJournalLineModel extends Model<IAccountJournalLineModelAttributes, TAccountJournalLineModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    journalEntryId: string;
+    ledgerId?: string;
+    costCenterId?: string;
+    debitAmount?: number;
+    creditAmount?: number;
+    entityType?: string;
+    entityId?: string;
+    lineNarration?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountJournalLineModel;

package/dist/models/psql/accountJournalLineModel.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountJournalLineModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountJournalEntryModel, AccountLedgerModel, AccountCostCenterModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountJournalEntryModel) {
+            AccountJournalLineModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (AccountLedgerModel) {
+            AccountJournalLineModel.belongsTo(AccountLedgerModel, { foreignKey: 'ledgerId', as: 'ledger' });
+        }
+        if (AccountCostCenterModel) {
+            AccountJournalLineModel.belongsTo(AccountCostCenterModel, { foreignKey: 'costCenterId', as: 'costCenter' });
+        }
+        if (InstituteModel) {
+            AccountJournalLineModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountJournalLineModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountJournalLineModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountJournalLineModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountJournalLineModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountJournalLineModel.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',
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+    ledgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'ledger_id',
+    },
+    costCenterId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'cost_center_id',
+    },
+    debitAmount: {
+        type: sequelize_1.DataTypes.DOUBLE,
+        allowNull: true,
+        field: 'debit_amount',
+    },
+    creditAmount: {
+        type: sequelize_1.DataTypes.DOUBLE,
+        allowNull: true,
+        field: 'credit_amount',
+    },
+    entityType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'entity_type',
+    },
+    entityId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'entity_id',
+    },
+    lineNarration: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'line_narration',
+    },
+}, {
+    modelName: 'AccountJournalLineModel',
+    tableName: 'account_journal_lines',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountJournalLineModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountLedgerBalanceModelAttributes } from '../../interfaces/accountLedgerBalanceInterface';
+import { TAccountLedgerBalanceModelCreationAttributes } from '../../types/accountLedgerBalanceType';
+declare class AccountLedgerBalanceModel extends Model<IAccountLedgerBalanceModelAttributes, TAccountLedgerBalanceModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    ledgerId?: string;
+    financialYearId?: string;
+    periodMonth?: number;
+    openingBalance?: number;
+    periodDebit?: number;
+    periodCredit?: number;
+    closingBalance?: number;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountLedgerBalanceModel;

package/dist/models/psql/accountLedgerBalanceModel.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountLedgerBalanceModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountLedgerModel, AccountFinancialYearModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountLedgerModel) {
+            AccountLedgerBalanceModel.belongsTo(AccountLedgerModel, { foreignKey: 'ledgerId', as: 'ledger' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountLedgerBalanceModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        if (InstituteModel) {
+            AccountLedgerBalanceModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountLedgerBalanceModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountLedgerBalanceModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountLedgerBalanceModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountLedgerBalanceModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountLedgerBalanceModel.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',
+    },
+    periodMonth: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+        field: 'period_month',
+    },
+    openingBalance: {
+        type: sequelize_1.DataTypes.DOUBLE,
+        allowNull: true,
+        field: 'opening_balance',
+    },
+    periodDebit: {
+        type: sequelize_1.DataTypes.DOUBLE,
+        allowNull: true,
+        field: 'period_debit',
+    },
+    periodCredit: {
+        type: sequelize_1.DataTypes.DOUBLE,
+        allowNull: true,
+        field: 'period_credit',
+    },
+    closingBalance: {
+        type: sequelize_1.DataTypes.DOUBLE,
+        allowNull: true,
+        field: 'closing_balance',
+    },
+}, {
+    modelName: 'AccountLedgerBalanceModel',
+    tableName: 'account_ledger_balances',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountLedgerBalanceModel;

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { IAccountPartyAccountModelAttributes } from '../../interfaces/accountPartyAccountInterface';
+import { TAccountPartyAccountModelCreationAttributes } from '../../types/accountPartyAccountType';
+import { AccountPartyType, AccountPartyMode } from '../../constants/app';
+declare class AccountPartyAccountModel extends Model<IAccountPartyAccountModelAttributes, TAccountPartyAccountModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    partyType?: AccountPartyType;
+    partyId?: string;
+    ledgerId?: string;
+    mode?: AccountPartyMode;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountPartyAccountModel;