@visuallyjs/browser-ui 1.0.0

package/types/core/toolkit.d.ts

@@ -0,0 +1,1314 @@
+import { Graph, IdFunction, TypeFunction, ObjectData, Base, Node, Port, Group, Vertex, Edge } from "./model/graph";
+import { AutoSaveOptions, AutoSaver } from "./autosaver";
+import { Cluster } from "./model/cluster";
+import { Path, PathOptions } from "./model/path";
+import { VisuallyJsSelection } from "./selection";
+import { VisuallyJsRenderer } from "./renderer";
+import { ObjectInfo, WriteableDatasource } from "./datasource";
+import { EVENT_DATA_APPEND_END, EVENT_DATA_APPEND_START, EVENT_DATA_LOAD_END, EVENT_DATA_LOAD_START, EVENT_DESELECT, EVENT_EDGE_ADDED, EVENT_EDGE_REMOVED, EVENT_EDGE_SOURCE_CHANGED, EVENT_EDGE_TARGET_CHANGED, EVENT_EDGE_TYPE_CHANGED, EVENT_EDGE_UPDATED, EVENT_GRAPH_CLEAR_START, EVENT_GRAPH_CLEARED, EVENT_GROUP_TYPE_CHANGED, EVENT_GROUP_UPDATED, EVENT_NODE_ADDED, EVENT_NODE_REMOVED, EVENT_NODE_TYPE_CHANGED, EVENT_NODE_UPDATED, EVENT_PORT_ADDED, EVENT_PORT_REMOVED, EVENT_PORT_TYPE_CHANGED, EVENT_PORT_UPDATED, EVENT_RENDERER_ADDED, EVENT_SELECT, EVENT_SELECTION_CLEARED, EVENT_UNDOREDO_UPDATE, EVENT_EDGE_PATH_EDITED, EVENT_DATA_UPDATED, EVENT_INTERNAL_GROUP_SIZE_CHANGED_UNDO, EVENT_INTERNAL_GROUP_SIZE_CHANGED_REDO, EVENT_INTERNAL_GROUP_SIZE_CHANGED } from "./event-constants";
+import { UrlFetchOptions } from "./io";
+import { DataModel, DataModelDefinition } from "./datamodel/data-model";
+import { SelectionMode } from './selection';
+import { AddEdgeOptions, ConnectReason, EdgeSelectionParams, LoadOptions } from "./params";
+import { TransactionCleanupAction, UndoRedoManager } from "./undo-redo/undo-redo";
+import { EVENT_GROUP_ADDED, EVENT_GROUP_MEMBER_ADDED, EVENT_GROUP_MEMBER_REMOVED, EVENT_GROUP_REMOVED, EVENT_UNDO, EVENT_REDO } from './event-constants';
+import { PointXY, Geometry } from "./util";
+import { OptimisticEventGenerator } from "./event-generator";
+import { ProxyLocation } from "./constants";
+/**
+ * Definition of a function to use as a beforeConnect interceptor.
+ * @param source The source vertex for the new edge
+ * @param target The target vertex for the new edge
+ * @param payload optional initial data for the edge, which would have
+ * @param userInstigated If true, the new edge came from user activity, with a pointer device or touch input. This will be
+ * false whenever the edge is added programmatically, either during a data load or via the `addEdge` method of the model.
+ * @group Model
+ */
+export type BeforeConnectInterceptor = (source: Vertex, target: Vertex, payload?: ObjectData, userInstigated?: boolean) => any;
+/**
+ * A function to run before an edge of the given type is relocated from its current source or target to a new source or target. Returning false from this method will abort the move.
+ * @param source Candidate source. May be the edge's current source, or may be a new source.
+ * @param target Candidate target. May be the edge's current target, or may be a new target.
+ * @param edge The edge that is being moved.
+ * @group Model
+ */
+export type BeforeMoveConnectionInterceptor = (source: Vertex, target: Vertex, edge: Edge) => any;
+/**
+ * A function to run before an edge of the given type is dragged from the given source. Returning false from this method will abort the connection.
+ * @param source
+ * @param type
+ * @returns If you return boolean false from this method the connection is aborted. If you return an object from this method it will be used as the initial data for the resulting edge.
+ * @group Model
+ */
+export type BeforeStartConnectInterceptor = (source: Vertex, type: string) => boolean | Record<string, any>;
+/**
+ * A function to run before the given edge is detached from the given source vertex. If this method returns false, the detach will be aborted.
+ * @param source Edge's source.
+ * @param target Candidate target for the edge
+ * @param edge The edge that is being detached.
+ * @group Model
+ */
+export type BeforeDetachInterceptor = (source: Vertex, target: Vertex, edge: Edge) => boolean;
+/**
+ * A function to run before the given edge is detached from the given source vertex. If this method returns false, the detach will be aborted. The difference between this and `beforeDetach` is that this method is fired as soon as a user tries to detach an edge in the UI, whereas `beforeDetach` allows a user to detach the edge in the UI.
+ * @param source
+ * @param edge
+ * @group Model
+ */
+export type BeforeStartDetachInterceptor = (source: Vertex, edge: Edge) => Record<string, any> | boolean;
+/**
+ * Constructor options for a VisuallyJs model instance.
+ * @group Model
+ */
+export interface ModelOptions {
+    /**
+     * The name of a property that will exist inside the backing data for nodes/group, and which represents a list of ports pertaining to that node/group. When a node/group is rendered, if this property is set, VisuallyJs will consider the value of this property to be a list of port data object. So this property's value should be of type `Array<ObjectData>`
+     */
+    portDataProperty?: string;
+    /**
+     * The name of a property inside of each port's data that can be used to order the ports. For instance, you might have ports that have a `rank` property, which is a number. VisuallyJs will sort the ports according to the natural ordering of this property.
+     */
+    portOrderProperty?: string;
+    model?: DataModelDefinition;
+    /**
+     * The name of the property inside a vertex's data that identifies its location in the x axis. Defaults to `left`.
+     */
+    modelTopAttribute?: string;
+    /**
+     * The name of the property inside a vertex's data that identifies its location in the y axis. Defaults to `top`.
+     */
+    modelLeftAttribute?: string;
+    /**
+     * The name of the property inside a vertex's data that identifies its width. Defaults to `width`.
+     */
+    modelWidthAttribute?: string;
+    /**
+     * The name of the property inside a vertex's data that identifies its height. Defaults to `height`.
+     */
+    modelHeightAttribute?: string;
+    /**
+     * The name of the property inside a vertex's data that identifies its rotation. Defaults to `rotation`.
+     */
+    modelRotationAttribute?: string;
+    /**
+     * Optional factory method used when creating nodes via the addFactoryNode method.
+     */
+    nodeFactory?: ObjectFactory;
+    /**
+     * Optional factory method used when creating edges via the addFactoryEdge method.
+     */
+    edgeFactory?: ObjectFactory;
+    /**
+     * Optional factory method used when creating ports via the addFactoryPort method.
+     */
+    portFactory?: ObjectFactory;
+    /**
+     * Optional factory method used when creating groups via the addFactoryGroup method.
+     */
+    groupFactory?: ObjectFactory;
+    autoSave?: AutoSaveOptions;
+    /**
+     * The character to use in port identifiers. Defaults to `.`, eg. someVertex.somePort.
+     */
+    portSeparator?: string;
+    /**
+     * The default cost for an edge. Default value is 1.
+     */
+    defaultCost?: number;
+    /**
+     * Whether edges are directed by default. The default value for this is `true` - edges are directed by default.
+     */
+    defaultDirected?: boolean;
+    /**
+     * @internal
+     */
+    enableSubgraphs?: boolean;
+    /**
+     * Definition of a function to use as a beforeConnect interceptor.
+     * @param source - The source vertex for the new edge
+     * @param target - The target vertex for the new edge
+     * @param userInstigated - If true, the new edge came from user activity, with a pointer device or touch input. This will be
+     * false whenever the edge is added programmatically, either during a data load or via the `addEdge` method of VisuallyJsModel.
+     */
+    beforeConnect?: BeforeConnectInterceptor;
+    /**
+     * A function to run before an edge of the given type is relocated from its current source or target to a new source or target. Returning false from this method will abort the move.
+     * @param source Candidate source. May be the edge's current source, or may be a new source.
+     * @param target Candidate target. May be the edge's current target, or may be a new target.
+     * @param edge The edge that is being moved.
+     */
+    beforeMoveConnection?: BeforeMoveConnectionInterceptor;
+    /**
+     * A function to run before an edge of the given type is dragged from the given source. Returning false from this method will abort the connection.
+     * @param source
+     * @param type
+     */
+    beforeStartConnect?: BeforeStartConnectInterceptor;
+    /**
+     * A function to run before the given edge is detached from the given source vertex. If this method returns false, the
+     * detach will be aborted.
+     * @param source Edge's source.
+     * @param target Candidate target for the edge
+     * @param edge The edge that is being detached.
+     */
+    beforeDetach?: BeforeDetachInterceptor;
+    /**
+     * A function to run before the given edge is detached from the given source vertex. If this method returns false, the detach will be aborted. The difference between this and `beforeDetach` is that this method is fired as soon as a user tries to detach an edge from an endpoint in the UI, whereas `beforeDetach` allows a user to detach the edge in the UI.
+     * @param source
+     * @param edge
+     */
+    beforeStartDetach?: BeforeStartDetachInterceptor;
+    /**
+     * Optional mode for VisuallyJs's current selection. Defaults to the Selection default - `SelectionModes.mixed`.
+     */
+    selectionMode?: SelectionMode;
+    /**
+     * The maximum number of nodes that can be selected at any one time. Defaults to Infinity.
+     */
+    maxSelectedNodes?: number;
+    /**
+     * The maximum number of edges that can be selected at any one time. Defaults to Infinity.
+     */
+    maxSelectedEdges?: number;
+    /**
+     * The maximum number of groups that can be selected at any one time. Defaults to Infinity.
+     */
+    maxSelectedGroups?: number;
+    /**
+     * Defines the action taken when appending an object that would take the selection above its limit for the given object type. This can be either Selection.DISCARD_EXISTING (the default) or Selection.DISCARD_NEW.
+     */
+    selectionCapacityPolicy?: string;
+    /**
+     * Data to load directly after Toolkit has been created.
+     */
+    data?: any;
+    /**
+     * Configuration for undo/redo
+     */
+    undoRedo?: {
+        /**
+         * Whether or not undo/redo is enabled. Defaults to true.
+         */
+        enabled?: boolean;
+        /**
+         * Maximum size of the undo stack. Defaults to 50.
+         */
+        maximumSize?: number;
+    };
+    /**
+     * A function to use to determine the ID of some data object. By default VisuallyJs uses the value of the object's `id` property.
+     */
+    idFunction?: IdFunction;
+    /**
+     * The name of the property that identifies a given object's `type`. By default this is the `type` property.
+     */
+    typeProperty?: string;
+    /**
+     * The name of the property that identifies a given edge's `type`. By default this is the `type` property. If you do not set this but you do set `typeProperty`, that value will be used.
+     */
+    edgeTypeProperty?: string;
+    /**
+     * The name of the property that identifies a given port's `type`. By default this is the `type` property. If you do not set this but you do set `typeProperty`, that value will be used.
+     */
+    portTypeProperty?: string;
+    /**
+     * A function to use to determine the type of some data object. By default VisuallyJs uses the value of the object's `type` property.
+     */
+    typeFunction?: TypeFunction;
+    /**
+     * A function to use to determine the ID of some edge from its data. By default VisuallyJs uses the value of the object's `id` property.
+     */
+    edgeIdFunction?: IdFunction;
+    /**
+     * A function to use to determine the type of some edge from its data object. By default VisuallyJs uses the value of the object's `type` property.
+     */
+    edgeTypeFunction?: TypeFunction;
+    /**
+     * A function to use to determine the ID of some port from its data. By default VisuallyJs uses the value of the object's `id` property.
+     */
+    portIdFunction?: IdFunction;
+    /**
+     * A function to use to determine the type of some port from its data object. By default VisuallyJs uses the value of the object's `type` property.
+     */
+    portTypeFunction?: TypeFunction;
+    /**
+     * A function to use to extract an array of ports from the data representing some node/group. Whenever a node/group is rendered, VisuallyJs will use this method, if provided, to determine a list of ports for that node/group. If you use this you probably also want to define a `portUpdater`. Note that if you provide the `portDataProperty` then you do not need to set this.
+     */
+    portExtractor?: (o: ObjectData) => Array<ObjectData>;
+    /**
+     * A function to use to update a given node/group's list of ports. Note that if you provide the `portDataProperty` then you do not need to set this.
+     */
+    portUpdater?: Function;
+    /**
+     * Optional model event mappings to bind
+     */
+    events?: ModelEventsOptions;
+}
+/**
+ * Definition of a model event callback.
+ */
+export type EventCallback<T = any> = (payload: T, evt?: any) => any;
+/**
+ * Model event mappings - a record whose keys are valid {@link ModelEvent}s.
+ */
+export type ModelEventsOptions = {
+    [K in ModelEvent]?: EventCallback;
+};
+/**
+ * Options for data export.
+ * @group Model
+ * @category Input and Output
+ */
+export interface ExportOptions {
+    /**
+     * Specifies the data type in which to format the data. Defaults to `"json"`. This must match the name of an exporter registered with the given instance of VisuallyJs.
+     */
+    type?: string;
+    /**
+     * Optional parameters to pass to the exporter. If you write a custom exporter you may wish to use this.
+     */
+    parameters?: Record<string, any>;
+}
+/**
+ * Options for a save via ajax.
+ * @group Model
+ * @category Input and Output
+ */
+export interface SaveOptions extends ExportOptions {
+    /**
+     * URL to POST data to. Required.
+     */
+    url: string;
+    /**
+     * Optional callback to execute once the data has saved successfully.
+     * @param r
+     */
+    success?: (r: any) => any;
+    /**
+     * Optional callback to execute if there was an error saving the data.
+     * @param e
+     * @param status
+     */
+    error?: (e: any, status?: any) => any;
+    /**
+     * Optional headers to set on the ajax request. By default, VisuallyJs will send a `Content-Type:"application/json"` header. If you provide your own headers this header will continue to be sent, unless of course you override it.
+     */
+    headers?: Record<string, string>;
+    /**
+     * optional data to save. If not provided we use the return value of `exportData()`.
+     */
+    data?: any;
+}
+/**
+ * Options for a `connect` call.
+ * @group Model
+ */
+export interface ConnectOptions {
+    source: any;
+    target: any;
+    geometry?: any;
+    data?: Record<string, any>;
+    cost?: number;
+    directed?: boolean;
+    doNotCreateMissingNodes?: boolean;
+}
+/**
+ * Definition of a function that can act as a factory for model objects.
+ */
+export type ObjectFactory = (model: VisuallyJsModel, type: string, data: ObjectData, continueCallback: (o: ObjectData) => any, abortCallback: () => any, params?: any) => boolean;
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_GROUP_RESIZED = "groupResized";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_ADD_PORT = "addPort";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_ADD_NEW_PORT = "addNewPort";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_REMOVE_PORT = "removePort";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_UPDATE_PORT = "updatePort";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_MOVED = "moved";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_LAYOUT = "layout";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_UPDATE_VERTEX = "updateVertex";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_UPDATE_NODE = "updateNode";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_UPDATE_GROUP = "updateGroup";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_MAGNETIZER = "magnetizer";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_SET_POSITION = "setPosition";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_SNAP_TO_GRID = "snapToGrid";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_SIZE_GROUP_TO_FIT = "sizeGroupToFit";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_DRAWING_TOOLS_RESIZE = "drawingToolsResize";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_ROTATION = "rotation";
+/** @internal */
+export declare const VERTEX_UPDATE_REASON_RESIZED = "resized";
+/**
+ * Reasons that a vertex has been updated.
+ * @internal
+ */
+export type VertexUpdatedReason = typeof VERTEX_UPDATE_REASON_ADD_NEW_PORT | typeof VERTEX_UPDATE_REASON_ADD_PORT | typeof VERTEX_UPDATE_REASON_DRAWING_TOOLS_RESIZE | typeof VERTEX_UPDATE_REASON_GROUP_RESIZED | typeof VERTEX_UPDATE_REASON_REMOVE_PORT | typeof VERTEX_UPDATE_REASON_UPDATE_PORT | typeof VERTEX_UPDATE_REASON_MOVED | typeof VERTEX_UPDATE_REASON_LAYOUT | typeof VERTEX_UPDATE_REASON_UPDATE_VERTEX | typeof VERTEX_UPDATE_REASON_UPDATE_NODE | typeof VERTEX_UPDATE_REASON_UPDATE_GROUP | typeof VERTEX_UPDATE_REASON_MAGNETIZER | typeof VERTEX_UPDATE_REASON_SET_POSITION | typeof VERTEX_UPDATE_REASON_SNAP_TO_GRID | typeof VERTEX_UPDATE_REASON_SIZE_GROUP_TO_FIT | typeof VERTEX_UPDATE_REASON_ROTATION | typeof VERTEX_UPDATE_REASON_RESIZED;
+/** @internal */
+export declare const EDGE_UPDATE_REASON_UPDATED = "updated";
+/**
+ * Reasons that en edge has been updated.
+ * @internal
+ */
+export type EdgeUpdatedReason = typeof EDGE_UPDATE_REASON_UPDATED;
+/**
+ * Names of internal events that can be fired by the VisuallyJsModel
+ * @group Events
+ * @internal
+ */
+export type InternalModelEvent = typeof EVENT_INTERNAL_GROUP_SIZE_CHANGED | typeof EVENT_INTERNAL_GROUP_SIZE_CHANGED_UNDO | typeof EVENT_INTERNAL_GROUP_SIZE_CHANGED_REDO | typeof EVENT_RENDERER_ADDED;
+/**
+ * Names of events that can be fired by the VisuallyJsModel.
+ * @group Events
+ */
+export type ModelEvent = typeof EVENT_NODE_ADDED | typeof EVENT_DATA_UPDATED | typeof EVENT_GROUP_ADDED | typeof EVENT_GROUP_MEMBER_ADDED | typeof EVENT_GROUP_MEMBER_REMOVED | typeof EVENT_EDGE_REMOVED | typeof EVENT_EDGE_SOURCE_CHANGED | typeof EVENT_EDGE_TARGET_CHANGED | typeof EVENT_PORT_ADDED | typeof EVENT_NODE_REMOVED | typeof EVENT_GROUP_REMOVED | typeof EVENT_EDGE_ADDED | typeof EVENT_GRAPH_CLEARED | typeof EVENT_PORT_REMOVED | typeof EVENT_SELECT | typeof EVENT_SELECTION_CLEARED | typeof EVENT_NODE_UPDATED | typeof EVENT_GROUP_UPDATED | typeof EVENT_EDGE_UPDATED | typeof EVENT_EDGE_PATH_EDITED | typeof EVENT_GRAPH_CLEAR_START | typeof EVENT_NODE_TYPE_CHANGED | typeof EVENT_PORT_TYPE_CHANGED | typeof EVENT_GROUP_TYPE_CHANGED | typeof EVENT_EDGE_TYPE_CHANGED | typeof EVENT_PORT_UPDATED | typeof EVENT_DESELECT | typeof EVENT_DATA_LOAD_START | typeof EVENT_DATA_LOAD_END | typeof EVENT_UNDOREDO_UPDATE | typeof EVENT_UNDO | typeof EVENT_REDO | typeof EVENT_DATA_APPEND_START | typeof EVENT_DATA_APPEND_END;
+/**
+ * Core VisuallyJs model functionality. This class provides the basic data model of an directed/undirected graph, and offers methods to add/update/remove nodes, groups, edges and ports. Multiple renderers can share one instance of the model.
+ * @group Model
+ */
+export declare abstract class VisuallyJsModel extends OptimisticEventGenerator implements WriteableDatasource {
+    graph: Graph;
+    autoSaver: AutoSaver;
+    idFunction: IdFunction;
+    typeProperty: string;
+    edgeTypeProperty: string;
+    portTypeProperty: string;
+    typeFunction: TypeFunction;
+    edgeIdFunction: IdFunction;
+    edgeTypeFunction: TypeFunction;
+    portIdFunction: IdFunction;
+    portTypeFunction: TypeFunction;
+    portExtractor: Function;
+    portUpdater: Function;
+    portDataProperty: string;
+    portOrderProperty: string;
+    modelTopAttribute: string;
+    modelLeftAttribute: string;
+    modelWidthAttribute: string;
+    modelHeightAttribute: string;
+    modelRotationAttribute: string;
+    model: DataModel;
+    private _$_dataLoading;
+    private _autoSave;
+    debugEnabled: boolean;
+    defaultObjectFactory: ObjectFactory;
+    nodeFactory: ObjectFactory;
+    edgeFactory: ObjectFactory;
+    portFactory: ObjectFactory;
+    groupFactory: ObjectFactory;
+    portSeparator: string;
+    undoRedo: UndoRedoManager;
+    private _graphParams;
+    beforeConnect: BeforeConnectInterceptor;
+    beforeMoveConnection: BeforeMoveConnectionInterceptor;
+    beforeStartConnect: BeforeStartConnectInterceptor;
+    beforeDetach: BeforeDetachInterceptor;
+    beforeStartDetach: BeforeStartDetachInterceptor;
+    private readonly _$_currentSelection;
+    private _$_renderersById;
+    constructor(params?: ModelOptions);
+    private _prepareDummyVertexPayload;
+    private _deriveVertex;
+    private _$_createSelection;
+    /**
+     * Filter the dataset and return a Selection containing matches. You can optionally provide a type parameter to indicate the type of objects you expect back in the Selection.
+     * @param spec Either a function which is passed every object in the dataset and expected to return `true` to indicate inclusion, or an object containing key:value pairs to match in the backing data of each object in the dataset
+     * @param includePartials If true, objects whose data matches one or more, but not all, of the pairs in `spec` will be included in the result. By default objects have to match all the pairs in `spec` to be included in the result.
+     */
+    filter<T = any>(spec: (o: Base) => boolean | ObjectData, includePartials?: boolean): VisuallyJsSelection;
+    /**
+     * Gets the model registered with this VisuallyJs instance, if any. Use VisuallyJs's model to map data model event handlers and other data model considerations such as the maximum number of connections a Port allows
+     * @returns Current model. May be null.
+     */
+    getModel(): DataModel;
+    /**
+     * Sets options for the auto save mechanism.
+     * @param autoSaveOptions
+     *
+     */
+    setAutoSave(autoSaveOptions: AutoSaveOptions): void;
+    /**
+     * Connects two nodes/ports (or a combination of the two), by ID.  By default, this method will create nodes that are missing. Port ids are specified with a dotted syntax, eg `foo.bar` refers to the port "bar" on the node "foo".
+     * @param params Connect parameters.
+     * @returns The new Edge.
+     *
+     */
+    connect(params: ConnectOptions): Edge;
+    /**
+     * Fires a 'graphClearStart' event, clears the graph, then fires a `graphClearEnd` event.
+     * @returns The current Toolkit instance.
+     *
+     */
+    clear(): VisuallyJsModel;
+    destroy(): void;
+    /**
+     * Returns the current Graph.
+     * @returns The underlying Graph.
+     *
+     */
+    getGraph(): Graph;
+    /**
+     * Returns the count of nodes in the Graph.
+     * @returns The count of Nodes in the Graph.
+     *
+     */
+    getNodeCount(): number;
+    /**
+     * Returns the Node at the given index.
+     * @returns The Node at the given index, null if not found.
+     *
+     */
+    getNodeAt(idx: number): Node;
+    /**
+     * Returns all the nodes in the Graph.
+     * @returns All the Nodes in the graph.
+     *
+     */
+    getNodes(): Array<Node>;
+    /**
+     * Iterates through all Nodes in the model one at a time. You should not perform destructive editing of the dataset inside one of these loops.
+     * @param fn A function that takes (index, node) as arguments and is applied for every Node in the VisuallyJs instance.
+     *
+     */
+    eachNode(fn: (idx: number, node: Node) => void): void;
+    /**
+     * Iterates through all Groups in the model one at a time. You should not perform destructive editing of the dataset inside one of these loops.
+     * @param fn A function that takes (index, node) as arguments and is applied for every Group in the VisuallyJs instance.
+     *
+     */
+    eachGroup(fn: (idx: number, group: Group) => void): void;
+    /**
+     * Combines eachNode and eachGroup into one method.
+     * @param fn
+     *
+     */
+    eachVertex(fn: (idx: number, vertex: Vertex) => void): void;
+    /**
+     * Iterates through all Edges in the model one at a time. You should not perform destructive editing of the dataset inside one of these loops.
+     * @param fn A function that takes (index, edge) as arguments and is applied for every Node in the VisuallyJs instance.
+     *
+     */
+    eachEdge(fn: (idx: number, edge: Edge) => void): void;
+    /**
+     * Returns the total number of edges in the graph.
+     */
+    getEdgeCount(): number;
+    /**
+     * Returns the total number of group in the Graph.
+     */
+    getGroupCount(): number;
+    /**
+     * Returns the Group at the given index, null if not found.
+     * @param idx Index into group list
+     */
+    getGroupAt(idx: number): Group;
+    /**
+     * Returns all the Groups in the Graph.
+     */
+    getGroups(): Array<Group>;
+    /**
+     * Gets a list of nodes/groups that are descendants of the given group.
+     * @param vertex
+     *
+     */
+    getDescendants(vertex: Group): Array<Node | Group>;
+    /**
+     * Gets a list of groups that are ancestors of the given node/group. 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
+     *
+     */
+    getAncestors(vertex: Node | Group): Array<Group>;
+    /**
+     * Returns whether or not `possibleAncestor` is in fact an ancestor of the given focus node/group
+     * @param focus Vertex to test
+     * @param possibleAncestor Group which may be an ancestor of `focus`
+     */
+    isAncestor(focus: Vertex, possibleAncestor: Group): boolean;
+    /**
+     * Determine whether `possibleDescendant` is in fact a descendant of the `ancestor` group
+     * @param possibleDescendant Group to test
+     * @param ancestor Ancestor group
+     *
+     */
+    isDescendantGroup(possibleDescendant: Group, ancestor: Group): boolean;
+    /**
+     * 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 arrays, each entry being a list of nodes in the cluster.
+     *
+     */
+    getClusters(): Array<Cluster>;
+    /**
+     * Calculates the set of nodes and groups (and edges) that are connected to the given vertex.
+     * @param vertex a Cluster - a list of vertices and a list of edges that are connected to the given vertex.
+     */
+    getCluster(vertex: Node | Group | string): Cluster;
+    /**
+     * Gets the id of the Node represented by the given arguments. If this is a JS object, we extract the id using the current idFunction. Otherwise we just pass it back as-is.
+     * @param node Object from which to retrieve id.
+     *
+     */
+    getNodeId(node: ObjectData | string): string;
+    /**
+     * Gets the type of the Node represented by the given JS object. We first try for a return value from the current typeFunction, but if that returns nothing we just return 'default'.
+     * @param nodeData  Node's data. Note: this is NOT a Node object, it is the backing data. You can use `getType` to get the type for some Toolkit object.
+     * @returns Either the object's type, or `default`.
+     *
+     */
+    getNodeType(nodeData: ObjectData): string;
+    /**
+     * Gets the id of the Group represented by the given arguments. If this is a JS object, we extract the id using the current idFunction. Otherwise we just pass it back as-is.
+     * @param group Object from which to retrieve id.
+     *
+     */
+    getGroupId(group: ObjectData | string): string;
+    /**
+     * Gets the type of the Group represented by the given JS object. We first try for a return value from the current typeFunction, but if that returns nothing we just return 'default'.
+     * @param groupData  Groups's data. Note: this is NOT a Group object, it is the backing data. You can use `getType` to get the type for some model object.
+     * @returns Either the object's type, or `default`.
+     */
+    getGroupType(groupData: ObjectData): string;
+    /**
+     * Gets the type of the Edge represented by the given JS object.
+     * @param edgeData Edge's data. Note: this is NOT an Edge object, it is the backing data. You can use `getType` to get the type for some Toolkit object.
+     * @returns Either the Edge's type, if set, or "default".
+     *
+     */
+    getEdgeType(edgeData: ObjectData): string;
+    /**
+     * Gets the id of the Port represented by the given arguments. If this is a JS object, we extract the id using the current portIdFunction. Otherwise we just pass it back as-is.
+     * @returns Port's id, if we could resolve it, otherwise the object we were given.
+     *
+     */
+    getPortId(port: ObjectData): string;
+    /**
+     * Gets the type of the Port represented by the given JS object
+     * @returns Either the port's type, if set, or "default".
+     *
+     */
+    getPortType(port: ObjectData): string;
+    /**
+     * Gets the type of the given Object. This is not a type such as `Node`, `Port` or `Edge` - this is the type of the object as defined by your system to identify types; these are the types used to lookup objects in the view.
+     * @param obj Object to retrieve type for
+     * @returns The object's type.
+     *
+     */
+    getType(obj: Base): string;
+    /**
+     * Sets the type of the given object. This will do two things - first it will update the appropriate property in the object's data to this new value. You can set what properties define types, but by default each of Node, Edge and Port use `type` as the property that indicates their type. Secondly, this method will attempt to apply a type definition for the new type, if one is found.
+     * @param obj Object to set the type for.
+     * @param newType Type to set on the object.
+     */
+    setType(obj: Base, newType: string): void;
+    /**
+     * Dispatch an event and invoke appropriate method on renderers
+     * @internal
+     * @param obj
+     * @param previousType
+     * @param newType
+     */
+    private $dispatchTypeChange;
+    resolveFullId(b: Base): 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
+     */
+    resolveNode(v: Vertex): Node | Group;
+    /**
+     * Adds a Node with the given data. If the data is null, VisuallyJs creates an empty object and assigns a uuid as the Node's id.  If no id can be derived for the given data, VisuallyJs creates a uuid and sets it as the data object's 'id' member. This method also calls the current `portExtractor` function, if one was supplied. Its purpose is to extract any Ports from the data for some given Node.
+     * @param data The Node's backing data - from your data model.
+     * @param eventInfo Optional data member that VisuallyJs will pass into any registered event listeners. This can be used by the UI layer, for instance, to track the position on screen of any newly added elements.
+     * @returns A Node object.  Your original data is available via the `data` member. The Node's id is available via the `id` member.
+     *
+     */
+    addNode(data: ObjectData, eventInfo?: any): Node;
+    private _$_notifyNodeAdded;
+    private _$_notifyGroupAdded;
+    /**
+     * Adds a Node by type, running the data generation for the node through the current NodeFactory.  This is different from `addNode` in that with `addNode` you are supplying the final data and your NodeFactory is not called. This method can be called with one, two or three arguments. A single argument is considered to be the new Node's `type`, and a backing data object will be created with this set, and no callback will occur. If you provide two arguments the second argument may be either the new Node's backing data OR a callback to hit with the newly created Node. With three arguments the second argument is the Node's backing data and the third is a callback to hit with the newly created Node.
+     * @param type Required. Type of the object to create. `type` will be passed as the first argument to your node factory.
+     * @param data Optional backing data for the Node.
+     * @param continueCallback Optional function to call with the newly created Node.
+     * @param abortCallback Optional function to call if the factory aborted the node add.
+     * @param useTransaction Whether or not to add this new factory node in a transaction.
+     */
+    addFactoryNode(type: string, data?: ObjectData, continueCallback?: Function, abortCallback?: Function, useTransaction?: boolean): void;
+    /**
+     * Adds a list of Nodes.
+     * @param nodeList An array of objects, one for each Node to be added.
+     */
+    addNodes(nodeList: Array<ObjectData>): VisuallyJsModel;
+    /**
+     * @internal
+     */
+    $transientVerticesByRenderer: Record<string, Record<string, Node>>;
+    private _getTransientVerticesForRenderer;
+    /**
+     * Add a node that some renderer considers to be transient - as an example, a renderer that supports dragging new edges. A new edge will require a temporary vertex to exist as the target of the new edge. This method does not invoke the render function of any registered renderers - a transient vertex is considered to be something private to a specific renderer, with a short lifespan that the single threaded nature of javascript will ensure the vertex is not referenced by other renderers.
+     * @param renderer
+     * @param data
+     * @internal
+     */
+    $addTransientVertex(data?: ObjectData, renderer?: VisuallyJsRenderer<any>): Node;
+    /**
+     * Adds a dummy vertex to the dataset and notifies each renderer to draw it. Not intended for use by users of the API.
+     * @param data
+     * @param renderer
+     * @internal
+     */
+    private _addDummyVertex;
+    private _cleanupDummyVertex;
+    /**
+     * Detach an edge from either its source or target vertex, creating a dummy vertex as a placeholder. This method is not intended for use by users of the API.
+     * @param edge
+     * @param loc
+     * @param idx
+     * @internal
+     */
+    $setEdgeDetached(edge: Edge, loc: PointXY, idx: ProxyLocation): void;
+    /**
+     * Removes a transient vertex from the underlying dataset, and from the list of transient vertices for
+     * the given renderer. Removes any edges attached to the transient node. None of these operations
+     * occur within a transaction and none are propagated to all attached renderers: only the renderer that
+     * invokes this method is notified of the deletion of edges and the node.
+     * @param renderer
+     * @param v
+     * @internal
+     */
+    $cleanupTransientVertex(v: Node, renderer: VisuallyJsRenderer<any>): void;
+    /**
+     * Adds a transient edge to the dataset.
+     * @param renderer
+     * @param source
+     * @param target
+     * @param data
+     * @param geometry
+     * @param context
+     * @internal
+     */
+    $addTransientEdge(renderer: VisuallyJsRenderer<any>, source: Vertex, target: Vertex, data?: ObjectData, geometry?: Geometry, context?: Record<string, any>): Edge;
+    /**
+     * Adds a Group by type, running the data generation for the node through the current GroupFactory.  This is different from `addGroup` in that with `addGroup` you are supplying the final data and your GroupFactory is not called. This method can be called with one, two or three arguments. A single argument is considered to be the new Group's `type`, and a backing data object will be created with this set, and no callback will occur. If you provide two arguments the second argument may be either the new Group's backing data OR a callback to hit with the newly created Group. With three arguments the second argument is the Group's backing data and the third is a callback to hit with the newly created Group.
+     * @param type Required. Type of the object to create. `type` will be passed as the first argument to your group factory.
+     * @param data Optional backing data for the Group.
+     * @param continueCallback Optional function to call with the newly created Group.
+     * @param abortCallback Optional function to call if the group factory aborted
+     *
+     */
+    addFactoryGroup(type: string, data?: ObjectData, continueCallback?: Function, abortCallback?: Function, useTransaction?: boolean): void;
+    /**
+     * Adds a new Group.
+     * @param data Backing data for the Group.
+     * @param eventInfo Used internally, sometimes, by VisuallyJs.
+     * @returns The Group that was added.
+     *
+     */
+    addGroup(data: ObjectData, eventInfo?: any): Group;
+    /**
+     * Adds a Node/Group to a Group.
+     * @param node Node to add
+     * @param group Group to add the Node/Group to
+     * @returns True if added, false otherwise.
+     *
+     */
+    addToGroup(node: Node | Group | string, group: Group | string, position?: PointXY): boolean;
+    /**
+     * Adds a Node/Group to a Group. This is an internal method that is not part of the public API.
+     * @param node Node/group to add
+     * @param group Group to add the Node/Group to
+     * @param sourceGroup Optional Group the node/group previously belonged to.
+     * @param originalPosition Optional previous position of the node/group in `sourceGroup`.
+     * @param newPosition Optional position in the new group
+     * @param source For internal use. Identifies the renderer that instigated this model change. This renderer will not subsequently respond to the model change, since it already knows about it and its UI has been changed accordingly already.
+     * @returns True if added, false otherwise.
+     * @internal
+     */
+    $addToGroup(node: Node | Group | string, group: Group | string, sourceGroup?: Group, originalPosition?: PointXY, newPosition?: PointXY, source?: VisuallyJsRenderer<any>): boolean;
+    /**
+     * Removes a Node/Group from a Group.
+     * @param node Node/Group to remove, or its id, or the data representing it.
+     *
+     */
+    removeFromGroup(node: Node | Group | string | ObjectData): Group;
+    /**
+     * Removes a Node/Group from a Group.
+     * @param node Node/Group to remove, or its id, or the data representing it.
+     * @param targetGroup For internal use. Group to which the Node is being moved, if that applies.
+     * @param source For internal use. The renderer in which user activity caused this method to be called. We echo that out in the event parameters, allowing renderers to not respond to events they raised.
+     * @returns The Group from which the Node was removed.
+     * @internal
+     */
+    $removeFromGroup(node: Node | Group | string | ObjectData, targetGroup?: Group, originalPosition?: PointXY, newPosition?: PointXY, source?: VisuallyJsRenderer<any>): Group;
+    private _$_notifyGroupRemoved;
+    private _$_notifyNodeRemoved;
+    /**
+     * Removes the given Group from the dataset.
+     * @param group Group or ID of Group to remove.
+     * @param removeChildren If true, Nodes/Groups that are members of the Group will also be removed. Defaults to false.
+     * @param doNotFireEvent  If true, a `group:removed` will not be fired as a result of this operation. Otherwise it will.
+     * @public
+     */
+    removeGroup(group: string | Group, removeChildren?: boolean, doNotFireEvent?: boolean): boolean;
+    /**
+     * Gets the Node with the given id.
+     * @param nodeId
+     * @public
+     */
+    getNode(nodeId: string): Node;
+    /**
+     * Gets an Edge by id, or if the given object is already an Edge, hands that back.
+     * @param edgeId ID of the Edge to retrieve.
+     * @returns The requested Edge, if found, otherwise null.
+     * @public
+     */
+    getEdge(edgeId: string): Edge;
+    /**
+     * Gets a Group by its ID, or if the object is already a Group, hands that back.
+     * @param groupId
+     * @returns The requested Group, if found, otherwise null.
+     *
+     */
+    getGroup(groupId: string): Group;
+    /**
+     * Gets the Vertex with the given id.
+     * @param id
+     *
+     */
+    getVertex(id: string): Node | Group;
+    /**
+     * Gets a port by its full id
+     * @param portId ID of the Port to retrieve, in nodeId.portId syntax.
+     * @returns The requested port, if found, otherwise null.
+     *
+     */
+    getPort(portId: string): Port;
+    /**
+     * Returns whether or not object(s) exist for the given id(s).
+     * @param objects List of ids to check existence for.  This method takes an arbitrary number of arguments.
+     * @returns True if objects exist for all given ids, false otherwise.
+     *
+     */
+    exists(...objects: Array<any>): boolean;
+    /**
+     * Removes the given Node, which may be passed in as the actual Node object, or its id.
+     * @param node Either a Node, or its ID.
+     * @returns True if node removed, false if not.
+     *
+     */
+    removeNode(node: string | Vertex): boolean;
+    /**
+     * Adds an Edge to the Graph.
+     * @param params Options for the new edge
+     * @returns The Edge that was added.
+     *
+     */
+    addEdge(params: AddEdgeOptions): Edge;
+    /**
+     * Internal method for adding edges. Users of the API should not call this method.
+     * @internal
+     * @param params
+     * @param reason
+     * @param renderer The renderer that was the source of the action. Optional, used internally.
+     * @param doNotFireEvent Optional. Won't fire an event if this is true. For internal use only.
+     * @param doNotFireEvent
+     */
+    $_addEdge(params: AddEdgeOptions & {
+        addedByMouse?: boolean;
+        context?: Record<string, any>;
+    }, reason: ConnectReason, renderer: VisuallyJsRenderer<any>, doNotFireEvent?: boolean): Edge;
+    /**
+     * Notify registered managers of edge removal, and fire event. used by a couple of call sites.
+     * @param edge
+     * @param source
+     * @internal
+     */
+    private _$_notifyEdgeRemoved;
+    /**
+     * Removes an Edge from the Graph.
+     * @param edge The Edge to remove, as either an Edge object or its id.
+     * @param renderer The source for the removeEdge operation. For internal use.
+     * @returns The model instance.
+     *
+     */
+    removeEdge(edge: string | Edge, renderer?: any): VisuallyJsModel;
+    /**
+     * @internal
+     * @param edge
+     * @param obj
+     * @param index
+     * TODO may no longer be necessary
+     */
+    /**
+     * Sets the target for the given edge to be the given vertex.
+     * @param edge Edge to set target for.
+     * @param o ID of vertex, or vertex.
+     */
+    setTarget(edge: Edge, o: string | Vertex | PointXY): any;
+    /**
+     * Sets the source for the given edge to be the given vertex.
+     * @param edge Edge to set source for.
+     * @param o ID of vertex, or vertex.
+     */
+    setSource(edge: Edge, o: string | Vertex | PointXY): any;
+    /**
+     * Adds a new Port to some Node. This will call the current `portFactory` to get the data for a new Port.
+     * @param obj node/group or id of the node/group to add a new Port to.
+     * @param type Type of Port to add.
+     * @param portData Data to pass to the PortFactory.
+     *
+     */
+    addNewPort(obj: string | Node | Group, type: string, portData?: ObjectData): void;
+    /**
+     * Adds a Port from existing data to some Node/Group. This is distinct from `addNewPort`, because in this case the data for the Port already exists.
+     * @param vertex Node/Group or id of the Node/Group to add the Port to.
+     * @param data Data for the Port.
+     * @returns The port that was added.
+     *
+     */
+    addPort(vertex: string | Node | Group, data: ObjectData): Port;
+    /**
+     * Removes a Port from the dataset, returning true if the port existed and was removed and false otherwise.
+     * @param vertexOrId If a string is passed in here, it may represent the full ID of some port, ie in "vertex.port" notation, or it may be the ID of the vertex on which the port to be removed resides. If you do not pass a string to this argument you can pass a Port instead, or you can pass the Node/Group on which the port resides (in which case you'll also need to provide a value for `portId`)
+     * @param portId Id of the port to remove from the given node. Only required if you did not provide a full port ID, or the Port itself, to `vertexOrId`.
+     * @returns
+     *
+     */
+    removePort(vertexOrId: string | Node | Group | Port, portId?: string): boolean;
+    /**
+     * Attempts to identify the given argument as a model object, and, if successful, removes it. If you pass in a group or group ID to this method, the group and all of its children will, by default, be removed. You can override that behaviour by setting `doNotRemoveGroupChildren` to true.
+     * @param obj A string representing the ID of some model object, or a model object of some type.
+     * @param doNotRemoveGroupChildren Whether or not to remove group children. Defaults to false, ie. group children will be removed by default.
+     *
+     */
+    remove(obj: any, doNotRemoveGroupChildren?: boolean): void;
+    /**
+     * Suspends or re-enables rendering. This method simply round-robins all the registered renderers and calls `setSuspendRendering` on each of them.
+     * @param v True to suspend rendering, false to enable it.
+     * @param thenRefresh Defaults to false. If true, a refresh will be called on all renderers after rendering is unsuspended.
+     *
+     */
+    setSuspendRendering(v: boolean, thenRefresh?: boolean): void;
+    /**
+     * Suspends rendering and then runs the given function, unsuspending rendering afterwards and doing a refresh. This method is just a convenience method that handles suspending and subsequent enabling of rendering. You might use this if you're bulk loading objects, or maybe you want to add a Node and one or more Edges before the layout recomputes.
+     * @param fn Function to run.
+     */
+    batch(fn: () => any): void;
+    /**
+     * Updates the given Group, notifying any Renderers to do a redraw. If autoSave is set, this method will cause the dataset to be saved.
+     * @param group Either a Group, a Group id, or the backing data for a Group.
+     * @param updates An object with path->value pairs. Path can be in dotted notation. You do not actually have to supply this, although in most cases you will want to. But there are edge cases in which you might simply wish to kick off a repaint.
+     *
+     */
+    updateGroup(group: Group | string | ObjectData, updates?: ObjectData): void;
+    /**
+     * @internal
+     * @param group
+     * @param updates
+     * @param reason
+     * @private
+     */
+    $_updateGroup(group: Group | string | ObjectData, updates: ObjectData, reason: VertexUpdatedReason, blat: boolean): void;
+    /**
+     * Updates the given Node, notifying any Renderers to do a redraw. If autoSave is set, this method will cause the dataset to be saved.
+     * @param node Either a Node, a Node id, or the backing data for a Node.
+     * @param updates An object with path->value pairs. Path can be in dotted notation. You do not actually have to supply this, although in most cases you will want to. But there are edge cases in which you might simply wish to kick off a repaint.
+     *
+     */
+    updateNode(node: string | Node | ObjectData, updates?: ObjectData): void;
+    /**
+     * @internal
+     * @param node
+     * @param updates
+     * @param reason
+     * @private
+     */
+    $_updateNode(node: string | Node | ObjectData, updates: ObjectData, reason: VertexUpdatedReason, blat: boolean): void;
+    /**
+     * Updates the given Node/Group, notifying any Renderers to do a redraw. If autoSave is set, this method will cause the dataset to be saved.
+     * @param vertex Either a Node/Group, a Node/Group id, or the backing data for a Node/Group.
+     * @param updates An object with path->value pairs. Path can be in dotted notation. You do not actually have to supply this, although in most cases you will want to. But there are edge cases in which you might simply wish to kick off a repaint.
+     *
+     */
+    updateVertex(vertex: string | Node | Group | Port | ObjectData, updates?: ObjectData): void;
+    /**
+     * Internal method for vertex update. DOES NOT create a transaction, and is intended for internal use.
+     * @internal
+     * @param vertex
+     * @param updates
+     * @param reason
+     * @param blat When true, this update completely replaces the existing data. This is used, for instance, during an undo/redo. When false, the updates are merged in to the existing data.
+     * @param source
+     */
+    $_updateVertex(vertex: string | Node | Group | Port | ObjectData, updates: ObjectData, reason: VertexUpdatedReason | string, blat: boolean, source?: VisuallyJsRenderer<any>): void;
+    /**
+     * Updates the given list of vertices.  This method runs in a transaction, by default appending itself to any current transaction (as updating a list of vertices is the common end result of various operations on the data model), but you can provide your own cleanup action if desired.
+     * @param updates
+     * @public
+     */
+    updateVertices(updates: Array<{
+        id: string;
+        updates?: ObjectData;
+    }>, cleanupAction?: TransactionCleanupAction): void;
+    /**
+     * @internal
+     * @param updates
+     * @param reason
+     * @param cleanupAction
+     * @private
+     */
+    _updateVertices(updates: Array<{
+        id: string;
+        updates?: ObjectData;
+    }>, reason: VertexUpdatedReason, blat: boolean, cleanupAction: TransactionCleanupAction): void;
+    /**
+     * Updates the given Port, notifying any Renderers to do a redraw. If autoSave is set, this method will cause the dataset to be saved.
+     * @param port Either a Port, or a full Port id
+     * @param updates An object with path->value pairs. Path can be in dotted notation. You do not actually have to supply this, although in most cases you will want to. But there are edge cases in which you might simply wish to kick off a repaint.
+     *
+     */
+    updatePort(port: Port | string, updates?: ObjectData): void;
+    /**
+     * @internal
+     * @param port
+     * @param updates
+     * @param reason
+     * @param blat
+     */
+    $_updatePort(port: Port | string, updates: ObjectData, reason: VertexUpdatedReason, blat: boolean): void;
+    /**
+     * Updates the given Edge, notifying any Renderers to do a redraw. If autoSave is set, this method will cause the dataset to be saved.
+     * @param obj Either an Edge, an Edge id, or the backing data for an Edge.
+     * @param updates An object with path->value pairs. Path can be in dotted notation. You do not actually have to supply this, although in most cases you will want to. But there are edge cases in which you might simply wish to kick off a repaint.
+     *
+     */
+    updateEdge(obj: Edge | string, updates?: ObjectData): void;
+    /**
+     * @internal
+     * @param obj
+     * @param updates
+     * @param reason
+     * @param blat
+     */
+    $_updateEdge(obj: Edge | string, updates: ObjectData, reason: EdgeUpdatedReason, blat: boolean): void;
+    /**
+     * Updates the given object, notifying any renderers to do a repaint.
+     * @param object Either a Node, Group, Port or Edge, or, as a string, the id of some Node, Group, Port or Edge.
+     * @param updates An object with path->value pairs. Path can be in dotted notation. You do not actually have to supply this, although in most cases you will want to. But there are edge cases in which you might simply wish to kick off a repaint.
+     *
+     */
+    update(object: Base, updates?: ObjectData): void;
+    /**
+     * @internal
+     * @param object
+     * @param updates
+     * @param reason
+     * @private
+     */
+    _update(object: Base, updates: ObjectData, reason: EdgeUpdatedReason | VertexUpdatedReason, blat: boolean): void;
+    /**
+     * Sets the geometry for the given edge. The type of `geometry` depends on the connector being used to represent the edge in the UI.
+     * @param edge The edge to update.
+     * @param geometry New geometry for the given edge.
+     * @param renderer The renderer that instigated this change.
+     * @internal
+     */
+    setEdgeGeometry(edge: Edge, geometry: any, originalGeometry: any, renderer: VisuallyJsRenderer<any>): void;
+    /**
+     * Clears the geometry for some edge. The edge will be repainted using the default route calculation, and an entry will be added to the undo stack.
+     * @param edge Edge to clear geometry for.
+     */
+    clearEdgeGeometry(edge: Edge): void;
+    /**
+     * Gets a Path from some source vertex to some target vertex.
+     * @param params Path spec params
+     */
+    getPath(params: PathOptions): Path;
+    /**
+     * Finds the object that matches the given spec.
+     * @param spec If a string, a Node/Port matching that id is retrieved. Otherwise if `spec` is already a Graph object (Node or Port), it is returned.
+     */
+    findGraphObject(spec: string | Vertex | Edge): Vertex | Edge | Graph;
+    /**
+     * @param obj
+     * @param append
+     * @param _selection
+     * @param fireSelectEvent
+     * @internal
+     */
+    private _$_select;
+    /**
+     * @param params Options for the edge selection.
+     * @param edgeResolver
+     * @param checkForPorts
+     * @internal
+     */
+    private _selectEdges;
+    private _$_maybeDispatchTypeChange;
+    /**
+     * Updates the given vertex with the given data. For internal use.
+     * @param obj
+     * @param updates
+     * @param blat when true, the new data replaces the previous. Otherwise the updates are merged in.
+     * @param evtId
+     * @param generator
+     * @internal
+     */
+    private _$_updateVertex;
+    /**
+     * After a change to a port, perhaps set the backing data for the associated node per the client app's portUpdater function. For internal use.
+     * @param nodeOrGroup
+     * @param reason
+     * @internal
+     */
+    private _$_updateVertexAfterPortChange;
+    /**
+     * Gets a set of edges.
+     * @param params Options for the edge selection
+     */
+    getEdges(params?: EdgeSelectionParams): Array<Edge>;
+    /**
+     * Get all Edges in the model
+     */
+    getAllEdges(): Array<Edge>;
+    /**
+     * Gets all edges for the given Node, Port or Group.
+     * @param obj Object to retrieve edges for.
+     * @param filter Optional filter function for edge selection.
+     */
+    getAllEdgesFor(obj: Vertex, filter?: (e: Edge) => boolean): Array<Edge>;
+    /**
+     * Gets all edges in the model as a {@link VisuallyJsSelection}.
+     */
+    selectAllEdges(): VisuallyJsSelection;
+    /**
+     * Adds all the edges in the model to the current selection.
+     */
+    addAllEdgesToSelection(): void;
+    /**
+     * Sets obj as the current selection for this model.
+     * @param obj Object to select. May be a Node/Edge/Group or an array of any of these, or a Node/Group id, or a Path.
+     */
+    setSelection(obj: string | Base | Array<Base> | Path): void;
+    /**
+     * Gets an ad-hoc selection
+     * @param obj Object to select. May be a Node/Group/Port/Edge or an array of any one of these, or a Vertex id, a Selection, or a Path.
+     * @param includeEdges If true, include edges between vertices
+     */
+    select(obj: string | Array<string> | Base | Array<Base> | Path | VisuallyJsSelection, includeEdges?: boolean): VisuallyJsSelection;
+    /**
+     * @param focus
+     * @param selection
+     * @param includeEdges
+     * @param touched
+     * @internal
+     */
+    private _$_descendants;
+    /**
+     * Selects all descendants of some Node or Group, and, optionally, the Node/Group itself.
+     * @param obj Node/Group, or ID of Node/Group, to select
+     * @param includeFocus Whether or not to include the focus node/group in the returned dataset. Defaults to false.
+     * @param includeEdges Whether or not to include edges in the returned dataset. Defaults to false.
+     * @graphQuery
+     */
+    selectDescendants(obj: string | Node | Group, includeFocus?: boolean, includeEdges?: boolean): VisuallyJsSelection;
+    /**
+     * @param obj
+     * @internal
+     */
+    private _$_resolveObjectForSelection;
+    /**
+     * Appends `obj` to the current selection. If there is no current selection, `obj` becomes it.
+     * @param obj Object to select. May be a Node/Group/Port/Edge or an array of any of these, or a Vertex id, or a Path.
+     */
+    addToSelection(obj: string | Base | Path | Array<Base> | Array<string>): void;
+    /**
+     * @internal
+     * @param evt
+     * @param objects
+     */
+    private _$_adhocSel;
+    /**
+     * Toggles whether or not the given `obj` forms part of the current selection. @param obj Object to select. May be a Node/Group/Port/Edge or an array of any of these, or a Vertex id, or a Path.
+     */
+    toggleSelection(obj: string | Base | Path | Array<Base>): void;
+    /**
+     * Removes obj from the current selection
+     * @param obj Object to deselect. May be a Node/Edge/Group/Port or an array of any of these, or a Vertex id, or a Path.
+     */
+    removeFromSelection(obj: string | Base | Array<Base> | Path): void;
+    /**
+     * Appends the Path from `source` to `target` to the current selection. If there is no current selection, `obj` becomes it. If the Path does not exist, there is no selection.
+     * @param params Path params
+     * @param params.source ID of source, or source Node/Port
+     * @param params.target ID of target, or target Node/Port
+     *
+     */
+    addPathToSelection(params: {
+        source: Vertex | string;
+        target: Vertex | string;
+        strict?: boolean;
+        nodeFilter?: (n: Node) => boolean;
+        edgeFilter?: (n: Edge) => boolean;
+    }): void;
+    /**
+     * Clears the current selection and fires a `selectionCleared` event.
+     */
+    clearSelection(): void;
+    /**
+     * Gets the current Selection for this model
+     * @returns Current Selection.
+     *
+     */
+    getSelection(): VisuallyJsSelection;
+    /**
+     * Sets the maximum number of nodes that may be selected at any one time. Default is Infinity.
+     * @param maxNodes Max number of nodes allowed to be selected at once.
+     */
+    setMaxSelectedNodes(maxNodes: number): void;
+    /**
+     * Sets the maximum number of edges that may be selected at any one time. Default is Infinity.
+     * @param maxEdges Max number of edges allowed to be selected at once.
+     */
+    setMaxSelectedEdges(maxEdges: number): void;
+    /**
+     * Sets The action taken when appending an edge or node that would take the selection above its limit for that given type. Depends on the current `capacityPolicy`, which can be either Selection.DISCARD_EXISTING (the default) or Selection.DISCARD_NEW.
+     * @param policy One of `Selection.DISCARD_EXISTING` (which removes the 0th entry from the list before insertion of the new value) or `Selection.DISCARD_NEW`.
+     *
+     */
+    setSelectionCapacityPolicy(policy: string): void;
+    /**
+     * @param endEvent
+     * @internal
+     */
+    private _$_notifyDataLoaded;
+    /**
+     *
+     * @param params
+     * @param startEvent
+     * @param endEvent
+     * @internal
+     */
+    private _$_doLoad;
+    /**
+     * Loads some data, either via ajax, or directly from a JS object.
+     * @param params Load options.
+     *
+     */
+    load(params: LoadOptions): VisuallyJsModel;
+    /**
+     * Appends some data to the dataset, either via ajax, or directly from a JS object. The only difference between this and `load` is the events that are fired during the loading process.
+     * @param params Append parameters.
+     *
+     */
+    append(params: LoadOptions): VisuallyJsModel;
+    /**
+     * Saves data via ajax POST to a given URL. By default this method sends the return value of {@link #exportData} as its payload, but you can provide your own data to save if you wish.
+     * @param params Save parameters
+     */
+    save(params: SaveOptions): VisuallyJsModel;
+    /**
+     * Method stub for subclasses to implement for fetching a URL
+     */
+    protected abstract fetchUrl(options: UrlFetchOptions): void;
+    /**
+     * Exports the current data to JSON.
+     * @param params Export parameters
+     * @returns JSON payload.
+     *
+     */
+    exportData(params?: ExportOptions): any;
+    /**
+     * Helper method to allow `JSON.stringify` to be called with an instance of VisuallyJs as argument (JSON.stringify looks for a `toJSON()` method on each object it is attempting to serialise). This method generates the same output as calling `exportData()`.
+     */
+    toJSON(): any;
+    /**
+     * Gets a renderer by the `id` parameter supplied to the `render` call (which is by default null, and only renderers for which an `id` was supplied are retrievable via this method)
+     * @param id ID of the renderer to retrieve.
+     * @returns Either a Renderer that was registered against the given id, or null if none found.
+     */
+    getRenderer<E>(id: string): VisuallyJsRenderer<E>;
+    /**
+     * Gets all renderers registered on this model
+     * @internal
+     */
+    getRenderers(): Map<string, VisuallyJsRenderer<any>>;
+    private _$_dispatchToRenderers;
+    /**
+     * Registers a renderer on this model instance. For internal use.
+     * @param renderer
+     * @param id
+     * @internal
+     */
+    $addRenderer(renderer: VisuallyJsRenderer<any>, id?: string): void;
+    /**
+     * Finds information related to the given object, which may be an existing model object, a Node/Group/Edge id, or the backing data for some object.
+     * @param obj A Node/Group/Edge id, or Node, Port, Group or Edge
+     * @returns ObjectInfo
+     *
+     */
+    getObjectInfo<T>(obj: string | Edge | Node | Port | Group | ObjectData): ObjectInfo<T>;
+    /**
+     * Undo the latest operation, if there is one. Otherwise does nothing.
+     */
+    undo(): void;
+    /**
+     * Redo the latest operation that was undone, if there is one. Otherwise does nothing.
+     */
+    redo(): void;
+    /**
+     * Opens a transaction and runs the given function within it, then commits the transaction. If your function returns false (boolean false, not false-y), the transaction is rolled back instead of committed.
+     * @param fn Function to run.
+     * @param cleanupAction What to do if a transaction already exists.
+     * @return A string providing the transaction's ID, null if no transaction was created.
+     */
+    transaction(fn: () => any, cleanupAction?: TransactionCleanupAction): string | false;
+    /**
+     * @internal
+     * @param fn
+     * @param cleanupAction
+     * @param canRunOutsideTransaction
+     */
+    $transaction(fn: () => any, cleanupAction: TransactionCleanupAction, canRunOutsideTransaction: boolean): string | false;
+    /**
+     * Opens a transaction and runs the given function. If the function returns true, the model changes from this transaction are merged with the previous entry on the undo stack, to form a new compound action, which can then be treated atomically. If the function return false, the transaction is rolled back and nothing is merged. If an uncommitted transaction is active when this method is called, the actions in this transaction are appended to the transaction in progress. This method is useful for situations where some user activity has resulted in a model change, and you want to respond with a further set of model changes, but you want to be able to undo/redo all of the actions as one unit.
+     * @return A string providing the associated transaction's ID, null if nothing was merged to a transaction.
+     * @param fn
+     */
+    mergeTransaction(fn: () => any): string | false;
+    /**
+     * Opens a transaction.
+     * @param cleanupAction What to do if a transaction already exists. If you supply nothing, or an inappropriate value, here and there is a current transaction, then an Error is thrown.
+     * @param cleanupAction action to perform if a transaction already exists
+     *
+     */
+    openTransaction(cleanupAction?: TransactionCleanupAction): string;
+    /**
+     * Rolls back the current transaction, undoing any changes to the data model made in the transaction. If there is no current transaction this method does nothing.
+     */
+    rollbackTransaction(): void;
+    /**
+     * Commits any changes made in the current transaction to the undo stack. If there is no current transaction this method does nothing.
+     */
+    commitTransaction(commitAll?: boolean): void;
+    /**
+     * Clears out the undo/redo stacks and discards (neither commits nor rolls back) any existing transaction.
+     */
+    flushUndoRedo(): void;
+    get version(): string;
+    /**
+     * Derives an appropriate ID for the given data that represents an edge. If the data is null we return a new uuid. If the data is a string we return that string. If the data has a property identifying its id (which by default is the `id` property), we return that property's value. If all else fails we return a new uuid.
+     * @param data
+     * @internal
+     */
+    private $_deriveEdgeId;
+}