@kipicore/dbcore 1.1.619 → 1.1.620

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;

package/dist/models/psql/accountSyncJobModel.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountSyncJobModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountIntegrationConnectionModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountSyncJobModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountSyncJobModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountIntegrationConnectionModel) {
+            AccountSyncJobModel.belongsTo(AccountIntegrationConnectionModel, { foreignKey: 'connectionId', as: 'connection' });
+        }
+        if (UserModel) {
+            AccountSyncJobModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountSyncJobModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountSyncJobModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountSyncJobModel.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',
+    },
+    objectType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'object_type',
+    },
+    objectId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'object_id',
+    },
+    action: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'action',
+    },
+    payloadRef: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'payload_ref',
+    },
+    attempts: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+        field: 'attempts',
+        defaultValue: 0,
+    },
+    nextRetryAt: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'next_retry_at',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountSyncJobModel',
+    tableName: 'account_sync_jobs',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountSyncJobModel;

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

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountSyncLogModelAttributes } from '../../interfaces/accountSyncLogInterface';
+import { TAccountSyncLogModelCreationAttributes } from '../../types/accountSyncLogType';
+import { AccountSyncStatus } from '../../constants/app';
+declare class AccountSyncLogModel extends Model<IAccountSyncLogModelAttributes, TAccountSyncLogModelCreationAttributes> implements IAccountSyncLogModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    syncJobId: string;
+    status: AccountSyncStatus;
+    requestRef?: any;
+    responseRef?: any;
+    message?: string;
+    attemptNo: number;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountSyncLogModel;