adminizer 4.3.0-build.80 → 4.3.0-build.81

package/lib/{v4/controls → controls}/AbstractControls.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../Adminizer";
 export type ControlType = 'wysiwyg' | 'jsonEditor' | 'geoJson' | 'markdown' | 'table' | 'codeEditor';
 export interface Path {
     jsPath: {

package/lib/{v4/controls → controls}/codeEditor/MonacoEditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class MonacoEditor extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{v4/controls → controls}/geojsoneditor/GeoEditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class GeoEditor extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{v4/controls → controls}/jsoneditor/JsonEditor.d.ts

@@ -1,6 +1,6 @@
 import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class JsonEditor extends AbstractControls {
     readonly config: Partial<EditorOptions>;
     readonly name: string;

package/lib/{v4/controls → controls}/markdown/ToastUiEditor.d.ts

@@ -1,6 +1,6 @@
 import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class ToastUiEditor extends AbstractControls {
     readonly config: Partial<EditorOptions>;
     readonly name: string;

package/lib/{v4/controls → controls}/table/Handsontable.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class Handsontable extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{v4/controls → controls}/wysiwyg/CKeditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class CKeditor extends AbstractControls {
     readonly name: string;
     readonly type: ControlType;

package/lib/{v4/datatable → datatable}/NodeTable.d.ts

@@ -1,4 +1,4 @@
-import { Fields } from '../../../helpers/fieldsHelper';
+import { Fields } from '../../helpers/fieldsHelper';
 import { AbstractModel } from '../model/AbstractModel';
 import { DataAccessor } from "../DataAccessor";
 interface Request {

package/lib/{v4/model → model}/AbstractModel.d.ts

@@ -46,6 +46,18 @@ export declare abstract class AbstractModel<T> {
     protected abstract _destroyOne(criteria: Partial<T>): Promise<T | null>;
     protected abstract _destroy(criteria: Partial<T>): Promise<T[]>;
     protected abstract _count(criteria: Partial<T> | undefined): Promise<number>;
+    /**
+     * Generate diff between old and new records
+     */
+    private generateDiff;
+    /**
+     * Generate delete diff (record vs empty object)
+     */
+    private generateDeleteDiff;
+    /**
+     * Log system event with diff
+     */
+    private logSystemEvent;
     create(data: T, dataAccessor: DataAccessor): Promise<Partial<T>>;
     findOne(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
     find(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;

package/lib/model/AbstractModel.js

@@ -0,0 +1,178 @@
+import { formatChanges, sanitizeForDiff } from "../../helpers/diffHelpers";
+import { diff } from "deep-object-diff";
+export class AbstractModel {
+    modelname;
+    attributes;
+    primaryKey;
+    identity;
+    constructor(modelname, attributes, primaryKey, identity) {
+        this.modelname = modelname;
+        this.attributes = attributes;
+        this.primaryKey = primaryKey;
+        this.identity = identity;
+    }
+    /**
+     * Generate diff between old and new records
+     */
+    generateDiff(oldRecord, newRecord) {
+        const cleanOldRecord = sanitizeForDiff(oldRecord);
+        const cleanNewRecord = sanitizeForDiff(newRecord);
+        const changesDiff = diff(cleanOldRecord, cleanNewRecord);
+        const formattedChanges = formatChanges(changesDiff, cleanOldRecord, cleanNewRecord);
+        return {
+            changesDiff,
+            formattedChanges,
+            cleanOldRecord,
+            cleanNewRecord
+        };
+    }
+    /**
+     * Generate delete diff (record vs empty object)
+     */
+    generateDeleteDiff(record) {
+        const cleanRecord = sanitizeForDiff(record);
+        const changesDiff = diff(cleanRecord, {});
+        const formattedChanges = formatChanges(changesDiff, cleanRecord, {});
+        return {
+            changesDiff,
+            formattedChanges,
+            cleanRecord
+        };
+    }
+    /**
+     * Log system event with diff
+     */
+    async logSystemEvent(dataAccessor, eventType, message, oldRecord, newRecord) {
+        let formattedChanges = [];
+        let summary = '';
+        switch (eventType) {
+            case 'Created':
+                const cleanNewRecord = sanitizeForDiff(newRecord);
+                formattedChanges = formatChanges({}, {}, cleanNewRecord, 'add');
+                summary = `Created ${formattedChanges.length} fields`;
+                break;
+            case 'Updated':
+                const { formattedChanges: updateChanges } = this.generateDiff(oldRecord, newRecord);
+                formattedChanges = updateChanges;
+                summary = `Changes ${formattedChanges.length} fields`;
+                break;
+            case 'Deleted':
+                const { formattedChanges: deleteChanges } = this.generateDeleteDiff(oldRecord);
+                formattedChanges = deleteChanges;
+                summary = `Deleted ${formattedChanges.length} fields`;
+                break;
+        }
+        // log system event notification
+        await dataAccessor.adminizer.logSystemEvent(eventType, message, {
+            changes: formattedChanges,
+            summary
+        });
+    }
+    async create(data, dataAccessor) {
+        let _data = await dataAccessor.setUserRelationAccess(dataAccessor.process(data));
+        let record = await this._create(_data);
+        // Log creation event
+        await this.logSystemEvent(dataAccessor, 'Created', 
+        // @ts-ignore
+        `user ${dataAccessor.user.login} create ${dataAccessor.entity.name} ${record[this.primaryKey]}`, {}, _data);
+        return dataAccessor.process(record);
+    }
+    async findOne(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        let record = await this._findOne(criteria);
+        return record ? dataAccessor.process(record) : null;
+    }
+    async find(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        let records = await this._find(criteria);
+        return records.map(record => dataAccessor.process(record));
+    }
+    async updateOne(criteria, data, dataAccessor) {
+        let _data = dataAccessor.process(data);
+        // Get the old record first for diff
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        const oldRecord = await this._findOne(criteria);
+        if (!oldRecord) {
+            return null;
+        }
+        let record = await this._updateOne(criteria, _data);
+        if (!record) {
+            return null;
+        }
+        // Log update event
+        await this.logSystemEvent(dataAccessor, 'Updated', 
+        // @ts-ignore
+        `user ${dataAccessor.user.login} update ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, record);
+        return dataAccessor.process(record);
+    }
+    async update(criteria, data, dataAccessor) {
+        let _data = dataAccessor.process(data);
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        // Get old records automatically
+        const oldRecords = await this._find(criteria);
+        let records = await this._update(criteria, _data);
+        // Log update events for each record
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            const oldRecord = oldRecords[i];
+            if (oldRecord) {
+                await this.logSystemEvent(dataAccessor, 'Updated', 
+                // @ts-ignore
+                `user ${dataAccessor.user.login} update ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, record);
+            }
+        }
+        return records.map(record => dataAccessor.process(record));
+    }
+    async destroyOne(criteria, dataAccessor) {
+        // Get the record first for diff
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        const oldRecord = await this._findOne(criteria);
+        if (!oldRecord) {
+            return null;
+        }
+        let record = await this._destroyOne(criteria);
+        if (!record) {
+            return null;
+        }
+        // Log delete event
+        await this.logSystemEvent(dataAccessor, 'Deleted', 
+        //@ts-ignore
+        `user ${dataAccessor.user.login} delete ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, {});
+        return dataAccessor.process(record);
+    }
+    async destroy(criteria, dataAccessor) {
+        // Get records first for diff
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        const oldRecords = await this._find(criteria);
+        let records = await this._destroy(criteria);
+        // Log delete events for each record
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            const oldRecord = oldRecords[i];
+            if (oldRecord) {
+                await this.logSystemEvent(dataAccessor, 'Deleted', 
+                //@ts-ignore
+                `user ${dataAccessor.user.login} delete ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, {});
+            }
+        }
+        return records.map(record => dataAccessor.process(record));
+    }
+    async count(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        return this._count(criteria);
+    }
+}
+export class AbstractAdapter {
+    orm;
+    ormType;
+    constructor(type, orm) {
+        this.ormType = type;
+        this.orm = orm;
+    }
+    /**
+     * This method must ensure system models registration and throw an error in case of errors. We force all adapters to realize it
+     */
+    static registerSystemModels(orm) {
+        throw new Error("Function 'registerSystemModels' must be implemented by subclass");
+    }
+}

package/lib/{v4/model → model}/ModelHandler.js

@@ -1,4 +1,4 @@
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../Adminizer";
 export class ModelHandler {
     models = new Map();
     add(modelName, modelInstance) {

package/lib/{v4/model → model}/adapter/sequelize.d.ts

@@ -26,7 +26,6 @@ export declare class SequelizeModel<T> extends AbstractModel<T> {
 export declare class SequelizeAdapter extends AbstractAdapter {
     private sequelize;
     Model: typeof SequelizeModel;
-    alter: boolean;
     constructor(sequelize: Sequelize);
     get models(): Record<string, any>;
     getModel(modelName: string): any;

package/lib/{v4/model → model}/adapter/sequelize.js

@@ -15,7 +15,11 @@ function generateAssociationsFromSchema(models, schemas) {
                 const targetModel = models[field.collection];
                 const targetSchema = schemas[field.collection];
                 const inverseField = targetSchema?.[field.via];
-                const throughTableName = [modelName, field.collection].sort().join("");
+                // Normalize join table to lowercase for consistency across dialects
+                const throughTableName = [modelName, field.collection]
+                    .sort()
+                    .join("")
+                    .toLowerCase();
                 // 💡 M:N связь
                 if (inverseField && inverseField.collection === modelName) {
                     model.belongsToMany(targetModel, {
@@ -533,7 +537,6 @@ export class SequelizeModel extends AbstractModel {
 export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
     Model = SequelizeModel;
-    alter = false;
     constructor(sequelize) {
         super("sequelize", sequelize);
         this.sequelize = sequelize;
@@ -575,7 +578,7 @@ export class SequelizeAdapter extends AbstractAdapter {
             generateSequelizeModel(sequelize, modelName, definition);
         }
         generateAssociationsFromSchema(sequelize.models, schemas);
-        if (alter === true) {
+        if (alter) {
             await sequelize.sync();
         }
     }

package/lib/{v4/notifications → notifications}/AbstractNotificationService.d.ts

@@ -1,22 +1,29 @@
 import { EventEmitter } from 'events';
-import { Adminizer } from '../../Adminizer';
-import { INotification, INotificationEvent } from '../../../interfaces/types';
+import { Adminizer } from '../Adminizer';
+import { INotification, INotificationEvent } from '../../interfaces/types';
+import { NotificationAPModel } from "../../models/NotificationAP";
+import { UserAP } from "../../models/UserAP";
 export declare abstract class AbstractNotificationService extends EventEmitter {
-    protected clients: Map<string, (event: INotificationEvent) => void>;
+    protected clients: Map<number, Map<string, (event: INotificationEvent) => void>>;
     protected adminizer: Adminizer;
     abstract readonly notificationClass: string;
     abstract readonly icon: string;
     abstract readonly iconColor: string;
     constructor(adminizer: Adminizer);
-    addClient(clientId: string, sendFn: (event: INotificationEvent) => void): void;
+    private _bindAccessRight;
+    addClient(clientId: string, sendFn: (event: INotificationEvent) => void, user: UserAP): void;
     removeClient(clientId: string): void;
+    getUserClients(userId: number): Map<string, (event: INotificationEvent) => void>;
+    getClientCount(): number;
+    getAllClients(): Map<string, (event: INotificationEvent) => void>;
     abstract dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
     protected broadcast(event: INotificationEvent): void;
     sendHeartbeat(clientId: string): void;
-    protected generateId(): string;
-    getClientCount(): number;
     protected createUserNotification(notificationId: string, userId?: number): Promise<void>;
     protected getUserNotification(notificationId: string, userId: number): Promise<any>;
-    getNotifications(userId: number, limit?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    getNotifications(userId: number, limit?: number, skip?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    protected prepareNotification(notificationsDB: NotificationAPModel[], userId: number): Promise<INotification[]>;
+    search(s: string, userId: number): Promise<INotification[]>;
     markAsRead(userId: number, id: string): Promise<void>;
+    markAllAsRead(userId: number): Promise<void>;
 }

package/lib/notifications/AbstractNotificationService.js

@@ -0,0 +1,233 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../Adminizer';
+export class AbstractNotificationService extends EventEmitter {
+    clients = new Map();
+    adminizer;
+    constructor(adminizer) {
+        super();
+        this.adminizer = adminizer;
+        this._bindAccessRight();
+    }
+    _bindAccessRight() {
+        setTimeout(() => {
+            this.adminizer.accessRightsHelper.registerToken({
+                id: `notification-${this.notificationClass}`,
+                name: this.notificationClass,
+                description: `Access to notification ${this.notificationClass}`,
+                department: 'notification',
+            });
+        }, 100);
+    }
+    // Добавление клиента
+    addClient(clientId, sendFn, user) {
+        const userId = user.id;
+        // Если у пользователя еще нет Map клиентов - создаем
+        if (!this.clients.has(userId)) {
+            this.clients.set(userId, new Map());
+        }
+        // Получаем Map клиентов пользователя и добавляем нового клиента
+        const userClients = this.clients.get(userId);
+        userClients.set(clientId, sendFn);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} connected for user ${userId}. Total users: ${this.clients.size}, user clients: ${userClients.size}`);
+    }
+    // Удаление клиента
+    removeClient(clientId) {
+        // Ищем клиента во всех пользовательских Map
+        for (const [userId, userClients] of this.clients.entries()) {
+            if (userClients.has(clientId)) {
+                userClients.delete(clientId);
+                // Если у пользователя больше нет клиентов - удаляем его Map
+                if (userClients.size === 0) {
+                    this.clients.delete(userId);
+                }
+                Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} disconnected from user ${userId}. Total users: ${this.clients.size}`);
+                return;
+            }
+        }
+        Adminizer.log.warn(`[${this.notificationClass}] Client ${clientId} not found for removal`);
+    }
+    // Получение клиентов конкретного пользователя
+    getUserClients(userId) {
+        return this.clients.get(userId) || new Map();
+    }
+    // Получение количества подключенных клиентов
+    getClientCount() {
+        return this.clients.size;
+    }
+    // Получение всех клиентов (для обратной совместимости)
+    getAllClients() {
+        const allClients = new Map();
+        for (const userClients of this.clients.values()) {
+            for (const [clientId, sendFn] of userClients.entries()) {
+                allClients.set(clientId, sendFn);
+            }
+        }
+        return allClients;
+    }
+    // Рассылка события всем клиентам
+    broadcast(event) {
+        for (const userClients of this.clients.values()) {
+            userClients.forEach((sendFn, clientId) => {
+                try {
+                    sendFn(event);
+                }
+                catch (error) {
+                    Adminizer.log.error(`[${this.notificationClass}] Error sending to client ${clientId}:`, error);
+                    this.removeClient(clientId);
+                }
+            });
+        }
+    }
+    // Отправка heartbeat
+    sendHeartbeat(clientId) {
+        for (const userClients of this.clients.values()) {
+            const sendFn = userClients.get(clientId);
+            if (sendFn) {
+                const heartbeatEvent = {
+                    type: 'heartbeat',
+                    data: 'ping'
+                };
+                sendFn(heartbeatEvent);
+                return;
+            }
+        }
+    }
+    // Метод для создания записи в UserNotificationAP
+    async createUserNotification(notificationId, userId) {
+        if (this.adminizer.modelHandler.model.has('usernotificationap') && userId) {
+            try {
+                await this.adminizer.modelHandler.model.get('usernotificationap')["_create"]({
+                    userId: userId,
+                    notificationId: notificationId,
+                    read: false
+                });
+            }
+            catch (error) {
+                Adminizer.log.error(`Error creating user notification record:`, error);
+            }
+        }
+    }
+    // Метод для получения UserNotificationAP по ID уведомления и пользователя
+    async getUserNotification(notificationId, userId) {
+        if (this.adminizer.modelHandler.model.has('usernotificationap')) {
+            try {
+                return await this.adminizer.modelHandler.model.get('usernotificationap')["_findOne"]({
+                    where: { notificationId: notificationId, userId: userId }
+                });
+            }
+            catch (error) {
+                Adminizer.log.error(`Error getting user notification:`, error);
+                return null;
+            }
+        }
+        return null;
+    }
+    async getNotifications(userId, limit = 20, skip = 0, unreadOnly = false) {
+        if (!this.adminizer.modelHandler.model.has('notificationap')) {
+            return [];
+        }
+        try {
+            let query = { notificationClass: this.notificationClass };
+            // Если запрашиваются уведомления для конкретного пользователя получаем ID уведомлений пользователя
+            const userNotifications = await this.adminizer.modelHandler.model.get('usernotificationap')["_find"]({
+                where: {
+                    userId: userId
+                }
+            }, { populate: [['notificationId', {}]] });
+            const notificationIds = userNotifications.map((un) => un.notificationId.id);
+            if (unreadOnly) {
+                // Только непрочитанные
+                query.id = userNotifications
+                    .filter((un) => !un.read)
+                    .map((un) => un.notificationId.id);
+            }
+            else {
+                query.id = notificationIds;
+            }
+            if (query.id.length === 0)
+                return [];
+            const notificationsDB = await this.adminizer.modelHandler.model.get('notificationap')["_find"]({
+                where: query,
+                sort: 'createdAt DESC',
+                limit: limit,
+                skip: skip
+            });
+            return await this.prepareNotification(notificationsDB, userId);
+        }
+        catch (error) {
+            Adminizer.log.error('Error fetching notifications:', error);
+            return [];
+        }
+    }
+    async prepareNotification(notificationsDB, userId) {
+        let notifications = [];
+        for (const notification of notificationsDB) {
+            let readStatus = false;
+            // Получаем статус прочтения из UserNotificationAP
+            const userNotification = await this.getUserNotification(notification.id, userId);
+            readStatus = userNotification ? userNotification.read : false;
+            notifications.push({
+                ...notification,
+                read: readStatus,
+                icon: {
+                    icon: this.icon,
+                    iconColor: this.iconColor
+                },
+            });
+        }
+        return notifications;
+    }
+    async search(s, userId) {
+        try {
+            const userNotifications = await this.adminizer.modelHandler.model.get('usernotificationap')["_find"]({
+                where: {
+                    userId: userId
+                }
+            }, { populate: [['notificationId', {}]] });
+            const notificationIds = userNotifications.map((un) => un.notificationId.id);
+            if (notificationIds.length === 0)
+                return [];
+            const notificationsDB = await this.adminizer.modelHandler.model.get('notificationap')["_find"]({
+                where: {
+                    message: { contains: s },
+                    id: notificationIds,
+                    notificationClass: this.notificationClass
+                },
+                sort: "createdAt DESC"
+            });
+            return await this.prepareNotification(notificationsDB, userId);
+        }
+        catch (error) {
+            Adminizer.log.error('Error searching notifications:', error);
+            return [];
+        }
+    }
+    async markAsRead(userId, id) {
+        try {
+            const userNotification = await this.getUserNotification(id, userId);
+            if (userNotification) {
+                await this.adminizer.modelHandler.model.get('usernotificationap')["_update"]({
+                    id: userNotification.id
+                }, { read: true });
+            }
+        }
+        catch (error) {
+            Adminizer.log.error('Error marking notification as read:', error);
+        }
+    }
+    async markAllAsRead(userId) {
+        try {
+            const userNotifications = await this.adminizer.modelHandler.model.get('usernotificationap')["_find"]({
+                where: { userId: userId }
+            });
+            for (const userNotification of userNotifications) {
+                await this.adminizer.modelHandler.model.get('usernotificationap')["_update"]({
+                    where: { id: userNotification.id },
+                }, { read: true });
+            }
+        }
+        catch (error) {
+            Adminizer.log.error('Error marking all notifications as read:', error);
+        }
+    }
+}

package/lib/{v4/notifications → notifications}/GeneralNotificationService.d.ts

@@ -1,5 +1,5 @@
 import { AbstractNotificationService } from './AbstractNotificationService';
-import { INotification } from '../../../interfaces/types';
+import { INotification } from '../../interfaces/types';
 export declare class GeneralNotificationService extends AbstractNotificationService {
     readonly notificationClass = "general";
     readonly icon: string;

package/lib/{v4/notifications → notifications}/GeneralNotificationService.js

@@ -1,5 +1,5 @@
 import { AbstractNotificationService } from './AbstractNotificationService';
-import { Adminizer } from '../../Adminizer';
+import { Adminizer } from '../Adminizer';
 export class GeneralNotificationService extends AbstractNotificationService {
     notificationClass = 'general';
     icon = 'info';
@@ -23,7 +23,9 @@ export class GeneralNotificationService extends AbstractNotificationService {
                     const users = await this.adminizer.modelHandler.model.get('userap')["_find"]({});
                     for (const user of users) {
                         try {
-                            await this.createUserNotification(notificationDB.id, user.id);
+                            if (this.adminizer.accessRightsHelper.hasPermission(`notification-${this.notificationClass}`, user)) {
+                                await this.createUserNotification(notificationDB.id, user.id);
+                            }
                         }
                         catch (error) {
                             Adminizer.log.error('Error creating UserNotificationAP:', error);

package/lib/notifications/NotificationHandler.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'events';
+import { AbstractNotificationService } from "./AbstractNotificationService";
+import { INotification } from '../../interfaces/types';
+export declare class NotificationHandler extends EventEmitter {
+    private services;
+    constructor();
+    /**
+     * Register a new notification service
+     * @param service
+     */
+    registerService(service: AbstractNotificationService): void;
+    /**
+     * Get a notification service by class
+     * @param notificationClass
+     */
+    getService(notificationClass: string): AbstractNotificationService | undefined;
+    /**
+     * Get all registered services
+     */
+    getAllServices(): AbstractNotificationService[];
+    /**
+     * Dispatch a notification to a service
+     * @param notificationClass
+     * @param notification
+     */
+    dispatchNotification(notificationClass: string, notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
+}