@kipicore/dbcore 1.1.615 → 1.1.616

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;

package/dist/models/psql/accountPartyAccountModel.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountPartyAccountModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountLedgerModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountLedgerModel) {
+            AccountPartyAccountModel.belongsTo(AccountLedgerModel, { foreignKey: 'ledgerId', as: 'ledger' });
+        }
+        if (InstituteModel) {
+            AccountPartyAccountModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountPartyAccountModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountPartyAccountModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountPartyAccountModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountPartyAccountModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountPartyAccountModel.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',
+    },
+    partyType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'party_type',
+    },
+    partyId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'party_id',
+    },
+    ledgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'ledger_id',
+    },
+    mode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+}, {
+    modelName: 'AccountPartyAccountModel',
+    tableName: 'account_party_accounts',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountPartyAccountModel;

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

@@ -0,0 +1,27 @@
+import { Model } from 'sequelize';
+import { IAccountPostingEventModelAttributes } from '../../interfaces/accountPostingEventInterface';
+import { TAccountPostingEventModelCreationAttributes } from '../../types/accountPostingEventType';
+import { AccountSourceModule, AccountEventType, AccountPostingEventStatus } from '../../constants/app';
+declare class AccountPostingEventModel extends Model<IAccountPostingEventModelAttributes, TAccountPostingEventModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    eventKey?: string;
+    sourceModule?: AccountSourceModule;
+    sourceType?: string;
+    sourceId?: string;
+    eventType?: AccountEventType;
+    eventDate?: Date;
+    payloadJson?: any;
+    journalEntryId?: string;
+    errorMessage?: string;
+    status?: AccountPostingEventStatus;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountPostingEventModel;

package/dist/models/psql/accountPostingEventModel.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountPostingEventModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountJournalEntryModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountJournalEntryModel) {
+            AccountPostingEventModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (InstituteModel) {
+            AccountPostingEventModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountPostingEventModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountPostingEventModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountPostingEventModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountPostingEventModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountPostingEventModel.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',
+    },
+    eventKey: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'event_key',
+    },
+    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',
+    },
+    eventType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'event_type',
+    },
+    eventDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'event_date',
+    },
+    payloadJson: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'payload_json',
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+    errorMessage: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'error_message',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+}, {
+    modelName: 'AccountPostingEventModel',
+    tableName: 'account_posting_events',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountPostingEventModel;

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

@@ -0,0 +1,26 @@
+import { Model } from 'sequelize';
+import { IAccountPostingRuleModelAttributes } from '../../interfaces/accountPostingRuleInterface';
+import { TAccountPostingRuleModelCreationAttributes } from '../../types/accountPostingRuleType';
+import { AccountSourceModule, AccountEventType } from '../../constants/app';
+declare class AccountPostingRuleModel extends Model<IAccountPostingRuleModelAttributes, TAccountPostingRuleModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    sourceModule?: AccountSourceModule;
+    eventType?: AccountEventType;
+    priority?: number;
+    conditionsJson?: any;
+    debitStrategy?: string;
+    creditStrategy?: string;
+    costCenterStrategy?: string;
+    effectiveFrom?: Date;
+    effectiveTo?: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountPostingRuleModel;

package/dist/models/psql/accountPostingRuleModel.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountPostingRuleModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel } = models;
+        if (InstituteModel) {
+            AccountPostingRuleModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountPostingRuleModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountPostingRuleModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountPostingRuleModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountPostingRuleModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountPostingRuleModel.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',
+    },
+    eventType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'event_type',
+    },
+    priority: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+    },
+    conditionsJson: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'conditions_json',
+    },
+    debitStrategy: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'debit_strategy',
+    },
+    creditStrategy: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'credit_strategy',
+    },
+    costCenterStrategy: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'cost_center_strategy',
+    },
+    effectiveFrom: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'effective_from',
+    },
+    effectiveTo: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'effective_to',
+    },
+}, {
+    modelName: 'AccountPostingRuleModel',
+    tableName: 'account_posting_rules',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountPostingRuleModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountReportSnapshotModelAttributes } from '../../interfaces/accountReportSnapshotInterface';
+import { TAccountReportSnapshotModelCreationAttributes } from '../../types/accountReportSnapshotType';
+import { AccountReportType } from '../../constants/app';
+declare class AccountReportSnapshotModel extends Model<IAccountReportSnapshotModelAttributes, TAccountReportSnapshotModelCreationAttributes> implements IAccountReportSnapshotModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    reportType: AccountReportType;
+    financialYearId: string;
+    fromDate: Date;
+    toDate: Date;
+    filtersJson?: any;
+    reportFileStorageId?: string;
+    generatedBy?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountReportSnapshotModel;

