@kipicore/dbcore 1.1.614 → 1.1.616

package/dist/models/psql/accountBudgetPeriodModel.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountBudgetPeriodModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountBudgetModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountBudgetPeriodModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountBudgetPeriodModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountBudgetModel) {
+            AccountBudgetPeriodModel.belongsTo(AccountBudgetModel, { foreignKey: 'budgetId', as: 'budget' });
+        }
+        if (UserModel) {
+            AccountBudgetPeriodModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountBudgetPeriodModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountBudgetPeriodModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountBudgetPeriodModel.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',
+    },
+    periodStart: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'period_start',
+    },
+    periodEnd: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'period_end',
+    },
+    allocatedAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'allocated_amount',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountBudgetPeriodModel',
+    tableName: 'account_budget_periods',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountBudgetPeriodModel;

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/accountDonorModel.d.ts

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IAccountDonorModelAttributes } from '../../interfaces/accountDonorInterface';
+import { TAccountDonorModelCreationAttributes } from '../../types/accountDonorType';
+import { AccountDonorType } from '../../constants/app';
+declare class AccountDonorModel extends Model<IAccountDonorModelAttributes, TAccountDonorModelCreationAttributes> implements IAccountDonorModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    donorName: string;
+    donorType: AccountDonorType;
+    contactDetails?: object;
+    totalDonated?: number;
+    fundId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountDonorModel;

package/dist/models/psql/accountDonorModel.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountDonorModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountFundModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountDonorModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountDonorModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFundModel) {
+            AccountDonorModel.belongsTo(AccountFundModel, { foreignKey: 'fundId', as: 'fund' });
+        }
+        if (UserModel) {
+            AccountDonorModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountDonorModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountDonorModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountDonorModel.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',
+    },
+    donorName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'donor_name',
+    },
+    donorType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'donor_type',
+    },
+    contactDetails: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'contact_details',
+    },
+    totalDonated: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'total_donated',
+    },
+    fundId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'fund_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountDonorModel',
+    tableName: 'account_donors',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountDonorModel;

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

@@ -0,0 +1,20 @@
+import { Model } from 'sequelize';
+import { IAccountExpenseCategoryModelAttributes } from '../../interfaces/accountExpenseCategoryInterface';
+import { TAccountExpenseCategoryModelCreationAttributes } from '../../types/accountExpenseCategoryType';
+declare class AccountExpenseCategoryModel extends Model<IAccountExpenseCategoryModelAttributes, TAccountExpenseCategoryModelCreationAttributes> implements IAccountExpenseCategoryModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    name?: string;
+    defaultLedgerId?: string;
+    defaultCostCenterId?: string;
+    taxTypeId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountExpenseCategoryModel;

package/dist/models/psql/accountExpenseCategoryModel.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountExpenseCategoryModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountLedgerModel, AccountCostCenterModel, UserModel } = models;
+        if (InstituteModel) {
+            AccountExpenseCategoryModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountExpenseCategoryModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountLedgerModel) {
+            AccountExpenseCategoryModel.belongsTo(AccountLedgerModel, { foreignKey: 'defaultLedgerId', as: 'defaultLedger' });
+        }
+        if (AccountCostCenterModel) {
+            AccountExpenseCategoryModel.belongsTo(AccountCostCenterModel, { foreignKey: 'defaultCostCenterId', as: 'defaultCostCenter' });
+        }
+        if (UserModel) {
+            AccountExpenseCategoryModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountExpenseCategoryModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountExpenseCategoryModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountExpenseCategoryModel.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,
+        allowNull: true,
+        field: 'name',
+    },
+    defaultLedgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'default_ledger_id',
+    },
+    defaultCostCenterId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'default_cost_center_id',
+    },
+    taxTypeId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'tax_type_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountExpenseCategoryModel',
+    tableName: 'account_expense_categories',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountExpenseCategoryModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountExpensePaymentModelAttributes } from '../../interfaces/accountExpensePaymentInterface';
+import { TAccountExpensePaymentModelCreationAttributes } from '../../types/accountExpensePaymentType';
+import { AccountPaymentMode } from '../../constants/app';
+declare class AccountExpensePaymentModel extends Model<IAccountExpensePaymentModelAttributes, TAccountExpensePaymentModelCreationAttributes> implements IAccountExpensePaymentModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    expenseRequestId: string;
+    bankAccountId?: string;
+    paymentMode: AccountPaymentMode;
+    paidAmount: number;
+    paidDate: Date;
+    voucherId?: string;
+    journalEntryId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountExpensePaymentModel;

