declare const enum State {
    pending = 0,
    resolved = 1,
    fulfilled = 2,
    rejected = 3
}
type Status<T> = {
    readonly state: State.pending;
} | {
    readonly state: State.resolved;
    readonly promise: PromiseLike<T>;
} | {
    readonly state: State.fulfilled;
    readonly value: T;
} | {
    readonly state: State.rejected;
    readonly reason: unknown;
};
export declare const internal: unique symbol;
interface AtomicPromiseLike<T> {
    readonly [internal]: Internal<T>;
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): AtomicPromise<TResult1 | TResult2>;
}
export declare class AtomicPromise<T = undefined> implements Promise<T>, AtomicPromiseLike<T> {
    readonly [Symbol.toStringTag]: string;
    static get [Symbol.species](): typeof AtomicPromise;
    static all<T extends readonly unknown[] | []>(values: T): AtomicPromise<{
        -readonly [P in keyof T]: Awaited<T[P]>;
    }>;
    static all<T>(values: Iterable<T | PromiseLike<T>>): AtomicPromise<Awaited<T>[]>;
    static race<T extends readonly unknown[] | []>(values: T): AtomicPromise<Awaited<T[number]>>;
    static race<T>(values: Iterable<T | PromiseLike<T>>): AtomicPromise<Awaited<T>>;
    static allSettled<T extends readonly unknown[] | []>(values: T): AtomicPromise<{
        -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>;
    }>;
    static allSettled<T>(values: Iterable<T>): AtomicPromise<PromiseSettledResult<Awaited<T>>[]>;
    static any<T extends readonly unknown[] | []>(values: T): AtomicPromise<Awaited<T[number]>>;
    static any<T>(values: Iterable<T | PromiseLike<T>>): AtomicPromise<Awaited<T>>;
    static resolve(): AtomicPromise<undefined>;
    static resolve<T>(value: T | PromiseLike<T>): AtomicPromise<T>;
    static reject<T = never>(reason?: unknown): AtomicPromise<T>;
    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void) => void);
    readonly [internal]: Internal<T>;
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): AtomicPromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): AtomicPromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): AtomicPromise<T>;
}
interface FulfillReaction {
    readonly internal: Internal<unknown>;
    readonly state: true;
    readonly procedure: ((param: unknown) => unknown) | undefined | null;
}
interface RejectReaction {
    readonly internal: Internal<unknown>;
    readonly state: false;
    readonly procedure: ((param: unknown) => unknown) | undefined | null;
}
export declare class Internal<T> {
    status: Status<T>;
    isPending(): boolean;
    resolve(value: T | PromiseLike<T>): void;
    reject(reason: unknown): void;
    fulfillReactions: FulfillReaction[];
    rejectReactions: RejectReaction[];
    then<TResult1, TResult2>(internal: Internal<TResult1 | TResult2>, onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): void;
    resume(): void;
}
export declare function isPromiseLike(value: any): value is PromiseLike<any>;
export declare const never: Promise<never>;
export {};