@kipicore/dbcore 1.1.614 → 1.1.616

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { IAccountAssetDisposalModelAttributes } from '../../interfaces/accountAssetDisposalInterface';
+import { TAccountAssetDisposalModelCreationAttributes } from '../../types/accountAssetDisposalType';
+declare class AccountAssetDisposalModel extends Model<IAccountAssetDisposalModelAttributes, TAccountAssetDisposalModelCreationAttributes> implements IAccountAssetDisposalModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    fixedAssetId: string;
+    disposalDate: Date;
+    proceeds: number;
+    gainLossAmount: 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 AccountAssetDisposalModel;

package/dist/models/psql/accountAssetDisposalModel.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountAssetDisposalModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountFixedAssetModel, AccountJournalEntryModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountAssetDisposalModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountAssetDisposalModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFixedAssetModel) {
+            AccountAssetDisposalModel.belongsTo(AccountFixedAssetModel, { foreignKey: 'fixedAssetId', as: 'fixedAsset' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountAssetDisposalModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (UserModel) {
+            AccountAssetDisposalModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountAssetDisposalModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountAssetDisposalModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountAssetDisposalModel.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',
+    },
+    fixedAssetId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'fixed_asset_id',
+    },
+    disposalDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'disposal_date',
+    },
+    proceeds: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'proceeds',
+        defaultValue: 0.00,
+    },
+    gainLossAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'gain_loss_amount',
+        defaultValue: 0.00,
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountAssetDisposalModel',
+    tableName: 'account_asset_disposals',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountAssetDisposalModel;

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

@@ -0,0 +1,25 @@
+import { Model } from 'sequelize';
+import { IAccountBankReconciliationBatchModelAttributes } from '../../interfaces/accountBankReconciliationBatchInterface';
+import { TAccountBankReconciliationBatchModelCreationAttributes } from '../../types/accountBankReconciliationBatchType';
+import { AccountApprovalStatus } from '../../constants/app';
+declare class AccountBankReconciliationBatchModel extends Model<IAccountBankReconciliationBatchModelAttributes, TAccountBankReconciliationBatchModelCreationAttributes> implements IAccountBankReconciliationBatchModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    bankAccountId: string;
+    statementDate: Date;
+    statementPeriodStartDate: Date;
+    statementPeriodEndDate: Date;
+    openingBalance: number;
+    closingBalance: number;
+    status: AccountApprovalStatus;
+    fileStorageId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountBankReconciliationBatchModel;

package/dist/models/psql/accountBankReconciliationBatchModel.js

@@ -0,0 +1,92 @@
+"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 AccountBankReconciliationBatchModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, BankAccountDetailsModel, FileStorageModel, UserModel } = models;
+        if (InstituteModel) {
+            AccountBankReconciliationBatchModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountBankReconciliationBatchModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (BankAccountDetailsModel) {
+            AccountBankReconciliationBatchModel.belongsTo(BankAccountDetailsModel, { foreignKey: 'bankAccountId', as: 'bankAccount' });
+        }
+        if (FileStorageModel) {
+            AccountBankReconciliationBatchModel.belongsTo(FileStorageModel, { foreignKey: 'fileStorageId', as: 'fileStorage' });
+        }
+        if (UserModel) {
+            AccountBankReconciliationBatchModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountBankReconciliationBatchModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountBankReconciliationBatchModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountBankReconciliationBatchModel.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',
+    },
+    bankAccountId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'bank_account_id',
+    },
+    statementDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'statement_date',
+    },
+    statementPeriodStartDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'statement_period_start_date',
+    },
+    statementPeriodEndDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'statement_period_end_date',
+    },
+    openingBalance: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'opening_balance',
+    },
+    closingBalance: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'closing_balance',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        defaultValue: app_1.AccountApprovalStatus.PENDING,
+    },
+    fileStorageId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'file_storage_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountBankReconciliationBatchModel',
+    tableName: 'account_bank_reconciliation_batches',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountBankReconciliationBatchModel;

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

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IAccountBankReconciliationMatchModelAttributes } from '../../interfaces/accountBankReconciliationMatchInterface';
+import { TAccountBankReconciliationMatchModelCreationAttributes } from '../../types/accountBankReconciliationMatchType';
+import { AccountMatchStatus } from '../../constants/app';
+declare class AccountBankReconciliationMatchModel extends Model<IAccountBankReconciliationMatchModelAttributes, TAccountBankReconciliationMatchModelCreationAttributes> implements IAccountBankReconciliationMatchModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    batchId: string;
+    statementLineId: string;
+    journalLineId: string;
+    matchedAmount: number;
+    matchStatus: AccountMatchStatus;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountBankReconciliationMatchModel;

package/dist/models/psql/accountBankReconciliationMatchModel.js

@@ -0,0 +1,82 @@
+"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 AccountBankReconciliationMatchModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountBankReconciliationBatchModel, AccountBankStatementLineModel, AccountJournalLineModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountBankReconciliationMatchModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountBankReconciliationMatchModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountBankReconciliationBatchModel) {
+            AccountBankReconciliationMatchModel.belongsTo(AccountBankReconciliationBatchModel, { foreignKey: 'batchId', as: 'batch' });
+        }
+        if (AccountBankStatementLineModel) {
+            AccountBankReconciliationMatchModel.belongsTo(AccountBankStatementLineModel, { foreignKey: 'statementLineId', as: 'statementLine' });
+        }
+        if (AccountJournalLineModel) {
+            AccountBankReconciliationMatchModel.belongsTo(AccountJournalLineModel, { foreignKey: 'journalLineId', as: 'journalLine' });
+        }
+        if (UserModel) {
+            AccountBankReconciliationMatchModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountBankReconciliationMatchModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountBankReconciliationMatchModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountBankReconciliationMatchModel.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',
+    },
+    batchId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'batch_id',
+    },
+    statementLineId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'statement_line_id',
+    },
+    journalLineId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_line_id',
+    },
+    matchedAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'matched_amount',
+        defaultValue: 0.00,
+    },
+    matchStatus: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'match_status',
+        defaultValue: app_1.AccountMatchStatus.UNMATCHED,
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountBankReconciliationMatchModel',
+    tableName: 'account_bank_reconciliation_matches',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountBankReconciliationMatchModel;

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

@@ -0,0 +1,25 @@
+import { Model } from 'sequelize';
+import { IAccountBankStatementLineModelAttributes } from '../../interfaces/accountBankStatementLineInterface';
+import { TAccountBankStatementLineModelCreationAttributes } from '../../types/accountBankStatementLineType';
+import { AccountMatchStatus } from '../../constants/app';
+declare class AccountBankStatementLineModel extends Model<IAccountBankStatementLineModelAttributes, TAccountBankStatementLineModelCreationAttributes> implements IAccountBankStatementLineModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    batchId: string;
+    transactionDate: Date;
+    description?: string;
+    referenceNumber?: string;
+    withdrawalAmount: number;
+    depositAmount: number;
+    balance: number;
+    matchStatus: AccountMatchStatus;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountBankStatementLineModel;

package/dist/models/psql/accountBankStatementLineModel.js

@@ -0,0 +1,92 @@
+"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 AccountBankStatementLineModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountBankReconciliationBatchModel, UserModel } = models;
+        if (InstituteModel) {
+            AccountBankStatementLineModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountBankStatementLineModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountBankReconciliationBatchModel) {
+            AccountBankStatementLineModel.belongsTo(AccountBankReconciliationBatchModel, { foreignKey: 'batchId', as: 'batch' });
+        }
+        if (UserModel) {
+            AccountBankStatementLineModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountBankStatementLineModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountBankStatementLineModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountBankStatementLineModel.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',
+    },
+    batchId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'batch_id',
+    },
+    transactionDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'transaction_date',
+    },
+    description: {
+        type: sequelize_1.DataTypes.TEXT,
+        allowNull: true,
+        field: 'description',
+    },
+    referenceNumber: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'reference_number',
+    },
+    withdrawalAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'withdrawal_amount',
+        defaultValue: 0.00,
+    },
+    depositAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'deposit_amount',
+        defaultValue: 0.00,
+    },
+    balance: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'balance',
+    },
+    matchStatus: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'match_status',
+        defaultValue: app_1.AccountMatchStatus.UNMATCHED,
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountBankStatementLineModel',
+    tableName: 'account_bank_statement_lines',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountBankStatementLineModel;

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

