declare type EventFn<S, T> = (data: T, sender: S) => void;
declare type EventEntry<S, T> = EventFn<S, T> | {
    fn: EventFn<S, T>;
    once?: boolean;
};
declare type ArrayOrSingle<T> = T | Array<T>;
export declare abstract class BaseEventHandler<EventMap extends Record<string, any>, SerializedEvent, SendArgs extends Array<any>, Sender> {
    protected eventMap: Map<keyof EventMap, ArrayOrSingle<EventEntry<Sender, EventMap[keyof EventMap]>>>;
    constructor();
    protected abstract serialize<K extends keyof EventMap>(type: K, data: EventMap[K]): SerializedEvent;
    protected abstract deserialize<K extends keyof EventMap>(serialized: SerializedEvent): {
        type: K;
        data: EventMap[K];
    };
    protected abstract sendEvent(serialized: SerializedEvent, ...args: SendArgs): void;
    protected abstract setup(): void;
    private insertEvent;
    on<K extends keyof EventMap>(key: K, fn: EventFn<Sender, EventMap[K]>): this;
    once<K extends keyof EventMap>(key: K, fn: EventFn<Sender, EventMap[K]>): this;
    emit<K extends keyof EventMap>(key: K, data: EventMap[K], ...args: SendArgs): void;
    protected handleEvent<K extends keyof EventMap>(key: K, data: EventMap[K], sender: Sender): void;
    protected handleSerialized(serialized: SerializedEvent, sender: Sender): void;
}
export {};