import * as grpc from './typesGrpc';
export type AnyError = Error | grpc.Error;
/**
 * Interface for data produced by a call
 */
export interface Publisher<T> {
    /**
     * Get reconnection status
     */
    get reconnecting(): boolean;
    /**
     * Connect after error
     */
    connected(): void;
    /**
     * Reconnect when error
     */
    reconnect(): void;
    /**
     * Cancel call
     */
    cancel(): void;
    /**
     * Handler for incoming data
     * @param handler
     */
    onData(handler: Handler<T>): Publisher<T>;
    /**
     * Handler for errors
     * @param handler
     */
    onError(handler: Handler<AnyError>): Publisher<T>;
    /**
     * Handler for a call end
     * @param handler
     */
    finally(handler: Handler<void>): Publisher<T>;
}
/**
 * Data conversion from one type to another
 */
export type DataMapper<I, O> = (data: I) => O;
/**
 * Handler for data
 */
export type Handler<T> = (value: T) => void;
/**
 * Publisher that may keep actual events in buffer, until a handler added to process.
 * I.e., for a case when request received data before onData(..) was called.
 * Otherwise the call may miss data or errors.
 */
export declare class BufferedPublisher<T> implements Publisher<T> {
    private _reconnecting;
    private buffer;
    private cancelled;
    private onDataHandler;
    private onErrorHandler;
    private onFinallyHandler;
    get reconnecting(): boolean;
    connected(): void;
    reconnect(): void;
    cancel(): void;
    execute(repeat?: boolean): void;
    emitData(data: T): void;
    emitError(error: AnyError): void;
    emitClosed(): void;
    onData(handler: Handler<T>): Publisher<T>;
    onError(handler: Handler<AnyError>): Publisher<T>;
    finally(handler: Handler<void>): Publisher<T>;
}
/**
 * Publisher with methods to emit events.
 */
export declare class ManagedPublisher<T> implements Publisher<T> {
    private readonly buffer;
    constructor();
    get reconnecting(): boolean;
    connected(): void;
    reconnect(): void;
    cancel(): void;
    emitData(data: T): void;
    emitError(error: AnyError): void;
    emitClosed(): void;
    onData(handler: Handler<T>): Publisher<T>;
    onError(handler: Handler<AnyError>): Publisher<T>;
    finally(handler: Handler<void>): Publisher<T>;
}
/**
 * Publisher that converts incoming data to another type
 */
export declare class MappingPublisher<I, O> implements Publisher<O> {
    private readonly buffer;
    private reader;
    constructor(reader: Publisher<I>, mapper: DataMapper<I, O>);
    get reconnecting(): boolean;
    connected(): void;
    reconnect(): void;
    cancel(): void;
    onData(handler: Handler<O>): Publisher<O>;
    onError(handler: Handler<AnyError>): Publisher<O>;
    finally(handler: Handler<void>): Publisher<O>;
}
export declare class PromisePublisher<T> implements Publisher<T> {
    private readonly value;
    constructor(value: Promise<T>);
    get reconnecting(): boolean;
    connected(): void;
    reconnect(): void;
    cancel(): void;
    onData(handler: Handler<T>): Publisher<T>;
    onError(handler: Handler<AnyError>): Publisher<T>;
    finally(handler: Handler<void>): Publisher<T>;
}
export declare function publishToPromise<T>(publisher: Publisher<T>): Promise<T>;
export declare function publishListToPromise<T>(publisher: Publisher<T>): Promise<T[]>;