import { IDataNode } from '@comyata/run/DataNode';
export interface IComputeStatsBase {
    step: string;
    dur?: number;
    cached?: number;
    stats?: ComputeStats[];
}
export interface NodeComputeStats extends IComputeStatsBase {
    dataNode?: IDataNode['path'];
    stats: (ComputeStats)[];
    cached?: 0 | 1 | 2 | 3;
    engine?: string;
}
export interface NodeRuntimeBaggage<TNode extends IDataNode> {
    nodesChain: Set<TNode | IDataNode>;
    abort?: AbortSignal;
}
export interface NodeRuntimeBaggageComplete<TNode extends IDataNode> extends NodeRuntimeBaggage<TNode> {
    stats: NodeComputeStats;
    getNodeContext: (node: TNode | IDataNode) => NodeContext;
}
export type ComputeFn<TNode extends IDataNode, C = unknown, TBaggage extends NodeRuntimeBaggageComplete<TNode> = NodeRuntimeBaggageComplete<TNode>> = (dataNode: TNode, context: C, parentData: unknown[], runtimeBaggage: TBaggage) => Promise<unknown>;
export type ComputeStats = IComputeStatsBase | NodeComputeStats;
export type NodeContext = [
    setter: (value: unknown) => void,
    getter: () => unknown,
    dataChain: unknown[]
];
type ResultState<TOutput = unknown, TNode extends IDataNode = IDataNode> = {
    output: () => TOutput;
    stats: ComputeStats[];
    getValue: (node: TNode | IDataNode) => unknown;
    compute: () => Promise<TOutput>;
};
export type NodeComputeEngines<TNode extends IDataNode, C = unknown, TBaggage extends NodeRuntimeBaggage<TNode> = NodeRuntimeBaggage<TNode>> = {
    [engine in NonNullable<TNode['engine']>]?: TNode extends {
        engine: engine;
        computed: true;
    } ? ComputeFn<TNode, C, TBaggage & NodeRuntimeBaggageComplete<TNode>> : never;
};
export declare const runtime: <TNode extends IDataNode, D = unknown, C = unknown, TBaggage extends NodeRuntimeBaggage<TNode> = NodeRuntimeBaggage<TNode>>(dataNode: TNode, context: C, computeEngines: NodeComputeEngines<TNode, C, TBaggage>, { onCompute, onComputed, onComputedError, __unsafeAllowCrossResolving, __unsafeDisableResultValidation, }?: {
    onCompute?: ((dataNode: TNode) => void) | undefined;
    onComputed?: ((dataNode: TNode, result: unknown, meta: {
        statsNode: NodeComputeStats;
        statsRun: IComputeStatsBase;
    }) => Promise<void> | void) | undefined;
    onComputedError?: ((dataNode: TNode, error: unknown, meta: {
        statsNode: NodeComputeStats;
        statsRun: IComputeStatsBase;
    }) => void) | undefined;
    /**
     * Allows to resolve other computed nodes from other computed nodes,
     * may lead to promise based deadlocks when cross-accessing computed nodes in the same file
     */
    __unsafeAllowCrossResolving?: boolean | undefined;
    /**
     * Disables the validation that the value is neither Error nor Promise,
     * checked after the computation of a property, based on the resolved value,
     * but before the value is set to the output data.
     */
    __unsafeDisableResultValidation?: boolean | undefined;
}, { nodesChain, ...baggage }?: TBaggage) => ResultState<D, TNode>;
export {};