@kipicore/dbcore 1.1.614 → 1.1.616

package/dist/models/psql/accountJournalLineModel.js

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

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

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

package/dist/models/psql/accountLedgerBalanceModel.js

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

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

@@ -0,0 +1,26 @@
+import { Model } from 'sequelize';
+import { IAccountLedgerModelAttributes } from '../../interfaces/accountLedgerInterface';
+import { TAccountLedgerModelCreationAttributes } from '../../types/accountLedgerType';
+import { AccountLedgerType, AccountNormalBalance } from '../../constants/app';
+declare class AccountLedgerModel extends Model<IAccountLedgerModelAttributes, TAccountLedgerModelCreationAttributes> implements IAccountLedgerModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    groupId: string;
+    ledgerCode: string;
+    ledgerName: string;
+    ledgerType: AccountLedgerType;
+    normalBalance: AccountNormalBalance;
+    entityType?: string | null;
+    entityId?: string | null;
+    bankAccountId?: string | null;
+    allowManualPosting: boolean;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountLedgerModel;

package/dist/models/psql/accountLedgerModel.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountLedgerModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountGroupModel, AccountLedgerOpeningModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountGroupModel) {
+            AccountLedgerModel.belongsTo(AccountGroupModel, { foreignKey: 'groupId', as: 'group' });
+        }
+        if (AccountLedgerOpeningModel) {
+            AccountLedgerModel.hasMany(AccountLedgerOpeningModel, { foreignKey: 'ledgerId', as: 'openings' });
+        }
+        if (InstituteModel) {
+            AccountLedgerModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountLedgerModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountLedgerModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountLedgerModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountLedgerModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountLedgerModel.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',
+    },
+    groupId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'group_id',
+    },
+    ledgerCode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ledger_code',
+    },
+    ledgerName: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ledger_name',
+    },
+    ledgerType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'ledger_type',
+    },
+    normalBalance: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'normal_balance',
+    },
+    entityType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'entity_type',
+    },
+    entityId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'entity_id',
+    },
+    bankAccountId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'bank_account_id',
+    },
+    allowManualPosting: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: true,
+        field: 'allow_manual_posting',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountLedgerModel',
+    tableName: 'account_ledgers',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountLedgerModel;

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

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IAccountLedgerOpeningModelAttributes } from '../../interfaces/accountLedgerOpeningInterface';
+import { TAccountLedgerOpeningModelCreationAttributes } from '../../types/accountLedgerOpeningType';
+import { AccountBalanceType } from '../../constants/app';
+declare class AccountLedgerOpeningModel extends Model<IAccountLedgerOpeningModelAttributes, TAccountLedgerOpeningModelCreationAttributes> implements IAccountLedgerOpeningModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    ledgerId: string;
+    financialYearId: string;
+    openingBalance: number;
+    balanceType: AccountBalanceType;
+    openingDate: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountLedgerOpeningModel;

package/dist/models/psql/accountLedgerOpeningModel.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountLedgerOpeningModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountLedgerModel, InstituteModel, AcademicCalendarModel, AccountFinancialYearModel } = models;
+        if (AccountLedgerModel) {
+            AccountLedgerOpeningModel.belongsTo(AccountLedgerModel, { foreignKey: 'ledgerId', as: 'ledger' });
+        }
+        if (InstituteModel) {
+            AccountLedgerOpeningModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountLedgerOpeningModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountLedgerOpeningModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountLedgerOpeningModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountLedgerOpeningModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountLedgerOpeningModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountLedgerOpeningModel.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',
+    },
+    openingBalance: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'opening_balance',
+    },
+    balanceType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'balance_type',
+    },
+    openingDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'opening_date',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountLedgerOpeningModel',
+    tableName: 'account_ledger_openings',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountLedgerOpeningModel;

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { IAccountNumberSequenceModelAttributes } from '../../interfaces/accountNumberSequenceInterface';
+import { TAccountNumberSequenceModelCreationAttributes } from '../../types/accountNumberSequenceType';
+declare class AccountNumberSequenceModel extends Model<IAccountNumberSequenceModelAttributes, TAccountNumberSequenceModelCreationAttributes> implements IAccountNumberSequenceModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    financialYearId: string;
+    sequenceKey: string;
+    prefix: string;
+    currentNumber: number;
+    padding: number;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountNumberSequenceModel;

package/dist/models/psql/accountNumberSequenceModel.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountNumberSequenceModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountFinancialYearModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountFinancialYearModel) {
+            AccountNumberSequenceModel.belongsTo(AccountFinancialYearModel, { foreignKey: { name: 'financialYearId', field: 'financial_year_id' }, as: 'financialYear' });
+        }
+        if (InstituteModel) {
+            AccountNumberSequenceModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountNumberSequenceModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountNumberSequenceModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountNumberSequenceModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountNumberSequenceModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountNumberSequenceModel.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',
+    },
+    sequenceKey: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'sequence_key',
+    },
+    prefix: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    currentNumber: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 1,
+        field: 'current_number',
+    },
+    padding: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 4,
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountNumberSequenceModel',
+    tableName: 'account_number_sequences',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountNumberSequenceModel;

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { IAccountPeriodLockModelAttributes } from '../../interfaces/accountPeriodLockInterface';
+import { TAccountPeriodLockModelCreationAttributes } from '../../types/accountPeriodLockType';
+declare class AccountPeriodLockModel extends Model<IAccountPeriodLockModelAttributes, TAccountPeriodLockModelCreationAttributes> implements IAccountPeriodLockModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    financialYearId: string;
+    periodStart: Date;
+    periodEnd: Date;
+    lockedBy: string;
+    reason: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountPeriodLockModel;