import { ForceLink, Simulation, SimulationLinkDatum, SimulationNodeDatum } from "d3-force";
import { NodysseusError } from "../nodysseus.js";
import { Graph, Edge, NodysseusNode, EdgeNoAs, NodeMetadata, NodeArg } from "../types.js";
import { Compartment, StateEffectType, StateField } from "@codemirror/state";
import { VarNode } from "src/dependency-tree/dependency-tree.js";
import { EditorView } from "codemirror";
export type Vector2 = {
    x: number;
    y: number;
};
export type Property = "ref" | "value" | "name" | "edge";
export type HyperappState = {
    editingGraphId: string;
    editingGraph: Graph;
    displayGraphId: string | false;
    displayGraph: Graph | false;
    hash: string;
    stopped: boolean;
    noautozoom: boolean;
    url_params: URLSearchParams;
    html_id: string;
    dimensions: Vector2;
    readonly: boolean;
    norun: boolean;
    hide_types: boolean;
    offset: Vector2;
    focused: boolean;
    editing: boolean;
    search: boolean;
    searchResults: Array<string>;
    searchFocused: boolean;
    show_all: boolean;
    show_result: boolean;
    node_el_width: number;
    args_display: boolean;
    selected: Array<string>;
    selected_edges_in: Array<Edge>;
    error: false | NodysseusError;
    levels: false | Levels;
    randid: string;
    inputs: Record<string, string>;
    copied?: {
        graph: Graph;
    };
    simulation?: NodysseusSimulation;
    nodeOffset: Vector2;
    clear_simulation_cache?: boolean;
    info_display_dispatch?: Function;
    result_display_dispatch?: Function;
    result_background_display_dispatch?: Function;
    custom_editor_display_dispatch?: Function;
    code_editor?: EditorView;
    code_editor_nodeid?: StateEffectType<string>;
    code_editor_nodeid_field?: StateField<string>;
    codeEditorExtensions?: Compartment;
    custom_editor_result: {};
    showHelp: boolean;
    refGraphs: Array<string>;
    selectedMetadata?: NodeMetadata;
    cachedMetadata: Record<string, NodeMetadata>;
    initialLayout: boolean;
    selectedNodeArgs?: Array<NodeArg>;
    selectedNodeEdgeLabels?: Array<string>;
    selectedVarNode?: VarNode<{
        graph: string;
        id: string;
    }>;
};
export type Levels = {
    level_by_node: Map<string, number>;
    parents: Map<string, string[]>;
    children: Map<string, string[]>;
    siblings: Map<string, string[]>;
    distance_from_selected: Map<string, number>;
    min: number;
    max: number;
    nodes_by_level: Record<number, string>;
};
export type d3NodeNode = SimulationNodeDatum & {
    node_id: string;
    nested_edge_count: number;
    nested_node_count: number;
    hash?: number;
    sibling_index_normalized?: number;
    calculatedX: number;
    calculatedY: number;
} & NodysseusNode;
export declare const isd3NodeNode: (n: d3Node) => n is d3NodeNode;
export type d3LinkNode = SimulationNodeDatum & {
    id: string;
    edge: Edge;
    desiredX: number;
    desiredY: number;
};
export type d3Node = d3NodeNode | d3LinkNode;
export type d3Link = SimulationLinkDatum<d3NodeNode> & {
    edge: Edge;
};
export type NodysseusSimulation = {
    selectedOffset: Vector2;
    simulation: Simulation<d3Node, d3Link>;
};
export type NodysseusForceLink = ForceLink<d3Node, d3Link>;
type _SharedWorkerMessages = {
    addPort: {
        to: {
            port: MessagePort;
        };
    };
    get: {
        to: {
            graphId: string;
        };
        from: {
            graph: Graph;
        };
    };
    set: {
        to: {
            graph: Graph;
        };
    };
    delete: {
        to: {
            graphId: string;
        };
        from: {};
    };
    clear: {
        to: {};
    };
    keys: {
        to: {};
        from: {
            keys: Array<string>;
        };
    };
    undo: {
        to: {
            graphId: string;
        };
        from: {
            graph: Graph;
        };
    };
    redo: {
        to: {
            graphId: string;
        };
        from: {
            graph: Graph;
        };
    };
    add_node: {
        to: {
            graphId: string;
            node: NodysseusNode;
        };
    };
    remove_node: {
        to: {
            graphId: string;
            node: string;
        };
    };
    add_edge: {
        to: {
            graphId: string;
            edge: Edge;
        };
    };
    remove_edge: {
        to: {
            graphId: string;
            edgeTo: string;
        };
    };
    add_nodes_edges: {
        to: {
            graphId: string;
            addedNodes: Array<NodysseusNode>;
            addedEdges: Array<Edge>;
            removedNodes: Array<NodysseusNode>;
            removedEdges: Array<EdgeNoAs>;
        };
    };
    connect: {
        from: {};
    };
    update: {
        from: {
            graphs: Array<Graph>;
        };
    };
    addFromUrl: {
        to: {
            url: string;
        };
        from: {
            graphs: Array<Graph>;
        };
    };
};
type _SharedWorkerMessageKind = keyof _SharedWorkerMessages;
export type SharedWorkerMessageKind = _SharedWorkerMessageKind;
export type TRespondableSharedWorkerMessage<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessages[T] extends {
    to: any;
    from: any;
} ? TSharedWorkerMessageTo<T> | TSharedWorkerMessageFrom<T> : never : never;
export type RespondableSharedWorkerMessage = TRespondableSharedWorkerMessage<SharedWorkerMessageKind>;
export type RespondableSharedWorkerMessageData = Omit<RespondableSharedWorkerMessage, "messageId">;
type _SharedWorkerMessageId<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessages[T] extends {
    to: any;
    from: any;
} ? {
    messageId: string;
} : {} : never;
type _SharedWorkerMessage<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessages[T] : never;
export type TSharedWorkerMessage<T> = _SharedWorkerMessage<T> & _SharedWorkerMessageId<T>;
export type SharedWorkerMessage = TSharedWorkerMessage<_SharedWorkerMessageKind>;
type _TSharedWorkerMessageTo<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessage<T> extends {
    to: any;
} ? _SharedWorkerMessage<T>["to"] & {
    kind: T;
} : never : never;
export type TSharedWorkerMessageToData<T> = _TSharedWorkerMessageTo<T>;
export type TSharedWorkerMessageTo<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessages[T] extends {
    to: any;
    from: any;
} ? _TSharedWorkerMessageTo<T> & {
    messageId: string;
} : _TSharedWorkerMessageTo<T> : never;
export type SharedWorkerMessageTo = TSharedWorkerMessageTo<_SharedWorkerMessageKind>;
type _TSharedWorkerMessageFrom<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessage<T> extends {
    from: any;
} ? _SharedWorkerMessage<T>["from"] & {
    kind: T;
} : never : never;
export type TSharedWorkerMessageFrom<T> = T extends _SharedWorkerMessageKind ? _SharedWorkerMessages[T] extends {
    to: any;
    from: any;
} ? _TSharedWorkerMessageFrom<T> & {
    messageId: string;
} : _TSharedWorkerMessageFrom<T> : never;
export type SharedWorkerMessageFrom = TSharedWorkerMessageFrom<_SharedWorkerMessageKind>;
export declare const expectSharedWorkerMessageResponse: <T extends keyof _SharedWorkerMessages>(m: SharedWorkerMessageTo | SharedWorkerMessageFrom) => m is TRespondableSharedWorkerMessage<T>;
export {};