import { Unshift } from '@ts-std/types';
import { Result, Maybe } from '@ts-std/monads';
export declare type PromiseTuple<L extends any[]> = {
    [K in keyof L]: Promise<L[K]>;
};
export declare type UnboxPromise<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
export declare type PromiseObject<O extends {
    [key: string]: Promise<any>;
}> = Promise<{
    [K in keyof O]: UnboxPromise<O[K]>;
}>;
export declare type PromiseResultTuple<L extends any[], E> = {
    [K in keyof L]: Promise<Result<L[K], E>>;
};
export declare type PromiseMaybeTuple<L extends any[]> = {
    [K in keyof L]: Promise<Maybe<L[K]>>;
};
declare global {
    interface Promise<T> {
        join<L extends any[]>(...args: PromiseTuple<L>): Promise<Unshift<T, L>>;
        result_join<T, L extends any[], E>(this: Promise<Result<T, E>>, ...args: PromiseResultTuple<L, E>): Promise<Result<Unshift<T, L>, E>>;
        maybe_join<T, L extends any[]>(this: Promise<Maybe<T>>, ...args: PromiseMaybeTuple<L>): Promise<Maybe<Unshift<T, L>>>;
        use_maybe(): Promise<Maybe<T>>;
        use_result(): Promise<Result<T, Error>>;
    }
    interface PromiseConstructor {
        join<L extends any[]>(...args: PromiseTuple<L>): Promise<L>;
        result_join<L extends any[], E>(...args: PromiseResultTuple<L, E>): Promise<Result<L, E>>;
        maybe_join<L extends any[]>(...args: PromiseMaybeTuple<L>): Promise<Maybe<L>>;
        join_object<O extends {
            [key: string]: Promise<any>;
        }>(obj: O): PromiseObject<O>;
        delay<T>(time: number, value: T): Promise<T>;
        delay(time: number): Promise<void>;
    }
}