package/dist/models/psql/accountReportSnapshotModel.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountReportSnapshotModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountFinancialYearModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountReportSnapshotModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountReportSnapshotModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountReportSnapshotModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        if (UserModel) {
+            AccountReportSnapshotModel.belongsTo(UserModel, { foreignKey: { name: 'generatedBy', allowNull: true, field: 'generated_by' }, as: 'generator' });
+            AccountReportSnapshotModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountReportSnapshotModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountReportSnapshotModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountReportSnapshotModel.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',
+    },
+    reportType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'report_type',
+    },
+    financialYearId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'financial_year_id',
+    },
+    fromDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'from_date',
+    },
+    toDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'to_date',
+    },
+    filtersJson: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'filters_json',
+    },
+    reportFileStorageId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'report_file_storage_id',
+    },
+    generatedBy: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'generated_by',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountReportSnapshotModel',
+    tableName: 'account_report_snapshots',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountReportSnapshotModel;

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

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountRuleLedgerMappingModelAttributes } from '../../interfaces/accountRuleLedgerMappingInterface';
+import { TAccountRuleLedgerMappingModelCreationAttributes } from '../../types/accountRuleLedgerMappingType';
+declare class AccountRuleLedgerMappingModel extends Model<IAccountRuleLedgerMappingModelAttributes, TAccountRuleLedgerMappingModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    ruleId?: string;
+    sourceRefType?: string;
+    sourceRefId?: string;
+    debitLedgerId?: string;
+    creditLedgerId?: string;
+    taxTypeId?: string;
+    costCenterId?: string;
+    isDefault: boolean;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountRuleLedgerMappingModel;

package/dist/models/psql/accountRuleLedgerMappingModel.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountRuleLedgerMappingModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountPostingRuleModel, AccountLedgerModel, AccountCostCenterModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountPostingRuleModel) {
+            AccountRuleLedgerMappingModel.belongsTo(AccountPostingRuleModel, { foreignKey: 'ruleId', as: 'rule' });
+        }
+        if (AccountLedgerModel) {
+            AccountRuleLedgerMappingModel.belongsTo(AccountLedgerModel, { foreignKey: 'debitLedgerId', as: 'debitLedger' });
+            AccountRuleLedgerMappingModel.belongsTo(AccountLedgerModel, { foreignKey: 'creditLedgerId', as: 'creditLedger' });
+        }
+        if (AccountCostCenterModel) {
+            AccountRuleLedgerMappingModel.belongsTo(AccountCostCenterModel, { foreignKey: 'costCenterId', as: 'costCenter' });
+        }
+        if (InstituteModel) {
+            AccountRuleLedgerMappingModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountRuleLedgerMappingModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountRuleLedgerMappingModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountRuleLedgerMappingModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountRuleLedgerMappingModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountRuleLedgerMappingModel.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',
+    },
+    ruleId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'rule_id',
+    },
+    sourceRefType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_ref_type',
+    },
+    sourceRefId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_ref_id',
+    },
+    debitLedgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'debit_ledger_id',
+    },
+    creditLedgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'credit_ledger_id',
+    },
+    taxTypeId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'tax_type_id',
+    },
+    costCenterId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'cost_center_id',
+    },
+    isDefault: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        field: 'is_default',
+    },
+}, {
+    modelName: 'AccountRuleLedgerMappingModel',
+    tableName: 'account_rule_ledger_mappings',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountRuleLedgerMappingModel;

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

@@ -0,0 +1,25 @@
+import { Model } from 'sequelize';
+import { IAccountSyncJobModelAttributes } from '../../interfaces/accountSyncJobInterface';
+import { TAccountSyncJobModelCreationAttributes } from '../../types/accountSyncJobType';
+import { AccountIntegrationProvider, AccountSyncAction } from '../../constants/app';
+declare class AccountSyncJobModel extends Model<IAccountSyncJobModelAttributes, TAccountSyncJobModelCreationAttributes> implements IAccountSyncJobModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    connectionId: string;
+    provider: AccountIntegrationProvider;
+    objectType: string;
+    objectId: string;
+    action: AccountSyncAction;
+    payloadRef: any;
+    attempts?: number;
+    nextRetryAt?: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountSyncJobModel;