import { Event } from 'nanoevent';
import * as t from '../types/index.js';
import { SchemaSpec } from '../types/index.js';
export declare const SYM_DEFERRED: unique symbol;
export declare const SYM_PENDING: unique symbol;
export declare const SYM_SKIPPED: unique symbol;
/**
 * GraphEvalContext provides runtime tools for graph computation,
 * node caching, introspection, etc.
 */
export declare class GraphEvalContext implements t.GraphEvalContext {
    readonly parent: GraphEvalContext | null;
    readonly lib: t.RuntimeLib;
    nodeEvaluated: Event<t.NodeResult>;
    scopeCaptured: Event<t.ScopeData>;
    pendingNodeUids: Set<string>;
    cache: Map<string, any>;
    locals: Map<string, any>;
    private scopeData;
    constructor(parent?: GraphEvalContext | null);
    clear(): void;
    finalize(): Promise<void>;
    get depth(): number;
    getLocal<T>(key: string, defaultValue?: T): T | undefined;
    setLocal(key: string, value: unknown): void;
    newScope(): t.GraphEvalContext;
    getScopeData(): any;
    setScopeData(data: any): this;
    convertType(value: unknown, schema: SchemaSpec): unknown;
    get(object: unknown, keyish: string): unknown;
    set(object: unknown, keyish: string, value: unknown): void;
    toArray(value: unknown): unknown[];
    convertAuto(value: string, targetSchema?: SchemaSpec): unknown;
    checkPendingNode(nodeUid: string): void;
    skipEvaluation(message?: string, token?: string, status?: number): void;
    isControlException(error: any): boolean;
    deferred(fn: () => unknown): Deferred;
    isDeferred(value: unknown): value is t.Deferred;
    resolveDeferred(value: unknown): unknown;
    /**
     * @deprecated kept for backwards compatibility
     */
    span(): void;
}
export declare class NodePendingError extends Error {
    name: string;
    code: string;
    get [SYM_PENDING](): boolean;
}
export declare class EvaluationSkippedError extends Error {
    code: string;
    status: number;
    token: string;
    constructor(message: string, token?: string, status?: number);
    get [SYM_SKIPPED](): boolean;
}
export declare class Deferred implements t.Deferred {
    resolve: () => unknown;
    constructor(resolve: () => unknown);
    get [SYM_DEFERRED](): boolean;
}