/**
 * A proxy to handle awaiting a core promise before executing methods.
 * Supports inheritance and composition.
 *
 * For inheritance, extend AwaitProxy and use `withAwaited` to wrap methods.
 *
 * For composition, create an instance of AwaitProxy and use `apply` to
 * wrap methods of the target instance.
 */
export declare class AwaitProxy<T> {
    private readonly _promise;
    private readonly _bindTo;
    private _awaited;
    constructor(_promise: Promise<T>, _bindTo?: any);
    get awaited(): T;
    /**
     * Wraps all methods of the target instance to await the core promise before executing.
     * Or pass a list of method names to apply to.
     */
    apply: <TTarget extends object>(target: TTarget, onlyNames?: (keyof TTarget)[]) => void;
    /**
     * Extends a method to await the core promise and passes it as the
     * first argument.
     */
    withAwaited<TArgs extends any[], TReturn>(fn: (awaited: T, ...args: TArgs) => TReturn): (...args: TArgs) => Promise<Unpacked<TReturn>>;
    /**
     * Wraps a method to await the core promise but does not change
     * its arguments.
     */
    afterAwaited<TArgs extends any[], TReturn>(fn: (...args: TArgs) => TReturn): (...args: TArgs) => Promise<Unpacked<TReturn>>;
}
type Unpacked<T> = T extends Promise<infer U> ? U : T;
export {};