/// /// declare module "Graphs/Enum" { /** * Specifies the final position of an assistant node. Assistants with type left * or right are always positioned to the left or right respectively. The position * of the "normal" assistants depends on their index in the children list. */ export type AssistantPosition = number; export namespace AssistantPosition { const Left: number; const Right: number; } /** * Indicates the type of an assistant node in a tree. */ export type AssistantType = number; export namespace AssistantType { export const Normal: number; const Left_1: number; export { Left_1 as Left }; const Right_1: number; export { Right_1 as Right }; } /** * Defines values that specify how automatic layout algorithms align links to anchor points. */ export type Anchoring = number; export namespace Anchoring { const Ignore: number; const Keep: number; const Reassign: number; const Custom: number; } /** * Specifies in what direction to place nodes processed by a layout algorithm. */ export type LayoutDirection = number; export namespace LayoutDirection { const TopToBottom: number; const LeftToRight: number; const BottomToTop: number; const RightToLeft: number; } /** * Specifies the shape of the diagram links after they are laid out. */ export type TreeLayoutLinkType = number; export namespace TreeLayoutLinkType { const Default: number; const Straight: number; const Cascading: number; } /** * Specifies placement of graph connected components relatively to each other. */ export type MultipleGraphsPlacement = number; export namespace MultipleGraphsPlacement { const Vertical: number; const Horizontal: number; const MinimalArea: number; } /** * Specifies general layout orientation. */ export type Orientation = number; export namespace Orientation { const Vertical_1: number; export { Vertical_1 as Vertical }; const Horizontal_1: number; export { Horizontal_1 as Horizontal }; } } declare module "Graphs/Vertex" { export default Vertex; /** * @class Represents a vertex in a graph. */ class Vertex { /** * A list containing all edges incident with this vertex. * returns {Array} */ edges: any[]; /** * A list containing all outgoing edges. */ outEdges: any[]; /** * A list containing all incoming edges. */ inEdges: any[]; /** * The relative weight of this vertex. */ weight: number; /** * For internal use only. * @private */ private clone; /** * For internal use only. * @private */ private removeEdge; /** * Checks if the current vertex is incident with the specified edge. * @param {Edge} edge The edge to check. * @returns {Boolean} true if the vertex is incident with the edge; otherwise, false. */ incidentWith(edge: any): boolean; /** * Checks if there is an edge connecting this vertex with the specified vertex. * @param {Vertex} vertex The vertex to check. * @returns {Boolean} true if the vertices are connected; otherwise, false. */ adjacentTo(vertex: Vertex): boolean; /** * Finds the edge connecting the current vertex with the specified vertex. * @param {Vertex} vertex The vertex to find an edge for. * @returns {Edge} The edge connecting the vertices or null. */ getCommonEdge(vertex: Vertex): any; getCommonEdges(vertex: any): boolean; /** * For internal use only. * @private */ private edgeTo; /** * Returns an array containing all vertices adjacent to the current vertex. * @returns {Array} A list with all neighbors. */ getNeighbors(): any[]; /** * Returns the number of incident edges. * @returns {Number} The number of incident edges. */ degree(): number; inDegree(): number; outDegree(): number; toString(): any; } } declare module "Graphs/Edge" { export default Edge; /** * @class Represents an edge connecting two vertices in a graph. */ class Edge { /** * Initializes a new instance of the Edge class. * @constructor * @param {Vertex} origin The origin vertex. * @param {Vertex} destination The destination vertex. */ constructor(origin: any, destination: any, prototype: any); /** * The origin vertex. */ origin: any; /** * The destination vertex. */ destination: any; weight: any; /** * Returns the vertex connected by this edge that is not the specified vertex. * @param {Vertex} vertex One of the vertices connected by this edge. * @returns {Vertex} The other vertex connected by this edge. */ getOtherEnd(vertex: any): any; /** * Returns a common vertex for the current edge and the specified edge. * @param {Edge} edge The edge for which to find common vertex. * @returns {Vertex} The common vertex if it exists, otherwise null. */ getCommonVertex(edge: Edge): any; /** * Checks if the current edge connects the specified vertices. * @param {Vertex} v1 The first vertex. * @param {Vertex} v2 The second vertex. * @returns {Boolean} true if the current edge connects the specified vertices; otherwise, false. */ joins(v1: any, v2: any): boolean; /** * Returns an array containing the origin and destination vertices of this edge. * @returns {Array} An array containing the related vertices. */ getEnds(): any[]; /** * Checks if the current edge is incident with the specified vertex. * @param {Vertex} vertex The vertex to check. * @returns {Boolean} true if the edge is incident with the vertex; otherwise, false. */ incidentWith(vertex: any): boolean; /** * Checks if the current edge is adjacent to the specified edge, that is, * they have common vertex. * @param {Edge} edge The edge to check. * @returns {Boolean} true if the current edge is adjacent to the specified edge; otherwise, false. */ adjacentTo(edge: Edge): boolean; /** * Changes the origin of the current edge to the specified vertex. * @param {Vertex} vertex The new origin of the edge. */ changeOrigin(v: any): void; /** * Changes the destination of the current edge to the specified vertex. * @param {Vertex} vertex The new destination of the edge. */ changeDestination(v: any): void; changeVertex(v: any, w: any): void; /** * Reverses this edge. */ reverse(): void; directTo(destination: any): void; /** * Creates a new edge similar to the current edge but with reversed direction. * @returns {Edge} */ createReverseEdge(): Edge; toString(): string; } } declare module "Graphs/PQTree" { export class PQTree { init(): void; consecutiveNodes: any; modifiedNodes: any[]; root: any; reinit(): void; reduction(s: any): any; bubble(s: any): boolean; reduce(s: any): any; pertinentRoot: any; templateL1(lNode: any): boolean; templateP1(pNode: any): boolean; templateP2(pNode: any): boolean; templateP3(pNode: any): boolean; templateP4(pNode: any): boolean; templateP5(pNode: any): boolean; templateP6(pNode: any): boolean; templateQ1(qNode: any): boolean; templateQ2(qNode: any): boolean; templateQ3(qNode: any): boolean; } export namespace PQTree { export { Node }; export { NodePair }; } export namespace NodeType { const pNode: number; const qNode: number; const directionIndicator: number; } export namespace NodeLabel { const empty: number; const partial: number; const full: number; } class Node { constructor(type: any, data: any); data: any; immediateSiblings: { nodes: any[]; trackDirection: boolean; directedTowardsIndex: any; add(node: any): void; remove(node: any): boolean; removeAt(index: any): boolean; getOther(node: any): any; replace(oldNode: any, newNode: any): void; indexOf(node: any): number; contains(node: any): boolean; get(index: any): any; readonly count: number; direction: any; }; readInReverseDirection: boolean; init(nodeType: any): void; _type: any; parent: any; endMostChildren: any; circularLink: any; left: any; right: any; childCount: any; fullChildrenList: any; fullLeft: any; fullRight: any; fullChildren: any; partialChildrenList: any; partialLeft: any; partialRight: any; partialChildren: any; pertinentChildCount: any; pertinentLeafCount: any; _label: any; blocked: boolean; queued: boolean; pseudoRoot: any; destroyed: any; destroy(): void; reinit(reinitParent: any): void; set label(arg: any); get label(): any; getBlockedSiblings(): any[]; getUnblockedSiblings(): any[]; getEndMostDirectedSibling(otherSide: any): any; getNonDirectedSibling(otherSide: any): any; setPseudoRoot(blockedList: any): void; set type(arg: any); get type(): any; getMaximalConsecutiveBlockedSiblings(): any[]; markBlocked(): void; markUnblocked(): void; markQueued(): void; fullChildrenAreAdjacent(): boolean; fullChildrenAreAdjacentTo(node: any): any; fullChildrenAreEndMost(): boolean; partialChildrenAtEnds(): boolean; endMostChildrenAreEmptyOrPartial(): boolean; childrenAreFull(): boolean; twoChildrenLeft(): boolean; getPartialChild(index: any): any; getFirstFullChild(): any; getFirstEmptyChild(): any; addToFullList(node: any): void; removeFromFullList(node: any): void; addToPartialList(node: any): void; removeFromPartialList(node: any): void; addChildToPNode(node: any): void; removeChildFromPNode(node: any): void; addChildToQNode(node: any): void; removeChildFromQNode(node: any): void; addChildToPseudoRoot(node: any): void; addChild(node: any, updateTree: any): void; removeChild(node: any, updateTree: any): void; replaceChild(node: any, newNode: any): void; getPertinentNeighbor(si: any): any; getEmptyNeighbor(si: any): any; getEndMostChild(nodeLabel: any): any; absorbPartialChild(qNode: any): void; replaceFullChildrenWith(node: any): void; becomeChild(theChild: any): void; moveFullChildrenTo(newParent: any): void; checkLabelDirected(node: any, nodeLabel: any): any; hasChildren(): boolean; getEndmostLeaves(): any[]; getAllNodes(list: any, nodeType: any): void; getQChildren(): any[]; getLeaf(): any; siblingOf(node: any): boolean; getFullLeavesFrom(): any; getFullLeavesTo(): any; getFullLeaves(): any[]; get nextPSibling(): any; get childLink(): any; get children(): any; get emptyChildren(): number; get unmarked(): boolean; set direction(arg: any); get direction(): any; } class NodePair { constructor(directionIndex: any); nodes: any[]; trackDirection: boolean; directedTowardsIndex: any; add(node: any): void; remove(node: any): boolean; removeAt(index: any): boolean; getOther(node: any): any; replace(oldNode: any, newNode: any): void; indexOf(node: any): number; contains(node: any): boolean; get(index: any): any; get count(): number; set direction(arg: any); get direction(): any; } export {}; } declare module "Graphs/Face" { /** * @namespace MindFusion.Graphs */ export default class Face { constructor(prototype: any); edges: any; incidentWith(v: any): boolean; adjacentTo(face: any): boolean; getCommonEdge(face: any): any; get degree(): any; getVertices(): Set; enumVertices(): any[]; isCycle(): boolean; edgeFromVertex(vertex: any): any; replaceEdge(edge: any, replacement: any): void; get bigAngles(): any[]; _bigAngles: any[]; } } declare module "Graphs/Embedding" { export default class Embedding { constructor(graph: any, copy: any, vertexCopyToOrigMap: any, edgeCopyToOrigMap: any); graph: any; embedding: any; addBlockEmbedding(block: any, blockEmbedding: any): void; add(v: any): void; remove(v: any): void; getNextRightFaceEdge(e: any): any; createDirectedEdges(): void; reverseEdges: Map; replaceEdges(e: any, e1: any, e2: any, r: any, r1: any, r2: any, newVertex: any): void; addEdge(e: any, r: any, fromEdge: any, toEdge: any): void; getNext(v: any, e: any): any; getPrevious(v: any, e: any): any; setReverseEdges(e: any, r: any): void; isVertexBimodal(v: any): boolean; isBimodal(): boolean; contractEdge(edge: any, vertex: any): void; replaceEdge(edge: any, vertex: any): void; quasiCapacity(face: any): number; countSourceSwitches(face: any): number; enumerateFaces(): void; _faces: any[]; faceOnLeftMap: Map; faceOnRightMap: Map; externalFace: any; enumerateFaceEdges(startEdge: any, startVertex: any): Face; prevInEmbedding(edge: any, vertex: any): any; insertEdge(edge: any, vertex: any, face: any): void; edgesBetween(edge1: any, edge2: any, vertex: any): any[]; getReverse(e: any): any; get(v: any): any; get vertices(): any; get faces(): any[]; } import Face from "Graphs/Face"; } declare module "Graphs/Interval" { /** * @namespace MindFusion.Graphs */ export default class Interval { constructor(min: any, max: any); min: any; max: any; contains(interval: any): boolean; intersects(interval: any): boolean; overlaps(interval: any): boolean; } } declare module "Graphs/BinaryTree" { /** * @namespace MindFusion.Graphs */ class BinaryTree { constructor(item: any); root: { item: any; addChildren(left: any, right: any): void; left: any; right: any; getLeaves(): any[]; collectLeaves(leaves: any): void; }; getLeaves(): any[]; } namespace BinaryTree { export { Node }; } export default BinaryTree; class Node { constructor(item: any); item: any; addChildren(left: any, right: any): void; left: { item: any; addChildren(left: any, right: any): void; left: any; right: any; getLeaves(): any[]; collectLeaves(leaves: any): void; }; right: { item: any; addChildren(left: any, right: any): void; left: any; right: any; getLeaves(): any[]; collectLeaves(leaves: any): void; }; getLeaves(): any[]; collectLeaves(leaves: any): void; } } declare module "Graphs/PriorityQueue" { /** * @namespace MindFusion.Graphs */ export default class PriorityQueue { constructor(maxN: any, array: any); a: any; N: number; d: number; pq: number[]; qp: number[]; empty(): boolean; insert(v: any): void; getMin(): number; lower(k: any): void; less(i: any, j: any): boolean; exchange(i: any, j: any): void; swim(k: any): void; sink(k: any, N: any): void; } } declare module "Graphs/Factory" { /** * @namespace MindFusion.Graphs */ export default class Factory { } } declare module "Graphs/TreeHelper" { export default class TreeHelper { constructor(reversedLinks: any); reversedLinks: any; parentNode(edge: any): any; childNode(edge: any): any; parentEdges(vertex: any): any; childEdges(vertex: any): any; assignPoints(edge: any, points: any): void; } } declare module "Graphs/Graph" { /** * @class Represents a graph. */ export class Graph { /** * A list containing all vertices in the graph. */ vertices: any[]; /** * A list containing all edges in the graph. */ edges: any[]; /** * Creates an exact copy of the current graph. * @param {Boolean} [saveMapping] Indicates whether to store vertex and edge mapping information in the copy. * @returns {Graph} The newly created copy. */ clone(saveMapping?: boolean): Graph; cloneSubset(vertexSubset: any, saveMapping: any): Graph; createReverseMaps(): void; vertexOrigToCopyMap: Map; edgeOrigToCopyMap: Map; /** * Returns a new graph object containing a subset of the vertices and edges * of the original graph, such that the new graph is a tree. * @param {Vertex} root The desired root vertex of the tree. * @param {Boolean} enableAssistants * @param {Boolean} compactAssistants * @returns {Graph} The newly created tree. */ tree(root: Vertex, reversedLinks: any, enableAssistants: boolean, compactAssistants: boolean): Graph; collectLevels(parent: any): void; /** * @private */ private childrenOf; /** * Reassigns tree levels when "assistants" are enabled. * @private */ private reassignLevels; /** * Creates a new edge connecting the specified vertices and adds it to the graph. * @param {Vertex} origin The origin vertex. * @param {Vertex} destination The destination vertex. * @param {Object} [owner] The owner of the new edge. * @returns {Edge} The newly created edge. */ createEdge(origin: Vertex, destination: Vertex, owner?: any): Edge; createEdgeP(origin: any, destination: any, prototype: any): Edge; /** * Adds an existing edge to the graph. * @param {Edge} edge The edge to add. */ addEdge(edge: Edge): void; /** * Removes an edge from the graph. * @param {Edge} edge The edge to remove. */ removeEdge(edge: Edge): void; removeAllEdges(): void; /** * Creates a new vertex with the specified position and size and adds it to the graph. * @param {Rect} layoutRect A rectangle specifying the position and size of the vertex. * @param {Object} [owner] The owner of the new vertex. * @returns {Vertex} The newly created vertex. */ createVertex(layoutRect: any, owner?: any): Vertex; removeVertex(vertex: any): void; /** * Adds an existing vertex and its related edges to the graph. * @param {Vertex} vertex The vertex to add. * @private */ private addVertexAndOutEdges; addVertex(debugId: any): Vertex; /** * Assigns unique indices to the items in the graph. * @private */ private setItemIndices; splitEdge(e: any): Vertex; findShortestPathVS(v1: any, destSet: any): any[]; findShortestPathSS(originSet: any, destSet: any): any[]; findShortestPathBfs(e: any, destSet: any, mark: any, searchTree: any, path: any): void; findShortestWeightedPathVS(origin: any, destSet: any, outMinWeigth: any): any[]; findShortestWeightedPathSS(originSet: any, destSet: any): any[]; /** * Returns a list with the connected subgraphs in the current graph. * @returns {Array} An array with connected Graph objects. */ getConnectedComponents(): any[]; searchCounter: number; /** * Performs a depth-first search for connected components. * @private */ private dfsConnectivity; getBiconnectedComponents(saveMapping: any, blocksHandler: any): any[]; getBiconnectedComponentsOfConnectedGraph(): any[]; visitedEdges: any[]; cutVertices: any[]; foundComponents: any[]; secondLevel: any[]; searchOrder: any[]; backMostEdges: any[]; biconnectivityDfs(parent: any, vertexId: any): void; stackToComponent2(child: any): void; getBiconnectedComponents2(): Graph[]; planarMakeBiconnected(): Edge[]; stillPlanar(v1: any, v2: any): boolean; father(vertex: any): any; getOutsideVertexCP(cutpoints: any): any; getOutsideVertexCPN(cutpoints: any, neighbor: any): any; get3EdgeConnectedComponents(): any[]; getCutPairs(): any[]; test3EdgeConnectivity(returnPairs: any): any[]; findBlockSeparationPairs(): any[][]; findBlockSeparationPairsB(): any[]; depthFirstSearch(start: any): void; searchParent: any[]; searchComponent(origin: any, dest: any): void; getStNumbering(sink: any): any[]; stOrder: any[]; convertToStGraph(sink: any): any[]; isCycleEdge(edge: any): boolean; findPath(v: any, oldVertices: any, oldEdges: any): any[]; isPlanar(): boolean; isPlanarSingleBicomponent(embeddingInfo: any): boolean; getPlanarEmbedding(): Embedding; getPlanarEmbeddingSingleBicomp(embeddingInfo: any): Map; /** * Should be called on a planar graph. * @param {Map} [embedding] Receives the embedding lists. * @param {Map} [embeddingInfo] Optional. * @returns {Vertex} The t node in st ordering. */ getUpwardEmbedding(embedding?: Map, embeddingInfo?: Map): Vertex; entireEmbed(upEmbedding: any, tVertex: any): Map; entireEmbedDfs(upEmbedding: any, entireEmbedding: any, vertex: any, oldVertices: any): void; findPlanarSubgraph(edgesToDelete: any, crossingConstrainedEdges: any): any; findPlanarSubgraphBySimpleEdgeInsertion(edgesToDelete: any, knownPlanarEdges: any, crossingConstrainedEdges: any): any; findPlanarSubgraphByBookEmbedding(edgesToDelete: any, crossingConstrainedEdges: any): any; minAdjacenciesNeighbor(vertex: any, vset: any): any; minDegreeVertex(vset: any): any; countAdjacencies(vertex: any, vset: any): number; embedOnSameFace(faceVertices: any): Embedding; planarize(edgeToDummyEdgesMap: any, crossingConstrainedEdges: any): any; /** * Makes the graph acyclic by reversing the direction of selected edges. * @returns {Array} A list with all edges that were reversed in order to make the graph acyclic. * @remarks Must be called on a simple connected graph. */ makeAcyclic(): any[]; getDualGraph(cacheIncidentFaces: any): any; getDualGraphE(embedding: any, s: any, t: any): any; topologicalSort(): any[]; postCounter: number; topologicalSortDfs(postOrder: any, topologicalOrder: any, dest: any): boolean; getWeightedTopologicalNumbering(minNumber: any): any[]; getWeightedTopologicalNumberingTS(tsort: any, minNumber: any): any[]; splitToMaxDegree(maxDegree: any, embedding: any): Map; splitToMaxDegreeV(vertex: any, maxDegree: any, embedding: any): Graph; reorderTopologically(): void; maxWeightedCliqueOfTransitiveDAG(): any[]; } import Vertex from "Graphs/Vertex"; import Edge from "Graphs/Edge"; import Embedding from "Graphs/Embedding"; } declare module "Graphs/BlockCutpointGraph" { export default class BlockCutpointGraph extends Graph { constructor(graph: any); targetGraph: any; blockToBnodeMap: Map; cutToCnodeMap: Map; blocks: any; onComponentBlocks(componentBlocks: any, componentCuts: any): void; cutVerticesB(block: any): any[]; cutVerticesV(bNode: any): any[]; isPendant(bNode: any): boolean; adjacentBlocks(cutVertex: any): any[]; directFromRoot(): void; root: any; directFrom(parent: any, vertex: any): void; findPendantCut(): any; getOutsideVertex(bNode: any): any; getOutsideVertexN(bNode: any, neighborCnode: any): any; getBlock(bNode: any): any; getCutvertex(cNode: any): any; getCnode(cut: any): any; mapVertices(vertices: any, map: any): any[]; mergeBlocks(bnodes: any, parent: any): void; setNewParent(vertex: any, parent: any): void; removeCnode(cNode: any): void; removeBnode(bNode: any): void; isCnode(vertex: any): boolean; isBnode(vertex: any): boolean; } import { Graph } from "Graphs/Graph"; } declare module "Graphs/DualGraph" { export default class DualGraph extends Graph { constructor(graph: any, embedding: any, cacheIncidentFaces: any, s: any, t: any); graph: any; embedding: any; faces: Face[]; edgeToFaceMap: Map; incidentFaces: Map; faceToVertexMap: Map; vertexToFaceMap: Map; splitExternalFace(s: any, t: any): void; leftExFace: any; leftExVertex: any; rightExFace: Face; rightExVertex: Vertex; getIncidentFaces(v: any): any; cacheIncidentFace(v: any, f: any): void; getVertices(face: any): Set; getFaceVertices(faceList: any): Set; getCommonEdge(f1: any, f2: any): any; getCommonEdgeMinWeight(f1: any, f2: any): any; getOriginalEdge(e: any): any; replaceEdge(oldEdge: any, newVertex: any): void; splitFace(f: any, newEdge: any): void; dgCreateVertex(f: any): Vertex; dgCreateEdge(e: any): Edge; setFaceIndices(): void; left(e: any): any; right(e: any): any; } import { Graph } from "Graphs/Graph"; import Face from "Graphs/Face"; import Vertex from "Graphs/Vertex"; import Edge from "Graphs/Edge"; } declare module "Graphs/IntervalGraph" { export default class IntervalGraph extends Graph { constructor(intervals: any); intervalVertices: Map; intervals: any; maxWeightedIndependentSet(): any[]; } import { Graph } from "Graphs/Graph"; } declare module "Graphs/OverlapGraph" { export default class OverlapGraph extends Graph { constructor(intervals: any); intervalVertices: Map; vertexIntervals: Map; intervals: any; maxIndependentSet(): Set; inclusionLevels: Map; levelVertices: any[]; setInclusionLevel(vertex: any): any; assignVertexToLevel(vertex: any, level: any): void; } import { Graph } from "Graphs/Graph"; } declare module "Graphs/Path" { export default Path; /** * @namespace MindFusion.Graphs */ class Path { static isNode(obj: any): boolean; static isLink(obj: any): boolean; /** * Initializes a new instance of the Path class. * @constructor */ constructor(path: any); nodes: any[]; links: any[]; items: any[]; contains(item: any): boolean; getWeight(incNodes: any, incLinks: any): number; add(link: any, node: any): void; } } declare module "Graphs/PathFinder" { export class PathFinder { /** * Finds and returns all paths starting from node 'from' and * ending at node 'to'. Returns empty collection if no * path exists. */ static findAllPaths(graph: any, from: any, to: any): Path[]; static findPaths(graph: any, from: any, to: any, shortestOnly: any, maxPaths: any): Path[]; static findShortestPath(graph: any, from: any, to: any, useNodeWeights: any, useLinkWeights: any): Path; static findLongestPath(graph: any, from: any, to: any): Path; static findLongUndirectedPath(graph: any, timeLimit: any): any; static findCycle(graph: any, participant: any): Path; static enumAllCycles(graph: any): any[]; static enumAllCyclesDirected(graph: any, callbackEnum: any): void; static deleted(v: any): any; static geometricDistance(v1: any, v2: any): number; static generateShortestRoute(graph: any, weight: any): Path; static findShortestRoute(graph: any): Path; } import Path from "Graphs/Path"; } declare module "Graphs/Layout" { /** * @class Superclass of graph layout algorithms that defines their common properties. */ export class Layout { set anchoring(arg: number); /** * Gets or sets how to align links to the anchor points of nodes. * @type {Anchoring} * @summary A member of the LayoutDirection enumeration. */ get anchoring(): number; set keepGroupLayout(arg: boolean); /** * Gets or sets whether to treat each group of attached nodes as a single vertex in the arranged graph. * @type {Boolean} * @summary true if each group should be processed as an integral graph node, or false otherwise. The default is false. */ get keepGroupLayout(): boolean; set multipleGraphsPlacement(arg: number); /** * Gets or sets how multiple independent graphs in the diagram should be positioned relatively to each other. * @type {MultipleGraphsPlacement} * @summary A member of the MultipleGraphsPlacement enumeration. */ get multipleGraphsPlacement(): number; set margins(arg: number); /** * Gets or sets the margins' size around individual subgraphs processed by this layout object. * @type {Number} * @summary A number specifying size of margins around arranged graphs. */ get margins(): number; _anchoring: number; _keepGroupLayout: boolean; _multipleGraphsPlacement: number; _margins: number; get setsLinkEndPoints(): boolean; get setsLinkPoints(): boolean; get requiresConnectedGraph(): boolean; get requiresSimpleGraph(): boolean; get routeRepeatingLinks(): boolean; get requiresBezierLinks(): boolean; get requiresCascadingLinks(): boolean; get requiresHierarchyInfo(): boolean; get isStatic(): boolean; } } declare module "Graphs/BorderedTreeLayout" { /** * @class Implements algorithms for arranging tree structures. * @augments Layout */ export class BorderedTreeLayout extends Layout { set levelDistance(arg: number); /** * Gets or sets the space to leave between adjacent levels of the tree. * @type {Number} * @summary The space to leave between adjacent levels of the tree. */ get levelDistance(): number; set nodeDistance(arg: number); /** * Gets or sets the space to leave between adjacent nodes on the same level. * @type {Number} * @summary The space to leave between adjacent nodes on the same level. */ get nodeDistance(): number; set keepRootPosition(arg: boolean); /** * Gets or sets a value indicating whether to keep the root node at its original position. * @type {Boolean} * @summary true if the root node should be kept at its original position, or false otherwise. */ get keepRootPosition(): boolean; set direction(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {LayoutDirection} * @summary A member of the LayoutDirection enumeration. */ get direction(): number; set linkType(arg: number); /** * Gets or sets the type of links in the arranged tree. * @type {TreeLayoutLinkType} * @summary A member of the TreeLayoutLinkType enumeration. */ get linkType(): number; set reversedLinks(arg: boolean); /** * Gets or sets a value indicating the link direction that relates parent nodes to child nodes. * @type {Boolean} * @summary true to indicate reversed direction (links point to parent nodes), or false otherwise. */ get reversedLinks(): boolean; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): any; treeHelper: TreeHelper; /** * @private */ private tree; /** * @private */ private x; /** * @private */ private y; /** * @private */ private rarrange; /** * Offset a branch of the tree with the specified values. * @private * * @param {Vertex} nodeFrom The root node of the branch to offset. * @param {Number} xoff The x-axis offset. * @param {Number} yoff The y-axis offset. */ private offsetBranch; /** * @private */ private isHorizontal; /** * @private */ private isStraight; getType(): any; _levelDistance: number; _nodeDistance: number; _keepRootPosition: boolean; _direction: number; _linkType: number; _reversedLinks: boolean; } import { Layout } from "Graphs/Layout"; import TreeHelper from "Graphs/TreeHelper"; } declare module "Graphs/LayoutUtils" { export default LayoutUtils; class LayoutUtils { static getGraphBounds(graph: any, defaultBounds: any): any; } } declare module "Graphs/Tools" { export function newPoint(x: any, y: any): Point; export function bounds(v: any): any; export class Tools { static GetLFarCenter(node: any, o: any): Point; static GetLNearCenter(node: any, o: any): Point; static GetBNearCenter(node: any, o: any): Point; static GetBFarCenter(node: any, o: any): Point; static MoveNode(node: any, x: any, y: any): void; static SetLinkPoints(link: any, points: any, ...args: any[]): void; static SetLinkPointsA(link: any, points: any): void; static GetLinkPoints(link: any): any; static Mirror(point: any, origin: any): Point; static GetBreadth(node: any, o: any): any; static GetBCenter(node: any, o: any): any; static GetLength(node: any, o: any): any; static GetLCenter(node: any, o: any): any; static GetBNear(node: any, o: any): any; static GetBFar(node: any, o: any): any; static GetLNear(node: any, o: any): any; static GetLFar(node: any, o: any): any; static GetBNearRect(rect: any, o: any): any; static GetBFarRect(rect: any, o: any): any; static GetLNearRect(rect: any, o: any): any; static GetLFarRect(rect: any, o: any): any; static GetB(point: any, o: any): any; static GetL(point: any, o: any): any; static OffsetL(node: any, offset: any, o: any): void; static OffsetOutLinks(links: any, offx: any, offy: any, o: any): void; } import { Point } from "@mindfusion/drawing"; } declare module "Graphs/FlowchartLayout" { /** * @class FlowchartLayout can be used to arrange flowcharts representing program source code. * @augments Layout */ export class FlowchartLayout extends Layout { set nodeDistance(arg: number); /** * Gets or sets the distance between consecutive nodes in the flowchart. * @type {Number} * @summary A numeric value specifying the distance between neighbor nodes in the same sequence. */ get nodeDistance(): number; set branchPadding(arg: number); /** * Gets or sets how much space to leave between adjacent decision branches in the flowchart. * @type {Number} * @summary A numeric value specifying the distance between adjacent branches. */ get branchPadding(): number; set linkPadding(arg: number); /** * Gets or sets how much space to leave between adjacent back links designating nested loops. * @type {Number} * @summary A numeric value specifying the distance between adjacent back links. */ get linkPadding(): number; set orientation(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {Orientation} * @summary A member of the Orientation enumeration. */ get orientation(): number; nodeOrder: Map; progressCounter: number; branchings: any[]; visitedNodes: Map; postOrder: Map; topologicalOrder: Map; searchCounter: number; flowchartNodes: Map; mm: number; arrange(graph: any): boolean; graph: any; placedNodes: any[]; furthestL: number; layoutRect: any; composeFlowChart(startNode: any): any; composeBlocks(node: any, parentBlock: any, loopDepth: any, onlyNotVisited: any, ignoreMerge: any): any; getSequence(block: any): any; followedByMergeNode(block: any): boolean; getFlowchartNode(node: any): any; getStartNodes(): any[]; getOutgoingDownLinks(node: any): number; getIncomingDownLinks(node: any): number; getType(): any; getOutgoingLoopLinks(node: any): number; getIncomingLoopLinks(node: any): number; isVisited(node: any): boolean; isStartNode(node: any): boolean; isEndNode(node: any): boolean; inDegree(node: any): any; outDegree(node: any): any; isBackLink(link: any): boolean; isDownLink(link: any): boolean; depthFirstSearch(node: any): void; topologicalSort(startNode: any, graphOrder: any): Map; getDownLinks(links: any): any[]; getTopologicalOrder(): Map; findPath(link: any, o: any, relaxed: any): Point[]; segmentsFromPoints(points: any): { index: number; points: any; horizontal(): boolean; xint(): any[]; yint(): any[]; }[]; pullLinksApart(links: any): void; splitPaths(links: any, horizontal: any): void; _branchPadding: number; _linkPadding: number; _nodeDistance: number; _orientation: number; dumpGraph(): void; } import { Layout } from "Graphs/Layout"; import { Point } from "@mindfusion/drawing"; } declare module "Graphs/FractalLayout" { /** * @class The FractalLayout tree layout algorithm places child nodes symmetrically around their parent node. * Nodes at the lowest level are arranged directly in a circle around their parent. At the upper level, * the already arranged nodes form branches that are arranged in a circle around the new parent node. * The algorithm is recursively repeated till the highest level is reached. * @augments Layout */ export class FractalLayout extends Layout { set root(arg: any); /** * Gets or sets the node that should be placed at the center of the tree. * @type {DiagramNode} * @summary The node that should be placed at the center of the tree. */ get root(): any; arrange(graph: any): void; branchCircles: Map; measureCircles(node: any): { node: any; radius: any; centerX: any; centerY: any; childCircles: any[]; }; arrangeCircles(circle: any, center: any, angle: any): void; getType(): any; _root: any; } import { Layout } from "Graphs/Layout"; } declare module "Graphs/LayeredLayout" { /** * @class Implements a layered graph layout algorithm. * This algorithm assigns diagram nodes to distinct horizontal or vertical layers. * While arranging the layers, the layout routine seeks to meet the following criteria: * - connected nodes must be placed close together; * - links must flow in one direction if possible; * - links must cross as few layers as possible; * - links must not cross other links; * @augments Layout */ export class LayeredLayout extends Layout { set nodeDistance(arg: number); /** * Gets or sets the space to leave between adjacent nodes on the same level. * @type {Number} * @summary The space to leave between adjacent nodes on the same level. */ get nodeDistance(): number; set layerDistance(arg: number); /** * Gets or sets the desired distance between layer axis lines. * @type {Number} * @summary The desired distance between layer axis lines. */ get layerDistance(): number; set direction(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {LayoutDirection} * @summary A member of the LayoutDirection enumeration. */ get direction(): number; set siftingRounds(arg: number); /** * Gets or sets the number of iterations to perform when untwining the layout. * @type {Number} * @summary The number of iterations to perform when untwining the layout. */ get siftingRounds(): number; initialMinimizeCrossingsDown: boolean; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): void; graph: any; reversedEdges: any; assignLayers(): void; layers: any[]; /** * @private */ private setMinDist; /** * @private */ private getMinDist; /** * @private */ private computeLeftClasses; nodeLeftClass: any; /** * @private */ private computeRightClasses; nodeRightClass: any; /** * @private */ private computeClasses; /** * @private */ private placeLeftToRight; dump(pos: any): void; /** * @private */ private placeRightToLeft; /** * @private */ private assignCoordinates; minDistances: any[]; downNodes: Map; upNodes: Map; /** * @private */ private adjustDirections; /** * @private */ private getNeighborOnLayer; /** * @private */ private placeSequence; /** * @private */ private placeSingle; /** * @private */ private combineSequences; /** * @private */ private placeLeft; /** * @private */ private placeRight; /** * @private */ private leftSibling; /** * @private */ private rightSibling; /** * @private */ private L; /** * Move nodes to their barycenters, according to their * priority but doing so without any box swapping * (i.e. the boxes' order remains the same). * @private */ private layout; /** * @private */ private layoutLayer; /** * @private */ private moveRight; /** * @private */ private moveLeft; /** * @private */ private mapVirtualNode; /** * @private */ private nodesInLongLink; /** * @private */ private dummify; linkToNodeMap: Map; nodeToLinkMap: Map; /** * @private */ private dedummify; /** * Tries to minimize crossings across all levels. * @private */ private minimizeCrossings; /** * Calculates up barycenters and linkCount for the nodes * in the layer whose index is specified in the parameter. * @private */ private calcUpData; /** * Calculates down barycenters and linkCount for the nodes * in the layer whose index is specified in the parameter. * @private */ private calcDownData; /** * Tries to minimize crossings between layers 'layer' and * 'layer' + 1 if down is true and between layers 'layer' - 1 * and 'layer' if down is false. * @private */ private minimizeCrossingsDir; /** * This method performs a single pass over the graph in an attempt to reduce * link crossings through neighbors swapping. * @private */ private swapPairs; /** * Returns the total number of crossings for the links inbetween the specified layers. * @private */ private countCrossings; getType(): any; _nodeDistance: number; _layerDistance: number; _direction: number; _siftingRounds: number; set startNode(arg: any); /** * Gets or sets the node that should be placed in the first layer of the arranged graph. * @type {DiagramNode} * @summary A DiagramNode object representing the start node. */ get startNode(): any; _startNode: any; set endNode(arg: any); /** * Gets or sets the node that should be placed in the last layer of the arranged graph. * @type {DiagramNode} * @summary A DiagramNode object representing the end node. */ get endNode(): any; _endNode: any; } import { Layout } from "Graphs/Layout"; } declare module "Graphs/SpringLayout" { /** * @class Implements the Spring-Embedder graph layout algorithm. * @augments Layout */ export class SpringLayout extends Layout { set nodeDistance(arg: number); /** * Gets or sets the desired distance between nodes. * @type {Number} * @summary the desired distance between nodes. */ get nodeDistance(): number; set iterations(arg: number); /** * Gets or sets the number of iterations to run the layout routine. * @type {Number} * @summary The number of iterations to run the layout routine. */ get iterations(): number; /** * @private */ private refineStage; /** * @private */ private initialTemperature; /** * @private */ private temperature; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): void; graph: any; width: number; height: number; /** * @private */ private moveToEpsilonCircle; /** * @private */ private attraction; /** * @private */ private repulsion; /** * @private */ private calcRepulsionForce; /** * @private */ private calcSpringForce; /** * @private */ private applyForce; getType(): any; _nodeDistance: number; _iterations: number; } import { Layout } from "Graphs/Layout"; } declare module "Graphs/TopologicalLayout" { /** * @class Implements a topological ordering. * The algorithm arranges nodes in a row or a column (depending on the value of the direction property) * in such a way that there are as few back links as possible. The links connecting non-adjacent nodes * are rendered as arcs. The links connecting adjacent nodes are rendered either as arcs or as straight lines, * depending on the bendAdjacentLinks property. The amplitude of the link arcs is proportional to the * distance between the connected nodes. All forward links are rendered at one side of the nodes and all * back links are rendered at the opposite side. Thus, all bent links follow the same rotation direction. * @augments Layout */ export class TopologicalLayout extends Layout { set nodeDistance(arg: number); /** * Gets or sets the desired distance between adjacent nodes. * @type {Number} * @summary The desired distance between adjacent nodes. */ get nodeDistance(): number; set direction(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {LayoutDirection} * @summary A member of the LayoutDirection enumeration. */ get direction(): number; set bendAdjacentLinks(arg: boolean); /** * Gets or sets a value indicating whether to bend links connecting adjacent nodes or draw them as straight lines. * @type {Boolean} * @summary true to bend links connecting adjacent nodes, or false otherwise. */ get bendAdjacentLinks(): boolean; mm: number; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): boolean; graph: any; getType(): any; _nodeDistance: number; _direction: number; _bendAdjacentLinks: boolean; } import { Layout } from "Graphs/Layout"; } declare module "Graphs/TreeLayout" { /** * @class Implements algorithms for arranging tree structures. * @augments Layout */ export class TreeLayout extends Layout { set levelDistance(arg: number); /** * Gets or sets the space to leave between adjacent levels of the tree. * @type {Number} * @summary The space to leave between adjacent levels of the tree. */ get levelDistance(): number; set nodeDistance(arg: number); /** * Gets or sets the space to leave between adjacent nodes on the same level. * @type {Number} * @summary The space to leave between adjacent nodes on the same level. */ get nodeDistance(): number; set keepRootPosition(arg: boolean); /** * Gets or sets a value indicating whether to keep the root node at its original position. * @type {Boolean} * @summary true if the root node should be kept at its original position, or false otherwise. */ get keepRootPosition(): boolean; set direction(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {LayoutDirection} * @summary A member of the LayoutDirection enumeration. */ get direction(): number; set linkType(arg: number); /** * Gets or sets the type of the links in the arranged tree. * @type {TreeLayoutLinkType} * @summary A member of the TreeLayoutLinkType enumeration. */ get linkType(): number; set enableAssistants(arg: boolean); /** * Gets or sets a value Indicating whether the "assistant" trait is regarded when performing the layout. * @type {Boolean} * @summary true if the "assistant" trait is regarded when performing the layout, or false otherwise. */ get enableAssistants(): boolean; set compactAssistants(arg: boolean); /** * Gets or sets a value indicating whether the "assistant" nodes on the same side of a single parent * are arranged as close to each other as possible. * @type {Boolean} * @summary true if the "assistant" nodes on the same side of a single parent * are arranged as close to each other as possible, or false otherwise. */ get compactAssistants(): boolean; set reversedLinks(arg: boolean); /** * Gets or sets a value indicating the link direction that relates parent nodes to child nodes. * @type {Boolean} * @summary true to indicate reversed direction (links point to parent nodes), or false otherwise. */ get reversedLinks(): boolean; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): any; treeHelper: TreeHelper; /** * @private */ private hasAssistants; /** * Calculates the bounding rectangle of the tree branch defined by * the specified node. The result is the smallest rectangle containing * all children of the specified node and the node itself. * @private */ private branchBounds; /** * Calculate the distance between the branches, whose * root nodes are specified as arguments. * @private * * @param {Vertex} node1 The root node of the first branch. * @param {Vertex} node2 The root note of the second branch. * @returns {Number} The distance between the branches. */ private branchDistance; right(vertex: any): any; left(vertex: any): number; /** * Offset a branch of the tree with the specified values. * @private * * @param {Vertex} nodeFrom The root node of the branch to offset. * @param {Number} xoff The x-axis offset. * @param {Number} yoff The y-axis offset. */ private offsetBranch; /** * @private */ private isHorizontal; /** * @private */ private isStraight; /** * @private */ private intDiv; getType(): any; _levelDistance: number; _nodeDistance: number; _keepRootPosition: boolean; _direction: number; _linkType: number; _enableAssistants: boolean; _compactAssistants: boolean; _reversedLinks: boolean; } import { Layout } from "Graphs/Layout"; import TreeHelper from "Graphs/TreeHelper"; } declare module "Graphs/TreeMapLayout" { /** * @class Performs tree-map layout on a graph. * @augments Layout */ export class TreeMapLayout extends Layout { set orientation(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {Orientation} * @summary A member of the Orientation enumeration. */ get orientation(): number; set squarify(arg: boolean); /** * Gets or sets a value indicating whether the layout should attempt to keep the dimension ratio of nodes closer to 1. * @type {Boolean} * @summary true if the layout should attempt to keep the dimension ratio of nodes closer to 1, or false otherwise. */ get squarify(): boolean; set padding(arg: number); /** * Gets or sets the distance between adjacent nodes. * @type {Number} * @summary The distance between adjacent nodes. */ get padding(): number; set layoutArea(arg: Rect); /** * Gets or sets the rectangle in which the layout will try to arrange nodes. * @type {Rect} * @summary The rectangle in which the layout will try to arrange nodes. */ get layoutArea(): Rect; set containerPadding(arg: number); /** * Gets or sets the padding inside containers. * @type {Number} * @summary The padding inside containers. */ get containerPadding(): number; minNodeSize: number; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): void; weights: Map; arrangeSquare(nodes: any, layoutArea: any, row: any, parentWeight: any): void; doSquarify(children: any, layoutArea: any, row: any, parentWeight: any): void; weight(row: any): number; subtractPadding(rect: any): void; layoutRow(layoutArea: any, row: any, horizontal: any, parentWeight: any): number; arrangeSiblings(nodes: any, layoutArea: any, horizontal: any, totalWeight: any): void; evalRatio(row: any, sideLen: any, rowArea: any): number; calcWeights(root: any): any; layOutArea(node: any): any; getType(): any; _orientation: number; _squarify: boolean; _padding: number; _layoutArea: Rect; _containerPadding: number; } import { Layout } from "Graphs/Layout"; import { Rect } from "@mindfusion/drawing"; } declare module "Graphs/DrawingGrid" { export default DrawingGrid; class DrawingGrid { constructor(graph: any, vertexPoints: any, edgePoints: any); graph: any; vertexPoints: any; edgePoints: any; cells: { has(point: any): boolean; get(point: any): any; set(point: any, value: any): void; delete(point: any): boolean; key(point: any): string; clear(): void; forEach(callbackfn: (value: any, key: any, map: Map) => void, thisArg?: any): void; readonly size: number; entries(): IterableIterator<[any, any]>; keys(): IterableIterator; values(): IterableIterator; [Symbol.iterator](): IterableIterator<[any, any]>; readonly [Symbol.toStringTag]: string; }; bounds: { left: any; top: any; right: any; bottom: any; }; columnWidths: Map; rowHeights: Map; setCellDimensions(vertexSize: any, padding: any, edgeCellSize: any): void; minWidth: Map; maxWidth: Map; minHeight: Map; maxHeight: Map; columnPositions: Map; rowPositions: Map; getPosition(point: any): Point; getEdgePointPosition(point: any, edge: any, width: any, height: any): Point; updateBounds(point: any): void; updateBoundsFromPoints(points: any): void; refine(iterations: any): void; refineSpace(): void; refineCacheEdges(): void; refineDegreeOneVertices(): void; removeUnusedRows(): void; removeUnusedColumns(): void; removeFromCell(cell: any, p: any, edge: any, horizontal: any): void; refineUTurns(): void; removeRedundantBends(): void; setSegmentsInRange(e: any, p1: any, includeP1: any, p2: any, includeP2: any): void; removeSegmentsFromRange(e: any, p1: any, removeP1: any, p2: any, removeP2: any): void; edgeContainsRange(e: any, p1: any, includeP1: any, p2: any, includeP2: any): boolean; normalizePath(path: any, e: any, setSegments: any): void; setApartOverlappingEdges(): void; horizontalEdges: Grid; verticalEdges: Grid; getBendNeighborPoints(bend: any, column: any, row: any): any; bendsToTheLeft(bend: any, column: any, row: any): boolean; bendsToTheTop(bend: any, column: any, row: any): boolean; setHorizontalEdgesInRange(edges: any, row: any, c1: any, c2: any): void; setVerticalEdgesInRange(edges: any, column: any, r1: any, r2: any): void; countHorizontalEdgesCrossings(edges: any, row: any, c1: any, c2: any, permutation: any): number; countVerticalEdgesCrossings(edges: any, column: any, r1: any, r2: any, permutation: any): number; permuteHorizontalEdgeLanes(row: any, c1: any, c2: any, permutation: any): void; permuteVerticalEdgeLanes(column: any, r1: any, r2: any, permutation: any): void; getCell(column: any, row: any): any; } namespace DrawingGrid { export { Cell }; export { Rectangle }; export { Size }; export { EdgeSegment }; export { Bend }; export { PointMap }; export { PermutationSet }; } import { Point } from "@mindfusion/drawing"; import { Grid } from "@mindfusion/collections"; class Cell { content: any[]; add(item: any): void; removeEdgeOrBend(e: any, horizontal: any): void; countEdges(horizontal: any): number; containsVertex(): boolean; containsVertexOrBend(): boolean; containsEdge(edge: any): boolean; containsEdgeSegment(edge: any, horizontal: any): boolean; getEdgeSegment(edge: any, horizontal: any): { edge: any; dx: any; dy: any; lane: number; maxNeighbors: number; readonly horizontal: boolean; }; getEdgeBend(edge: any): { edge: any; horizontalLane: number; maxHNeighbors: number; verticalLane: number; maxVNeighbors: number; neighborPoints: any; }; getEdgeLane(edge: any, horizontal: any, neighbors: any): number; permuteLanes(permutation: any, horizontal: any): void; } class Rectangle { constructor(left: any, top: any, right: any, bottom: any); left: any; top: any; right: any; bottom: any; } class Size { constructor(width: any, height: any); width: any; height: any; } class EdgeSegment { constructor(edge: any, dx: any, dy: any); edge: any; dx: any; dy: any; lane: number; maxNeighbors: number; get horizontal(): boolean; } class Bend { constructor(edge: any); edge: any; horizontalLane: number; maxHNeighbors: number; verticalLane: number; maxVNeighbors: number; neighborPoints: any; } class PointMap extends Map { constructor(); constructor(entries?: readonly (readonly [any, any])[]); constructor(iterable: Iterable); key(point: any): string; } class PermutationSet { constructor(n: any); permutations: any[]; current: number[]; heapPermute(n: any): void; addItem(): void; swap(i: any, j: any): void; get(i: any): any; list(): any[]; } } declare module "Graphs/Representation" { /** * @namespace MindFusion.Graphs */ export default class Representation { constructor(stGraph: any, weighted: any, xOrdering: any, stEmbedding: any); stsort: any; Y: any; s: any; t: any; d: any; X: any; left(e: any): any; right(e: any): any; leftV(v: any): any; rightV(v: any): any; orig(e: any): any; dest(e: any): any; origF(f: any): any; destF(f: any): any; leftMostIncoming(v: any): any; leftMostOutgoing(v: any): any; rightMostOutgoing(v: any): any; getOutEdges(v: any): any[]; getInEdges(v: any): any[]; getOutMedian(v: any): any; getInMedian(v: any): any; newHSegment(): { y: number; x1: number; x2: number; }; newVSegment(): { x: number; y1: number; y2: number; }; get dualGraph(): any; get source(): any; get sink(): any; get topologicalSort(): any; } } declare module "Graphs/ConstrainedVisibility" { export default class ConstrainedVisibility extends Representation { constructor(stGraph: any, vpaths: any); edgeToPathMap: Map; pathToVertexMap: Map; hSegments: Map; vSegments: Map; get vertexSegments(): Map; get edgeSegments(): Map; } import Representation from "Graphs/Representation"; } declare module "Graphs/OrthogonalLayout" { /** * @class Implements orthogonal graph layout algorithm. * Each link is drawn as a chain of alternating horizontal and vertical segments. * Nodes are placed in a way that facilitates few links bends and crossings. * @augments Layout */ export class OrthogonalLayout extends Layout { set refine(arg: boolean); /** * Gets or sets a value indicating whether to refine the layout. * @type {Boolean} * @summary True to refine the layout, or false otherwise. */ get refine(): boolean; set padding(arg: number); /** * Gets or sets a value indicating how much space to leave between nodes in adjacent lanes. * @type {Number} * @summary The space to leave between nodes in adjacent lanes. */ get padding(): number; set minLaneSize(arg: number); /** * Gets or sets a value indicating the minimum size of a lane. * @type {Number} * @summary The minimum size of a lane. */ get minLaneSize(): number; mm: number; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): boolean; graph: any; vertexPoints: Map; edgePoints: Map; drawingGrid: DrawingGrid; applyGrid(grid: any): boolean; alignEndsToNode(edge: any): void; getType(): any; reverseRange(array: any, l: any, r: any): void; mergePaths(v: any, c: any, rs: any, re: any, step: any): void; mergePath(edges: any, stgEdgePoints: any): any[]; _refine: boolean; _padding: number; _minLaneSize: number; } import { Layout } from "Graphs/Layout"; import DrawingGrid from "Graphs/DrawingGrid"; } declare module "Graphs/RadialTreeLayout" { /** * @class Implements a radial tree layout algorithm. * @augments Layout */ export class RadialTreeLayout extends Layout { set levelDistance(arg: number); /** * Gets or sets the space to leave between adjacent levels of the tree. * @type {Number} * @summary The space to leave between adjacent levels of the tree. */ get levelDistance(): number; set keepRootPosition(arg: boolean); /** * Gets or sets a value indicating whether to keep the root node at its original position. * @type {Boolean} * @summary true if the root node should be kept at its original position, or false otherwise. */ get keepRootPosition(): boolean; set direction(arg: number); /** * Gets or sets the orientation of the arranged graph. * @type {LayoutDirection} * @summary A member of the LayoutDirection enumeration. */ get direction(): number; set stretchFactor(arg: number); /** * Gets or sets the stretch factor in radial layouts. * @type {Number} * @summary The stretch factor. */ get stretchFactor(): number; set reversedLinks(arg: boolean); /** * Gets or sets a value indicating the link direction that relates parent nodes to child nodes. * @type {Boolean} * @summary true to indicate reversed direction (links point to parent nodes), or false otherwise. */ get reversedLinks(): boolean; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): any; treeHelper: TreeHelper; tree: any; arrangeLevel(parentLevel: any): any; calcBounds(): any; calcRadius(level: any): any; getType(): any; _levelDistance: number; _keepRootPosition: boolean; _direction: number; _stretchFactor: number; _reversedLinks: boolean; } import { Layout } from "Graphs/Layout"; import TreeHelper from "Graphs/TreeHelper"; } declare module "Graphs/AdjacencyMatrix" { export default AdjacencyMatrix; class AdjacencyMatrix { constructor(graph: any); adjacent: Grid; edge: Grid; } import { Grid } from "@mindfusion/collections"; } declare module "Graphs/GridLayout" { /** * @class Implements a grid graph layout algorithm. * @augments Layout */ export class GridLayout extends Layout { set startNode(arg: any); /** * Gets or sets the node that is placed at the upper left corner of the grid. * @type {DiagramNode} * @summary An instance of the DiagramNode class. The default is null. */ get startNode(): any; set endNode(arg: any); /** * Gets or sets the node that is placed at the lower right corner of the grid. * @type {DiagramNode} * @summary An instance of the DiagramNode class. Default value is null. */ get endNode(): any; set iterations(arg: number); /** * Gets or sets for how many iterations to run the grid layout algorithm. * @type {Number} * @summary An integer number specifying the number of iterations. The default is 3000. */ get iterations(): number; set gridSize(arg: number); /** * Gets or sets the desired distance between adjacent grid points. * @type {Number} * @summary A number specifying the grid size. The default is 25. */ get gridSize(): number; set timeLimit(arg: number); /** * Gets or sets a time-out value for the path-finding part of the grid layout algorithm. * @type {Number} * @summary An integer value specifying time-out in milliseconds. The default is 10000 (10 seconds). */ get timeLimit(): number; set useLongestPath(arg: boolean); /** * Gets or sets a value indicating whether the algorithm should arrange nodes around the longest path in the graph. * @type {Boolean} * @summary true to look for the longest path in the graph and arrange nodes around it; otherwise, false. */ get useLongestPath(): boolean; /** * Applies the layout to the specified graph. * @param {Graph} graph The graph to arrange. */ arrange(graph: any): void; graph: any; adjacencyMatrix: AdjacencyMatrix; backbone: any[]; countIterations(maxShift: any): number; initGrid(): Grid; gridWidth: number; gridHeight: number; scrambleGrid(grid: any, maxShift: any, iter: any): any; calcLinkDir(node: any): Vector; scrambleGridStep(newGrid: any, maxShift: any, iter: any, i: any, j: any): void; evaluateGrid(grid: any, maxShift: any): number; applyGrid(grid: any): void; placeObjects(grid: any): void; _startNode: any; _endNode: any; _iterations: number; _gridSize: number; _timeLimit: number; _useLongestPath: boolean; } import { Layout } from "Graphs/Layout"; import AdjacencyMatrix from "Graphs/AdjacencyMatrix"; import { Grid } from "@mindfusion/collections"; import { Vector } from "@mindfusion/drawing"; } declare module "@mindfusion/graphs" { import { AssistantPosition, AssistantType, Anchoring, LayoutDirection, TreeLayoutLinkType, MultipleGraphsPlacement, Orientation } from "Graphs/Enum"; export { AssistantPosition, AssistantType, Anchoring, LayoutDirection, TreeLayoutLinkType, MultipleGraphsPlacement, Orientation }; export { Graph } from "Graphs/Graph"; export { PathFinder } from "Graphs/PathFinder"; export { BorderedTreeLayout } from "Graphs/BorderedTreeLayout"; export { FlowchartLayout } from "Graphs/FlowchartLayout"; export { FractalLayout } from "Graphs/FractalLayout"; export { LayeredLayout } from "Graphs/LayeredLayout"; export { SpringLayout } from "Graphs/SpringLayout"; export { TopologicalLayout } from "Graphs/TopologicalLayout"; export { TreeLayout } from "Graphs/TreeLayout"; export { TreeMapLayout } from "Graphs/TreeMapLayout"; export { OrthogonalLayout } from "Graphs/OrthogonalLayout"; export { RadialTreeLayout } from "Graphs/RadialTreeLayout"; export { GridLayout } from "Graphs/GridLayout"; }