@visuallyjs/browser-ui 1.0.0

package/types/core/model/graph.d.ts

@@ -0,0 +1,1166 @@
+import { ShortestPathResult } from "./djikstra";
+import { Cluster } from "./cluster";
+import { ObjectAnchorSpec } from "./anchor";
+/**
+ * A function that can return the ID representing the given object data. The default implementation of this returns the value of the object's `id` property.
+ * @group Data Model
+ * @category Type Aliases
+ */
+export type IdFunction = (o: ObjectData) => string;
+/**
+ * A function that can return the type representing the given object data. The default implementation of this returns the value of the object's `type` property.
+ * @group Data Model
+ * @category Type Aliases
+ */
+export type TypeFunction = (o: ObjectData) => string;
+/**
+ * Basic object data definition - a map of objects of any type keyed by strings.
+ * @group Data Model
+ * @category Type Aliases
+ */
+export type ObjectData = Record<string, any>;
+/**
+ * Models an object that has an ID
+ * @group Data Model
+ * @category Type Aliases
+ */
+export interface HasId {
+    /**
+     * ID of the object.
+     */
+    id: string;
+}
+/**
+ * Models an object that has a type
+ * @group Data Model
+ * @category Type Aliases
+ */
+export interface HasType {
+    /**
+     * Type of the object.
+     */
+    type: string;
+}
+/**
+ * Models an object that has an ID and a type.
+ * @group Data Model
+ * @category Type Aliases
+ */
+export interface HasIdAndType extends HasId, HasType {
+}
+/**
+ * Models an object that has an x/y location.
+ * @group Data Model
+ * @category Type Aliases
+ */
+export interface HasXY {
+    x: number;
+    y: number;
+}
+/**
+ * Models an object that has a width and height
+ * @group Data Model
+ * @category Type Aliases
+ */
+export interface HasWidthHeight {
+    width: number;
+    height: number;
+}
+/**
+ * Base interface for the result of some delete operation. All operations can result in the deletion of zero or more edges, and if the deletion was for a vertex then that vertex may have been inside some group.
+ */
+export interface Deletion {
+    /**
+     * Optional, provided if the deleted object was the child of a group.
+     */
+    parentGroup?: Group;
+    /**
+     * List of edges that were deleted. Always present but may be empty.
+     */
+    edges: Array<Edge>;
+}
+/**
+ * The result of a node deletion.
+ */
+export interface NodeDeletion extends Deletion {
+    /**
+     * The node that was deleted.
+     */
+    node: Node;
+}
+/**
+ * The result of a group deletion.
+ * @group Model
+ */
+export interface GroupDeletion extends Deletion {
+    /**
+     * The group that was deleted
+     */
+    group: Group;
+    /**
+     * List of group's child nodes that were also deleted as a result of this group's deletion. This array is always present but may be empty: the group may have been empty, or the user may have instructed the model not to delete its child nodes.
+     */
+    nodes: Array<NodeDeletion>;
+    /**
+     * List of group's child groups that were also deleted as a result of this group's deletion. This array is always present but may be empty: the group may have been empty, or the user may have instructed the model not to delete its child groups.
+     */
+    nestedGroups: Array<GroupDeletion>;
+    /**
+     * List all nodes and groups that were deleted. Always present; may be empty.
+     */
+    children: Array<Node | Group>;
+}
+/**
+ * for the given vertex, resolves the id of the node/group it belongs to - the vertex might be a port, which has
+ * a parent node or group.
+ * @param v
+ * @internal
+ */
+export declare function resolveNodeId(v: Vertex): string;
+/**
+ * For the given vertex, resolves the node/group it pertains to. If the vertex is already a node/group, it is returned. Otherwise, if
+ * it is a port, the parent of the port is returned.
+ * @param v
+ * @group Data Model
+ * @category Utils
+ */
+export declare function resolveNode(v: Vertex): Node | Group;
+/**
+ * For the given vertex, resolve its port id. If it is not a port, null is returned. If it is a port, its id is returned (without the parent vertex's id prefixed to it)
+ * @param v
+ * @internal
+ */
+export declare function resolvePortId(v: Vertex): string;
+/**
+ * Returns whether or not the given object is a Node. This method is a type guard and after using this method to test an object it can subsequently be treated as a Node if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param obj
+ */
+export declare function isNode(obj: any): obj is Node;
+/**
+ * Returns whether or not the given object is a Node and it is inside a Group. This method is a type guard and after using this method to test an object it can subsequently be treated as a Node if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param obj
+ */
+export declare function isNodeInsideAGroup(obj: Base): obj is Node;
+/**
+ * Returns whether or not the given object is a Group. This method is a type guard and after using this method to test an object it can subsequently be treated as a Group if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param obj
+ */
+export declare function isGroup(obj: any): obj is Group;
+/**
+ * Returns whether or not the given object is a Group and is nested inside another group. This method is a type guard and after using this method to test an object it can subsequently be treated as a Group if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param obj
+ */
+export declare function isNestedGroup(obj: Base): obj is Group;
+/**
+ * Returns whether or not the given object is an Edge. This method is a type guard and after using this method to test an object it can subsequently be treated as an Edge if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param obj
+ */
+export declare function isEdge(obj: any): obj is Edge;
+/**
+ * Returns whether or not the given object is a Port. This method is a type guard and after using this method to test an object it can subsequently be treated as a Port if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param obj
+ */
+export declare function isPort(obj: any): obj is Port;
+/**
+ * Returns whether or not the given Vertex is a Node or Group (ie. not a Port). This method is a type guard and after using this method to test an object it can subsequently be treated as a Node if the method returns true.
+ * @group Data Model
+ * @category Utils
+ * @param v
+ */
+export declare function isNodeVertex(v: Vertex): v is Node;
+/**
+ * Returns whether or not the given object is a Vertex. This method is a type guard and after using this method to test an object it can subsequently be treated as a Vertex if the method returns true.
+ * @param o
+ * @group Data Model
+ * @category Utils
+ */
+export declare function isVertex(o: any): o is Vertex;
+/**
+ * @internal
+ */
+export interface InternalAddEdgeOptions {
+    source: Vertex | string;
+    target: Vertex | string;
+    geometry?: any;
+    data?: any;
+    cost?: number;
+    directed?: boolean;
+    transient?: boolean;
+    anchors?: {
+        source?: ObjectAnchorSpec;
+        target?: ObjectAnchorSpec;
+    };
+}
+/**
+ * @internal
+ * @param obj
+ */
+export declare function defaultIdFunction(obj: ObjectData): string;
+/**
+ * @internal
+ */
+export interface GraphOptions {
+    id?: string;
+    defaultDirected?: boolean;
+    defaultCost?: number;
+    defaultIdFunction?: IdFunction;
+    typeFunction?: TypeFunction;
+    enableSubgraphs?: boolean;
+    portSeparator?: string;
+}
+/**
+ * The super-interface of every object type in a Graph.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export interface GraphObject {
+    /**
+     * Gets the object's "full" id. For many objects this is the same as `id`, but a Port's full ID is in the form `vertex.portId`.
+     */
+    getFullId(): string;
+    /**
+     * Object's backing data
+     */
+    data: any;
+    /**
+     * The kind of the object.
+     */
+    objectType: string;
+    /**
+     * Object's ID, unique to some scope. All edges must have a unique ID, but an edge may have the same ID as some vertex. No two nodes and groups may have the same ID. Ports must have a unique ID on the vertex on which they reside.
+     */
+    id: string;
+}
+/**
+ * This is the base interface for objects in a Graph that can act as the terminus for an Edge.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export interface AbstractEdgeTerminus extends GraphObject {
+    /**
+     * Gets edges attached to this terminus where this terminus is the source
+     */
+    getSourceEdges(): Array<Edge>;
+    /**
+     * Gets edges attached to this terminus where this terminus is the target
+     */
+    getTargetEdges(): Array<Edge>;
+    /**
+     * Gets edges attached to this terminus where this terminus is the source or target
+     */
+    getAllEdges(): Array<Edge>;
+}
+/**
+ * Gets all Edges where this Vertex is either the source or the target of the Edge. Note that this does *not* retrieve Edges on any Ports associated with this Vertex - for that, see {@link getAllEdges}.
+ * @param v
+ * @param filter Optional function to test whether a given edge should be included.
+ * @returns List of matching edges.
+ * @group Data Model
+ * @category Utils
+ */
+export declare function getEdges(v: Vertex, filter?: (e: Edge) => boolean): Array<Edge>;
+/**
+ * Retrieves all edges from the given vertex and all of its ports, optionally with a filter.
+ * @param v
+ * @param filter Optional function to test whether a given edge should be included.
+ * @group Data Model
+ * @category Utils
+ */
+export declare function getAllEdges(v: Vertex, filter?: (e: Edge) => boolean): Array<Edge>;
+/**
+ * Gets all Edges where this Vertex is the source. Does not take into account edges connected to ports on the given vertex.
+ * @group Data Model
+ * @category Utils
+ */
+export declare function getSourceEdges(v: Vertex): Array<Edge>;
+/**
+ * Gets all Edges where this Vertex is the target. Does not take into account edges connected to ports on the given vertex.
+ * @group Data Model
+ * @category Utils
+ */
+export declare function getTargetEdges(v: Vertex): Array<Edge>;
+/**
+ * Gets all edges where this vertex, or one of its ports, is the source.
+ * @param v
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function getAllSourceEdges(v: Vertex): Edge[];
+/**
+ * Gets all edges where this vertex, or one of its ports, is the target.
+ * @param v
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function getAllTargetEdges(v: Vertex): Edge[];
+/**
+ * Gets edges connected to descendants of the given group.
+ * @param g Group to retrieve descendant edges for
+ * @param thisGroupOnly If true, the code only retrieves edges connected to vertices that are a direct child of this group. Otherwise, the code descends through all child groups.
+ * @param includePorts If true, the code will retrieve edges connected to the ports of any child vertex that is encountered as well as edges connected to the child vertex itself.
+ * @param filter Optional filter to use to exclude edges
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function getDescendantEdges(g: Group, thisGroupOnly?: boolean, includePorts?: boolean, filter?: (e: Edge) => boolean): Array<Edge>;
+/**
+ * For the given vertex, calculate how deeply it is nested inside groups.  A value of 0 means no nesting.
+ * @param v Vertex to test.
+ * @group Data Model
+ * @category Utils
+ * @graph
+ * @graphQuery
+ */
+export declare function calculateNestedDepth(v: Node | Group): number;
+/**
+ * Gets a list of groups that are ancestors of the given node/group/port. The list of ancestors is ordered in terms of their proximity to the focus, ie. the first entry is the focus vertex's immediate parent.
+ * @param vertex
+ * @group Data Model
+ * @category Utils
+ * @graph
+ * @graphQuery
+ */
+export declare function getAncestors(vertex: Vertex): Array<Group>;
+/**
+ * Returns whether or not `possibleAncestor` is in fact an ancestor of the given focus node/group
+ * @param focus
+ * @param possibleAncestor
+ * @group Data Model
+ * @category Utils
+ * @graph
+ * @graphQuery
+ */
+export declare function isAncestor(focus: Vertex, possibleAncestor: Group): boolean;
+/**
+ * Determine whether the `possibleDescendant` is in fact a descendant of the `ancestor` group
+ * @param possibleDescendant Group to test
+ * @param ancestor Ancestor group
+ * @group Data Model
+ * @category Utils
+ * @graph
+ * @graphQuery
+ */
+export declare function isDescendantGroup(possibleDescendant: Group, ancestor: Group): boolean;
+/**
+ * Gets a list of nodes/groups that are descendants of the given group.
+ * @param vertex
+ * @group Data Model
+ * @category Utils
+ * @group
+ * @graphQuery
+ */
+export declare function getDescendants(vertex: Group): Array<Node | Group>;
+/**
+ * Gets the list of vertices that are the targets of edges connected to this vertex as a source.
+ * @param obj The vertex to get downstream vertices for.
+ * @param vertexOnly If `obj` is a Node or Group, this method will automatically include vertices connected to ports on the node/group. Set this to true to suppress that behaviour.
+ * @graph
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function getDownstreamVertices(obj: Vertex, vertexOnly: boolean): Array<Vertex>;
+/**
+ * Gets the list of vertices that are the sources of edges connected to this vertex as a target.
+ * @param obj The vertex to get upstream vertices for.
+ * @param vertexOnly If `obj` is a Node or Group, this method will automatically include vertices connected to ports on the node/group. Set this to true to suppress that behaviour.
+ * @graph
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function getUpstreamVertices(obj: Vertex, vertexOnly?: boolean): Array<Vertex>;
+/**
+ * Gets the list of vertices that are attached to this vertex via an edge, either upstream or downstream.
+ * @param obj The vertex to get connected vertices for.
+ * @param vertexOnly If `obj` is a Node or Group, this method will automatically include vertices connected to ports on the node/group. Set this to true to suppress that behaviour.
+ * @graph
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function getConnectedVertices(obj: Vertex, vertexOnly?: boolean): Array<Vertex>;
+/**
+ * Returns whether or not the two vertices are connected by an edge.
+ * @graph
+ * @param v1
+ * @param v2
+ * @group Data Model
+ * @category Utils
+ * @graphQuery
+ */
+export declare function areVerticesConnected(v1: Vertex, v2: Vertex): boolean;
+/**
+ * Models a directed/undirected graph, consisting of a set of vertices and edges, which may be directed or undirected. Users of the API do not interact directly with this class; access is mediated via the VisuallyJsModel class.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare class Graph {
+    nodes: Array<Node>;
+    id: string;
+    edges: Array<Edge>;
+    groups: Array<Group>;
+    _nodeMap: Map<string, Node>;
+    _edgeMap: Map<string, Edge>;
+    _groupMap: Map<string, Group>;
+    defaultDirected: boolean;
+    defaultCost: number;
+    _defaultIdFunction: IdFunction;
+    typeFunction: TypeFunction;
+    enableSubgraphs: boolean;
+    portSeparator: string;
+    _topLevelCache: Record<string, Vertex>;
+    private _removeFromTopLevelCache;
+    private _addToTopLevelCache;
+    private _clearTopLevelCache;
+    constructor(params: GraphOptions);
+    getIdFunction(): IdFunction;
+    setIdFunction(f: IdFunction): void;
+    setTypeFunction(f: TypeFunction): void;
+    /**
+     * Gets the type for some data, by running it through the current typeFunction.
+     * @param data Object to get type from.
+     * @returns The calculated type for the given object.
+     * @internal
+     */
+    getType(data: ObjectData): string;
+    getId(data?: ObjectData, idFunction?: IdFunction): string;
+    getTopLevelElements(): Record<string, Vertex>;
+    /**
+     * Sets whether or not Nodes are Graphs themselves, and can have child Nodes. If you enable this then you cannot use slashes (/) in your Node ids, as they will be treated as components of a path to a Node in a nested Graph.
+     * @param enable True to enable, false to disable.
+     * @internal
+     */
+    setEnableSubgraphs(enable: boolean): void;
+    /**
+     * Sets the character(s) used to separate ports from nodes in port ids. By default this is '.', ie a port is addressed as `nodeId.portId`. This may need to be changed depending on the data in your model.
+     * @param separator Separator to use.
+     * @internal
+     */
+    setPortSeparator(separator: string): void;
+    /**
+     * Gets the current port separator.
+     * @returns Port separator string. Default is "."
+     * @internal
+     */
+    getPortSeparator(): string;
+    /**
+     * Splits the given port id using the current portSeparator.
+     * @param portId Port ID to split.
+     * @returns An array of [ vertexId, portId], or [] if the portId was null.
+     * @internal
+     */
+    splitPortId(portId: string): Array<string>;
+    /**
+     * Looks up a vertex identified by the port id, which is in full port id (vertexId.portId) format, returning null if nothing found.
+     * (Note that we show full port id format as vertexId.portId, but the '.' is just the default portSeparator; it is possible to change that
+     * to some other character)
+     * @param portId ID of the port to find a vertex for.
+     * @internal
+     */
+    getVertexByPortId(portId: string): Vertex;
+    getVertex(e: string | Base, createPortsIfMissing?: boolean): Vertex;
+    clear(): void;
+    /**
+     * Gets all the nodes in the Graph.
+     * @internal
+     */
+    getVertices(): Array<Node>;
+    /**
+     * Gets the count of nodes in the Graph.
+     * @internal
+     */
+    getVertexCount(): number;
+    /**
+     * Returns the vertex at the given index (used for bulk init type purposes)
+     * @param index Index of the Node to retrieve
+     * @returns vertex at the given index.
+     * @internal
+     */
+    getVertexAt(index: number): Node;
+    /**
+     * Returns the total number of Edges in the graph.
+     * @returns The total number of Edges.
+     * @internal
+     */
+    getEdgeCount(): number;
+    /**
+     * Adds an edge to the graph.
+     * @param id ID for the edge.
+     * @param params Source, target, cost, directional etc
+     * @param idFunction
+     * @internal
+     */
+    addEdge(params: InternalAddEdgeOptions, id?: string, idFunction?: IdFunction): Edge;
+    addNode(data?: ObjectData, idFunction?: IdFunction): Node;
+    /**
+     * Adds a list of Nodes to the Graph
+     * @param data List of data objects, one for each Node to be added.
+     * @param idFunction Optional function to use to retrieve ID from backing data. Defaults to retrieving `id` from data object.
+     * @internal
+     */
+    addNodes(data: Array<ObjectData>, idFunction?: IdFunction): void;
+    /**
+     * Adds a Group to the Graph.
+     * @param data
+     * @param idFunction
+     * @internal
+     */
+    addGroup(data: ObjectData, idFunction?: IdFunction): Group;
+    getGroupCount(): number;
+    /**
+     * Returns the Group at the given index.
+     * @param idx Index into group list
+     * @returns a Group, or null if not found.
+     * @internal
+     */
+    getGroupAt(idx: number): Group;
+    /**
+     * Gets the Groups in the graph.
+     * @returns All the groups in the Graph.
+     * @internal
+     */
+    getGroups(): Array<Group>;
+    $addMemberToGroup(v: Node, g: string | Group): void;
+    $addMembersToGroup(v: Array<Node>, g: Group): void;
+    $removeMemberFromGroup(v: string | Node): void;
+    $removeMembersFromGroup(v: Array<Node>): void;
+    getGroup(group: string | Group): Group;
+    /**
+     * Deletes a Group
+     * @param g Either a Group, or a Group id.
+     * @param removeMembers If true, also remove all the Nodes/Groups that are members of the Group.
+     * @internal
+     */
+    deleteGroup(g: string | Group, removeMembers?: boolean): GroupDeletion;
+    /**
+     * @internal
+     * @param port
+     */
+    deletePort(port: Port): Array<Edge>;
+    private $_removeNodeFromCache;
+    /**
+     * Deletes a Node
+     * @param vertex a Node
+     * @internal
+     */
+    deleteNode(vertex: Node): NodeDeletion;
+    /**
+     * Deletes an Edge.
+     * @param edge Edge, or ID of Edge, to delete.
+     * @internal
+     */
+    deleteEdge(edge: string | Edge): void;
+    /**
+     * Gets an Edge by id, or if the given object is already an Edge, hands that back.
+     * @param e ID of the Edge to retrieve, or an actual Edge, or some data from which an ID could be derived.
+     * @returns The requested Edge, if found, otherwise null.
+     * @internal
+     */
+    getEdge(e: string | Edge | any): Edge;
+    /**
+     * For some given node, get a subset of edges that match the given filter function.
+     * @param params Method parameters
+     * @param params.source If true, only match edges for which this node is the source.
+     * @param params.target If true, only match edges for which this node is the target.
+     * @param params.filter Optional edge filter.
+     * @internal
+     */
+    getEdges(params?: {
+        node?: Vertex | string;
+        source?: boolean;
+        target?: boolean;
+        filter?: (e: Edge) => boolean;
+    }): Array<Edge>;
+    /**
+     * Gets every edge in the Graph.
+     * @internal
+     */
+    getAllEdges(): Array<Edge>;
+    /**
+     * @internal
+     * @param port
+     * @param newId
+     */
+    renamePort(port: Port, newId: string): boolean;
+    /**
+     * Finds the shortest path from source to target, using the Djikstra algorithm.
+     * @param source Source Node or Node ID.
+     * @param target Target Node or Node ID.
+     * @param strict Defaults to true. Sets whether or not paths are searched strictly by the given source/target. If, for instance, you supply a node as the source, but there are only edges connected to ports on that node, by default these edges will be ignored. Switching `strict` to false will mean these edges are considered.
+     * @param nodeFilter Optional function that is given each Node's backing data and asked to return true or false - true means include the Node, false means exclude it.
+     * @param edgeFilter Optional function that is given each Edge's backing data and asked to return true or false - true means include the Edge, false means exclude it.
+     * @returns A ShortestPathResult object.
+     * @internal
+     * @graphQuery
+     */
+    findPath(source: string | Vertex, target: string | Vertex, strict?: boolean, nodeFilter?: Function, edgeFilter?: Function): ShortestPathResult;
+    /**
+     * Finds the distance between source and target.
+     * @param source Source vertex or vertex ID.
+     * @param target Target vertex or vertex ID.
+     * @param strict Defauls to true. Sets whether or not paths are searched strictly by the given source/target. If, for instance, you supply a node as the source, but there are only edges connected to ports on that node, by default these edges will be ignored. Switching `strict` to false will mean these edges are considered.
+     * @returns Distance from the source to the target.
+     * @internal
+     * @graphQuery
+     */
+    getDistance(source: Vertex, target: Vertex, strict?: boolean): number;
+    /**
+     * Sets the target Group/Node/Port for some Edge.
+     * @param edge The Edge to change the target for
+     * @param o group/Node/Port/id for new Edge target
+     * @internal
+     */
+    setTarget(edge: Edge, o: string | Vertex): {
+        old?: Vertex;
+        edge?: Edge;
+        new?: Vertex;
+        success: boolean;
+    };
+    /**
+     * Sets the source Group/Node/Port for some Edge.
+     * @param edge The Edge to change the source for
+     * @param o Group/Node/Port or id for new Edge source
+     * @internal
+     */
+    setSource(edge: Edge, o: string | Vertex): {
+        old?: Vertex;
+        edge?: Edge;
+        new?: Vertex;
+        success: boolean;
+    };
+    /**
+     * Returns the path from source to target as a string.
+     * @returns Printed path. Mostly useful for debugging.
+     * @internal
+     */
+    printPath(source: string | Vertex, target: string | Vertex): string;
+    /**
+     * Returns the `diameter` of the Graph.
+     * @param dontUseMax Whether or not to return Infinity if there is at least one pair of nodes for which there is no available path. Defaults to false.
+     * @returns Diameter of the Graph.
+     * @internal
+     * @graphQuery
+     */
+    getDiameter(dontUseMax?: boolean): number;
+    /**
+     * @internal
+     * @param node
+     * @graphQuery
+     */
+    getCentrality(node: Vertex | string): number;
+    /**
+     * Returns the indegree centrality of the given vertex (number of connections entering the vertex)
+     * @param vertex Vertex, or Vertex ID, to retrieve indegree centrality for.
+     * @returns Vertex's indegree centrality.
+     * @internal
+     * @graphQuery
+     */
+    getIndegreeCentrality(vertex: Vertex | string): number;
+    /**
+     * Returns the outdegree centrality of the given vertex (number of connections exiting the vertex)
+     * @param vertex Vertex, or Vertex ID, to retrieve outdegree centrality for.
+     * @returns Vertex's indegree centrality.
+     * @internal
+     * @graphQuery
+     */
+    getOutdegreeCentrality(vertex: Vertex | string): number;
+    /**
+     * Returns the Closeness centrality of the given vertex. This is the inverse of the vertex's farness.
+     * @param vertex Vertex, or Vertex ID, to retrieve closeness for.
+     * @returns Node's "closeness".
+     * @see getFarness
+     * @internal
+     * @graphQuery
+     */
+    getCloseness(vertex: Vertex | string): number;
+    /**
+     * Returns the farness centrality of the given node, ie. the sum of its distance from all other nodes, where the distance from one vertex to another is given by the associated cost of the Edge joining the two nodes.
+     * @param vertex Vertex, or Vertex ID, to retrieve farness for.
+     * @returns Vertex's "farness".
+     * @internal
+     * @graphQuery
+     */
+    getFarness(vertex: Vertex | string): number;
+    /**
+     * Returns the betweenness centrality of the given node.
+     * @param vertex Vertex, or Vertex ID, to retrieve betweenness centrality for.
+     * @returns Vertex's "betweenness" centrality.
+     * @internal
+     * @graphQuery
+     */
+    getBetweenness(vertex: Vertex | string): number;
+    inspect(): string;
+    /**
+     * Serialize the graph.
+     * @internal
+     */
+    serialize(): any;
+    /**
+     * Calculates "clusters" of nodes (and groups), where a 'cluster' is a set of Nodes/Groups that are connected. Direction of connections is not taken into account. Nodes that are children of Groups are included in all cluster calculations, which might cause some weird situations, but this functionality is mostly intended just for Nodes anyway.
+     * @returns An array of Clusters
+     * @internal
+     * @graphQuery
+     */
+    getClusters(): Array<Cluster>;
+    /**
+     * Get the cluster containing the given vertex.
+     * @param seed
+     * @graphQuery
+     */
+    getCluster(seed: Vertex): Cluster;
+    private _getClusters;
+}
+/**
+ * Base class for model objects.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare abstract class Base {
+    protected graph: Graph;
+    data: ObjectData;
+    atts: Map<string, string>;
+    /**
+     * Object's type.
+     */
+    type: string;
+    abstract objectType: string;
+    abstract getFullId(): string;
+    protected constructor(graph: Graph, data?: ObjectData);
+    setAttribute(key: string, value: string): void;
+    getAttribute(key: string): string;
+    getType(): string;
+    /**
+     * @internal
+     * @param t
+     */
+    setType(t: string): void;
+}
+/**
+ * Base vertex class, extended by Port and Node (which is itself extended by Group). A vertex models some entity in your app, and may have one or more edges to other vertices.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare abstract class Vertex extends Base implements AbstractEdgeTerminus, HasId {
+    graph: Graph;
+    /**
+     * The vertex's id. Must be a string.
+     */
+    id: string;
+    /**
+     * Transient vertices are created at various points in the lifecycle of a renderer, such as dragging new edges, and are not exported in the dataset
+     * @internal
+     */
+    transient?: boolean;
+    /**
+     * Transient vertices may have a renderer associated with them.
+     * @internal
+     */
+    transientRenderer?: string;
+    /**
+     * Marks an internal dummy vertex, which is associated with a single edge and which will be removed from the dataset if the associated edge is removed.
+     * @internal
+     */
+    dummy?: boolean;
+    /**
+     * @internal
+     */
+    edges: Array<Edge>;
+    protected indegreeCentrality: number;
+    protected outdegreeCentrality: number;
+    nestedGraphs: Array<Graph>;
+    graphs: Array<Graph>;
+    protected constructor(graph: Graph, data?: ObjectData, idFunction?: IdFunction);
+    /**
+     * Returns the indegree centrality of this vertex.
+     *
+     */
+    getIndegreeCentrality(): number;
+    /**
+     * Returns the outdegree centrality of this vertex.
+     *
+     */
+    getOutdegreeCentrality(): number;
+    /**
+     * Adds a sub-graph to this vertex. If you provide an existing Graph instance that does not have
+     * an id, one will be assigned.
+     * @param g Either a Graph instance, or the id you wish to assign to a new Graph.
+     * @returns The Graph that was added.
+     * @internal
+     */
+    addGraph(g: string | Graph): Graph;
+    /**
+     * Retrieves a sub-graph by id.
+     * @returns Sub-graph with the given id, null if not found.
+     * @internal
+     */
+    getGraph(id: string): Graph;
+    /**
+     * Gets the Vertex's id, which, for Nodes and Groups, is just the `id` property. This method is overridden by Ports.
+     * @returns Vertex id
+     */
+    getFullId(): string;
+    /**
+     * Gets all edges where this vertex is either the source or the target of the edge.
+     * Note that this does *not* retrieve edges on any ports associated with this Vertex - for that, @see #getAllEdges.
+     * @param params.filter Optional function to test whether a given edge should be included.
+     * @returns List of matching edges.
+     */
+    getEdges(params?: {
+        filter: (e: Edge) => boolean;
+    }): Array<Edge>;
+    /**
+     * Gets all edges where this vertex - or any of its ports - are the source of target of the edge.
+     * @param filter
+     */
+    abstract getAllEdges(filter?: (e: Edge) => boolean): Array<Edge>;
+    /**
+     * Gets all Edges where this Vertex is the source.
+     */
+    getSourceEdges(): Array<Edge>;
+    /**
+     * Gets all Edges where this Vertex is the target.
+     */
+    getTargetEdges(): Array<Edge>;
+    /**
+     * Adds an Edge to the vertex.
+     * @param edge The Edge to add.
+     * @internal
+     */
+    $addEdge(edge: Edge): void;
+    /**
+     * Deletes an Edge from the Vertex.
+     * @param edge The Edge to delete.
+     * @internal
+     */
+    $deleteEdge(edge: Edge): boolean;
+    /**
+     * Returns a string representation of the Vertex.
+          * @returns Vertex dumped to a string.
+     */
+    inspect(): string;
+    isChildOf(v: Vertex | Graph | Edge): boolean;
+}
+/**
+ * A Node is a Vertex that does not contain other nodes/groups.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare class Node extends Vertex {
+    static objectType: string;
+    objectType: string;
+    /**
+     * Array of ports on the node, if any. This property should never be written by user code.
+     * @internal
+     */
+    ports: Array<Port>;
+    /**
+     * Group the node is a member of, if any.  This property should never be written by your code.
+     *
+     */
+    group: Group;
+    /**
+     * @internal
+     */
+    portMap: Record<string, Port>;
+    private defaultInternalCost;
+    private internalEdges;
+    constructor(graph: Graph, data?: any, idFunction?: IdFunction);
+    /**
+     * Gets all of the edges connected to this node, both on the node itself and on all of its ports.
+     * @param filter Optional Edge filter.
+     *
+     */
+    getAllEdges(filter?: (e: Edge) => boolean): Array<Edge>;
+    /**
+     * Gets all of the Edges connected to this Node, both on the Node itself and on all of its Ports, where this node/port is the source of edge
+     *
+     */
+    getAllSourceEdges(): Edge[];
+    /**
+     * Gets all of the Edges connected to this Node, both on the Node itself and on all of its Ports, where this node/port is the target of edge
+     *
+     */
+    getAllTargetEdges(): Edge[];
+    /**
+     * Gets all Edges directly connected to this Vertex, ie. not to one of the Ports on the Vertex. This is an alias for `getEdges`.
+     * @param filter Optional Edge filter.
+     *
+     */
+    getDirectEdges(filter?: (e: Edge) => boolean): Edge[];
+    /**
+     * Gets all Edges directly connected to this Vertex, ie. not to one of the Ports on the Vertex, where this Vertex is the source.
+     * This is an alias for `getSourceEdges`.
+     *
+     */
+    getDirectSourceEdges(): Edge[];
+    /**
+     * Gets all Edges directly connected to this Vertex, ie. not to one of the Ports on the Vertex, where this Vertex is the target.
+     * This is an alias for `getTargetEdges`.
+     *
+     */
+    getDirectTargetEdges(): Edge[];
+    /**
+     * Gets all Edges that are connected to Ports on this Node, not directly to the Node itself.
+     * @param filter Optional edge filter
+     *
+     */
+    getPortEdges(filter?: (e: Edge) => boolean): Array<Edge>;
+    /**
+     * Gets all Edges that are connected to Ports on this Node, not directly to the Node itself, where the Port on this Node is the source of the edge.
+     *
+     */
+    getPortSourceEdges(): Array<Edge>;
+    /**
+     * Gets all Edges that are connected to Ports on this Node, not directly to the Node itself, where the Port on this Node is the target of the edge.
+     */
+    getPortTargetEdges(): Array<Edge>;
+    /**
+     * Gets this Node's "indegree" centrality; a measure of how many other Nodes are connected to this Node as the target of some Edge.
+     */
+    getIndegreeCentrality(): number;
+    /**
+     * Gets this Node's "outdegree" centrality; a measure of how many other Nodes this Node is connected to as the source of some Edge.
+     */
+    getOutdegreeCentrality(): number;
+    /**
+     * Gets all Ports associated with this Node.
+     */
+    getPorts(): Array<Port>;
+    /**
+     * Adds a Port to the Node.
+     * @param data Optional data backing the Port. This object can be of any type you like.
+     * @param idFunction Optional function that can take a Port's data and return its ID. By default this looks for an `id` member in the backing data.
+     * @internal
+     */
+    $addPort(data: any, idFunction?: IdFunction): Port;
+    /**
+     * Sets the underlying data for the Port with the given id.  If the Port does not yet exist, it is created.
+     * @param id Id of the Port for which to set data.
+     * @param data Data to set for the Port.
+     * @internal
+     */
+    $setPort(id: string, data?: any): Port;
+    /**
+     * Gets the Port with the given id, null if nothing found.
+     * @param portId Port id.
+     *
+     */
+    getPort(portId: string): Port;
+    /**
+     * Change the ID of some port
+     * @param port
+     * @param newId
+     * @internal
+     */
+    $renamePort(port: Port, newId: string): boolean;
+    /**
+     * Removes the given Port.
+     * @param port Either a Port, or a port id.
+     * @internal
+     */
+    $removePort(port: string | Port): boolean;
+    /**
+     * Sets the default cost of travelling from one Port to another inside some Node. When a Node is created, this value is set to 1.
+     * @param cost Default internal cost.
+     * @internal
+     */
+    $setDefaultInternalCost(cost: number): void;
+    /**
+     * Gets an "internal" Edge from one Port to another.
+     * @param source Source Port.
+     * @param target Target Port.
+     * @internal
+     */
+    getInternalEdge(source: string | Port, target: string | Port): any;
+    /**
+     * Sets the cost and directedness of some internal Edge.
+     * @param source Source Port.
+     * @param target Target Port.
+     * @param cost Cost to set. If you leave this as null, the default will be used.
+     * @param directed Whether or not the internal Edge is directed.
+     * @internal
+     */
+    $setInternalEdge(source: string | Port, target: string | Port, cost?: number, directed?: boolean): Edge;
+}
+/**
+ * A Port models a logical connection point on some vertex. Examples are things like columns on a database table, or yes/no outputs in a flowchart question, or, from the real world, TCP ports on a server
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare class Port extends Vertex {
+    parent: Node;
+    static objectType: string;
+    objectType: string;
+    constructor(parent: Node, data?: any, idFunction?: IdFunction);
+    /**
+     * Gets the vertex this Port belongs to. Remember that Group extends Node, so this could be a Group, but Ports cannot have child Ports.
+     */
+    getParent(): Node;
+    /**
+     * Overrides the `getFullId` of Node to return a value in dotted notation of the form `nodeId.portId`.
+     */
+    getFullId(): string;
+    /**
+     * Returns whether or not this port is a child of the given object.
+     * @param v Object to test if this is a child.
+     */
+    isChildOf(v: Vertex | Graph | Edge): boolean;
+    /**
+     * gets all the edges connected to this port, as source or target.
+     * @param filter
+     */
+    getAllEdges(filter?: (e: Edge) => boolean): Array<Edge>;
+}
+/**
+ * A group is an extension of node that can contain other nodes and groups.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare class Group extends Node {
+    static objectType: string;
+    objectType: string;
+    /**
+     * Members of the group. Do not write to, or manipulate in any way, this array.
+     *
+     */
+    members: Array<Node>;
+    /**
+     * @internal
+     */
+    _memberMap: Record<string, Node>;
+    constructor(graph: Graph, data?: any, idFunction?: IdFunction);
+    /**
+     * @internal
+     * @param v
+     */
+    $addMember(v: Node): boolean;
+    /**
+     * Gets how many members the group has.
+     * @graphQuery
+     */
+    getMemberCount(): number;
+    /**
+     * Gets the group members
+     * @graphQuery
+     */
+    getMembers(): Node[];
+    /**
+     * @internal
+     * @param v
+     */
+    $removeMember(v: string | Node): boolean;
+    /**
+     * Gets all the edges connecting to this group and any ports on the group.
+     * @param filter Optional edge filter.
+     * @graphQuery
+     */
+    getAllDirectEdges(filter?: (e: Edge) => boolean): Array<Edge>;
+    /**
+     * Gets all the edges to/from the group, any ports the Group has, and any edges connected to all child vertices of the group.
+     * @param filter Optional edge filter to apply to all members and the group itself.
+     * @graphQuery
+     */
+    getInternalEdges(filter?: (e: Edge) => boolean): Array<Edge>;
+}
+export interface EdgeOptions {
+    graph: Graph;
+    data?: any;
+    source: Vertex;
+    target: Vertex;
+    cost?: number;
+    directed?: boolean;
+    id?: string;
+    geometry?: any;
+    transient?: boolean;
+    anchors?: {
+        source?: ObjectAnchorSpec;
+        target?: ObjectAnchorSpec;
+    };
+}
+/**
+ * An edge connects two vertices.
+ * @group Data Model
+ * @category Graph Objects
+ */
+export declare class Edge extends Base {
+    static objectType: string;
+    objectType: string;
+    /**
+     * Source of the Edge.
+     */
+    source: Vertex;
+    /**
+     * Target of the Edge.
+     */
+    target: Vertex;
+    /**
+     * Edge cost
+     */
+    cost: number;
+    directed: boolean;
+    id: string;
+    geometry: any;
+    transient: boolean;
+    anchors?: {
+        source?: ObjectAnchorSpec;
+        target?: ObjectAnchorSpec;
+    };
+    constructor(params: EdgeOptions);
+    /**
+     * Gets the cost for this edge. Defaults to 1.
+     * @returns Edge cost.
+     */
+    getCost(): number;
+    /**
+     * Sets the cost for this edge.
+     * @param c Edge cost.
+     * @internal
+     */
+    setCost(c: number): void;
+    /**
+     * Gets the id for this Edge.
+     * @returns Edge id.
+     */
+    getId(): string;
+    /**
+     * Alias for the getId method.
+     */
+    getFullId(): string;
+    /**
+     * @internal
+     * @param id
+     */
+    setId(id: string): void;
+    /**
+     * Gets whether or not the Edge is directed.
+     * @returns True if the Edge is directed (unidirectional), false otherwise.
+     */
+    isDirected(): boolean;
+    /**
+     * Sets whether or not the Edge is directed.
+     * @internal
+     */
+    setDirected(directed: boolean): void;
+    /**
+     * Returns a string representation of the Edge.
+     * @returns Edge dumped to a string.
+     * @internal
+     */
+    inspect(): string;
+}