Class GraphStore<NodeData, EdgeData>

new GraphStore<NodeData = unknown, EdgeData = unknown>(
    graph?: RawGraph<NodeData, EdgeData>,
): GraphStore<NodeData, EdgeData>

addEdge(edge: RawEdge<EdgeData>): GraphMutationResult

addNode(node: RawNode<NodeData>): GraphMutationResult

applyBatch(
    operations: readonly GraphBatchOperation<NodeData, EdgeData>[],
    options?: GraphBatchOptions,
): GraphBatchMutationResult

clear(): GraphMutationResult

edges(ids?: readonly GraphId[]): GraphEdgeCollection<NodeData, EdgeData>

getBounds(): GraphBounds | null

getEdge(id: GraphId): GraphEdge<EdgeData> | undefined

getEdges(): readonly GraphEdge<EdgeData>[]

getEdgesBetween(
    sourceId: GraphId,
    targetId: GraphId,
    options?: EdgesBetweenOptions,
): readonly GraphEdge<EdgeData>[]

getIncidentEdges(nodeId: GraphId): readonly GraphEdge<EdgeData>[]

getIncomingEdges(nodeId: GraphId): readonly GraphEdge<EdgeData>[]

getNeighbors(
    nodeId: GraphId,
    direction?: NeighborDirection,
): readonly GraphNode<NodeData>[]

getNode(id: GraphId): GraphNode<NodeData> | undefined

getNodes(): readonly GraphNode<NodeData>[]

getOutgoingEdges(nodeId: GraphId): readonly GraphEdge<EdgeData>[]

getVersion(): number

loadGraph(graph: RawGraph<NodeData, EdgeData>): GraphMutationResult

nodes(ids?: readonly GraphId[]): GraphNodeCollection<NodeData, EdgeData>

on<
    TType extends
        | "graph:loaded"
        | "graph:cleared"
        | "node:added"
        | "node:removed"
        | "node:updated"
        | "edge:added"
        | "edge:removed"
        | "edge:updated"
        | "node:position-updated"
        | "node:positions-updated"
        | "graph:batch-applied"
        | "graph:changed",
>(
    type: TType,
    handler: (
        event:
            | Extract<GraphLoadedEvent, { type: TType }>
            | Extract<GraphClearedEvent, { type: TType }>
            | Extract<NodeRemovedEvent, { type: TType }>
            | Extract<EdgeRemovedEvent, { type: TType }>
            | Extract<NodePositionUpdatedEvent, { type: TType }>
            | Extract<NodePositionsUpdatedEvent, { type: TType }>
            | Extract<GraphBatchAppliedEvent, { type: TType }>
            | Extract<GraphChangedEvent, { type: TType }>
            | Extract<NodeAddedEvent<NodeData>, { type: TType }>
            | Extract<NodeUpdatedEvent<NodeData>, { type: TType }>
            | Extract<EdgeAddedEvent<EdgeData>, { type: TType }>
            | Extract<EdgeUpdatedEvent<EdgeData>, { type: TType }>,
    ) => void,
): Unsubscribe

onAny(handler: (event: GraphEvent<NodeData, EdgeData>) => void): Unsubscribe

removeEdge(id: GraphId): GraphMutationResult

removeNode(id: GraphId): GraphMutationResult

selectEdges(
    predicate: (edge: GraphEdge<EdgeData>, index: number) => boolean,
): GraphEdgeCollection<NodeData, EdgeData>

selectNodes(
    predicate: (node: GraphNode<NodeData>, index: number) => boolean,
): GraphNodeCollection<NodeData, EdgeData>

snapshot(): GraphSnapshot<NodeData, EdgeData>

updateEdgeAttributes(
    id: GraphId,
    attributes: GraphAttributes,
    mode?: AttributeUpdateMode,
): GraphMutationResult

updateEdgeData(id: GraphId, data: EdgeData): GraphMutationResult

updateNodeAttributes(
    id: GraphId,
    attributes: GraphAttributes,
    mode?: AttributeUpdateMode,
): GraphMutationResult

updateNodeData(id: GraphId, data: NodeData): GraphMutationResult

updateNodePosition(id: GraphId, position: Point | null): GraphMutationResult

updateNodePositions(updates: readonly NodePositionUpdate[]): GraphMutationResult