import { Throws } from './throws';
type InferErrors<T> = T extends ThrowsPromise<any, infer E> ? E : T extends PromiseLike<infer U> ? U extends {
    __throws?(error: infer E): void;
} ? E : never : never;
interface PromiseRejectedResult<E> {
    status: 'rejected';
    reason: E;
}
type SettledResult<T> = T extends ThrowsPromise<infer U, infer E> ? PromiseFulfilledResult<U> | PromiseRejectedResult<E> : T extends PromiseLike<infer U> ? PromiseFulfilledResult<U> | PromiseRejectedResult<unknown> : PromiseFulfilledResult<T> | PromiseRejectedResult<unknown>;
export declare class ThrowsPromise<T, E extends Error> extends Promise<Throws<T, E>> {
    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: E) => void) => void);
    catch<TResult = never>(onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined): ThrowsPromise<T | TResult, E>;
    static resolve: {
        (): ThrowsPromise<void, never>;
        <V>(value: V): ThrowsPromise<Awaited<V>, never>;
    };
    static reject<E extends Error>(reason: E): ThrowsPromise<never, E>;
    static all<T extends readonly unknown[] | []>(values: T): ThrowsPromise<{
        -readonly [P in keyof T]: Awaited<T[P]>;
    }, InferErrors<T[number]>>;
    static allSettled<T extends readonly unknown[] | []>(values: T): ThrowsPromise<{
        -readonly [P in keyof T]: SettledResult<T[P]>;
    }, never>;
    static race<T extends readonly (ThrowsPromise<any, any> | any)[]>(values: T): ThrowsPromise<T[number] extends ThrowsPromise<infer U, any> ? U : T[number] extends PromiseLike<infer U> ? U : Awaited<T[number]>, InferErrors<T[number]>>;
    /** type cast (third party promise) to a ThrowsPromise */
    static fromPromise<T, E extends Error>(promise: Promise<T>): ThrowsPromise<T, E>;
    /** type cast that strips the throws type */
    asPromise(): Promise<T>;
}
export {};