interface Ok<D> {
    data: D;
    errors: never;
}
interface HasErrors<D> {
    data?: D;
    errors: Error[];
}
declare type Result<D> = Ok<D> | HasErrors<D>;
export declare type CoreFn<C extends Core<any>> = (this: Immutable<C> & Context, core: Immutable<C> & Context) => any;
export declare type Immutable<C extends Core<any>> = Omit<C, 'update'>;
export interface Context {
    pure(...passIfChanged: any[]): void;
    report(...errors: Error[]): void;
}
export declare const ErrNoData: (causes?: Error[] | undefined) => import("./error").GraphQLErrorExt<"NoData"> & {
    message: string;
    causes: Error[] | undefined;
};
export declare const ErrEvalStackEmpty: () => import("./error").GraphQLErrorExt<"EvalStackEmpty"> & {
    code: string;
    message: string;
};
export declare const ErrCheckFailed: (causes: Error[]) => import("./error").GraphQLErrorExt<"CheckFailed"> & {
    message: string;
    causes: Error[];
};
export declare class Core<T> {
    constructor(data: T);
    get data(): T;
    get<F extends CoreFn<this>>(fn: F): ReturnType<F>;
    try<F extends CoreFn<this>>(fn: F): ReturnType<F> | undefined;
    getResult<F extends CoreFn<this>>(fn: F): Result<ReturnType<F>>;
    check(...fns: CoreFn<this>[]): this;
    update(update: (data: T) => T): void;
    protected pure(...passIfChanged: any[]): void;
    protected report(...errors: Error[]): void;
    protected get currentCell(): Cell;
    protected get currentTracer(): TraceCallback | undefined;
    protected trace(block: () => any, onEvent: TraceCallback): void;
    private evaluate;
    private getCell;
    private _cells;
    private _stack;
    private _traceStack;
    private _data;
}
export default Core;
export declare const ROLLBACK: Readonly<{
    ROLLBACK: boolean;
}>;
export declare class Cell {
    pure(...changed: any[]): void;
    report(error: Error): void;
    evaluate<C extends Core<any> & Context, F extends CoreFn<C>>(core: C, fn: F): void;
    status: 'empty' | 'run' | 'ready';
    result: Result<any> | undefined;
    private _pendingResult;
    private _guards;
    private _nextGuard;
}
declare type TraceCallback = (event: 'begin' | 'end', fn: CoreFn<any>, result?: Result<any>) => void;
//# sourceMappingURL=core.d.ts.map