import { EventKey, EventMap, TypedEmitter } from './utils/TypedEmitter.js';
/**
 * @internal
 */
interface PromisifyEmitter<EM extends EventMap> {
    on<K extends EventKey<EM>>(eventName: K, fn: EM[K]): void;
}
/**
 * @internal
 */
type PromisifyFunc<T, EM extends EventMap> = (emitter: PromisifyEmitter<EM>, resolve: (result: T) => void, reject: (err: Error) => void) => void;
declare const StreamablePromise_base: new <TEM extends EventMap>() => TypedEmitter<TEM>;
/**
 * @internal
 */
export declare class StreamablePromise<T, EM extends EventMap> extends StreamablePromise_base<EM> implements Promise<T> {
    private _promise;
    protected _collectResults: boolean;
    /**
     * @internal
     */
    constructor(promisefyFn: PromisifyFunc<T, EM>);
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
    addListener<T extends EventKey<EM>>(eventName: T, listener: EM[T]): this;
    on<T extends EventKey<EM>>(eventName: T, listener: EM[T]): this;
    /**
     * @internal
     */
    get [Symbol.toStringTag](): string;
}
/**
 * Provides the ability to be used as both a promise, or an event emitter.  Enabling
 * an application to easily retrieve all results using async/await, while also enabling
 * streaming of results by listening for the row and meta events.
 */
export declare class StreamableRowPromise<T, TRow, TMeta> extends StreamablePromise<T, {
    row: (row: TRow) => void;
    meta: (meta: TMeta) => void;
    error: (err: Error) => void;
    end: () => void;
}> {
    constructor(fn: (rows: TRow[], meta: TMeta) => T);
}
/**
 * Provides the ability to be used as both a promise, or an event emitter.  Enabling
 * an application to easily retrieve all results using async/await, while also enabling
 * streaming of results by listening for the replica event.
 */
export declare class StreamableReplicasPromise<T, TRep> extends StreamablePromise<T, {
    replica: (resultFromReplica: TRep) => void;
    error: (err: Error) => void;
    end: () => void;
}> {
    constructor(fn: (replicas: [TRep, ...TRep[]]) => T);
}
export declare class StreamableScanPromise<T, TRes> extends StreamablePromise<T, {
    result: (result: TRes) => void;
    error: (err: Error) => void;
    end: () => void;
}> {
    private _cancelRequested;
    constructor(fn: (results: TRes[]) => T);
    get cancelRequested(): boolean;
    cancelStreaming(): void;
}
export {};