/*!
 * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
 * Licensed under the MIT License.
 */
/**
 * A deferred creates a promise and the ability to resolve or reject it
 *
 * @deprecated Moved to the `@fluidframework/core-utils` package.
 * @internal
 */
export declare class Deferred<T> {
    private readonly p;
    private res;
    private rej;
    private completed;
    constructor();
    /**
     * Returns whether the underlying promise has been completed
     */
    get isCompleted(): boolean;
    /**
     * Retrieves the underlying promise for the deferred
     *
     * @returns the underlying promise
     */
    get promise(): Promise<T>;
    /**
     * Resolves the promise
     *
     * @param value - the value to resolve the promise with
     */
    resolve(value: T | PromiseLike<T>): void;
    /**
     * Rejects the promise
     *
     * @param value - the value to reject the promise with
     */
    reject(error: any): void;
}
/**
 * A lazy evaluated promise. The execute function is delayed until
 * the promise is used, e.g. await, then, catch ...
 * The execute function is only called once.
 * All calls are then proxied to the promise returned by the execute method.
 *
 * @deprecated Moved to the `@fluidframework/core-utils` package.
 * @internal
 */
export declare class LazyPromise<T> implements Promise<T> {
    private readonly execute;
    get [Symbol.toStringTag](): string;
    private result;
    constructor(execute: () => Promise<T>);
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
    private getPromise;
}
//# sourceMappingURL=promises.d.ts.map