import { Subject } from './subject';
import { ConstructorOf, SubjectMessage, SubjectMessageEnvelope, SubjectMessageHandler, SubjectMessageHeader, SubjectMessageOptions } from './messages';
import * as LRUCache from 'lru-cache';
export type MeshState = 'running' | 'stopping' | 'stopped';
export interface Mesh {
    readonly status: MeshState;
    subject(name: string): Subject;
    shutdown(): Promise<void>;
}
export interface MeshBackend {
    subscriptionIds: string[];
    register(subject: string, name: string | ConstructorOf<any>, handler: SubjectMessageHandler<any>): void;
    unregister(subject: string): Promise<void>;
    isRegistered(subject: string): Promise<void>;
    shutdown(): Promise<void>;
    send<T>(subject: string, partitionKey: string, message: SubjectMessage, options: SubjectMessageOptions, broadcast: boolean): Promise<T>;
}
export interface MeshErrorSerializedCause {
    message: string;
    stack: string;
}
export interface MeshErrorSerialized {
    ns: string;
    type: string;
    cause?: MeshErrorSerializedCause;
    header?: any;
}
export declare class MeshSignal {
    protected readonly namespace: string;
    static readonly MESH_SIGNAL_NAMESPACE: string;
    static readonly MESH_ERROR_NAMESPACE: string;
    readonly [key: string]: any;
    constructor(namespace?: string, details?: {
        [key: string]: any;
    });
    static PROCESS_RESPONSE_SYNC(response: any, forBroadcast: boolean, keepSignals: boolean): any;
    static PROCESS_RESPONSE(response: any, forBroadcast: boolean, keepSignals: boolean, resolve: (value: any) => void, reject?: (value: any) => void): void;
    private static isSignal;
    serialize(): MeshErrorSerialized;
    protected processResponseMatch(resolve: (value: any) => void, reject: (value: any) => void): void;
    protected processResponseMatchForBroadcast(resolve: (value: any) => void, reject: (value: any) => void): void;
}
export declare class MeshError extends MeshSignal {
    constructor(details?: {
        [key: string]: any;
    });
}
export declare class MeshTimeoutError extends MeshError {
}
export declare class MeshRegistrationTimeoutError extends MeshError {
}
export declare class MeshDuplicateMessageError extends MeshError {
    readonly header: SubjectMessageHeader;
    constructor(header: SubjectMessageHeader);
    serialize(): MeshErrorSerialized;
}
export declare class MeshInvocationError extends MeshError {
    readonly cause: Error;
    constructor(cause: Error);
    serialize(): MeshErrorSerialized;
}
export declare class MeshVoidResponse extends MeshSignal {
    protected processResponseMatch(resolve: (value: any) => void, reject: (value: any) => void): void;
    protected processResponseMatchForBroadcast(resolve: (value: any) => void, reject: (value: any) => void): void;
}
export declare function deserializeMeshErrorOrSignal(value: MeshErrorSerialized): MeshError;
export declare class MeshBase implements Mesh {
    private readonly meshPrivate;
    protected _status: MeshState;
    constructor(meshPrivate: MeshBackend);
    get status(): MeshState;
    subject(name: string): Subject;
    shutdown(): Promise<void>;
}
export type MessagePrivateBaseMessageHandler = (err: Error, message: SubjectMessageEnvelope) => Promise<any>;
export type MeshSubjectHandlers = {
    [subject: string]: {
        [name: string]: MeshSubjectHandlerRegistration;
    };
};
export interface MeshSubjectHandlerRegistration {
    subject: string;
    messageName: string;
    handler: MessagePrivateBaseMessageHandler;
    registered: boolean;
}
export declare abstract class MeshBackendBase implements MeshBackend {
    protected readonly instanceId: string;
    protected handlers: MeshSubjectHandlers;
    protected lruCache: LRUCache<string, void>;
    abstract get subscriptionIds(): string[];
    protected get allHandlers(): MeshSubjectHandlerRegistration[];
    isRegistered(subject: string): Promise<void>;
    register(subject: string, name: string | ConstructorOf<any>, handler: SubjectMessageHandler<any>): void;
    send<T>(subject: string, partitionKey: string, message: SubjectMessage, options: SubjectMessageOptions, broadcast: boolean): Promise<T>;
    abstract shutdown(): Promise<void>;
    abstract unregister(subject: string): Promise<void>;
    protected abstract doSend<T>(address: string, envelope: SubjectMessageEnvelope, options: SubjectMessageOptions, broadcast: boolean): Promise<T>;
    protected abstract doRegistrations(): Promise<void>;
    protected invokeHandler<T>(message: SubjectMessageEnvelope, callback?: (err?: MeshError, result?: T) => void): Promise<T>;
}
export interface MeshBackendProvision {
    backend: MeshBackend;
    callback?(mesh: Mesh): any;
}
export type MeshBackendProvided = MeshBackend | MeshBackendProvision;
export type MeshBackendProvider = () => MeshBackendProvided;
export declare function toMeshBackendProvision(provided: MeshBackendProvided): MeshBackendProvision;
export declare function mesh(meshBackendProvider: MeshBackendProvider): Mesh;