import { F } from "../util/Utils.js";
import { Reaction, ReactivityOptions } from "../Options.js";
import { FieldKey, ObjectHandle, ContentFootprint, OperationFootprint, ListeningInfo, AbstractChangeset } from "./Data.js";
import { Transaction } from "./Transaction.js";
import { OptionsImpl } from "./Mvcc.js";
export declare class ReactionImpl implements Reaction<any> {
    readonly ownerHandle: ObjectHandle;
    readonly fieldKey: FieldKey;
    configure(options: Partial<ReactivityOptions>): ReactivityOptions;
    get options(): ReactivityOptions;
    get nonreactive(): any;
    get args(): ReadonlyArray<any>;
    get result(): any;
    get error(): boolean;
    get stamp(): number;
    get isReusable(): boolean;
    markObsolete(): void;
    pullLastResult(args?: any[]): any;
    constructor(h: ObjectHandle, fk: FieldKey);
    reuseOrRelaunch(weak: boolean, args: any[] | undefined): OperationFootprintImpl;
    static manageReaction(method: F<any>): Reaction<any>;
    static configureImpl(self: ReactionImpl | undefined, options: Partial<ReactivityOptions>): ReactivityOptions;
    static proceedWithinGivenLaunch<T>(footprint: OperationFootprintImpl | undefined, func: F<T>, ...args: any[]): T;
    static why(): string;
    static briefWhy(): string;
    static dependencies(): string[];
    private peek;
    private use;
    private edit;
    private acquireFromObjectVersion;
    private relaunch;
    private static markObsolete;
}
declare class OperationFootprintImpl extends ContentFootprint implements OperationFootprint {
    static current?: OperationFootprintImpl;
    static queuedReactions: Array<OperationFootprint>;
    static deferredReactions: Array<OperationFootprintImpl>;
    readonly margin: number;
    readonly transaction: Transaction;
    readonly descriptor: ReactionImpl;
    readonly changeset: AbstractChangeset;
    signals: Map<ContentFootprint, ListeningInfo> | undefined;
    options: OptionsImpl;
    cause: string | undefined;
    args: any[];
    result: any;
    error: any;
    started: number;
    obsoleteDueTo: string | undefined;
    obsoleteSince: number;
    successor: OperationFootprintImpl | undefined;
    constructor(transaction: Transaction, descriptor: ReactionImpl, changeset: AbstractChangeset, former: OperationFootprintImpl | OptionsImpl, clone: boolean);
    get isComputed(): boolean;
    hint(): string;
    get order(): number;
    get ["#this#"](): string;
    clone(t: Transaction, cs: AbstractChangeset): ContentFootprint;
    why(): string;
    briefWhy(): string;
    dependencies(): string[];
    wrap<T>(func: F<T>): F<T>;
    proceed(proxy: any, args: any[] | undefined): void;
    markObsoleteDueTo(footprint: ContentFootprint, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: OperationFootprint[]): void;
    relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
    isNotUpToDate(): boolean;
    reenterOver(head: OperationFootprintImpl): this;
    private static proceed;
    private enter;
    private leaveOrAsync;
    private leave;
    private indicatorEnter;
    private indicatorLeave;
    private addToDeferredReactiveFunctions;
    private static processDeferredReactions;
    private static markUsed;
    private static markEdited;
    private static tryResolveConflict;
    private static propagateAllChangesToListeners;
    private static discardAllListeners;
    private static propagateFieldChangeToListeners;
    private static enqueueReactionsToRun;
    private static migrateContentFootprint;
    private static processQueuedReactions;
    private stopListeningAllSignals;
    private listenTo;
    private static canListenTo;
    private static createOperationDescriptor;
    private static rememberOperationOptions;
    static init(): void;
}
export declare function resolveReturn(value: any): any;
export declare function rejectRethrow(error: any): never;
export {};