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>>;
}
export declare class EventManager {
    private _isEventLoopRunning;
    dispatchers: ((event: Types.Event) => void)[];
    private eventsQueue;
    constructor();
    private listenForEvents;
    static startEventLoop(eventQueue: {
        waitEvent: () => Promise<Types.Event>;
    }): EventManager;
    stopEventLoop(): void;
    removeAllDispatchers: () => void;
    protected onEvent(event: Types.Event): void;
    registerDispatcher(manager: BaseEventManager): void;
    getThreadEventManager(threadApi: SubscriberForThreadsEvents): ThreadEventsManager;
    getStoreEventManager(storeApi: SubscriberForStoreEvents): StoreEventsManager;
    getInboxEventManager(inboxApi: SubscriberForInboxEvents): InboxEventsManager;
    getConnectionEventManager(connectionId: string): ConnectionEventsManager;
}
export {};