import type { IDisposable } from '../lifecycle/dispose/disposable.js';
export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
export type ProgressCallback<T = any> = (value: T) => void;
export interface IProgressHolder<T, PT> {
    progress(fn: ProgressCallback<PT>): Promise<T> & IProgressHolder<T, PT>;
}
/**
 * a promise can resolve or reject later
 * @public
 */
export declare class DeferredPromise<T, PT = any> {
    #private;
    readonly promise: Promise<T> & IProgressHolder<T, PT>;
    constructor();
    get p(): Promise<T> & IProgressHolder<T, PT>;
    /**
     * notify progress to callbacks
     * @param progress argument
     * @returns
     */
    notify(progress: PT): this;
    /**
     * register a progress callback
     * @param fn progress callback function, will be called when notify is called
     */
    protected progress(fn: ProgressCallback<PT>): IDisposable;
    /**
     * whether the promise is still working (not completed)
     */
    get working(): boolean;
    /**
     * @deprecated use settled
     */
    get completed(): boolean;
    /**
     * whether the promise is settled (resolved or rejected)
     */
    get settled(): boolean;
    get resolved(): boolean;
    get rejected(): boolean;
    /**
     * resolve the promise
     */
    complete(value: T): void;
    /**
     * reject the promise
     */
    error(err: any): void;
    /**
     * reject the deferred with {CancelError}
     */
    cancel(): void;
    get callback(): (error?: null | undefined | Error, data?: T) => void;
    private timer?;
    timeout(ms: number): {
        dispose: () => void;
    };
    /**
     * Convert promise into deferred
     * returns a DeferredPromise, resolve when prev resolve, reject when prev reject
     */
    static wrap(prev: Promise<any>): DeferredPromise<unknown, any>;
}
//# sourceMappingURL=deferred-promise.d.ts.map