package/dist/models/psql/accountExpensePaymentModel.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountExpensePaymentModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountExpenseRequestModel, AccountVoucherModel, AccountJournalEntryModel, UserModel } = models;
+        if (InstituteModel) {
+            AccountExpensePaymentModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountExpensePaymentModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountExpenseRequestModel) {
+            AccountExpensePaymentModel.belongsTo(AccountExpenseRequestModel, { foreignKey: 'expenseRequestId', as: 'expenseRequest' });
+        }
+        if (AccountVoucherModel) {
+            AccountExpensePaymentModel.belongsTo(AccountVoucherModel, { foreignKey: 'voucherId', as: 'voucher' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountExpensePaymentModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (UserModel) {
+            AccountExpensePaymentModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountExpensePaymentModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountExpensePaymentModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountExpensePaymentModel.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',
+    },
+    expenseRequestId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'expense_request_id',
+    },
+    bankAccountId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'bank_account_id',
+    },
+    paymentMode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'payment_mode',
+    },
+    paidAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'paid_amount',
+    },
+    paidDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'paid_date',
+    },
+    voucherId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'voucher_id',
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountExpensePaymentModel',
+    tableName: 'account_expense_payments',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountExpensePaymentModel;

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

@@ -0,0 +1,26 @@
+import { Model } from 'sequelize';
+import { IAccountExpenseRequestModelAttributes } from '../../interfaces/accountExpenseRequestInterface';
+import { TAccountExpenseRequestModelCreationAttributes } from '../../types/accountExpenseRequestType';
+import { AccountApprovalStatus, AccountExpensePaymentStatus } from '../../constants/app';
+declare class AccountExpenseRequestModel extends Model<IAccountExpenseRequestModelAttributes, TAccountExpenseRequestModelCreationAttributes> implements IAccountExpenseRequestModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    expenseCategoryId: string;
+    vendorId?: string;
+    amount: number;
+    expenseDate: Date;
+    dueDate?: Date;
+    billFileStorageId?: string;
+    approvalStatus?: AccountApprovalStatus;
+    paymentStatus?: AccountExpensePaymentStatus;
+    journalEntryId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountExpenseRequestModel;

package/dist/models/psql/accountExpenseRequestModel.js

@@ -0,0 +1,102 @@
+"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 AccountExpenseRequestModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountExpenseCategoryModel, AccountJournalEntryModel, UserModel, FileStorageModel } = models;
+        if (InstituteModel) {
+            AccountExpenseRequestModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountExpenseRequestModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountExpenseCategoryModel) {
+            AccountExpenseRequestModel.belongsTo(AccountExpenseCategoryModel, { foreignKey: 'expenseCategoryId', as: 'expenseCategory' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountExpenseRequestModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (FileStorageModel) {
+            AccountExpenseRequestModel.belongsTo(FileStorageModel, { foreignKey: 'billFileStorageId', as: 'billFileStorage' });
+        }
+        if (UserModel) {
+            AccountExpenseRequestModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountExpenseRequestModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountExpenseRequestModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountExpenseRequestModel.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',
+    },
+    expenseCategoryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'expense_category_id',
+    },
+    vendorId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'vendor_id',
+    },
+    amount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'amount',
+    },
+    expenseDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'expense_date',
+    },
+    dueDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'due_date',
+    },
+    billFileStorageId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'bill_file_storage_id',
+    },
+    approvalStatus: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'approval_status',
+        defaultValue: app_1.AccountApprovalStatus.PENDING,
+    },
+    paymentStatus: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'payment_status',
+        defaultValue: app_1.AccountExpensePaymentStatus.PENDING,
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountExpenseRequestModel',
+    tableName: 'account_expense_requests',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountExpenseRequestModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountFinancialKpiModelAttributes } from '../../interfaces/accountFinancialKpiInterface';
+import { TAccountFinancialKpiModelCreationAttributes } from '../../types/accountFinancialKpiType';
+import { AccountFinancialKpiCode } from '../../constants/app';
+declare class AccountFinancialKpiModel extends Model<IAccountFinancialKpiModelAttributes, TAccountFinancialKpiModelCreationAttributes> implements IAccountFinancialKpiModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    periodStart: Date;
+    periodEnd: Date;
+    kpiCode: AccountFinancialKpiCode;
+    value: number;
+    costCenterId?: string;
+    sourceSnapshotId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountFinancialKpiModel;