@simplito/privmx-webendpoint 2.5.2 → 2.6.0

package/extra/__tests__/inboxEventManager.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../__mocks__/utils");
+const constants_1 = require("../__mocks__/constants");
+const subscriptions_1 = require("../subscriptions");
+const Types_1 = require("../../Types");
+const mockContainerSubscriber_1 = require("../__mocks__/mockContainerSubscriber");
+describe("Inbox event manager", () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let mockEventsManager = manager.getInboxEventManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
+    beforeEach(() => {
+        let { q: _q, manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        mockEventsManager = manager.getInboxEventManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
+    });
+    it("should add callback for event", async () => {
+        const sub = (0, subscriptions_1.createInboxSubscription)({
+            type: Types_1.InboxEventType.INBOX_UPDATE,
+            id: "",
+            selector: Types_1.InboxEventSelectorType.CONTEXT_ID,
+            callbacks: [() => { }],
+        });
+        await mockEventsManager.subscribeFor([sub]);
+        expect(mockEventsManager.listeners.size).toBe(1);
+    });
+    it("should function to remove callback from event", async () => {
+        const sub = (0, subscriptions_1.createInboxSubscription)({
+            type: Types_1.InboxEventType.INBOX_UPDATE,
+            id: "",
+            selector: Types_1.InboxEventSelectorType.CONTEXT_ID,
+            callbacks: [() => { }],
+        });
+        const [subId] = await mockEventsManager.subscribeFor([sub]);
+        expect(mockEventsManager.listeners.size).toBe(1);
+        await mockEventsManager.unsubscribeFrom([subId]);
+        expect(mockEventsManager.listeners.size).toBe(0);
+    });
+    it("should register multiple callbacks for channel", async () => {
+        const storeEventCb = jest.fn();
+        const sub = (0, subscriptions_1.createInboxSubscription)({
+            type: Types_1.InboxEventType.INBOX_UPDATE,
+            id: "",
+            selector: Types_1.InboxEventSelectorType.CONTEXT_ID,
+            callbacks: [storeEventCb, storeEventCb],
+        });
+        const [subId] = await mockEventsManager.subscribeFor([sub]);
+        q.dispatchEvent((0, constants_1.MOCK_INBOX_CREATED_EVENT)(subId));
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(storeEventCb).toHaveBeenCalledTimes(2);
+    });
+    it("should handle subscription for two channels", async () => {
+        const inboxEventCb = jest.fn();
+        const entryEventCb = jest.fn();
+        const inboxId = "98dsyvb8as7ybd0asydvb0as";
+        const subA = (0, subscriptions_1.createInboxSubscription)({
+            type: Types_1.InboxEventType.INBOX_CREATE,
+            id: "",
+            selector: Types_1.InboxEventSelectorType.CONTEXT_ID,
+            callbacks: [inboxEventCb],
+        });
+        const subB = (0, subscriptions_1.createInboxSubscription)({
+            type: Types_1.InboxEventType.ENTRY_DELETE,
+            id: inboxId,
+            selector: Types_1.InboxEventSelectorType.INBOX_ID,
+            callbacks: [entryEventCb],
+        });
+        const [subIdA, subIdB] = await mockEventsManager.subscribeFor([subA, subB]);
+        const event = (0, constants_1.MOCK_INBOX_ENTRY_DELETED_EVENT)(inboxId, subIdB);
+        const eventCreated = (0, constants_1.MOCK_INBOX_CREATED_EVENT)(subIdA);
+        q.dispatchEvent(eventCreated);
+        await (0, utils_1.waitForNextTick)();
+        q.dispatchEvent(event);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(inboxEventCb).toHaveBeenCalledTimes(1);
+        expect(entryEventCb).toHaveBeenCalledTimes(1);
+    });
+});

package/extra/__tests__/storeEventManager.test.js

