import { Graph, Lib, NodysseusNode, NodysseusStore } from "../types.js";
export declare function compareObjectsNeq(value1: any, value2: any): boolean;
type NodeKind = "const" | "map" | "var" | "bind";
type Nothing = {
    __kind: "nothing";
};
export declare const isNothing: (a: any) => a is Nothing;
export declare const isNothingOrUndefined: (a: any) => a is Nothing;
export declare class State<T> {
    private value;
    constructor(value?: T | Nothing);
    write(value: T | Nothing): void;
    read(): Nothing | T;
}
export type WatchNode<T = unknown> = {
    __kind: "watch";
    id: string;
    watch: AsyncIterator<T>;
    graphNode?: NodysseusNode;
};
export declare const isWatchNode: <T>(a: any) => a is AnyNode<T>;
export type AnyNode<T> = Node<NodeKind, T>;
export type UnwrapNode<T> = T extends AnyNode<infer I> ? I : never;
type AnyNodeMap<S extends Record<string, unknown>> = {
    [k in keyof S]: AnyNode<S[k]>;
};
export type Node<K extends NodeKind, T = unknown> = {
    __kind: K;
    id: string;
    value: State<T>;
};
export type ConstNode<T> = Node<"const", T>;
export type VarNode<T> = AnyNode<T> & {
    __kind: "var";
    set: (value: T) => void;
    compare: (a: T, b: T) => boolean;
};
export type MapNode<T, S extends Record<string, unknown>> = Node<"map", T> & {
    fn: State<(s: S) => T>;
    cachedInputs: State<S>;
    isStale: (p: S, n: S) => boolean;
    inputs: Record<string, string>;
    isDirty: State<boolean>;
};
export type BindNode<T, S extends Record<string, unknown>> = T extends AnyNode<unknown> ? Node<"bind", T> & {
    isStale: (p: S, n: S) => boolean;
    fn: (s: S) => T;
    inputs: {
        [k in keyof S]: string;
    };
    cachedInputs: State<S>;
    isDirty: State<boolean>;
} : never;
declare class Scope {
    private nodes;
    constructor();
    add(node: Node<NodeKind>): void;
    get<T>(id: string): AnyNode<T>;
    has(id: string): boolean;
    count(): number;
    findKeys(id: string): string[];
    removeAll(id: string): void;
}
export declare const constNode: <T>(a: T, id?: string) => ConstNode<T>;
export declare const varNode: <T>(set: (value: T) => void, compare?: (a: T, b: T) => boolean, id?: string) => VarNode<T>;
export declare const mapNode: <T, S extends Record<string, unknown>>(inputs: { [k in keyof S]: AnyNode<S[k]>; }, fn: (s: S) => T, isStale: (previous: S, next: S) => boolean, id?: string) => MapNode<T, S>;
export declare const bindNode: <R, T extends AnyNode<R>, S extends Record<string, unknown>>(inputs: { [k in keyof S]: AnyNode<S[k]>; }, fn: (inputs: S) => T | PromiseLike<T>, isStale?: (p: any, n: any) => boolean, id?: string) => BindNode<T, S>;
export declare const handleError: (e: Error, nodeGraphId: string) => void;
type NodeOutputs<T, D, M> = AnyNode<{
    value: AnyNode<T>;
    display: AnyNode<D>;
    metadata: AnyNode<M>;
}> & {
    graphId: string;
    nodeId: string;
};
export type NodeOutputsU = NodeOutputs<unknown, unknown, unknown>;
export declare class NodysseusRuntime {
    private id;
    store: NodysseusStore;
    private event;
    scope: Scope;
    private _outputReturns;
    private watches;
    private outputs;
    private inputs;
    private rerun;
    private lib;
    private eventQueue;
    private running;
    private dirtying;
    constructor(id: any, store: NodysseusStore, lib?: Lib, event?: string);
    refs(): string[] | Promise<string[]>;
    graphExport(graphid: any): any;
    nodeCount(): void;
    createWatch<T>(node: AnyNode<T>): AsyncIterable<T>;
    clearWatch(node: any, watch: any): void;
    private addWatchFn;
    private resetOutputs;
    private checkWatch;
    private checkWatches;
    private dirty;
    constNode<T>(v: T, id?: string, useExisting?: boolean): AnyNode<T>;
    varNode<T>(initial?: T, compare?: (a: T, b: T) => boolean, id?: string, useExisting?: boolean, dirty?: boolean): VarNode<T>;
    mapNode<T, S extends Record<string, unknown>>(inputs: {
        [k in keyof S]: AnyNode<S[k]>;
    }, fn: (s: S) => T, isStale?: (previous: S, next: S) => boolean, id?: string, useExisting?: boolean): AnyNode<T>;
    /**
     * Bind a function that creates a node to inputs. Inspired by monadic bind.
     */
    bindNode<R, T extends AnyNode<R>, S extends Record<string, unknown>>(inputs: {
        [k in keyof S]: AnyNode<S[k]>;
    }, fn: (s: S) => T | PromiseLike<T>, isStale?: (previous: S, next: S) => boolean, id?: string, useExisting?: boolean): AnyNode<T>;
    /**
     * Uses bindNode to create a switch statement based on a key node
     */
    switchNode<T, S extends Record<string, T>>(key: AnyNode<string>, inputs: {
        [k in keyof S]: AnyNode<T>;
    }, id?: string, useExisting?: boolean): AnyNode<T | PromiseLike<T>>;
    accessor<T, S extends Record<string, unknown>>(map: AnyNode<AnyNodeMap<S>> | NodeOutputsU, key: string, id: string, useExisting: boolean, isNodeRun?: boolean): AnyNode<T>;
    private removeKey;
    runNodeNode<T>(node: AnyNode<AnyNode<T>>, nodeGraphId: string, useExisting?: boolean): AnyNode<T>;
    fromNode<T, D, M, S extends Record<string, unknown>>(graph: Graph | string, nodeId: string, closure?: AnyNodeMap<S>): NodeOutputs<T, D, M> | Promise<NodeOutputs<T, D, M>>;
    private calcNode;
    private valueMap;
    private checkEvents;
    private mergeClosure;
    private dereference;
    private fromNodeInternal;
    private runNode;
    runGraphNode<T>(graph: Graph | string, node: string): T | Promise<T>;
    run<T>(node: AnyNode<T> | Promise<AnyNode<T>> | string, _output?: "display" | "value" | "metadata"): T | Promise<T>;
}
export {};