import { Logger, Module } from '@nu-art/ts-common';
export declare const Key_UndefinedMessage = "undefined-message";
/**
 * Subset of interface Window, which contains postMessage functions
 */
interface Messagable {
    postMessage(message: any, targetOrigin: string, transfer?: Transferable[]): void;
    postMessage(message: any, options?: WindowPostMessageOptions): void;
}
export type Message = {
    key: string;
};
declare class ModuleFE_WindowMessenger_Class extends Module {
    readonly receivers: BaseReceiver<any>[];
    private listener?;
    addReceiver(receiver: BaseReceiver<any>): void;
    removeReceiver(receiver: BaseReceiver<any>): void;
    sendMessage<T extends Message>(message: T, target: Messagable): void;
    createMessenger<T extends Message>(target: Messagable): Messenger<T>;
    createReceiver<T extends Message>(origin?: string, transformer?: (data: any) => T[]): Receiver<T>;
    createRawReceiver(execute: (message: any) => void, origin?: string): RawReceiver;
}
export declare const ModuleFE_WindowMessenger: ModuleFE_WindowMessenger_Class;
export declare class Messenger<T extends Message> {
    readonly target: Messagable;
    constructor(target: Messagable);
    sendMessage(message: T): void;
}
export declare abstract class BaseReceiver<T = any> extends Logger {
    readonly origin: string;
    private readonly regex;
    private filter;
    constructor(origin?: string);
    mount(): this;
    unmount(): this;
    readonly execute: (origin: string, message: T) => void;
    abstract executeImpl(message: T): void;
    setFilter(filter: (message: any) => boolean): this;
}
export declare class RawReceiver extends BaseReceiver {
    readonly execute: (message: any) => void;
    constructor(execute: (message: any) => void, origin?: string);
    executeImpl(message: any): void;
}
/**
 * Need to add a processor per each key prop's value that can be returned in the transformer output.
 */
export declare class Receiver<T extends Message> extends BaseReceiver {
    private readonly messageProcessorMap;
    private readonly transform;
    private defaultProcessor?;
    /**
     *
     * @param origin window.origin
     * @param transform Receives the MessageEvent and needs to transform it into an array of objects, each having prop "key". To each potential "key", you need to add an appropriate processor.
     */
    constructor(origin?: string, transform?: (data: any) => T[]);
    setDefaultProcessor(processor: (transformedMessage: T, message: any) => void): this;
    addProcessor<K extends T>(key: K['key'], processor: (message: K) => void): this;
    executeImpl(message: any): void;
}
export {};