@@ -1,53 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const mockEventAPIs_1 = require("./__mocks__/mockEventAPIs");
-const utils_1 = require("./__mocks__/utils");
-const constants_1 = require("./__mocks__/constants");
-describe('Store event manager', () => {
+const utils_1 = require("../__mocks__/utils");
+const constants_1 = require("../__mocks__/constants");
+const mockContainerSubscriber_1 = require("../__mocks__/mockContainerSubscriber");
+const subscriptions_1 = require("../subscriptions");
+const Types_1 = require("../../Types");
+describe("Store event manager", () => {
     let { q, manager } = (0, utils_1.createTestSetup)();
-    let mockEventsManager = manager.getStoreEventManager(new mockEventAPIs_1.MockStoreEventApi(q));
+    let mockEventsManager = manager.getStoreEventManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
     beforeEach(() => {
         let { q: _q, manager } = (0, utils_1.createTestSetup)();
         q = _q;
-        mockEventsManager = manager.getStoreEventManager(new mockEventAPIs_1.MockStoreEventApi(q));
+        mockEventsManager = manager.getStoreEventManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
     });
-    it('should add callback for event', async () => {
-        await mockEventsManager.onStoreEvent({
-            event: 'storeStatsChanged',
-            callback: () => { }
+    it("should add callback for event", async () => {
+        const sub = (0, subscriptions_1.createStoreSubscription)({
+            type: Types_1.StoreEventType.STORE_UPDATE,
+            id: "",
+            selector: Types_1.StoreEventSelectorType.CONTEXT_ID,
+            callbacks: [() => { }],
         });
+        await mockEventsManager.subscribeFor([sub]);
         expect(mockEventsManager.listeners.size).toBe(1);
     });
-    it('should function to remove callback from event', async () => {
-        const removeListener = await mockEventsManager.onStoreEvent({
-            event: 'storeStatsChanged',
-            callback: () => { }
+    it("should function to remove callback from event", async () => {
+        const sub = (0, subscriptions_1.createStoreSubscription)({
+            type: Types_1.StoreEventType.STORE_UPDATE,
+            id: "",
+            selector: Types_1.StoreEventSelectorType.CONTEXT_ID,
+            callbacks: [() => { }],
         });
+        const [subId] = await mockEventsManager.subscribeFor([sub]);
         expect(mockEventsManager.listeners.size).toBe(1);
-        await removeListener();
+        await mockEventsManager.unsubscribeFrom([subId]);
         expect(mockEventsManager.listeners.size).toBe(0);
     });
-    it('should register multiple callbacks for channel', async () => {
+    it("should register multiple callbacks for channel", async () => {
         const storeEventCb = jest.fn();
-        await mockEventsManager.onStoreEvent({ event: constants_1.MOCK_STORE_CREATED_EVENT.type, callback: storeEventCb });
-        await mockEventsManager.onStoreEvent({ event: constants_1.MOCK_STORE_CREATED_EVENT.type, callback: storeEventCb });
-        q.dispatchEvent(constants_1.MOCK_STORE_CREATED_EVENT);
+        const sub = (0, subscriptions_1.createStoreSubscription)({
+            type: Types_1.StoreEventType.STORE_UPDATE,
+            id: "",
+            selector: Types_1.StoreEventSelectorType.CONTEXT_ID,
+            callbacks: [storeEventCb, storeEventCb],
+        });
+        const [subId] = await mockEventsManager.subscribeFor([sub]);
+        q.dispatchEvent((0, constants_1.MOCK_STORE_CREATED_EVENT)(subId));
         //adding task on end of js event loop
         await (0, utils_1.waitForNextTick)();
         expect(storeEventCb).toHaveBeenCalledTimes(2);
     });
-    it('should handle subscription for two channels', async () => {
+    it("should handle subscription for two channels", async () => {
         const storeEventCb = jest.fn();
         const messageEventCb = jest.fn();
-        const STORE_ID = '98dsyvs87dybv9a87dyvb98';
-        const storeEvent = (0, constants_1.MOCK_STORE_FILE_DELETED_EVENT)(STORE_ID);
-        await mockEventsManager.onStoreEvent({ event: constants_1.MOCK_STORE_CREATED_EVENT.type, callback: storeEventCb });
-        await mockEventsManager.onFileEvent(STORE_ID, {
-            event: storeEvent.type,
-            callback: messageEventCb
+        const STORE_ID = "98dsyvs87dybv9a87dyvb98";
+        const subA = (0, subscriptions_1.createStoreSubscription)({
+            type: Types_1.StoreEventType.STORE_CREATE,
+            id: "",
+            selector: Types_1.StoreEventSelectorType.CONTEXT_ID,
+            callbacks: [storeEventCb],
+        });
+        const subB = (0, subscriptions_1.createStoreSubscription)({
+            type: Types_1.StoreEventType.FILE_DELETE,
+            id: STORE_ID,
+            selector: Types_1.StoreEventSelectorType.STORE_ID,
+            callbacks: [messageEventCb],
         });
-        q.dispatchEvent(constants_1.MOCK_STORE_CREATED_EVENT);
-        q.dispatchEvent(storeEvent);
+        const [subIdA, subIdB] = await mockEventsManager.subscribeFor([subA, subB]);
+        q.dispatchEvent((0, constants_1.MOCK_STORE_CREATED_EVENT)(subIdA));
+        q.dispatchEvent((0, constants_1.MOCK_STORE_FILE_DELETED_EVENT)(STORE_ID, subIdB));
         //adding task on end of js event loop
         await (0, utils_1.waitForNextTick)();
         expect(storeEventCb).toHaveBeenCalledTimes(1);

package/extra/__tests__/threadEventManager.test.js

@@ -1,57 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const mockEventAPIs_1 = require("./__mocks__/mockEventAPIs");
-const utils_1 = require("./__mocks__/utils");
-const constants_1 = require("./__mocks__/constants");
-describe('Thread event manager', () => {
+const utils_1 = require("../__mocks__/utils");
+const mockContainerSubscriber_1 = require("../__mocks__/mockContainerSubscriber");
+const subscriptions_1 = require("../subscriptions");
+const Types_1 = require("../../Types");
+const constants_1 = require("../__mocks__/constants");
+describe("Thread event manager", () => {
     let { q, manager } = (0, utils_1.createTestSetup)();
-    let mockEventsManager = manager.getThreadEventManager(new mockEventAPIs_1.MockThreadEventApi(q));
+    let mockEventsManager = manager.getThreadEventManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
     beforeEach(() => {
         let { q: _q, manager } = (0, utils_1.createTestSetup)();
         q = _q;
-        mockEventsManager = manager.getThreadEventManager(new mockEventAPIs_1.MockThreadEventApi(q));
+        mockEventsManager = manager.getThreadEventManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
     });
-    it('should create manager', async () => {
+    it("should create manager", async () => {
         expect(mockEventsManager).toBeDefined();
         expect(manager.dispatchers.length).toBe(1);
     });
-    it('should add callback for event', async () => {
-        await mockEventsManager.onThreadEvent({
-            event: 'threadStatsChanged',
-            callback: () => { }
+    it("should add callback for event", async () => {
+        const sub = (0, subscriptions_1.createThreadSubscription)({
+            type: Types_1.ThreadEventType.THREAD_UPDATE,
+            id: "",
+            selector: Types_1.ThreadEventSelectorType.CONTEXT_ID,
+            callbacks: [() => { }],
         });
+        await mockEventsManager.subscribeFor([sub]);
         expect(mockEventsManager.listeners.size).toBe(1);
     });
-    it('should function to remove callback from event', async () => {
-        const removeListener = await mockEventsManager.onThreadEvent({
-            event: 'threadStatsChanged',
-            callback: () => { }
+    it("should function to remove callback from event", async () => {
+        const sub = (0, subscriptions_1.createThreadSubscription)({
+            type: Types_1.ThreadEventType.THREAD_UPDATE,
+            id: "",
+            selector: Types_1.ThreadEventSelectorType.CONTEXT_ID,
+            callbacks: [() => { }],
         });
+        const [subId] = await mockEventsManager.subscribeFor([sub]);
         expect(mockEventsManager.listeners.size).toBe(1);
-        await removeListener();
+        await mockEventsManager.unsubscribeFrom([subId]);
         expect(mockEventsManager.listeners.size).toBe(0);
     });
-    it('should register multiple callbacks for channel', async () => {
+    it("should register multiple callbacks for channel", async () => {
         const threadEventCb = jest.fn();
-        await mockEventsManager.onThreadEvent({ event: constants_1.MOCK_THREAD_CREATED_EVENT.type, callback: threadEventCb });
-        await mockEventsManager.onThreadEvent({ event: constants_1.MOCK_THREAD_CREATED_EVENT.type, callback: threadEventCb });
-        q.dispatchEvent(constants_1.MOCK_THREAD_CREATED_EVENT);
+        const sub = (0, subscriptions_1.createThreadSubscription)({
+            type: Types_1.ThreadEventType.THREAD_UPDATE,
+            id: "",
+            selector: Types_1.ThreadEventSelectorType.CONTEXT_ID,
+            callbacks: [threadEventCb, threadEventCb],
+        });
+        const [subId] = await mockEventsManager.subscribeFor([sub]);
+        q.dispatchEvent((0, constants_1.MOCK_THREAD_CREATED_EVENT)(subId));
         //adding task on end of js event loop
         await (0, utils_1.waitForNextTick)();
         expect(threadEventCb).toHaveBeenCalledTimes(2);
     });
-    it('should handle subscription for two channels', async () => {
+    it("should handle subscription for two channels", async () => {
         const threadEventCb = jest.fn();
         const messageEventCb = jest.fn();
-        const THREAD_ID = '823yrcby32987yc23984b7y3w';
-        const threadEvent = (0, constants_1.MOCK_THREAD_MESSAGE_DELETED_EVENT)(THREAD_ID);
-        await mockEventsManager.onThreadEvent({ event: constants_1.MOCK_THREAD_CREATED_EVENT.type, callback: threadEventCb });
-        await mockEventsManager.onMessageEvent(THREAD_ID, {
-            event: threadEvent.type,
-            callback: messageEventCb
+        const THREAD_ID = "98dsyvs87dybv9a87dyvb98";
+        const subA = (0, subscriptions_1.createThreadSubscription)({
+            type: Types_1.ThreadEventType.THREAD_CREATE,
+            id: "",
+            selector: Types_1.ThreadEventSelectorType.CONTEXT_ID,
+            callbacks: [threadEventCb],
+        });
+        const subB = (0, subscriptions_1.createThreadSubscription)({
+            type: Types_1.ThreadEventType.MESSAGE_DELETE,
+            id: THREAD_ID,
+            selector: Types_1.ThreadEventSelectorType.THREAD_ID,
+            callbacks: [messageEventCb],
         });
-        q.dispatchEvent(constants_1.MOCK_THREAD_CREATED_EVENT);
-        q.dispatchEvent(threadEvent);
+        const [subIdA, subIdB] = await mockEventsManager.subscribeFor([subA, subB]);
+        q.dispatchEvent((0, constants_1.MOCK_THREAD_CREATED_EVENT)(subIdA));
+        q.dispatchEvent((0, constants_1.MOCK_THREAD_MESSAGE_DELETED_EVENT)(THREAD_ID, subIdB));
         //adding task on end of js event loop
         await (0, utils_1.waitForNextTick)();
         expect(threadEventCb).toHaveBeenCalledTimes(1);

package/extra/events.d.ts

@@ -1,219 +1,6 @@
 import { Types } from "..";
-export type Channel = 'inbox' | `inbox/${string}/entries` | 'store' | `store/${string}/files` | 'thread' | `thread/${string}/messages` | `connection/${string}`;
-/**
- * Represents a generic event structure.
- */
-export interface GenericEvent<K extends keyof EventPayload> extends Types.Event {
-    /**
-     * Type of the event.
-     */
-    type: keyof EventPayload;
-    /**
-     * The channel through which the event was emitted.
-     */
-    channel: Channel;
-    /**
-     * Data associated with the event.
-     */
-    data: EventPayload[K];
-    /**
-     * ID of connection to which the event was sent.
-     */
-    connectionId: number;
-}
-export interface EventPayload {
-    threadCreated: Types.Thread;
-    threadUpdated: Types.Thread;
-    threadDeleted: {
-        threadId: string;
-    };
-    threadStatsChanged: {
-        lastMsgDate: number;
-        messagesCount: number;
-        threadId: string;
-    };
-    threadNewMessage: Types.Message;
-    threadUpdatedMessage: Types.Message;
-    threadMessageDeleted: {
-        threadId: string;
-        messageId: string;
-    };
-    storeCreated: Types.Store;
-    storeUpdated: Types.Store;
-    storeDeleted: {
-        storeId: string;
-    };
-    storeStatsChanged: {
-        contextId: string;
-        storeId: string;
-        lastFileDate: number;
-        filesCount: number;
-    };
-    storeFileCreated: Types.File;
-    storeFileUpdated: Types.File;
-    storeFileDeleted: {
-        contextId: string;
-        storeId: string;
-        fileId: string;
-    };
-    inboxDeleted: {
-        inboxId: string;
-    };
-    inboxUpdated: Types.Inbox;
-    inboxCreated: Types.Inbox;
-    inboxEntryCreated: Types.InboxEntry;
-    inboxEntryDeleted: {
-        inboxId: string;
-        entryId: string;
-    };
-    libConnected: undefined;
-    libDisconnected: undefined;
-    libPlatformDisconnected: undefined;
-    libBreak: undefined;
-}
-type EventType = keyof EventPayload;
-type EventHandler<E extends keyof EventPayload> = {
-    event: E;
-    callback: (event: GenericEvent<E>) => void;
-};
-export type OnMessageEventHandler = EventHandler<'threadMessageDeleted'> | EventHandler<'threadNewMessage'> | EventHandler<'threadUpdatedMessage'>;
-export type OnThreadEventHandler = EventHandler<'threadCreated'> | EventHandler<'threadDeleted'> | EventHandler<'threadUpdated'> | EventHandler<'threadStatsChanged'>;
-export type OnFileEventHandler = EventHandler<'storeFileDeleted'> | EventHandler<'storeFileCreated'> | EventHandler<'storeFileUpdated'>;
-export type OnStoreEventHandler = EventHandler<'storeCreated'> | EventHandler<'storeStatsChanged'> | EventHandler<'storeUpdated'> | EventHandler<'storeDeleted'>;
-export type OnInboxEventHandler = EventHandler<'inboxDeleted'> | EventHandler<'inboxCreated'> | EventHandler<'inboxUpdated'>;
-export type OnEntryEventHandler = EventHandler<'inboxEntryCreated'> | EventHandler<'inboxEntryDeleted'>;
-export type OnConnectionHandler = EventHandler<'libConnected'> | EventHandler<'libDisconnected'> | EventHandler<'libBreak'> | EventHandler<'libPlatformDisconnected'>;
-export declare abstract class BaseEventManager {
-    private _listeners;
-    get listeners(): Map<string, Function[]>;
-    protected channels: Set<Channel>;
-    protected abstract subscribeForModuleEvents(): Promise<void>;
-    protected abstract subscribeForModuleElementsEvents(containerId: string): Promise<void>;
-    protected abstract unsubscribeFromModuleEvents(): Promise<void>;
-    protected abstract unsubscribeFromModuleElementsEvents(containerId: string): Promise<void>;
-    constructor();
-    /**
-     * Checks whether the user is subscribed to given channel
-     * @param channel Channel
-     * @returns {boolean} `boolean`
-     */
-    protected isSubscribedToChannel(channel: Channel): boolean;
-    protected hasEventsOnChannel(channel: Channel): boolean;
-    /**
-     * Removes an event listeners from given `channel` and `eventType`
-     * @param {Channel} channel channel
-     * @param {string} eventType type of the event
-     * @param {function} callback callback function
-     */
-    protected removeEventListener: (channel: Channel, eventType: EventType, callback: Function) => void;
-    /**
-     * Removes all listeners from given channel
-     * @param {Channel} channel channel
-     * @returns {void}
-     */
-    removeChannelEvents: (channel: Channel) => void;
-    dispatchEvent(event: Types.Event): void;
-    /**
-     * Add an event listeners on given channel and eventType
-     * @param {Channel} channel channel
-     * @param {string} eventType type of the event
-     * @param {function} callback callback function
-     * @returns {function} function to remove the event listeners
-     */
-    private addEventListener;
-    protected addContainerListener: (channel: Channel, eventType: EventType, callback: Function) => Promise<() => Promise<void>>;
-    protected addContainerElementListener: (containerId: string, channel: Channel, eventType: EventType, callback: Function) => Promise<() => Promise<void>>;
-}
-export interface SubscriberForThreadsEvents {
-    subscribeForThreadEvents(): Promise<void>;
-    /**
-     * Unsubscribes from the Thread module main events.
-     */
-    unsubscribeFromThreadEvents(): Promise<void>;
-    /**
-     * Subscribes for events in given Thread.
-     * @param {string} threadId ID of the Thread to subscribe
-     */
-    subscribeForMessageEvents(threadId: string): Promise<void>;
-    /**
-     * Unsubscribes from events in given Thread.
-     * @param {string} threadId ID of the Thread to unsubscribe
-     */
-    unsubscribeFromMessageEvents(threadId: string): Promise<void>;
-}
-export declare class ThreadEventsManager extends BaseEventManager {
-    private threadApi;
-    constructor(threadApi: SubscriberForThreadsEvents);
-    subscribeForModuleEvents(): Promise<void>;
-    subscribeForModuleElementsEvents(id: string): Promise<void>;
-    unsubscribeFromModuleEvents(): Promise<void>;
-    unsubscribeFromModuleElementsEvents(id: string): Promise<void>;
-    onThreadEvent(handler: OnThreadEventHandler): Promise<() => Promise<void>>;
-    onMessageEvent(threadId: string, handler: OnMessageEventHandler): Promise<() => Promise<void>>;
-}
-export interface SubscriberForStoreEvents {
-    subscribeForStoreEvents(): Promise<void>;
-    /**
-     * Unsubscribes from the Store module main events.
-     */
-    unsubscribeFromStoreEvents(): Promise<void>;
-    /**
-     * Subscribes for events in given Store.
-     * @param {string} storeId ID of the Store to subscribe
-     */
-    subscribeForFileEvents(storeId: string): Promise<void>;
-    /**
-     * Unsubscribes from events in given Store.
-     * @param {string} storeId ID of the Store to unsubscribe
-     */
-    unsubscribeFromFileEvents(storeId: string): Promise<void>;
-}
-export declare class StoreEventsManager extends BaseEventManager {
-    private storeApi;
-    constructor(storeApi: SubscriberForStoreEvents);
-    subscribeForModuleEvents(): Promise<void>;
-    subscribeForModuleElementsEvents(id: string): Promise<void>;
-    unsubscribeFromModuleEvents(): Promise<void>;
-    unsubscribeFromModuleElementsEvents(id: string): Promise<void>;
-    onStoreEvent(handler: OnStoreEventHandler): Promise<() => Promise<void>>;
-    onFileEvent(storeId: string, handler: OnFileEventHandler): Promise<() => Promise<void>>;
-}
-export interface SubscriberForInboxEvents {
-    subscribeForInboxEvents(): Promise<void>;
-    /**
-     * Unsubscribes from the Inbox module main events.
-     */
-    unsubscribeFromInboxEvents(): Promise<void>;
-    /**
-     * Subscribes for events in given Inbox.
-     * @param {string} inboxId ID of the Inbox to subscribe
-     */
-    subscribeForEntryEvents(inboxId: string): Promise<void>;
-    /**
-     * Unsubscribes from events in given Inbox.
-     * @param {string} inboxId ID of the Inbox to unsubscribe
-     */
-    unsubscribeFromEntryEvents(inboxId: string): Promise<void>;
-}
-export declare class InboxEventsManager extends BaseEventManager {
-    private inboxApi;
-    constructor(inboxApi: SubscriberForInboxEvents);
-    subscribeForModuleEvents(): Promise<void>;
-    subscribeForModuleElementsEvents(id: string): Promise<void>;
-    unsubscribeFromModuleEvents(): Promise<void>;
-    unsubscribeFromModuleElementsEvents(id: string): Promise<void>;
-    onInboxEvent(handler: OnInboxEventHandler): Promise<() => Promise<void>>;
-    onEntryEvent(inboxId: string, handler: OnEntryEventHandler): Promise<() => Promise<void>>;
-}
-export declare class ConnectionEventsManager extends BaseEventManager {
-    private connectionId;
-    protected subscribeForModuleEvents(): Promise<void>;
-    protected subscribeForModuleElementsEvents(): Promise<void>;
-    protected unsubscribeFromModuleEvents(): Promise<void>;
-    protected unsubscribeFromModuleElementsEvents(): Promise<void>;
-    constructor(connectionId: string);
-    onConnectionEvent(handler: OnConnectionHandler): Promise<() => Promise<void>>;
-}
+import { SubscriberForInboxEvents, SubscriberForKvdbEvents, SubscriberForStoreEvents, SubscriberForThreadsEvents } from "./subscriptions";
+import { BaseEventDispatcherManager, ConnectionEventsManager, InboxEventsManager, KvdbEventsManager, StoreEventsManager, ThreadEventsManager } from "./managers";
 export declare class EventManager {
     private _isEventLoopRunning;
     dispatchers: ((event: Types.Event) => void)[];
@@ -226,10 +13,10 @@ export declare class EventManager {
     stopEventLoop(): void;
     removeAllDispatchers: () => void;
     protected onEvent(event: Types.Event): void;
-    registerDispatcher(manager: BaseEventManager): void;
+    registerDispatcher(manager: BaseEventDispatcherManager): void;
     getThreadEventManager(threadApi: SubscriberForThreadsEvents): ThreadEventsManager;
     getStoreEventManager(storeApi: SubscriberForStoreEvents): StoreEventsManager;
+    getKvdbEventManager(kvdbApi: SubscriberForKvdbEvents): KvdbEventsManager;
     getInboxEventManager(inboxApi: SubscriberForInboxEvents): InboxEventsManager;
     getConnectionEventManager(connectionId: string): ConnectionEventsManager;
 }
-export {};