import { IAutorunOptions, IReactionOptions } from 'mobx';
import { CancelToken } from 'axios';
import { Payload } from './payload';
export declare type Autorun<T> = (props: ReactOpts) => Promise<T> | Payload<T> | undefined;
export declare type Reaction<T, E> = (expression: E, props: ReactOpts) => Promise<T> | Payload<T> | undefined;
export interface ReactOpts {
    refreshToken: number;
    cancelToken: CancelToken;
}
export declare type MobxPromiseOpts<T, E = {}> = MobxPromiseAutorunOpts<T> | MobxPromiseReactionOpts<T, E>;
export interface MobxPromiseAutorunOpts<T> {
    autorun: Autorun<T>;
    keep?: boolean;
    options?: IAutorunOptions;
}
export interface MobxPromiseReactionOpts<T, E> {
    expression: () => E;
    effect: Reaction<T, E>;
    keep?: boolean;
    options?: IReactionOptions;
}
export declare function spyForPayloads<T>(cb: () => T): T;
/**
 * Dummy function to avoid TypeScript complaining on unused
 * expressions
 */
export declare function reference<T>(x: T): T;
export declare class MobxPromiseBuilder<O, E, Opts> {
    _view: Autorun<O>;
    _exp: () => E;
    _eff: Reaction<any, any>;
    _opts: Opts;
    autorun<T>(view: Autorun<T>): MobxPromiseBuilder<T, E, IAutorunOptions>;
    expression<T>(exp: () => T): MobxPromiseBuilder<O, T, IReactionOptions>;
    effect<T>(eff: Reaction<T, E>): MobxPromiseBuilder<T, E, IReactionOptions>;
    options(o: Opts): this;
    build(): MobxPromise<O>;
}
export declare function mobxPromise(): MobxPromiseBuilder<{}, {}, {}>;
export declare class MobxPromise<T> {
    private mainAtom;
    private spyAtom;
    private _payload;
    private opts;
    private cancel;
    private activeReaction?;
    private scheduledUpdate;
    private observed;
    private reloadToken;
    readonly payload: Payload<T>;
    readonly loading: boolean;
    reload(): void;
    constructor(opts: MobxPromiseOpts<T>);
    private becomeObserved;
    private tick;
    private update;
    private becomeUnobserved;
    private dispose;
}
//# sourceMappingURL=promise.d.ts.map