@kipicore/dbcore 1.0.8 → 1.0.10

package/dist/models/psql/workingDayModel.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+const userModel_1 = __importDefault(require("./userModel"));
+class WorkingDayModel extends sequelize_1.Model {
+}
+WorkingDayModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    dayName: {
+        type: sequelize_1.DataTypes.STRING(20),
+        field: 'day_name',
+        allowNull: false,
+    },
+    dayOfWeek: {
+        type: sequelize_1.DataTypes.INTEGER,
+        field: 'day_of_week',
+        allowNull: false,
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING(30),
+        allowNull: false,
+        defaultValue: app_1.WORKIN_DAY_STATUS.INACTIVE,
+    },
+    startTime: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: false,
+        field: 'start_time',
+    },
+    endTime: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: false,
+        field: 'end_time',
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: true,
+    },
+}, {
+    modelName: 'WorkingDayModel',
+    tableName: 'working_days',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+WorkingDayModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+WorkingDayModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+WorkingDayModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+exports.default = WorkingDayModel;

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { SCHOOL_SHIFT, WORKIN_DAY_STATUS } from '../../constants/app';
+import { IWorkingShiftAttributes } from '../../interfaces/workingShiftInterface';
+import { TWorkingShiftCreationAttributes } from '../../types/workingShiftType';
+declare class WorkingShiftModel extends Model<IWorkingShiftAttributes, TWorkingShiftCreationAttributes> {
+    id: string;
+    status: WORKIN_DAY_STATUS;
+    shiftType: SCHOOL_SHIFT;
+    startTime: Date;
+    endTime: Date;
+    workingId: string;
+    instituteId: string;
+    slotId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default WorkingShiftModel;

package/dist/models/psql/workingShiftModel.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+const userModel_1 = __importDefault(require("./userModel"));
+const workingDayModel_1 = __importDefault(require("./workingDayModel"));
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const slotModel_1 = __importDefault(require("./slotModel"));
+class WorkingShiftModel extends sequelize_1.Model {
+}
+WorkingShiftModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    workingId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'working_id',
+        allowNull: false,
+    },
+    slotId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'slot_id',
+        allowNull: false,
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING(30),
+        allowNull: false,
+        defaultValue: app_1.WORKIN_DAY_STATUS.ACTIVE,
+    },
+    shiftType: {
+        type: sequelize_1.DataTypes.STRING(30),
+        allowNull: false,
+    },
+    startTime: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: false,
+        field: 'start_time',
+    },
+    endTime: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: false,
+        field: 'end_time',
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: true,
+    },
+}, {
+    modelName: 'WorkingShiftModel',
+    tableName: 'working_shift_days',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+WorkingShiftModel.belongsTo(workingDayModel_1.default, { foreignKey: 'workingId', as: 'shiftHasWorkingDay' });
+workingDayModel_1.default.hasMany(WorkingShiftModel, { foreignKey: 'workingId', as: 'workingDayShift' });
+WorkingShiftModel.belongsTo(instituteModel_1.default, { foreignKey: 'instituteId', as: 'shiftHasInstituted' });
+workingDayModel_1.default.hasMany(WorkingShiftModel, { foreignKey: 'instituteId', as: 'institutedShift' });
+WorkingShiftModel.belongsTo(slotModel_1.default, { foreignKey: 'slotId', as: 'shiftSlot' });
+slotModel_1.default.hasMany(WorkingShiftModel, { foreignKey: 'slotId', as: 'slotHasShift' });
+WorkingShiftModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+WorkingShiftModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+WorkingShiftModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+exports.default = WorkingShiftModel;

package/dist/services/Concrete/mongooseCommonService.d.ts

@@ -0,0 +1,36 @@
+import { FilterQuery, UpdateQuery, Document, QueryOptions, Model as MongooseModel, PopulateOptions, MongooseUpdateQueryOptions, UpdateWriteOpResult, ClientSession, CreateOptions } from "mongoose";
+import { TPaginationOptions } from "../../types/commonType";
+import { IMongooseCommonService } from "../Contracts/IMongooseCommonService";
+import { PipelineStage } from "mongoose";
+export declare class MongooseCommonService<T extends Document> implements IMongooseCommonService<T> {
+    private model;
+    constructor(model: MongooseModel<T>);
+    findAll(filter: FilterQuery<T>, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<T[]>;
+    findOne(filter: FilterQuery<T>, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<T | null>;
+    findById(id: string, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<T | null>;
+    findAllWithPagination: (filter: FilterQuery<T>, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]) => Promise<TPaginationOptions<T>>;
+    count(filter: FilterQuery<T>): Promise<number>;
+    update(filter: FilterQuery<T>, updateData: UpdateQuery<T>, options?: MongooseUpdateQueryOptions<T> & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<UpdateWriteOpResult | null>;
+    upsert(filter: FilterQuery<T>, updateData: UpdateQuery<T>, options?: QueryOptions & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<T | null>;
+    create(createData: Partial<T>, options?: CreateOptions & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<T>;
+    bulkCreate(createData: Partial<T>[], options?: CreateOptions & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<T[]>;
+    delete(filter: FilterQuery<T>, options?: MongooseUpdateQueryOptions<T> & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<UpdateWriteOpResult | null>;
+    aggregate(pipeline: PipelineStage[]): Promise<{
+        [key: string]: string | number | object;
+    }[]>;
+}

package/dist/services/Concrete/mongooseCommonService.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongooseCommonService = void 0;
+const app_1 = require("../../constants/app");
+class MongooseCommonService {
+    constructor(model) {
+        this.findAllWithPagination = async (filter, options = {}, populate) => {
+            try {
+                const convertOrderToSort = (order) => {
+                    const sort = {};
+                    for (const [key, direction] of order) {
+                        sort[key] = direction.toUpperCase() === "DESC" ? -1 : 1;
+                    }
+                    return sort;
+                };
+                const { order, projection, ...restOptions } = options;
+                let { page, limit } = options;
+                const sort = convertOrderToSort(order || app_1.PAGINATION_ORDER);
+                // Ensure page and limit are positive integers
+                page = Math.max(1, page || app_1.PAGINATION.PAGE);
+                limit = Math.max(1, limit || app_1.PAGINATION.LIMIT);
+                // Calculate offset
+                const skip = (page - 1) * limit;
+                // Count total records
+                const totalRecords = await this.model.countDocuments(filter).exec();
+                const totalPages = Math.ceil(totalRecords / limit);
+                // Query the records
+                const query = this.model.find(filter, projection, {
+                    ...restOptions,
+                    limit,
+                    skip,
+                    sort,
+                });
+                // Apply populate if necessary
+                if (populate) {
+                    query.populate(populate);
+                }
+                const recordList = await query.exec();
+                // Construct the pagination result
+                const paginationOptions = {
+                    limit,
+                    totalRecords,
+                    totalPages,
+                    hasPreviousPage: page > 1,
+                    currentPage: Math.min(page, totalPages),
+                    hasNextPage: page < totalPages,
+                    recordList,
+                };
+                return paginationOptions;
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.model = model;
+    }
+    async findAll(filter, options = {}, populate) {
+        const query = this.model.find(filter, null, options);
+        if (populate)
+            query.populate(populate);
+        return query.exec();
+    }
+    async findOne(filter, options = {}, populate) {
+        const query = this.model.findOne(filter, null, options);
+        if (populate)
+            query.populate(populate);
+        return query.exec();
+    }
+    async findById(id, options = {}, populate) {
+        const query = this.model.findById(id, null, options);
+        if (populate)
+            query.populate(populate);
+        return query.exec();
+    }
+    async count(filter) {
+        return this.model.countDocuments(filter).exec();
+    }
+    async update(filter, updateData, options = {}) {
+        return this.model.updateMany(filter, updateData, options).exec();
+    }
+    async upsert(filter, updateData, options = {
+        upsert: true,
+        new: true,
+    }) {
+        return this.model.findOneAndUpdate(filter, updateData, options).exec();
+    }
+    async create(createData, options = {}) {
+        const [createdDoc] = await this.model.create([{ ...createData, createdBy: options.userId }], options);
+        return createdDoc;
+    }
+    async bulkCreate(createData, options = {}) {
+        return this.model.create(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        createData.map((data) => {
+            data.createdBy = options.userId;
+            return data;
+        }), options);
+    }
+    async delete(filter, options = {}) {
+        return this.model
+            .updateMany(filter, { deletedBy: options.userId, deletedAt: new Date() }, options)
+            .exec();
+    }
+    async aggregate(pipeline) {
+        return this.model.aggregate(pipeline).exec();
+    }
+}
+exports.MongooseCommonService = MongooseCommonService;

package/dist/services/Concrete/sequelizeCommanService.d.ts

@@ -0,0 +1,17 @@
+import { FindOptions, WhereOptions, Model, ModelStatic, UpdateOptions, BulkCreateOptions, DestroyOptions, CreateOptions, Identifier, UpsertOptions, CountOptions } from 'sequelize';
+import { ISequelizeCommonService } from '../Contracts/ISequelizeCommonService';
+import { TPaginationOptions } from '../../types/commonType';
+export default class SequelizeCommonService<T extends Model> implements ISequelizeCommonService<T> {
+    private model;
+    constructor(model: ModelStatic<T>);
+    findByPk(identifier: Identifier, options?: FindOptions<T['_attributes']>): Promise<T['_attributes'] | null>;
+    findAll: (where: WhereOptions<T["_attributes"]>, options?: FindOptions<T["_attributes"]>) => Promise<T["_attributes"][]>;
+    findAllWithPagination: (where: WhereOptions<T["_attributes"]>, options?: FindOptions<T["_attributes"]>) => Promise<TPaginationOptions<T["_attributes"]>>;
+    findOne: (where: WhereOptions<T["_attributes"]>, options?: FindOptions<T["_attributes"]>) => Promise<T["_attributes"] | null>;
+    update: (where: WhereOptions<T["_attributes"]>, updateData: Partial<T["_attributes"]>, options?: Omit<UpdateOptions, "where">) => Promise<[number]>;
+    upsert: (conflictWhere: WhereOptions<T["_attributes"]>, updateData: T["_creationAttributes"], options?: Partial<UpsertOptions>) => Promise<[T["_attributes"], boolean | null]>;
+    create: (createData: T["_creationAttributes"], options?: CreateOptions) => Promise<T["_attributes"]>;
+    bulkCreate: (createData: T["_creationAttributes"][], options?: BulkCreateOptions<T["_attributes"]>) => Promise<T["_attributes"][]>;
+    delete: (where: WhereOptions<T["_attributes"]>, options?: DestroyOptions<T["_attributes"]>) => Promise<number>;
+    count: (where: WhereOptions<T["_attributes"]>, options?: CountOptions<T["_attributes"]>) => Promise<number>;
+}

package/dist/services/Concrete/sequelizeCommanService.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_1 = require("../../constants/app");
+class SequelizeCommonService {
+    constructor(model) {
+        this.findAll = (where, options) => {
+            try {
+                const finalOptions = {
+                    ...(options || {}),
+                    order: options?.order || app_1.PAGINATION_ORDER,
+                };
+                return this.model.findAll({ where, ...finalOptions });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.findAllWithPagination = async (where, options) => {
+            try {
+                if (!options)
+                    options = {};
+                const limit = options.limit || app_1.PAGINATION.LIMIT;
+                const currentPage = options.page || app_1.PAGINATION.PAGE;
+                // Clean options for count()
+                const countOptions = { ...options };
+                // options.subQuery = false;
+                delete countOptions.order;
+                delete countOptions.limit;
+                delete countOptions.offset;
+                const totalRecords = await this.model.count({
+                    where,
+                    include: options.include,
+                    distinct: true,
+                });
+                const totalPages = Math.ceil(totalRecords / limit);
+                // Apply pagination + order for findAll
+                options.limit = limit;
+                options.offset = (currentPage - 1) * limit;
+                options.order = options.order || app_1.PAGINATION_ORDER;
+                const listOfRecords = await this.findAll(where, options);
+                const paginationOptions = {
+                    limit,
+                    totalRecords,
+                    totalPages,
+                    hasPreviousPage: currentPage - 1 > 0 ? true : false,
+                    currentPage: currentPage > totalPages ? totalPages : currentPage,
+                    hasNextPage: currentPage < totalPages,
+                    recordList: listOfRecords,
+                };
+                return paginationOptions;
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.findOne = async (where, options) => {
+            try {
+                return this.model.findOne({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.update = async (where, updateData, options) => {
+            try {
+                return this.model.update(updateData, { where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.upsert = async (conflictWhere, updateData, options) => {
+            try {
+                return this.model.upsert(updateData, { conflictWhere, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.create = async (createData, options) => {
+            try {
+                return this.model.create(createData, options);
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.bulkCreate = async (createData, options) => {
+            try {
+                return this.model.bulkCreate(createData, options);
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.delete = async (where, options) => {
+            try {
+                return this.model.destroy({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.count = (where, options) => {
+            try {
+                return this.model.count({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.model = model;
+    }
+    findByPk(identifier, options) {
+        try {
+            return this.model.findByPk(identifier, options);
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.default = SequelizeCommonService;

package/dist/services/Contracts/IMongooseCommonService.d.ts

@@ -0,0 +1,36 @@
+import { FilterQuery, UpdateQuery, Document, QueryOptions, PopulateOptions, MongooseUpdateQueryOptions, UpdateWriteOpResult, ClientSession, CreateOptions } from "mongoose";
+import { TPaginationOptions } from "../../types/commonType";
+interface IReadService<T extends Document> {
+    findAll(filter: FilterQuery<T>, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<T[]>;
+    findOne(filter: FilterQuery<T>, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<T | null>;
+    findById(id: string, options?: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<T | null>;
+    findAllWithPagination(filter: FilterQuery<T>, options: QueryOptions, populate?: PopulateOptions | PopulateOptions[]): Promise<TPaginationOptions<T>>;
+    count(filter: FilterQuery<T>): Promise<number>;
+}
+interface IWriteService<T extends Document> {
+    update(filter: FilterQuery<T>, updateData: UpdateQuery<T>, options?: MongooseUpdateQueryOptions<T> & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<UpdateWriteOpResult | null>;
+    upsert(filter: FilterQuery<T>, updateData: UpdateQuery<T>, options?: QueryOptions & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<T | null>;
+    create(createData: Partial<T>, options?: CreateOptions & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<T>;
+    bulkCreate(createData: Partial<T>[], options?: CreateOptions & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<T[]>;
+}
+interface IDeleteService<T extends Document> {
+    delete(filter: FilterQuery<T>, options?: MongooseUpdateQueryOptions<T> & {
+        userId?: string;
+        session?: ClientSession;
+    }): Promise<UpdateWriteOpResult | null>;
+}
+export interface IMongooseCommonService<T extends Document> extends IReadService<T>, IWriteService<T>, IDeleteService<T> {
+}
+export {};

package/dist/services/Contracts/IMongooseCommonService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/Contracts/ISequelizeCommonService.d.ts

@@ -0,0 +1,21 @@
+import { FindOptions, WhereOptions, UpdateOptions, BulkCreateOptions, DestroyOptions, CreateOptions, Identifier, Model, UpsertOptions, CountOptions } from "sequelize";
+import { TPaginationOptions } from "../../types/commonType";
+interface IReadService<T extends Model> {
+    findAll(where: WhereOptions<T["_attributes"]>, options?: FindOptions<T["_attributes"]>): Promise<T["_attributes"][]>;
+    findOne(where: WhereOptions<T["_attributes"]>, options?: FindOptions<T["_attributes"]>): Promise<T["_attributes"] | null>;
+    findByPk(identifier: Identifier, options?: FindOptions<T["_attributes"]>): Promise<T["_attributes"] | null>;
+    findAllWithPagination(where: WhereOptions<T["_attributes"]>, options?: FindOptions<T["_attributes"]>): Promise<TPaginationOptions<T["_attributes"]>>;
+    count(where: WhereOptions<T["_attributes"]>, options?: CountOptions<T["_attributes"]>): Promise<number>;
+}
+interface IWriteService<T extends Model> {
+    update(where: WhereOptions<T["_attributes"]>, updateData: Partial<T["_attributes"]>, options?: Partial<UpdateOptions>): Promise<[number]>;
+    upsert(conflictWhere: WhereOptions<T["_attributes"]>, updateData: T["_creationAttributes"], options?: Partial<UpsertOptions>): Promise<[T["_attributes"], boolean | null]>;
+    create(createData: T["_creationAttributes"], options?: CreateOptions): Promise<T["_attributes"]>;
+    bulkCreate(createData: T["_creationAttributes"][], options?: BulkCreateOptions<T["_attributes"]>): Promise<T["_attributes"][]>;
+}
+interface IDeleteService<T extends Model> {
+    delete(where: WhereOptions<T["_attributes"]>, options?: DestroyOptions<T["_attributes"]>): Promise<number>;
+}
+export interface ISequelizeCommonService<T extends Model> extends IReadService<T>, IWriteService<T>, IDeleteService<T> {
+}
+export {};

package/dist/services/Contracts/ISequelizeCommonService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/academicCalendarType.d.ts

@@ -0,0 +1,6 @@
+import { Optional } from 'sequelize';
+import { IAcademicCalendarModelAttributes } from '../interfaces/academicCalendarInterface';
+export type TAcademicCalendarModelCreationAttributes = Optional<IAcademicCalendarModelAttributes, 'id'>;
+export interface TUpdateAcademicCalenderStatusParams {
+    instituteId?: string | null;
+}

package/dist/types/academicCalendarType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/accountHasReceiptDetailsType.d.ts

@@ -0,0 +1,7 @@
+import { Optional } from 'sequelize';
+import { IAccountHasReceiptDetailsInterfaceModelAttributes } from '../interfaces/accountHasReceiptDetailsInterface';
+import { IFileStorageAttributes } from '../interfaces/fileStorageInterface';
+export type TAccountHasReceiptDetailsModelCreationAttributes = Optional<IAccountHasReceiptDetailsInterfaceModelAttributes, 'id'>;
+export type TAccountHasReceiptDetailAttributesWithAssociations = IAccountHasReceiptDetailsInterfaceModelAttributes & {
+    accountHasReceiptDetailsProfileImage?: IFileStorageAttributes;
+};

package/dist/types/accountHasReceiptDetailsType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/announcementType.d.ts

@@ -0,0 +1,6 @@
+import { Optional } from 'sequelize';
+import { IAnnouncementModelAttributes } from '../interfaces/announcementInterface';
+export type TAnnouncementModelCreationAttributes = Optional<IAnnouncementModelAttributes, 'id'>;
+export type TAnnouncementCreateParams = {
+    announcementId?: string;
+};

package/dist/types/announcementType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/approveRequestType.d.ts

@@ -0,0 +1,2 @@
+import { IApproveRequestModelAttributes } from '../interfaces/approvalRequestInterface';
+export type TApproveRequestCreationAttributes = Omit<IApproveRequestModelAttributes, 'id'>;

package/dist/types/approveRequestType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/areaType.d.ts

@@ -0,0 +1,3 @@
+import { Optional } from 'sequelize';
+import { IAreaModelAttributes } from '../interfaces/areaInterface';
+export type TAeraModelCreationAttributes = Optional<IAreaModelAttributes, 'id'>;

package/dist/types/areaType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/attendanceType.d.ts

@@ -0,0 +1,2 @@
+import { IAttendanceModelAttributes } from '../interfaces/attendanceInterface';
+export type TAttendanceCreationAttributes = Omit<IAttendanceModelAttributes, 'id'>;

package/dist/types/attendanceType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bankAccountDetailsType.d.ts

@@ -0,0 +1,3 @@
+import { Optional } from 'sequelize';
+import { IBankAccountDetailsInterfaceModelAttributes } from '../interfaces/bankAccountDetailsInterface';
+export type TBankAccountDetailsModelCreationAttributes = Optional<IBankAccountDetailsInterfaceModelAttributes, 'id'>;

package/dist/types/bankAccountDetailsType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bannerType.d.ts

@@ -0,0 +1,7 @@
+import { Optional } from 'sequelize';
+import { IBannerModelAttributes } from '../interfaces/bannerInterface';
+import { IFileStorageAttributes } from '../interfaces/fileStorageInterface';
+export type TBannerModelCreationAttributes = Optional<IBannerModelAttributes, 'id'>;
+export type TBannerAttributesWithAssociations = IBannerModelAttributes & {
+    bannerFileStorage?: IFileStorageAttributes;
+};

package/dist/types/bannerType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/batchSubjectBookAssessmentType.d.ts

@@ -0,0 +1,7 @@
+import { Optional } from 'sequelize';
+import { IBatchSubjectBookAssessmentModelAttributes } from '../interfaces/batchSubjectBookAssessmentInterface';
+import { IFileStorageAttributes } from '../interfaces/fileStorageInterface';
+export type TBatchSubjectBookAssessmentModelCreationAttributes = Optional<IBatchSubjectBookAssessmentModelAttributes, 'id'>;
+export type TBatchSubjectBookAssessmentAttributesWithAssociations = IBatchSubjectBookAssessmentModelAttributes & {
+    batchSubjectBookAssessmentFileStorage?: IFileStorageAttributes;
+};

package/dist/types/batchSubjectBookAssessmentType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/batchSubjectProjectAssessmentType.d.ts

@@ -0,0 +1,7 @@
+import { Optional } from 'sequelize';
+import { IBatchSubjectProjectAssessmentModelAttributes } from '../interfaces/batchSubjectProjectAssessmentInterface';
+import { IFileStorageAttributes } from '../interfaces/fileStorageInterface';
+export type TBatchSubjectProjectAssessmentModelCreationAttributes = Optional<IBatchSubjectProjectAssessmentModelAttributes, 'id'>;
+export type TBatchSubjectProjectAssessmentAttributesWithAssociations = IBatchSubjectProjectAssessmentModelAttributes & {
+    batchSubjectProjectAssessmentFileStorage?: IFileStorageAttributes;
+};