import { Protoframe, ProtoframeMessageType, ProtoframeMessageResponse, ProtoframeMessageBody, ProtoframeDescriptor } from './types';
interface Connector {
    /** Destroy the connector and all resources/listeners being held. */
    destroy(): void;
}
interface AbstractProtoframeSubscriber<P extends Protoframe> extends Connector {
    /**
     * Handle a message that was sent with the [[ProtoframePublisher.tell]]
     * function.
     *
     * @param type The message type being handled
     * @param handler The handler function for the message
     */
    handleTell<T extends ProtoframeMessageType<P>, _R extends ProtoframeMessageResponse<P, T> & undefined>(type: T, handler: (body: ProtoframeMessageBody<P, T>) => void): void;
}
interface AbstractProtoframePublisher<P extends Protoframe> extends Connector {
    /**
     * Send a message to a receiving connector. This is a fire-and-forget emitter
     * that does not accept a response. If you want a request-response workflow,
     * use [[ProtoframePubsub.ask]].
     *
     * @param type The message type being sent
     * @param body The body of the message to send
     */
    tell<T extends ProtoframeMessageType<P>, _R extends ProtoframeMessageResponse<P, T> & undefined>(type: T, body: ProtoframeMessageBody<P, T>): void;
}
interface AbstractProtoframePubsub<P extends Protoframe> extends AbstractProtoframeSubscriber<P>, AbstractProtoframePublisher<P> {
    /**
     * Send an "ask" message to the receiving connector. On the other end, a
     * connector would have invoked `handleAsk` in order to receive this message
     * and issue a response.
     *
     * The promise returned by this call will resolve when a response as been
     * received from the target connector, or if the timeout has been exceeded
     *
     * @param type The message type being asked
     * @param body The body of the ask message
     * @param timeout How long to wait for a response before the resulting promise
     *  is rejected with a timeout error.
     */
    ask<T extends ProtoframeMessageType<P>, B extends ProtoframeMessageBody<P, T>, R extends ProtoframeMessageResponse<P, T> & Record<string, unknown>>(type: T, body: B, timeout?: number): Promise<R>;
    /**
     * Handle an "ask" message and provide a response. This is invoked when the
     * asking connector has invoked the `ask` method of the pubsub connector.
     *
     * @param type The message type being listened to
     * @param handler The message handler that eventually returns a response
     */
    handleAsk<T extends ProtoframeMessageType<P>, R extends ProtoframeMessageResponse<P, T> & Record<string, unknown>>(type: T, handler: (body: ProtoframeMessageBody<P, T>) => Promise<R>): void;
}
export declare class ProtoframeSubscriber<P extends Protoframe> implements AbstractProtoframeSubscriber<P> {
    private readonly protocol;
    private readonly thisWindow;
    constructor(protocol: ProtoframeDescriptor<P>, thisWindow?: Window);
    private listeners;
    handleTell<T extends ProtoframeMessageType<P>, _R extends ProtoframeMessageResponse<P, T> & undefined>(type: T, handler: (body: ProtoframeMessageBody<P, T>) => void): void;
    destroy(): void;
}
export declare class ProtoframePublisher<P extends Protoframe> implements AbstractProtoframePublisher<P> {
    private readonly protocol;
    private readonly targetWindow;
    private readonly targetOrigin;
    /**
     * We are a "parent" page that is embedding an iframe, and we wish to connect
     * to that iframe in order to publish messages.
     *
     * @param protocol The protocol this connector will communicate with
     * @param iframe The target iframe HTML element we are connecting to
     * @param targetOrigin The target scheme and host we expect the receiver to be
     */
    static parent<P extends Protoframe>(protocol: ProtoframeDescriptor<P>, iframe: HTMLIFrameElement, targetOrigin?: string): ProtoframePublisher<P>;
    /**
     * We are an "iframe" page that will be embedded, and we wish to connect to a
     * parent page in order to publish messages.
     *
     * @param protocol The protocol this connector will communicate with
     * @param targetOrigin The target scheme and host we expect the receiver to be
     * @param targetWindow The window of the parent frame. This should normally be
     *  the `window.parent`
     */
    static iframe<P extends Protoframe>(protocol: ProtoframeDescriptor<P>, targetOrigin?: string, targetWindow?: Window): ProtoframePublisher<P>;
    private listeners;
    constructor(protocol: ProtoframeDescriptor<P>, targetWindow: Window, targetOrigin?: string);
    tell<T extends ProtoframeMessageType<P>, _R extends undefined>(type: T, body: P[T]['body']): void;
    destroy(): void;
}
export declare class ProtoframePubsub<P extends Protoframe> implements AbstractProtoframePubsub<P> {
    private readonly protocol;
    private readonly targetWindow;
    private readonly thisWindow;
    private readonly targetOrigin;
    /**
     * Connect to the target configured in the supplied pubsub connector by
     * sending ping requests over and over until we get a response.
     *
     * @param pubsub The pubsub connector to wait until is "connected" to its
     *  target
     * @param retries How many times to retry and ping the target. By default,
     *  this will retry 50 times (thus waiting 25 seconds total)
     * @param timeout How long to wait for a response from the target before
     *  retrying. By default the timeout is 500ms (thus waiting 25 seconds total)
     */
    static connect<P extends Protoframe>(pubsub: ProtoframePubsub<P>, retries?: number, timeout?: number): Promise<ProtoframePubsub<P>>;
    /**
     * We are a "parent" page that is embedding an iframe, and we wish to connect
     * to that iframe for communication.
     *
     * @param protocol The protocol this connector will communicate with
     * @param iframe The target iframe HTML element we are connecting to
     * @param targetOrigin The target scheme and host we expect the receiver to be
     * @param thisWindow The parent window (our window). This should normally be
     *  the current `window`
     */
    static parent<P extends Protoframe>(protocol: ProtoframeDescriptor<P>, iframe: HTMLIFrameElement, targetOrigin?: string, thisWindow?: Window): ProtoframePubsub<P>;
    /**
     * We are an "iframe" page that will be embedded, and we wish to connect to a
     * parent page for communication.
     *
     * @param protocol The protocol this connector will communicate with
     * @param targetOrigin The target scheme and host we expect the receiver to be
     * @param thisWindow The window of the current iframe. This should normally be
     *  the current `window`
     * @param targetWindow The window of the parent frame. This should normally be
     *  the `window.parent`
     */
    static iframe<P extends Protoframe>(protocol: ProtoframeDescriptor<P>, targetOrigin?: string, { thisWindow, targetWindow, }?: {
        thisWindow?: Window;
        targetWindow?: Window;
    }): ProtoframePubsub<P>;
    private systemProtocol;
    private listeners;
    constructor(protocol: ProtoframeDescriptor<P>, targetWindow: Window, thisWindow?: Window, targetOrigin?: string);
    /**
     * Send a 'ping' request to check if there is a listener open at the target
     * window. If this times out, then it means no listener was available *at the
     * time the ping request was sent*. Since requests are not buffered, then this
     * should be retried if we're waiting for some target iframe to start up and
     * load its assets. See `ProtoframePubsub.connect` as an implementation of
     * this functionality.
     *
     * @param timeout How long to wait for the reply before resulting in an error
     */
    ping({ timeout }: {
        timeout?: number;
    }): Promise<void>;
    handleTell<T extends ProtoframeMessageType<P>, _R extends ProtoframeMessageResponse<P, T> & undefined>(type: T, handler: (body: ProtoframeMessageBody<P, T>) => void): void;
    tell<T extends ProtoframeMessageType<P>, _R extends undefined>(type: T, body: P[T]['body']): void;
    handleAsk<T extends ProtoframeMessageType<P>, R extends P[T]['response'] & Record<string, unknown>>(type: T, handler: (body: P[T]['body']) => Promise<R>): void;
    ask<T extends ProtoframeMessageType<P>, B extends P[T]['body'], R extends P[T]['response'] & Record<string, unknown>>(type: T, body: B, timeout?: number): Promise<R>;
    destroy(): void;
}
export {};