import { ReactivePromise as IReactivePromise, ReactivePromiseConstructor, ReactiveTask, ReactiveOptions, RelayActivate } from '../types.js';
import { ReactiveSignal } from './reactive.js';
import { PromiseEdge } from './edge.js';
import { SignalScope } from './contexts.js';
export declare class ReactivePromiseImpl<T> {
    private _value;
    private _error;
    private _flags;
    private _signal;
    private _equals;
    private _promise;
    private _pending;
    private _stateSubs;
    _awaitSubs: Map<WeakRef<ReactiveSignal<unknown, unknown[]>>, PromiseEdge>;
    _updatedCount: number;
    private _version;
    private run;
    constructor(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: unknown) => void) => void);
    static all<T extends readonly unknown[] | []>(values: T): ReactivePromiseImpl<{
        -readonly [P in keyof T]: Awaited<T[P]>;
    }>;
    static race<T extends readonly unknown[] | []>(values: T): ReactivePromiseImpl<Awaited<T[number]>>;
    static any<T>(values: Iterable<T | PromiseLike<T>>): ReactivePromiseImpl<Awaited<T>>;
    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
    static resolve<T>(value: T): ReactivePromiseImpl<T>;
    static reject<T = never>(reason: any): ReactivePromiseImpl<T>;
    static withResolvers<T>(): {
        readonly promise: ReactivePromiseImpl<T>;
        readonly resolve: (value: T | PromiseLike<T>) => void;
        readonly reject: (reason: unknown) => void;
    };
    private _initFlags;
    private _consumeFlags;
    private _connect;
    private _setFlags;
    _getPending(): boolean;
    _setPending(): Map<any, any>;
    _clearPending(): void;
    _setPromise(promise: Promise<T>): Promise<void>;
    private _setValue;
    private _setError;
    private _scheduleSubs;
    get value(): T | undefined;
    get error(): unknown;
    get isPending(): boolean;
    get isRejected(): boolean;
    get isResolved(): boolean;
    get isReady(): boolean;
    get isSettled(): boolean;
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
    finally(onfinally?: (() => void) | null): Promise<T>;
    get [Symbol.toStringTag](): string;
}
/**
 * This is a utility function to mark a value as a ReactivePromise, primarily to enable _proxy_
 * wrapping of ReactivePromises to add additional functionality (see: Signalium Query)
 */
export declare function setReactivePromise(value: object): void;
export declare function isReactivePromise(value: object): value is ReactivePromiseImpl<unknown>;
export declare function isRelay<T>(obj: object): obj is ReactivePromiseImpl<T>;
export declare function createPromise<T>(promise: Promise<T>, signal: ReactiveSignal<T, unknown[]>): ReactivePromiseImpl<T>;
export declare function createRelay<T>(activate: RelayActivate<T>, scope: SignalScope, opts?: ReactiveOptions<T, unknown[]>): ReactivePromiseImpl<T>;
export declare function createTask<T, Args extends unknown[]>(task: (...args: Args) => Promise<T>, scope: SignalScope, opts?: ReactiveOptions<T, Args>): ReactiveTask<T, Args>;
export declare const ReactivePromise: ReactivePromiseConstructor;
export type ReactivePromise<T> = IReactivePromise<T>;
//# sourceMappingURL=async.d.ts.map