@@ -0,0 +1,20 @@
+import { Model } from 'sequelize';
+import { IAccountBudgetConsumptionModelAttributes } from '../../interfaces/accountBudgetConsumptionInterface';
+import { TAccountBudgetConsumptionModelCreationAttributes } from '../../types/accountBudgetConsumptionType';
+declare class AccountBudgetConsumptionModel extends Model<IAccountBudgetConsumptionModelAttributes, TAccountBudgetConsumptionModelCreationAttributes> implements IAccountBudgetConsumptionModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    budgetId: string;
+    journalLineId: string;
+    amount: number;
+    consumedOn: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountBudgetConsumptionModel;

package/dist/models/psql/accountBudgetConsumptionModel.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountBudgetConsumptionModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountBudgetModel, AccountJournalLineModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountBudgetConsumptionModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountBudgetConsumptionModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountBudgetModel) {
+            AccountBudgetConsumptionModel.belongsTo(AccountBudgetModel, { foreignKey: 'budgetId', as: 'budget' });
+        }
+        if (AccountJournalLineModel) {
+            AccountBudgetConsumptionModel.belongsTo(AccountJournalLineModel, { foreignKey: 'journalLineId', as: 'journalLine' });
+        }
+        if (UserModel) {
+            AccountBudgetConsumptionModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountBudgetConsumptionModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountBudgetConsumptionModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountBudgetConsumptionModel.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',
+    },
+    budgetId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'budget_id',
+    },
+    journalLineId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_line_id',
+    },
+    amount: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'amount',
+    },
+    consumedOn: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'consumed_on',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountBudgetConsumptionModel',
+    tableName: 'account_budget_consumptions',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountBudgetConsumptionModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountBudgetModelAttributes } from '../../interfaces/accountBudgetInterface';
+import { TAccountBudgetModelCreationAttributes } from '../../types/accountBudgetType';
+import { AccountBudgetType } from '../../constants/app';
+declare class AccountBudgetModel extends Model<IAccountBudgetModelAttributes, TAccountBudgetModelCreationAttributes> implements IAccountBudgetModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    financialYearId: string;
+    costCenterId?: string;
+    ledgerId?: string;
+    groupId?: string;
+    budgetName: string;
+    budgetType: AccountBudgetType;
+    amount: number;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountBudgetModel;

package/dist/models/psql/accountBudgetModel.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountBudgetModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountFinancialYearModel, AccountCostCenterModel, AccountLedgerModel, AccountGroupModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountBudgetModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountBudgetModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountBudgetModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        if (AccountCostCenterModel) {
+            AccountBudgetModel.belongsTo(AccountCostCenterModel, { foreignKey: 'costCenterId', as: 'costCenter' });
+        }
+        if (AccountLedgerModel) {
+            AccountBudgetModel.belongsTo(AccountLedgerModel, { foreignKey: 'ledgerId', as: 'ledger' });
+        }
+        if (AccountGroupModel) {
+            AccountBudgetModel.belongsTo(AccountGroupModel, { foreignKey: 'groupId', as: 'group' });
+        }
+        if (UserModel) {
+            AccountBudgetModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountBudgetModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountBudgetModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountBudgetModel.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',
+    },
+    financialYearId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'financial_year_id',
+    },
+    costCenterId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'cost_center_id',
+    },
+    ledgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'ledger_id',
+    },
+    groupId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'group_id',
+    },
+    budgetName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'budget_name',
+    },
+    budgetType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'budget_type',
+    },
+    amount: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'amount',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountBudgetModel',
+    tableName: 'account_budgets',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountBudgetModel;

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

@@ -0,0 +1,20 @@
+import { Model } from 'sequelize';
+import { IAccountBudgetPeriodModelAttributes } from '../../interfaces/accountBudgetPeriodInterface';
+import { TAccountBudgetPeriodModelCreationAttributes } from '../../types/accountBudgetPeriodType';
+declare class AccountBudgetPeriodModel extends Model<IAccountBudgetPeriodModelAttributes, TAccountBudgetPeriodModelCreationAttributes> implements IAccountBudgetPeriodModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    budgetId: string;
+    periodStart: Date;
+    periodEnd: Date;
+    allocatedAmount: number;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountBudgetPeriodModel;