@mindfusion/graphs 4.0.4 → 4.0.5-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/graphs.d.mts ADDED
@@ -0,0 +1,1998 @@
1
+ /// <reference types="../../@mindfusion/drawing" />
2
+ /// <reference types="../../@mindfusion/collections" />
3
+ declare module "Graphs/Enum" {
4
+ /**
5
+ * Specifies the final position of an assistant node. Assistants with type left
6
+ * or right are always positioned to the left or right respectively. The position
7
+ * of the "normal" assistants depends on their index in the children list.
8
+ */
9
+ export type AssistantPosition = number;
10
+ export namespace AssistantPosition {
11
+ const Left: number;
12
+ const Right: number;
13
+ }
14
+ /**
15
+ * Indicates the type of an assistant node in a tree.
16
+ */
17
+ export type AssistantType = number;
18
+ export namespace AssistantType {
19
+ export const Normal: number;
20
+ const Left_1: number;
21
+ export { Left_1 as Left };
22
+ const Right_1: number;
23
+ export { Right_1 as Right };
24
+ }
25
+ /**
26
+ * Defines values that specify how automatic layout algorithms align links to anchor points.
27
+ */
28
+ export type Anchoring = number;
29
+ export namespace Anchoring {
30
+ const Ignore: number;
31
+ const Keep: number;
32
+ const Reassign: number;
33
+ const Custom: number;
34
+ }
35
+ /**
36
+ * Specifies in what direction to place nodes processed by a layout algorithm.
37
+ */
38
+ export type LayoutDirection = number;
39
+ export namespace LayoutDirection {
40
+ const TopToBottom: number;
41
+ const LeftToRight: number;
42
+ const BottomToTop: number;
43
+ const RightToLeft: number;
44
+ }
45
+ /**
46
+ * Specifies the shape of the diagram links after they are laid out.
47
+ */
48
+ export type TreeLayoutLinkType = number;
49
+ export namespace TreeLayoutLinkType {
50
+ const Default: number;
51
+ const Straight: number;
52
+ const Cascading: number;
53
+ }
54
+ /**
55
+ * Specifies placement of graph connected components relatively to each other.
56
+ */
57
+ export type MultipleGraphsPlacement = number;
58
+ export namespace MultipleGraphsPlacement {
59
+ const Vertical: number;
60
+ const Horizontal: number;
61
+ }
62
+ /**
63
+ * Specifies general layout orientation.
64
+ */
65
+ export type Orientation = number;
66
+ export namespace Orientation {
67
+ const Vertical_1: number;
68
+ export { Vertical_1 as Vertical };
69
+ const Horizontal_1: number;
70
+ export { Horizontal_1 as Horizontal };
71
+ }
72
+ }
73
+ declare module "Graphs/Vertex" {
74
+ export default Vertex;
75
+ /**
76
+ * @class Represents a vertex in a graph.
77
+ */
78
+ class Vertex {
79
+ /**
80
+ * A list containing all edges incident with this vertex.
81
+ * returns {Array}
82
+ */
83
+ edges: any[];
84
+ /**
85
+ * A list containing all outgoing edges.
86
+ */
87
+ outEdges: any[];
88
+ /**
89
+ * A list containing all incoming edges.
90
+ */
91
+ inEdges: any[];
92
+ /**
93
+ * The relative weight of this vertex.
94
+ */
95
+ weight: number;
96
+ /**
97
+ * For internal use only.
98
+ * @private
99
+ */
100
+ private clone;
101
+ /**
102
+ * For internal use only.
103
+ * @private
104
+ */
105
+ private removeEdge;
106
+ /**
107
+ * Checks if the current vertex is incident with the specified edge.
108
+ * @param {Edge} edge The edge to check.
109
+ * @returns {Boolean} true if the vertex is incident with the edge; otherwise, false.
110
+ */
111
+ incidentWith(edge: any): boolean;
112
+ /**
113
+ * Checks if there is an edge connecting this vertex with the specified vertex.
114
+ * @param {Vertex} vertex The vertex to check.
115
+ * @returns {Boolean} true if the vertices are connected; otherwise, false.
116
+ */
117
+ adjacentTo(vertex: Vertex): boolean;
118
+ /**
119
+ * Finds the edge connecting the current vertex with the specified vertex.
120
+ * @param {Vertex} vertex The vertex to find an edge for.
121
+ * @returns {Edge} The edge connecting the vertices or null.
122
+ */
123
+ getCommonEdge(vertex: Vertex): any;
124
+ getCommonEdges(vertex: any): boolean;
125
+ /**
126
+ * For internal use only.
127
+ * @private
128
+ */
129
+ private edgeTo;
130
+ /**
131
+ * Returns an array containing all vertices adjacent to the current vertex.
132
+ * @returns {Array} A list with all neighbors.
133
+ */
134
+ getNeighbors(): any[];
135
+ /**
136
+ * Returns the number of incident edges.
137
+ * @returns {Number} The number of incident edges.
138
+ */
139
+ degree(): number;
140
+ inDegree(): number;
141
+ outDegree(): number;
142
+ toString(): any;
143
+ }
144
+ }
145
+ declare module "Graphs/Edge" {
146
+ export default Edge;
147
+ /**
148
+ * @class Represents an edge connecting two vertices in a graph.
149
+ */
150
+ class Edge {
151
+ /**
152
+ * Initializes a new instance of the Edge class.
153
+ * @constructor
154
+ * @param {Vertex} origin The origin vertex.
155
+ * @param {Vertex} destination The destination vertex.
156
+ */
157
+ constructor(origin: any, destination: any, prototype: any);
158
+ /**
159
+ * The origin vertex.
160
+ */
161
+ origin: any;
162
+ /**
163
+ * The destination vertex.
164
+ */
165
+ destination: any;
166
+ weight: any;
167
+ /**
168
+ * Returns the vertex connected by this edge that is not the specified vertex.
169
+ * @param {Vertex} vertex One of the vertices connected by this edge.
170
+ * @returns {Vertex} The other vertex connected by this edge.
171
+ */
172
+ getOtherEnd(vertex: any): any;
173
+ /**
174
+ * Returns a common vertex for the current edge and the specified edge.
175
+ * @param {Edge} edge The edge for which to find common vertex.
176
+ * @returns {Vertex} The common vertex if it exists, otherwise null.
177
+ */
178
+ getCommonVertex(edge: Edge): any;
179
+ /**
180
+ * Checks if the current edge connects the specified vertices.
181
+ * @param {Vertex} v1 The first vertex.
182
+ * @param {Vertex} v2 The second vertex.
183
+ * @returns {Boolean} true if the current edge connects the specified vertices; otherwise, false.
184
+ */
185
+ joins(v1: any, v2: any): boolean;
186
+ /**
187
+ * Returns an array containing the origin and destination vertices of this edge.
188
+ * @returns {Array} An array containing the related vertices.
189
+ */
190
+ getEnds(): any[];
191
+ /**
192
+ * Checks if the current edge is incident with the specified vertex.
193
+ * @param {Vertex} vertex The vertex to check.
194
+ * @returns {Boolean} true if the edge is incident with the vertex; otherwise, false.
195
+ */
196
+ incidentWith(vertex: any): boolean;
197
+ /**
198
+ * Checks if the current edge is adjacent to the specified edge, that is,
199
+ * they have common vertex.
200
+ * @param {Edge} edge The edge to check.
201
+ * @returns {Boolean} true if the current edge is adjacent to the specified edge; otherwise, false.
202
+ */
203
+ adjacentTo(edge: Edge): boolean;
204
+ /**
205
+ * Changes the origin of the current edge to the specified vertex.
206
+ * @param {Vertex} vertex The new origin of the edge.
207
+ */
208
+ changeOrigin(v: any): void;
209
+ /**
210
+ * Changes the destination of the current edge to the specified vertex.
211
+ * @param {Vertex} vertex The new destination of the edge.
212
+ */
213
+ changeDestination(v: any): void;
214
+ changeVertex(v: any, w: any): void;
215
+ /**
216
+ * Reverses this edge.
217
+ */
218
+ reverse(): void;
219
+ directTo(destination: any): void;
220
+ /**
221
+ * Creates a new edge similar to the current edge but with reversed direction.
222
+ * @returns {Edge}
223
+ */
224
+ createReverseEdge(): Edge;
225
+ toString(): string;
226
+ }
227
+ }
228
+ declare module "Graphs/PQTree" {
229
+ export class PQTree {
230
+ init(): void;
231
+ consecutiveNodes: any;
232
+ modifiedNodes: any[];
233
+ root: any;
234
+ reinit(): void;
235
+ reduction(s: any): any;
236
+ bubble(s: any): boolean;
237
+ reduce(s: any): any;
238
+ pertinentRoot: any;
239
+ templateL1(lNode: any): boolean;
240
+ templateP1(pNode: any): boolean;
241
+ templateP2(pNode: any): boolean;
242
+ templateP3(pNode: any): boolean;
243
+ templateP4(pNode: any): boolean;
244
+ templateP5(pNode: any): boolean;
245
+ templateP6(pNode: any): boolean;
246
+ templateQ1(qNode: any): boolean;
247
+ templateQ2(qNode: any): boolean;
248
+ templateQ3(qNode: any): boolean;
249
+ }
250
+ export namespace PQTree {
251
+ export { Node };
252
+ export { NodePair };
253
+ }
254
+ export namespace NodeType {
255
+ const pNode: number;
256
+ const qNode: number;
257
+ const directionIndicator: number;
258
+ }
259
+ export namespace NodeLabel {
260
+ const empty: number;
261
+ const partial: number;
262
+ const full: number;
263
+ }
264
+ class Node {
265
+ constructor(type: any, data: any);
266
+ data: any;
267
+ immediateSiblings: {
268
+ nodes: any[];
269
+ trackDirection: boolean;
270
+ directedTowardsIndex: any;
271
+ add(node: any): void;
272
+ remove(node: any): boolean;
273
+ removeAt(index: any): boolean;
274
+ getOther(node: any): any;
275
+ replace(oldNode: any, newNode: any): void;
276
+ indexOf(node: any): number;
277
+ contains(node: any): boolean;
278
+ get(index: any): any;
279
+ readonly count: number;
280
+ direction: any;
281
+ };
282
+ readInReverseDirection: boolean;
283
+ init(nodeType: any): void;
284
+ _type: any;
285
+ parent: any;
286
+ endMostChildren: any;
287
+ circularLink: any;
288
+ left: any;
289
+ right: any;
290
+ childCount: any;
291
+ fullChildrenList: any;
292
+ fullLeft: any;
293
+ fullRight: any;
294
+ fullChildren: any;
295
+ partialChildrenList: any;
296
+ partialLeft: any;
297
+ partialRight: any;
298
+ partialChildren: any;
299
+ pertinentChildCount: any;
300
+ pertinentLeafCount: any;
301
+ _label: any;
302
+ blocked: boolean;
303
+ queued: boolean;
304
+ pseudoRoot: any;
305
+ destroyed: any;
306
+ destroy(): void;
307
+ reinit(reinitParent: any): void;
308
+ set label(arg: any);
309
+ get label(): any;
310
+ getBlockedSiblings(): any[];
311
+ getUnblockedSiblings(): any[];
312
+ getEndMostDirectedSibling(otherSide: any): any;
313
+ getNonDirectedSibling(otherSide: any): any;
314
+ setPseudoRoot(blockedList: any): void;
315
+ set type(arg: any);
316
+ get type(): any;
317
+ getMaximalConsecutiveBlockedSiblings(): any[];
318
+ markBlocked(): void;
319
+ markUnblocked(): void;
320
+ markQueued(): void;
321
+ fullChildrenAreAdjacent(): boolean;
322
+ fullChildrenAreAdjacentTo(node: any): any;
323
+ fullChildrenAreEndMost(): boolean;
324
+ partialChildrenAtEnds(): boolean;
325
+ endMostChildrenAreEmptyOrPartial(): boolean;
326
+ childrenAreFull(): boolean;
327
+ twoChildrenLeft(): boolean;
328
+ getPartialChild(index: any): any;
329
+ getFirstFullChild(): any;
330
+ getFirstEmptyChild(): any;
331
+ addToFullList(node: any): void;
332
+ removeFromFullList(node: any): void;
333
+ addToPartialList(node: any): void;
334
+ removeFromPartialList(node: any): void;
335
+ addChildToPNode(node: any): void;
336
+ removeChildFromPNode(node: any): void;
337
+ addChildToQNode(node: any): void;
338
+ removeChildFromQNode(node: any): void;
339
+ addChildToPseudoRoot(node: any): void;
340
+ addChild(node: any, updateTree: any): void;
341
+ removeChild(node: any, updateTree: any): void;
342
+ replaceChild(node: any, newNode: any): void;
343
+ getPertinentNeighbor(si: any): any;
344
+ getEmptyNeighbor(si: any): any;
345
+ getEndMostChild(nodeLabel: any): any;
346
+ absorbPartialChild(qNode: any): void;
347
+ replaceFullChildrenWith(node: any): void;
348
+ becomeChild(theChild: any): void;
349
+ moveFullChildrenTo(newParent: any): void;
350
+ checkLabelDirected(node: any, nodeLabel: any): any;
351
+ hasChildren(): boolean;
352
+ getEndmostLeaves(): any[];
353
+ getAllNodes(list: any, nodeType: any): void;
354
+ getQChildren(): any[];
355
+ getLeaf(): any;
356
+ siblingOf(node: any): boolean;
357
+ getFullLeavesFrom(): any;
358
+ getFullLeavesTo(): any;
359
+ getFullLeaves(): any[];
360
+ get nextPSibling(): any;
361
+ get childLink(): any;
362
+ get children(): any;
363
+ get emptyChildren(): number;
364
+ get unmarked(): boolean;
365
+ set direction(arg: any);
366
+ get direction(): any;
367
+ }
368
+ class NodePair {
369
+ constructor(directionIndex: any);
370
+ nodes: any[];
371
+ trackDirection: boolean;
372
+ directedTowardsIndex: any;
373
+ add(node: any): void;
374
+ remove(node: any): boolean;
375
+ removeAt(index: any): boolean;
376
+ getOther(node: any): any;
377
+ replace(oldNode: any, newNode: any): void;
378
+ indexOf(node: any): number;
379
+ contains(node: any): boolean;
380
+ get(index: any): any;
381
+ get count(): number;
382
+ set direction(arg: any);
383
+ get direction(): any;
384
+ }
385
+ export {};
386
+ }
387
+ declare module "Graphs/Face" {
388
+ /**
389
+ * @namespace MindFusion.Graphs
390
+ */
391
+ export default class Face {
392
+ constructor(prototype: any);
393
+ edges: any;
394
+ incidentWith(v: any): boolean;
395
+ adjacentTo(face: any): boolean;
396
+ getCommonEdge(face: any): any;
397
+ get degree(): any;
398
+ getVertices(): Set<any>;
399
+ enumVertices(): any[];
400
+ isCycle(): boolean;
401
+ edgeFromVertex(vertex: any): any;
402
+ replaceEdge(edge: any, replacement: any): void;
403
+ get bigAngles(): any[];
404
+ _bigAngles: any[];
405
+ }
406
+ }
407
+ declare module "Graphs/Embedding" {
408
+ export default class Embedding {
409
+ constructor(graph: any, copy: any, vertexCopyToOrigMap: any, edgeCopyToOrigMap: any);
410
+ graph: any;
411
+ embedding: any;
412
+ addBlockEmbedding(block: any, blockEmbedding: any): void;
413
+ add(v: any): void;
414
+ remove(v: any): void;
415
+ getNextRightFaceEdge(e: any): any;
416
+ createDirectedEdges(): void;
417
+ reverseEdges: Map<any, any>;
418
+ replaceEdges(e: any, e1: any, e2: any, r: any, r1: any, r2: any, newVertex: any): void;
419
+ addEdge(e: any, r: any, fromEdge: any, toEdge: any): void;
420
+ getNext(v: any, e: any): any;
421
+ getPrevious(v: any, e: any): any;
422
+ setReverseEdges(e: any, r: any): void;
423
+ isVertexBimodal(v: any): boolean;
424
+ isBimodal(): boolean;
425
+ contractEdge(edge: any, vertex: any): void;
426
+ replaceEdge(edge: any, vertex: any): void;
427
+ quasiCapacity(face: any): number;
428
+ countSourceSwitches(face: any): number;
429
+ enumerateFaces(): void;
430
+ _faces: any[];
431
+ faceOnLeftMap: Map<any, any>;
432
+ faceOnRightMap: Map<any, any>;
433
+ externalFace: any;
434
+ enumerateFaceEdges(startEdge: any, startVertex: any): Face;
435
+ prevInEmbedding(edge: any, vertex: any): any;
436
+ insertEdge(edge: any, vertex: any, face: any): void;
437
+ edgesBetween(edge1: any, edge2: any, vertex: any): any[];
438
+ getReverse(e: any): any;
439
+ get(v: any): any;
440
+ get vertices(): any;
441
+ get faces(): any[];
442
+ }
443
+ import Face from "Graphs/Face";
444
+ }
445
+ declare module "Graphs/Interval" {
446
+ /**
447
+ * @namespace MindFusion.Graphs
448
+ */
449
+ export default class Interval {
450
+ constructor(min: any, max: any);
451
+ min: any;
452
+ max: any;
453
+ contains(interval: any): boolean;
454
+ intersects(interval: any): boolean;
455
+ overlaps(interval: any): boolean;
456
+ }
457
+ }
458
+ declare module "Graphs/BinaryTree" {
459
+ /**
460
+ * @namespace MindFusion.Graphs
461
+ */
462
+ class BinaryTree {
463
+ constructor(item: any);
464
+ root: {
465
+ item: any;
466
+ addChildren(left: any, right: any): void;
467
+ left: any;
468
+ right: any;
469
+ getLeaves(): any[];
470
+ collectLeaves(leaves: any): void;
471
+ };
472
+ getLeaves(): any[];
473
+ }
474
+ namespace BinaryTree {
475
+ export { Node };
476
+ }
477
+ export default BinaryTree;
478
+ class Node {
479
+ constructor(item: any);
480
+ item: any;
481
+ addChildren(left: any, right: any): void;
482
+ left: {
483
+ item: any;
484
+ addChildren(left: any, right: any): void;
485
+ left: any;
486
+ right: any;
487
+ getLeaves(): any[];
488
+ collectLeaves(leaves: any): void;
489
+ };
490
+ right: {
491
+ item: any;
492
+ addChildren(left: any, right: any): void;
493
+ left: any;
494
+ right: any;
495
+ getLeaves(): any[];
496
+ collectLeaves(leaves: any): void;
497
+ };
498
+ getLeaves(): any[];
499
+ collectLeaves(leaves: any): void;
500
+ }
501
+ }
502
+ declare module "Graphs/PriorityQueue" {
503
+ /**
504
+ * @namespace MindFusion.Graphs
505
+ */
506
+ export default class PriorityQueue {
507
+ constructor(maxN: any, array: any);
508
+ a: any;
509
+ N: number;
510
+ d: number;
511
+ pq: number[];
512
+ qp: number[];
513
+ empty(): boolean;
514
+ insert(v: any): void;
515
+ getMin(): number;
516
+ lower(k: any): void;
517
+ less(i: any, j: any): boolean;
518
+ exchange(i: any, j: any): void;
519
+ swim(k: any): void;
520
+ sink(k: any, N: any): void;
521
+ }
522
+ }
523
+ declare module "Graphs/Factory" {
524
+ /**
525
+ * @namespace MindFusion.Graphs
526
+ */
527
+ export default class Factory {
528
+ }
529
+ }
530
+ declare module "Graphs/TreeHelper" {
531
+ export default class TreeHelper {
532
+ constructor(reversedLinks: any);
533
+ reversedLinks: any;
534
+ parentNode(edge: any): any;
535
+ childNode(edge: any): any;
536
+ parentEdges(vertex: any): any;
537
+ childEdges(vertex: any): any;
538
+ assignPoints(edge: any, points: any): void;
539
+ }
540
+ }
541
+ declare module "Graphs/Graph" {
542
+ /**
543
+ * @class Represents a graph.
544
+ */
545
+ export class Graph {
546
+ /**
547
+ * A list containing all vertices in the graph.
548
+ */
549
+ vertices: any[];
550
+ /**
551
+ * A list containing all edges in the graph.
552
+ */
553
+ edges: any[];
554
+ /**
555
+ * Creates an exact copy of the current graph.
556
+ * @param {Boolean} [saveMapping] Indicates whether to store vertex and edge mapping information in the copy.
557
+ * @returns {Graph} The newly created copy.
558
+ */
559
+ clone(saveMapping?: boolean): Graph;
560
+ cloneSubset(vertexSubset: any, saveMapping: any): Graph;
561
+ createReverseMaps(): void;
562
+ vertexOrigToCopyMap: Map<any, any>;
563
+ edgeOrigToCopyMap: Map<any, any>;
564
+ /**
565
+ * Returns a new graph object containing a subset of the vertices and edges
566
+ * of the original graph, such that the new graph is a tree.
567
+ * @param {Vertex} root The desired root vertex of the tree.
568
+ * @param {Boolean} enableAssistants
569
+ * @param {Boolean} compactAssistants
570
+ * @returns {Graph} The newly created tree.
571
+ */
572
+ tree(root: Vertex, reversedLinks: any, enableAssistants: boolean, compactAssistants: boolean): Graph;
573
+ collectLevels(parent: any): void;
574
+ /**
575
+ * @private
576
+ */
577
+ private childrenOf;
578
+ /**
579
+ * Reassigns tree levels when "assistants" are enabled.
580
+ * @private
581
+ */
582
+ private reassignLevels;
583
+ /**
584
+ * Creates a new edge connecting the specified vertices and adds it to the graph.
585
+ * @param {Vertex} origin The origin vertex.
586
+ * @param {Vertex} destination The destination vertex.
587
+ * @param {Object} [owner] The owner of the new edge.
588
+ * @returns {Edge} The newly created edge.
589
+ */
590
+ createEdge(origin: Vertex, destination: Vertex, owner?: any): Edge;
591
+ createEdgeP(origin: any, destination: any, prototype: any): Edge;
592
+ /**
593
+ * Adds an existing edge to the graph.
594
+ * @param {Edge} edge The edge to add.
595
+ */
596
+ addEdge(edge: Edge): void;
597
+ /**
598
+ * Removes an edge from the graph.
599
+ * @param {Edge} edge The edge to remove.
600
+ */
601
+ removeEdge(edge: Edge): void;
602
+ removeAllEdges(): void;
603
+ /**
604
+ * Creates a new vertex with the specified position and size and adds it to the graph.
605
+ * @param {Rect} layoutRect A rectangle specifying the position and size of the vertex.
606
+ * @param {Object} [owner] The owner of the new vertex.
607
+ * @returns {Vertex} The newly created vertex.
608
+ */
609
+ createVertex(layoutRect: any, owner?: any): Vertex;
610
+ removeVertex(vertex: any): void;
611
+ /**
612
+ * Adds an existing vertex and its related edges to the graph.
613
+ * @param {Vertex} vertex The vertex to add.
614
+ * @private
615
+ */
616
+ private addVertexAndOutEdges;
617
+ addVertex(debugId: any): Vertex;
618
+ /**
619
+ * Assigns unique indices to the items in the graph.
620
+ * @private
621
+ */
622
+ private setItemIndices;
623
+ splitEdge(e: any): Vertex;
624
+ findShortestPathVS(v1: any, destSet: any): any[];
625
+ findShortestPathSS(originSet: any, destSet: any): any[];
626
+ findShortestPathBfs(e: any, destSet: any, mark: any, searchTree: any, path: any): void;
627
+ findShortestWeightedPathVS(origin: any, destSet: any, outMinWeigth: any): any[];
628
+ findShortestWeightedPathSS(originSet: any, destSet: any): any[];
629
+ /**
630
+ * Returns a list with the connected subgraphs in the current graph.
631
+ * @returns {Array} An array with connected Graph objects.
632
+ */
633
+ getConnectedComponents(): any[];
634
+ searchCounter: number;
635
+ /**
636
+ * Performs a depth-first search for connected components.
637
+ * @private
638
+ */
639
+ private dfsConnectivity;
640
+ getBiconnectedComponents(saveMapping: any, blocksHandler: any): any[];
641
+ getBiconnectedComponentsOfConnectedGraph(): any[];
642
+ visitedEdges: any[];
643
+ cutVertices: any[];
644
+ foundComponents: any[];
645
+ secondLevel: any[];
646
+ searchOrder: any[];
647
+ backMostEdges: any[];
648
+ biconnectivityDfs(parent: any, vertexId: any): void;
649
+ stackToComponent2(child: any): void;
650
+ getBiconnectedComponents2(): Graph[];
651
+ planarMakeBiconnected(): Edge[];
652
+ stillPlanar(v1: any, v2: any): boolean;
653
+ father(vertex: any): any;
654
+ getOutsideVertexCP(cutpoints: any): any;
655
+ getOutsideVertexCPN(cutpoints: any, neighbor: any): any;
656
+ get3EdgeConnectedComponents(): any[];
657
+ getCutPairs(): any[];
658
+ test3EdgeConnectivity(returnPairs: any): any[];
659
+ findBlockSeparationPairs(): any[][];
660
+ findBlockSeparationPairsB(): any[];
661
+ depthFirstSearch(start: any): void;
662
+ searchParent: any[];
663
+ searchComponent(origin: any, dest: any): void;
664
+ getStNumbering(sink: any): any[];
665
+ stOrder: any[];
666
+ convertToStGraph(sink: any): any[];
667
+ isCycleEdge(edge: any): boolean;
668
+ findPath(v: any, oldVertices: any, oldEdges: any): any[];
669
+ isPlanar(): boolean;
670
+ isPlanarSingleBicomponent(embeddingInfo: any): boolean;
671
+ getPlanarEmbedding(): Embedding;
672
+ getPlanarEmbeddingSingleBicomp(embeddingInfo: any): Map<any, any>;
673
+ /**
674
+ * Should be called on a planar graph.
675
+ * @param {Map} [embedding] Receives the embedding lists.
676
+ * @param {Map} [embeddingInfo] Optional.
677
+ * @returns {Vertex} The t node in st ordering.
678
+ */
679
+ getUpwardEmbedding(embedding?: Map<any, any>, embeddingInfo?: Map<any, any>): Vertex;
680
+ entireEmbed(upEmbedding: any, tVertex: any): Map<any, any>;
681
+ entireEmbedDfs(upEmbedding: any, entireEmbedding: any, vertex: any, oldVertices: any): void;
682
+ findPlanarSubgraph(edgesToDelete: any, crossingConstrainedEdges: any): any;
683
+ findPlanarSubgraphBySimpleEdgeInsertion(edgesToDelete: any, knownPlanarEdges: any, crossingConstrainedEdges: any): any;
684
+ findPlanarSubgraphByBookEmbedding(edgesToDelete: any, crossingConstrainedEdges: any): any;
685
+ minAdjacenciesNeighbor(vertex: any, vset: any): any;
686
+ minDegreeVertex(vset: any): any;
687
+ countAdjacencies(vertex: any, vset: any): number;
688
+ embedOnSameFace(faceVertices: any): Embedding;
689
+ planarize(edgeToDummyEdgesMap: any, crossingConstrainedEdges: any): any;
690
+ /**
691
+ * Makes the graph acyclic by reversing the direction of selected edges.
692
+ * @returns {Array} A list with all edges that were reversed in order to make the graph acyclic.
693
+ * @remarks Must be called on a simple connected graph.
694
+ */
695
+ makeAcyclic(): any[];
696
+ getDualGraph(cacheIncidentFaces: any): any;
697
+ getDualGraphE(embedding: any, s: any, t: any): any;
698
+ topologicalSort(): any[];
699
+ postCounter: number;
700
+ topologicalSortDfs(postOrder: any, topologicalOrder: any, dest: any): boolean;
701
+ getWeightedTopologicalNumbering(minNumber: any): any[];
702
+ getWeightedTopologicalNumberingTS(tsort: any, minNumber: any): any[];
703
+ splitToMaxDegree(maxDegree: any, embedding: any): Map<any, any>;
704
+ splitToMaxDegreeV(vertex: any, maxDegree: any, embedding: any): Graph;
705
+ reorderTopologically(): void;
706
+ maxWeightedCliqueOfTransitiveDAG(): any[];
707
+ }
708
+ import Vertex from "Graphs/Vertex";
709
+ import Edge from "Graphs/Edge";
710
+ import Embedding from "Graphs/Embedding";
711
+ }
712
+ declare module "Graphs/BlockCutpointGraph" {
713
+ export default class BlockCutpointGraph extends Graph {
714
+ constructor(graph: any);
715
+ targetGraph: any;
716
+ blockToBnodeMap: Map<any, any>;
717
+ cutToCnodeMap: Map<any, any>;
718
+ blocks: any;
719
+ onComponentBlocks(componentBlocks: any, componentCuts: any): void;
720
+ cutVerticesB(block: any): any[];
721
+ cutVerticesV(bNode: any): any[];
722
+ isPendant(bNode: any): boolean;
723
+ adjacentBlocks(cutVertex: any): any[];
724
+ directFromRoot(): void;
725
+ root: any;
726
+ directFrom(parent: any, vertex: any): void;
727
+ findPendantCut(): any;
728
+ getOutsideVertex(bNode: any): any;
729
+ getOutsideVertexN(bNode: any, neighborCnode: any): any;
730
+ getBlock(bNode: any): any;
731
+ getCutvertex(cNode: any): any;
732
+ getCnode(cut: any): any;
733
+ mapVertices(vertices: any, map: any): any[];
734
+ mergeBlocks(bnodes: any, parent: any): void;
735
+ setNewParent(vertex: any, parent: any): void;
736
+ removeCnode(cNode: any): void;
737
+ removeBnode(bNode: any): void;
738
+ isCnode(vertex: any): boolean;
739
+ isBnode(vertex: any): boolean;
740
+ }
741
+ import { Graph } from "Graphs/Graph";
742
+ }
743
+ declare module "Graphs/DualGraph" {
744
+ export default class DualGraph extends Graph {
745
+ constructor(graph: any, embedding: any, cacheIncidentFaces: any, s: any, t: any);
746
+ graph: any;
747
+ embedding: any;
748
+ faces: Face[];
749
+ edgeToFaceMap: Map<any, any>;
750
+ incidentFaces: Map<any, any>;
751
+ faceToVertexMap: Map<any, any>;
752
+ vertexToFaceMap: Map<any, any>;
753
+ splitExternalFace(s: any, t: any): void;
754
+ leftExFace: any;
755
+ leftExVertex: any;
756
+ rightExFace: Face;
757
+ rightExVertex: Vertex;
758
+ getIncidentFaces(v: any): any;
759
+ cacheIncidentFace(v: any, f: any): void;
760
+ getVertices(face: any): Set<any>;
761
+ getFaceVertices(faceList: any): Set<any>;
762
+ getCommonEdge(f1: any, f2: any): any;
763
+ getCommonEdgeMinWeight(f1: any, f2: any): any;
764
+ getOriginalEdge(e: any): any;
765
+ replaceEdge(oldEdge: any, newVertex: any): void;
766
+ splitFace(f: any, newEdge: any): void;
767
+ dgCreateVertex(f: any): Vertex;
768
+ dgCreateEdge(e: any): Edge;
769
+ setFaceIndices(): void;
770
+ left(e: any): any;
771
+ right(e: any): any;
772
+ }
773
+ import { Graph } from "Graphs/Graph";
774
+ import Face from "Graphs/Face";
775
+ import Vertex from "Graphs/Vertex";
776
+ import Edge from "Graphs/Edge";
777
+ }
778
+ declare module "Graphs/IntervalGraph" {
779
+ export default class IntervalGraph extends Graph {
780
+ constructor(intervals: any);
781
+ intervalVertices: Map<any, any>;
782
+ intervals: any;
783
+ maxWeightedIndependentSet(): any[];
784
+ }
785
+ import { Graph } from "Graphs/Graph";
786
+ }
787
+ declare module "Graphs/OverlapGraph" {
788
+ export default class OverlapGraph extends Graph {
789
+ constructor(intervals: any);
790
+ intervalVertices: Map<any, any>;
791
+ vertexIntervals: Map<any, any>;
792
+ intervals: any;
793
+ maxIndependentSet(): Set<any>;
794
+ inclusionLevels: Map<any, any>;
795
+ levelVertices: any[];
796
+ setInclusionLevel(vertex: any): any;
797
+ assignVertexToLevel(vertex: any, level: any): void;
798
+ }
799
+ import { Graph } from "Graphs/Graph";
800
+ }
801
+ declare module "Graphs/Path" {
802
+ export default Path;
803
+ /**
804
+ * @namespace MindFusion.Graphs
805
+ */
806
+ class Path {
807
+ static isNode(obj: any): boolean;
808
+ static isLink(obj: any): boolean;
809
+ /**
810
+ * Initializes a new instance of the Path class.
811
+ * @constructor
812
+ */
813
+ constructor(path: any);
814
+ nodes: any[];
815
+ links: any[];
816
+ items: any[];
817
+ contains(item: any): boolean;
818
+ getWeight(incNodes: any, incLinks: any): number;
819
+ add(link: any, node: any): void;
820
+ }
821
+ }
822
+ declare module "Graphs/PathFinder" {
823
+ export class PathFinder {
824
+ /**
825
+ * Finds and returns all paths starting from node 'from' and
826
+ * ending at node 'to'. Returns empty collection if no
827
+ * path exists.
828
+ */
829
+ static findAllPaths(graph: any, from: any, to: any): Path[];
830
+ static findPaths(graph: any, from: any, to: any, shortestOnly: any, maxPaths: any): Path[];
831
+ static findShortestPath(graph: any, from: any, to: any, useNodeWeights: any, useLinkWeights: any): Path;
832
+ static findLongestPath(graph: any, from: any, to: any): Path;
833
+ static findCycle(graph: any, participant: any): Path;
834
+ static enumAllCycles(graph: any): any[];
835
+ static enumAllCyclesDirected(graph: any, callbackEnum: any): void;
836
+ static deleted(v: any): any;
837
+ }
838
+ import Path from "Graphs/Path";
839
+ }
840
+ declare module "Graphs/Layout" {
841
+ /**
842
+ * @class Superclass of graph layout algorithms that defines their common properties.
843
+ */
844
+ export class Layout {
845
+ set anchoring(arg: number);
846
+ /**
847
+ * Gets or sets how to align links to the anchor points of nodes.
848
+ * @type {Anchoring}
849
+ * @summary A member of the LayoutDirection enumeration.
850
+ */
851
+ get anchoring(): number;
852
+ set keepGroupLayout(arg: boolean);
853
+ /**
854
+ * Gets or sets whether to treat each group of attached nodes as a single vertex in the arranged graph.
855
+ * @type {Boolean}
856
+ * @summary true if each group should be processed as an integral graph node, or false otherwise. The default is false.
857
+ */
858
+ get keepGroupLayout(): boolean;
859
+ set multipleGraphsPlacement(arg: number);
860
+ /**
861
+ * Gets or sets how multiple independent graphs in the diagram should be positioned relatively to each other.
862
+ * @type {MultipleGraphsPlacement}
863
+ * @summary A member of the MultipleGraphsPlacement enumeration.
864
+ */
865
+ get multipleGraphsPlacement(): number;
866
+ set margins(arg: number);
867
+ /**
868
+ * Gets or sets the margins' size around individual subgraphs processed by this layout object.
869
+ * @type {Number}
870
+ * @summary A number specifying size of margins around arranged graphs.
871
+ */
872
+ get margins(): number;
873
+ _anchoring: number;
874
+ _keepGroupLayout: boolean;
875
+ _multipleGraphsPlacement: number;
876
+ _margins: number;
877
+ get setsLinkEndPoints(): boolean;
878
+ get setsLinkPoints(): boolean;
879
+ get requiresConnectedGraph(): boolean;
880
+ get requiresSimpleGraph(): boolean;
881
+ get routeRepeatingLinks(): boolean;
882
+ get requiresBezierLinks(): boolean;
883
+ get requiresCascadingLinks(): boolean;
884
+ get requiresHierarchyInfo(): boolean;
885
+ get isStatic(): boolean;
886
+ }
887
+ }
888
+ declare module "Graphs/BorderedTreeLayout" {
889
+ /**
890
+ * @class Implements algorithms for arranging tree structures.
891
+ * @augments Layout
892
+ */
893
+ export class BorderedTreeLayout extends Layout {
894
+ set levelDistance(arg: number);
895
+ /**
896
+ * Gets or sets the space to leave between adjacent levels of the tree.
897
+ * @type {Number}
898
+ * @summary The space to leave between adjacent levels of the tree.
899
+ */
900
+ get levelDistance(): number;
901
+ set nodeDistance(arg: number);
902
+ /**
903
+ * Gets or sets the space to leave between adjacent nodes on the same level.
904
+ * @type {Number}
905
+ * @summary The space to leave between adjacent nodes on the same level.
906
+ */
907
+ get nodeDistance(): number;
908
+ set keepRootPosition(arg: boolean);
909
+ /**
910
+ * Gets or sets a value indicating whether to keep the root node at its original position.
911
+ * @type {Boolean}
912
+ * @summary true if the root node should be kept at its original position, or false otherwise.
913
+ */
914
+ get keepRootPosition(): boolean;
915
+ set direction(arg: number);
916
+ /**
917
+ * Gets or sets the orientation of the arranged graph.
918
+ * @type {LayoutDirection}
919
+ * @summary A member of the LayoutDirection enumeration.
920
+ */
921
+ get direction(): number;
922
+ set linkType(arg: number);
923
+ /**
924
+ * Gets or sets the type of links in the arranged tree.
925
+ * @type {TreeLayoutLinkType}
926
+ * @summary A member of the TreeLayoutLinkType enumeration.
927
+ */
928
+ get linkType(): number;
929
+ set reversedLinks(arg: boolean);
930
+ /**
931
+ * Gets or sets a value indicating the link direction that relates parent nodes to child nodes.
932
+ * @type {Boolean}
933
+ * @summary true to indicate reversed direction (links point to parent nodes), or false otherwise.
934
+ */
935
+ get reversedLinks(): boolean;
936
+ /**
937
+ * Applies the layout to the specified graph.
938
+ * @param {Graph} graph The graph to arrange.
939
+ */
940
+ arrange(graph: any): any;
941
+ treeHelper: TreeHelper;
942
+ /**
943
+ * @private
944
+ */
945
+ private tree;
946
+ /**
947
+ * @private
948
+ */
949
+ private x;
950
+ /**
951
+ * @private
952
+ */
953
+ private y;
954
+ /**
955
+ * @private
956
+ */
957
+ private rarrange;
958
+ /**
959
+ * Offset a branch of the tree with the specified values.
960
+ * @private
961
+ *
962
+ * @param {Vertex} nodeFrom The root node of the branch to offset.
963
+ * @param {Number} xoff The x-axis offset.
964
+ * @param {Number} yoff The y-axis offset.
965
+ */
966
+ private offsetBranch;
967
+ /**
968
+ * @private
969
+ */
970
+ private isHorizontal;
971
+ /**
972
+ * @private
973
+ */
974
+ private isStraight;
975
+ getType(): any;
976
+ _levelDistance: number;
977
+ _nodeDistance: number;
978
+ _keepRootPosition: boolean;
979
+ _direction: number;
980
+ _linkType: number;
981
+ _reversedLinks: boolean;
982
+ }
983
+ import { Layout } from "Graphs/Layout";
984
+ import TreeHelper from "Graphs/TreeHelper";
985
+ }
986
+ declare module "Graphs/LayoutUtils" {
987
+ export default LayoutUtils;
988
+ class LayoutUtils {
989
+ static getGraphBounds(graph: any, defaultBounds: any): any;
990
+ }
991
+ }
992
+ declare module "Graphs/Tools" {
993
+ export function newPoint(x: any, y: any): Point;
994
+ export function bounds(v: any): any;
995
+ export class Tools {
996
+ static GetLFarCenter(node: any, o: any): Point;
997
+ static GetLNearCenter(node: any, o: any): Point;
998
+ static GetBNearCenter(node: any, o: any): Point;
999
+ static GetBFarCenter(node: any, o: any): Point;
1000
+ static MoveNode(node: any, x: any, y: any): void;
1001
+ static SetLinkPoints(link: any, points: any, ...args: any[]): void;
1002
+ static SetLinkPointsA(link: any, points: any): void;
1003
+ static GetLinkPoints(link: any): any;
1004
+ static Mirror(point: any, origin: any): Point;
1005
+ static GetBreadth(node: any, o: any): any;
1006
+ static GetBCenter(node: any, o: any): any;
1007
+ static GetLength(node: any, o: any): any;
1008
+ static GetLCenter(node: any, o: any): any;
1009
+ static GetBNear(node: any, o: any): any;
1010
+ static GetBFar(node: any, o: any): any;
1011
+ static GetLNear(node: any, o: any): any;
1012
+ static GetLFar(node: any, o: any): any;
1013
+ static GetBNearRect(rect: any, o: any): any;
1014
+ static GetBFarRect(rect: any, o: any): any;
1015
+ static GetLNearRect(rect: any, o: any): any;
1016
+ static GetLFarRect(rect: any, o: any): any;
1017
+ static GetB(point: any, o: any): any;
1018
+ static GetL(point: any, o: any): any;
1019
+ static OffsetL(node: any, offset: any, o: any): void;
1020
+ static OffsetOutLinks(links: any, offx: any, offy: any, o: any): void;
1021
+ }
1022
+ import { Point } from "@mindfusion/drawing";
1023
+ }
1024
+ declare module "Graphs/FlowchartLayout" {
1025
+ /**
1026
+ * @class FlowchartLayout can be used to arrange flowcharts representing program source code.
1027
+ * @augments Layout
1028
+ */
1029
+ export class FlowchartLayout extends Layout {
1030
+ set nodeDistance(arg: number);
1031
+ /**
1032
+ * Gets or sets the distance between consecutive nodes in the flowchart.
1033
+ * @type {Number}
1034
+ * @summary A numeric value specifying the distance between neighbor nodes in the same sequence.
1035
+ */
1036
+ get nodeDistance(): number;
1037
+ set branchPadding(arg: number);
1038
+ /**
1039
+ * Gets or sets how much space to leave between adjacent decision branches in the flowchart.
1040
+ * @type {Number}
1041
+ * @summary A numeric value specifying the distance between adjacent branches.
1042
+ */
1043
+ get branchPadding(): number;
1044
+ set linkPadding(arg: number);
1045
+ /**
1046
+ * Gets or sets how much space to leave between adjacent back links designating nested loops.
1047
+ * @type {Number}
1048
+ * @summary A numeric value specifying the distance between adjacent back links.
1049
+ */
1050
+ get linkPadding(): number;
1051
+ set orientation(arg: number);
1052
+ /**
1053
+ * Gets or sets the orientation of the arranged graph.
1054
+ * @type {Orientation}
1055
+ * @summary A member of the Orientation enumeration.
1056
+ */
1057
+ get orientation(): number;
1058
+ nodeOrder: Map<any, any>;
1059
+ progressCounter: number;
1060
+ branchings: any[];
1061
+ visitedNodes: Map<any, any>;
1062
+ postOrder: Map<any, any>;
1063
+ topologicalOrder: Map<any, any>;
1064
+ searchCounter: number;
1065
+ flowchartNodes: Map<any, any>;
1066
+ mm: number;
1067
+ arrange(graph: any): boolean;
1068
+ graph: any;
1069
+ placedNodes: any[];
1070
+ furthestL: number;
1071
+ layoutRect: any;
1072
+ composeFlowChart(startNode: any): any;
1073
+ composeBlocks(node: any, parentBlock: any, loopDepth: any, onlyNotVisited: any, ignoreMerge: any): any;
1074
+ getSequence(block: any): any;
1075
+ followedByMergeNode(block: any): boolean;
1076
+ getFlowchartNode(node: any): any;
1077
+ getStartNodes(): any[];
1078
+ getOutgoingDownLinks(node: any): number;
1079
+ getIncomingDownLinks(node: any): number;
1080
+ getType(): any;
1081
+ getOutgoingLoopLinks(node: any): number;
1082
+ getIncomingLoopLinks(node: any): number;
1083
+ isVisited(node: any): boolean;
1084
+ isStartNode(node: any): boolean;
1085
+ isEndNode(node: any): boolean;
1086
+ inDegree(node: any): any;
1087
+ outDegree(node: any): any;
1088
+ isBackLink(link: any): boolean;
1089
+ isDownLink(link: any): boolean;
1090
+ depthFirstSearch(node: any): void;
1091
+ topologicalSort(startNode: any, graphOrder: any): Map<any, any>;
1092
+ getDownLinks(links: any): any[];
1093
+ getTopologicalOrder(): Map<any, any>;
1094
+ findPath(link: any, o: any, relaxed: any): Point[];
1095
+ segmentsFromPoints(points: any): {
1096
+ index: number;
1097
+ points: any;
1098
+ horizontal(): boolean;
1099
+ xint(): any[];
1100
+ yint(): any[];
1101
+ }[];
1102
+ pullLinksApart(links: any): void;
1103
+ splitPaths(links: any, horizontal: any): void;
1104
+ _branchPadding: number;
1105
+ _linkPadding: number;
1106
+ _nodeDistance: number;
1107
+ _orientation: number;
1108
+ dumpGraph(): void;
1109
+ }
1110
+ import { Layout } from "Graphs/Layout";
1111
+ import { Point } from "@mindfusion/drawing";
1112
+ }
1113
+ declare module "Graphs/FractalLayout" {
1114
+ /**
1115
+ * @class The FractalLayout tree layout algorithm places child nodes symmetrically around their parent node.
1116
+ * Nodes at the lowest level are arranged directly in a circle around their parent. At the upper level,
1117
+ * the already arranged nodes form branches that are arranged in a circle around the new parent node.
1118
+ * The algorithm is recursively repeated till the highest level is reached.
1119
+ * @augments Layout
1120
+ */
1121
+ export class FractalLayout extends Layout {
1122
+ set root(arg: any);
1123
+ /**
1124
+ * Gets or sets the node that should be placed at the center of the tree.
1125
+ * @type {DiagramNode}
1126
+ * @summary The node that should be placed at the center of the tree.
1127
+ */
1128
+ get root(): any;
1129
+ arrange(graph: any): void;
1130
+ branchCircles: Map<any, any>;
1131
+ measureCircles(node: any): {
1132
+ node: any;
1133
+ radius: any;
1134
+ centerX: any;
1135
+ centerY: any;
1136
+ childCircles: any[];
1137
+ };
1138
+ arrangeCircles(circle: any, center: any, angle: any): void;
1139
+ getType(): any;
1140
+ _root: any;
1141
+ }
1142
+ import { Layout } from "Graphs/Layout";
1143
+ }
1144
+ declare module "Graphs/LayeredLayout" {
1145
+ /**
1146
+ * @class Implements a layered graph layout algorithm.
1147
+ * This algorithm assigns diagram nodes to distinct horizontal or vertical layers.
1148
+ * While arranging the layers, the layout routine seeks to meet the following criteria:
1149
+ * - connected nodes must be placed close together;
1150
+ * - links must flow in one direction if possible;
1151
+ * - links must cross as few layers as possible;
1152
+ * - links must not cross other links;
1153
+ * @augments Layout
1154
+ */
1155
+ export class LayeredLayout extends Layout {
1156
+ set nodeDistance(arg: number);
1157
+ /**
1158
+ * Gets or sets the space to leave between adjacent nodes on the same level.
1159
+ * @type {Number}
1160
+ * @summary The space to leave between adjacent nodes on the same level.
1161
+ */
1162
+ get nodeDistance(): number;
1163
+ set layerDistance(arg: number);
1164
+ /**
1165
+ * Gets or sets the desired distance between layer axis lines.
1166
+ * @type {Number}
1167
+ * @summary The desired distance between layer axis lines.
1168
+ */
1169
+ get layerDistance(): number;
1170
+ set direction(arg: number);
1171
+ /**
1172
+ * Gets or sets the orientation of the arranged graph.
1173
+ * @type {LayoutDirection}
1174
+ * @summary A member of the LayoutDirection enumeration.
1175
+ */
1176
+ get direction(): number;
1177
+ set siftingRounds(arg: number);
1178
+ /**
1179
+ * Gets or sets the number of iterations to perform when untwining the layout.
1180
+ * @type {Number}
1181
+ * @summary The number of iterations to perform when untwining the layout.
1182
+ */
1183
+ get siftingRounds(): number;
1184
+ initialMinimizeCrossingsDown: boolean;
1185
+ /**
1186
+ * Applies the layout to the specified graph.
1187
+ * @param {Graph} graph The graph to arrange.
1188
+ */
1189
+ arrange(graph: any): void;
1190
+ graph: any;
1191
+ layers: any[];
1192
+ /**
1193
+ * @private
1194
+ */
1195
+ private setMinDist;
1196
+ /**
1197
+ * @private
1198
+ */
1199
+ private getMinDist;
1200
+ /**
1201
+ * @private
1202
+ */
1203
+ private computeLeftClasses;
1204
+ nodeLeftClass: any;
1205
+ /**
1206
+ * @private
1207
+ */
1208
+ private computeRightClasses;
1209
+ nodeRightClass: any;
1210
+ /**
1211
+ * @private
1212
+ */
1213
+ private computeClasses;
1214
+ /**
1215
+ * @private
1216
+ */
1217
+ private placeLeftToRight;
1218
+ dump(pos: any): void;
1219
+ /**
1220
+ * @private
1221
+ */
1222
+ private placeRightToLeft;
1223
+ /**
1224
+ * @private
1225
+ */
1226
+ private assignCoordinates;
1227
+ minDistances: any[];
1228
+ downNodes: Map<any, any>;
1229
+ upNodes: Map<any, any>;
1230
+ /**
1231
+ * @private
1232
+ */
1233
+ private adjustDirections;
1234
+ /**
1235
+ * @private
1236
+ */
1237
+ private getNeighborOnLayer;
1238
+ /**
1239
+ * @private
1240
+ */
1241
+ private placeSequence;
1242
+ /**
1243
+ * @private
1244
+ */
1245
+ private placeSingle;
1246
+ /**
1247
+ * @private
1248
+ */
1249
+ private combineSequences;
1250
+ /**
1251
+ * @private
1252
+ */
1253
+ private placeLeft;
1254
+ /**
1255
+ * @private
1256
+ */
1257
+ private placeRight;
1258
+ /**
1259
+ * @private
1260
+ */
1261
+ private leftSibling;
1262
+ /**
1263
+ * @private
1264
+ */
1265
+ private rightSibling;
1266
+ /**
1267
+ * @private
1268
+ */
1269
+ private L;
1270
+ /**
1271
+ * Move nodes to their barycenters, according to their
1272
+ * priority but doing so without any box swapping
1273
+ * (i.e. the boxes' order remains the same).
1274
+ * @private
1275
+ */
1276
+ private layout;
1277
+ /**
1278
+ * @private
1279
+ */
1280
+ private layoutLayer;
1281
+ /**
1282
+ * @private
1283
+ */
1284
+ private moveRight;
1285
+ /**
1286
+ * @private
1287
+ */
1288
+ private moveLeft;
1289
+ /**
1290
+ * @private
1291
+ */
1292
+ private mapVirtualNode;
1293
+ /**
1294
+ * @private
1295
+ */
1296
+ private nodesInLongLink;
1297
+ /**
1298
+ * @private
1299
+ */
1300
+ private dummify;
1301
+ linkToNodeMap: Map<any, any>;
1302
+ nodeToLinkMap: Map<any, any>;
1303
+ /**
1304
+ * @private
1305
+ */
1306
+ private dedummify;
1307
+ /**
1308
+ * Tries to minimize crossings across all levels.
1309
+ * @private
1310
+ */
1311
+ private minimizeCrossings;
1312
+ /**
1313
+ * Calculates up barycenters and linkCount for the nodes
1314
+ * in the layer whose index is specified in the parameter.
1315
+ * @private
1316
+ */
1317
+ private calcUpData;
1318
+ /**
1319
+ * Calculates down barycenters and linkCount for the nodes
1320
+ * in the layer whose index is specified in the parameter.
1321
+ * @private
1322
+ */
1323
+ private calcDownData;
1324
+ /**
1325
+ * Tries to minimize crossings between layers 'layer' and
1326
+ * 'layer' + 1 if down is true and between layers 'layer' - 1
1327
+ * and 'layer' if down is false.
1328
+ * @private
1329
+ */
1330
+ private minimizeCrossingsDir;
1331
+ /**
1332
+ * This method performs a single pass over the graph in an attempt to reduce
1333
+ * link crossings through neighbors swapping.
1334
+ * @private
1335
+ */
1336
+ private swapPairs;
1337
+ /**
1338
+ * Returns the total number of crossings for the links inbetween the specified layers.
1339
+ * @private
1340
+ */
1341
+ private countCrossings;
1342
+ getType(): any;
1343
+ _nodeDistance: number;
1344
+ _layerDistance: number;
1345
+ _direction: number;
1346
+ _siftingRounds: number;
1347
+ }
1348
+ import { Layout } from "Graphs/Layout";
1349
+ }
1350
+ declare module "Graphs/SpringLayout" {
1351
+ /**
1352
+ * @class Implements the Spring-Embedder graph layout algorithm.
1353
+ * @augments Layout
1354
+ */
1355
+ export class SpringLayout extends Layout {
1356
+ set nodeDistance(arg: number);
1357
+ /**
1358
+ * Gets or sets the desired distance between nodes.
1359
+ * @type {Number}
1360
+ * @summary the desired distance between nodes.
1361
+ */
1362
+ get nodeDistance(): number;
1363
+ set iterations(arg: number);
1364
+ /**
1365
+ * Gets or sets the number of iterations to run the layout routine.
1366
+ * @type {Number}
1367
+ * @summary The number of iterations to run the layout routine.
1368
+ */
1369
+ get iterations(): number;
1370
+ /**
1371
+ * @private
1372
+ */
1373
+ private refineStage;
1374
+ /**
1375
+ * @private
1376
+ */
1377
+ private initialTemperature;
1378
+ /**
1379
+ * @private
1380
+ */
1381
+ private temperature;
1382
+ /**
1383
+ * Applies the layout to the specified graph.
1384
+ * @param {Graph} graph The graph to arrange.
1385
+ */
1386
+ arrange(graph: any): void;
1387
+ graph: any;
1388
+ width: number;
1389
+ height: number;
1390
+ /**
1391
+ * @private
1392
+ */
1393
+ private moveToEpsilonCircle;
1394
+ /**
1395
+ * @private
1396
+ */
1397
+ private attraction;
1398
+ /**
1399
+ * @private
1400
+ */
1401
+ private repulsion;
1402
+ /**
1403
+ * @private
1404
+ */
1405
+ private calcRepulsionForce;
1406
+ /**
1407
+ * @private
1408
+ */
1409
+ private calcSpringForce;
1410
+ /**
1411
+ * @private
1412
+ */
1413
+ private applyForce;
1414
+ getType(): any;
1415
+ _nodeDistance: number;
1416
+ _iterations: number;
1417
+ }
1418
+ import { Layout } from "Graphs/Layout";
1419
+ }
1420
+ declare module "Graphs/TopologicalLayout" {
1421
+ /**
1422
+ * @class Implements a topological ordering.
1423
+ * The algorithm arranges nodes in a row or a column (depending on the value of the direction property)
1424
+ * in such a way that there are as few back links as possible. The links connecting non-adjacent nodes
1425
+ * are rendered as arcs. The links connecting adjacent nodes are rendered either as arcs or as straight lines,
1426
+ * depending on the bendAdjacentLinks property. The amplitude of the link arcs is proportional to the
1427
+ * distance between the connected nodes. All forward links are rendered at one side of the nodes and all
1428
+ * back links are rendered at the opposite side. Thus, all bent links follow the same rotation direction.
1429
+ * @augments Layout
1430
+ */
1431
+ export class TopologicalLayout extends Layout {
1432
+ set nodeDistance(arg: number);
1433
+ /**
1434
+ * Gets or sets the desired distance between adjacent nodes.
1435
+ * @type {Number}
1436
+ * @summary The desired distance between adjacent nodes.
1437
+ */
1438
+ get nodeDistance(): number;
1439
+ set direction(arg: number);
1440
+ /**
1441
+ * Gets or sets the orientation of the arranged graph.
1442
+ * @type {LayoutDirection}
1443
+ * @summary A member of the LayoutDirection enumeration.
1444
+ */
1445
+ get direction(): number;
1446
+ set bendAdjacentLinks(arg: boolean);
1447
+ /**
1448
+ * Gets or sets a value indicating whether to bend links connecting adjacent nodes or draw them as straight lines.
1449
+ * @type {Boolean}
1450
+ * @summary true to bend links connecting adjacent nodes, or false otherwise.
1451
+ */
1452
+ get bendAdjacentLinks(): boolean;
1453
+ mm: number;
1454
+ /**
1455
+ * Applies the layout to the specified graph.
1456
+ * @param {Graph} graph The graph to arrange.
1457
+ */
1458
+ arrange(graph: any): boolean;
1459
+ graph: any;
1460
+ getType(): any;
1461
+ _nodeDistance: number;
1462
+ _direction: number;
1463
+ _bendAdjacentLinks: boolean;
1464
+ }
1465
+ import { Layout } from "Graphs/Layout";
1466
+ }
1467
+ declare module "Graphs/TreeLayout" {
1468
+ /**
1469
+ * @class Implements algorithms for arranging tree structures.
1470
+ * @augments Layout
1471
+ */
1472
+ export class TreeLayout extends Layout {
1473
+ set levelDistance(arg: number);
1474
+ /**
1475
+ * Gets or sets the space to leave between adjacent levels of the tree.
1476
+ * @type {Number}
1477
+ * @summary The space to leave between adjacent levels of the tree.
1478
+ */
1479
+ get levelDistance(): number;
1480
+ set nodeDistance(arg: number);
1481
+ /**
1482
+ * Gets or sets the space to leave between adjacent nodes on the same level.
1483
+ * @type {Number}
1484
+ * @summary The space to leave between adjacent nodes on the same level.
1485
+ */
1486
+ get nodeDistance(): number;
1487
+ set keepRootPosition(arg: boolean);
1488
+ /**
1489
+ * Gets or sets a value indicating whether to keep the root node at its original position.
1490
+ * @type {Boolean}
1491
+ * @summary true if the root node should be kept at its original position, or false otherwise.
1492
+ */
1493
+ get keepRootPosition(): boolean;
1494
+ set direction(arg: number);
1495
+ /**
1496
+ * Gets or sets the orientation of the arranged graph.
1497
+ * @type {LayoutDirection}
1498
+ * @summary A member of the LayoutDirection enumeration.
1499
+ */
1500
+ get direction(): number;
1501
+ set linkType(arg: number);
1502
+ /**
1503
+ * Gets or sets the type of the links in the arranged tree.
1504
+ * @type {TreeLayoutLinkType}
1505
+ * @summary A member of the TreeLayoutLinkType enumeration.
1506
+ */
1507
+ get linkType(): number;
1508
+ set enableAssistants(arg: boolean);
1509
+ /**
1510
+ * Gets or sets a value Indicating whether the "assistant" trait is regarded when performing the layout.
1511
+ * @type {Boolean}
1512
+ * @summary true if the "assistant" trait is regarded when performing the layout, or false otherwise.
1513
+ */
1514
+ get enableAssistants(): boolean;
1515
+ set compactAssistants(arg: boolean);
1516
+ /**
1517
+ * Gets or sets a value indicating whether the "assistant" nodes on the same side of a single parent
1518
+ * are arranged as close to each other as possible.
1519
+ * @type {Boolean}
1520
+ * @summary true if the "assistant" nodes on the same side of a single parent
1521
+ * are arranged as close to each other as possible, or false otherwise.
1522
+ */
1523
+ get compactAssistants(): boolean;
1524
+ set reversedLinks(arg: boolean);
1525
+ /**
1526
+ * Gets or sets a value indicating the link direction that relates parent nodes to child nodes.
1527
+ * @type {Boolean}
1528
+ * @summary true to indicate reversed direction (links point to parent nodes), or false otherwise.
1529
+ */
1530
+ get reversedLinks(): boolean;
1531
+ /**
1532
+ * Applies the layout to the specified graph.
1533
+ * @param {Graph} graph The graph to arrange.
1534
+ */
1535
+ arrange(graph: any): any;
1536
+ treeHelper: TreeHelper;
1537
+ /**
1538
+ * @private
1539
+ */
1540
+ private hasAssistants;
1541
+ /**
1542
+ * Calculates the bounding rectangle of the tree branch defined by
1543
+ * the specified node. The result is the smallest rectangle containing
1544
+ * all children of the specified node and the node itself.
1545
+ * @private
1546
+ */
1547
+ private branchBounds;
1548
+ /**
1549
+ * Calculate the distance between the branches, whose
1550
+ * root nodes are specified as arguments.
1551
+ * @private
1552
+ *
1553
+ * @param {Vertex} node1 The root node of the first branch.
1554
+ * @param {Vertex} node2 The root note of the second branch.
1555
+ * @returns {Number} The distance between the branches.
1556
+ */
1557
+ private branchDistance;
1558
+ right(vertex: any): any;
1559
+ left(vertex: any): number;
1560
+ /**
1561
+ * Offset a branch of the tree with the specified values.
1562
+ * @private
1563
+ *
1564
+ * @param {Vertex} nodeFrom The root node of the branch to offset.
1565
+ * @param {Number} xoff The x-axis offset.
1566
+ * @param {Number} yoff The y-axis offset.
1567
+ */
1568
+ private offsetBranch;
1569
+ /**
1570
+ * @private
1571
+ */
1572
+ private isHorizontal;
1573
+ /**
1574
+ * @private
1575
+ */
1576
+ private isStraight;
1577
+ /**
1578
+ * @private
1579
+ */
1580
+ private intDiv;
1581
+ getType(): any;
1582
+ _levelDistance: number;
1583
+ _nodeDistance: number;
1584
+ _keepRootPosition: boolean;
1585
+ _direction: number;
1586
+ _linkType: number;
1587
+ _enableAssistants: boolean;
1588
+ _compactAssistants: boolean;
1589
+ _reversedLinks: boolean;
1590
+ }
1591
+ import { Layout } from "Graphs/Layout";
1592
+ import TreeHelper from "Graphs/TreeHelper";
1593
+ }
1594
+ declare module "Graphs/TreeMapLayout" {
1595
+ /**
1596
+ * @class Performs tree-map layout on a graph.
1597
+ * @augments Layout
1598
+ */
1599
+ export class TreeMapLayout extends Layout {
1600
+ set orientation(arg: number);
1601
+ /**
1602
+ * Gets or sets the orientation of the arranged graph.
1603
+ * @type {Orientation}
1604
+ * @summary A member of the Orientation enumeration.
1605
+ */
1606
+ get orientation(): number;
1607
+ set squarify(arg: boolean);
1608
+ /**
1609
+ * Gets or sets a value indicating whether the layout should attempt to keep the dimension ratio of nodes closer to 1.
1610
+ * @type {Boolean}
1611
+ * @summary true if the layout should attempt to keep the dimension ratio of nodes closer to 1, or false otherwise.
1612
+ */
1613
+ get squarify(): boolean;
1614
+ set padding(arg: number);
1615
+ /**
1616
+ * Gets or sets the distance between adjacent nodes.
1617
+ * @type {Number}
1618
+ * @summary The distance between adjacent nodes.
1619
+ */
1620
+ get padding(): number;
1621
+ set layoutArea(arg: Rect);
1622
+ /**
1623
+ * Gets or sets the rectangle in which the layout will try to arrange nodes.
1624
+ * @type {Rect}
1625
+ * @summary The rectangle in which the layout will try to arrange nodes.
1626
+ */
1627
+ get layoutArea(): Rect;
1628
+ set containerPadding(arg: number);
1629
+ /**
1630
+ * Gets or sets the padding inside containers.
1631
+ * @type {Number}
1632
+ * @summary The padding inside containers.
1633
+ */
1634
+ get containerPadding(): number;
1635
+ minNodeSize: number;
1636
+ /**
1637
+ * Applies the layout to the specified graph.
1638
+ * @param {Graph} graph The graph to arrange.
1639
+ */
1640
+ arrange(graph: any): void;
1641
+ weights: Map<any, any>;
1642
+ arrangeSquare(nodes: any, layoutArea: any, row: any, parentWeight: any): void;
1643
+ doSquarify(children: any, layoutArea: any, row: any, parentWeight: any): void;
1644
+ weight(row: any): number;
1645
+ subtractPadding(rect: any): void;
1646
+ layoutRow(layoutArea: any, row: any, horizontal: any, parentWeight: any): number;
1647
+ arrangeSiblings(nodes: any, layoutArea: any, horizontal: any, totalWeight: any): void;
1648
+ evalRatio(row: any, sideLen: any, rowArea: any): number;
1649
+ calcWeights(root: any): any;
1650
+ layOutArea(node: any): any;
1651
+ getType(): any;
1652
+ _orientation: number;
1653
+ _squarify: boolean;
1654
+ _padding: number;
1655
+ _layoutArea: Rect;
1656
+ _containerPadding: number;
1657
+ }
1658
+ import { Layout } from "Graphs/Layout";
1659
+ import { Rect } from "@mindfusion/drawing";
1660
+ }
1661
+ declare module "Graphs/DrawingGrid" {
1662
+ export default DrawingGrid;
1663
+ class DrawingGrid {
1664
+ constructor(graph: any, vertexPoints: any, edgePoints: any);
1665
+ graph: any;
1666
+ vertexPoints: any;
1667
+ edgePoints: any;
1668
+ cells: {
1669
+ has(point: any): boolean;
1670
+ get(point: any): any;
1671
+ set(point: any, value: any): void;
1672
+ delete(point: any): boolean;
1673
+ key(point: any): string;
1674
+ clear(): void;
1675
+ forEach(callbackfn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any): void;
1676
+ readonly size: number;
1677
+ entries(): IterableIterator<[any, any]>;
1678
+ keys(): IterableIterator<any>;
1679
+ values(): IterableIterator<any>;
1680
+ [Symbol.iterator](): IterableIterator<[any, any]>;
1681
+ readonly [Symbol.toStringTag]: string;
1682
+ };
1683
+ bounds: {
1684
+ left: any;
1685
+ top: any;
1686
+ right: any;
1687
+ bottom: any;
1688
+ };
1689
+ columnWidths: Map<any, any>;
1690
+ rowHeights: Map<any, any>;
1691
+ setCellDimensions(vertexSize: any, padding: any, edgeCellSize: any): void;
1692
+ minWidth: Map<any, any>;
1693
+ maxWidth: Map<any, any>;
1694
+ minHeight: Map<any, any>;
1695
+ maxHeight: Map<any, any>;
1696
+ columnPositions: Map<any, any>;
1697
+ rowPositions: Map<any, any>;
1698
+ getPosition(point: any): Point;
1699
+ getEdgePointPosition(point: any, edge: any, width: any, height: any): Point;
1700
+ updateBounds(point: any): void;
1701
+ updateBoundsFromPoints(points: any): void;
1702
+ refine(iterations: any): void;
1703
+ refineSpace(): void;
1704
+ refineCacheEdges(): void;
1705
+ refineDegreeOneVertices(): void;
1706
+ removeUnusedRows(): void;
1707
+ removeUnusedColumns(): void;
1708
+ removeFromCell(cell: any, p: any, edge: any, horizontal: any): void;
1709
+ refineUTurns(): void;
1710
+ removeRedundantBends(): void;
1711
+ setSegmentsInRange(e: any, p1: any, includeP1: any, p2: any, includeP2: any): void;
1712
+ removeSegmentsFromRange(e: any, p1: any, removeP1: any, p2: any, removeP2: any): void;
1713
+ edgeContainsRange(e: any, p1: any, includeP1: any, p2: any, includeP2: any): boolean;
1714
+ normalizePath(path: any, e: any, setSegments: any): void;
1715
+ setApartOverlappingEdges(): void;
1716
+ horizontalEdges: Grid;
1717
+ verticalEdges: Grid;
1718
+ getBendNeighborPoints(bend: any, column: any, row: any): any;
1719
+ bendsToTheLeft(bend: any, column: any, row: any): boolean;
1720
+ bendsToTheTop(bend: any, column: any, row: any): boolean;
1721
+ setHorizontalEdgesInRange(edges: any, row: any, c1: any, c2: any): void;
1722
+ setVerticalEdgesInRange(edges: any, column: any, r1: any, r2: any): void;
1723
+ countHorizontalEdgesCrossings(edges: any, row: any, c1: any, c2: any, permutation: any): number;
1724
+ countVerticalEdgesCrossings(edges: any, column: any, r1: any, r2: any, permutation: any): number;
1725
+ permuteHorizontalEdgeLanes(row: any, c1: any, c2: any, permutation: any): void;
1726
+ permuteVerticalEdgeLanes(column: any, r1: any, r2: any, permutation: any): void;
1727
+ getCell(column: any, row: any): any;
1728
+ }
1729
+ namespace DrawingGrid {
1730
+ export { Cell };
1731
+ export { Rectangle };
1732
+ export { Size };
1733
+ export { EdgeSegment };
1734
+ export { Bend };
1735
+ export { PointMap };
1736
+ export { PermutationSet };
1737
+ }
1738
+ import { Point } from "@mindfusion/drawing";
1739
+ import { Grid } from "@mindfusion/collections";
1740
+ class Cell {
1741
+ content: any[];
1742
+ add(item: any): void;
1743
+ removeEdgeOrBend(e: any, horizontal: any): void;
1744
+ countEdges(horizontal: any): number;
1745
+ containsVertex(): boolean;
1746
+ containsVertexOrBend(): boolean;
1747
+ containsEdge(edge: any): boolean;
1748
+ containsEdgeSegment(edge: any, horizontal: any): boolean;
1749
+ getEdgeSegment(edge: any, horizontal: any): {
1750
+ edge: any;
1751
+ dx: any;
1752
+ dy: any;
1753
+ lane: number;
1754
+ maxNeighbors: number;
1755
+ readonly horizontal: boolean;
1756
+ };
1757
+ getEdgeBend(edge: any): {
1758
+ edge: any;
1759
+ horizontalLane: number;
1760
+ maxHNeighbors: number;
1761
+ verticalLane: number;
1762
+ maxVNeighbors: number;
1763
+ neighborPoints: any;
1764
+ };
1765
+ getEdgeLane(edge: any, horizontal: any, neighbors: any): number;
1766
+ permuteLanes(permutation: any, horizontal: any): void;
1767
+ }
1768
+ class Rectangle {
1769
+ constructor(left: any, top: any, right: any, bottom: any);
1770
+ left: any;
1771
+ top: any;
1772
+ right: any;
1773
+ bottom: any;
1774
+ }
1775
+ class Size {
1776
+ constructor(width: any, height: any);
1777
+ width: any;
1778
+ height: any;
1779
+ }
1780
+ class EdgeSegment {
1781
+ constructor(edge: any, dx: any, dy: any);
1782
+ edge: any;
1783
+ dx: any;
1784
+ dy: any;
1785
+ lane: number;
1786
+ maxNeighbors: number;
1787
+ get horizontal(): boolean;
1788
+ }
1789
+ class Bend {
1790
+ constructor(edge: any);
1791
+ edge: any;
1792
+ horizontalLane: number;
1793
+ maxHNeighbors: number;
1794
+ verticalLane: number;
1795
+ maxVNeighbors: number;
1796
+ neighborPoints: any;
1797
+ }
1798
+ class PointMap extends Map<any, any> {
1799
+ constructor();
1800
+ constructor(entries?: readonly (readonly [any, any])[]);
1801
+ constructor(iterable: Iterable<readonly [any, any]>);
1802
+ key(point: any): string;
1803
+ }
1804
+ class PermutationSet {
1805
+ constructor(n: any);
1806
+ permutations: any[];
1807
+ current: number[];
1808
+ heapPermute(n: any): void;
1809
+ addItem(): void;
1810
+ swap(i: any, j: any): void;
1811
+ get(i: any): any;
1812
+ list(): any[];
1813
+ }
1814
+ }
1815
+ declare module "Graphs/Representation" {
1816
+ /**
1817
+ * @namespace MindFusion.Graphs
1818
+ */
1819
+ export default class Representation {
1820
+ constructor(stGraph: any, weighted: any, xOrdering: any, stEmbedding: any);
1821
+ stsort: any;
1822
+ Y: any;
1823
+ s: any;
1824
+ t: any;
1825
+ d: any;
1826
+ X: any;
1827
+ left(e: any): any;
1828
+ right(e: any): any;
1829
+ leftV(v: any): any;
1830
+ rightV(v: any): any;
1831
+ orig(e: any): any;
1832
+ dest(e: any): any;
1833
+ origF(f: any): any;
1834
+ destF(f: any): any;
1835
+ leftMostIncoming(v: any): any;
1836
+ leftMostOutgoing(v: any): any;
1837
+ rightMostOutgoing(v: any): any;
1838
+ getOutEdges(v: any): any[];
1839
+ getInEdges(v: any): any[];
1840
+ getOutMedian(v: any): any;
1841
+ getInMedian(v: any): any;
1842
+ newHSegment(): {
1843
+ y: number;
1844
+ x1: number;
1845
+ x2: number;
1846
+ };
1847
+ newVSegment(): {
1848
+ x: number;
1849
+ y1: number;
1850
+ y2: number;
1851
+ };
1852
+ get dualGraph(): any;
1853
+ get source(): any;
1854
+ get sink(): any;
1855
+ get topologicalSort(): any;
1856
+ }
1857
+ }
1858
+ declare module "Graphs/ConstrainedVisibility" {
1859
+ export default class ConstrainedVisibility extends Representation {
1860
+ constructor(stGraph: any, vpaths: any);
1861
+ edgeToPathMap: Map<any, any>;
1862
+ pathToVertexMap: Map<any, any>;
1863
+ hSegments: Map<any, any>;
1864
+ vSegments: Map<any, any>;
1865
+ get vertexSegments(): Map<any, any>;
1866
+ get edgeSegments(): Map<any, any>;
1867
+ }
1868
+ import Representation from "Graphs/Representation";
1869
+ }
1870
+ declare module "Graphs/OrthogonalLayout" {
1871
+ /**
1872
+ * @class Implements orthogonal graph layout algorithm.
1873
+ * Each link is drawn as a chain of alternating horizontal and vertical segments.
1874
+ * Nodes are placed in a way that facilitates few links bends and crossings.
1875
+ * @augments Layout
1876
+ */
1877
+ export class OrthogonalLayout extends Layout {
1878
+ set refine(arg: boolean);
1879
+ /**
1880
+ * Gets or sets a value indicating whether to refine the layout.
1881
+ * @type {Boolean}
1882
+ * @summary True to refine the layout, or false otherwise.
1883
+ */
1884
+ get refine(): boolean;
1885
+ set padding(arg: number);
1886
+ /**
1887
+ * Gets or sets a value indicating how much space to leave between nodes in adjacent lanes.
1888
+ * @type {Number}
1889
+ * @summary The space to leave between nodes in adjacent lanes.
1890
+ */
1891
+ get padding(): number;
1892
+ set minLaneSize(arg: number);
1893
+ /**
1894
+ * Gets or sets a value indicating the minimum size of a lane.
1895
+ * @type {Number}
1896
+ * @summary The minimum size of a lane.
1897
+ */
1898
+ get minLaneSize(): number;
1899
+ mm: number;
1900
+ /**
1901
+ * Applies the layout to the specified graph.
1902
+ * @param {Graph} graph The graph to arrange.
1903
+ */
1904
+ arrange(graph: any): boolean;
1905
+ graph: any;
1906
+ vertexPoints: Map<any, any>;
1907
+ edgePoints: Map<any, any>;
1908
+ drawingGrid: DrawingGrid;
1909
+ applyGrid(grid: any): boolean;
1910
+ alignEndsToNode(edge: any): void;
1911
+ getType(): any;
1912
+ reverseRange(array: any, l: any, r: any): void;
1913
+ mergePaths(v: any, c: any, rs: any, re: any, step: any): void;
1914
+ mergePath(edges: any, stgEdgePoints: any): any[];
1915
+ _refine: boolean;
1916
+ _padding: number;
1917
+ _minLaneSize: number;
1918
+ }
1919
+ import { Layout } from "Graphs/Layout";
1920
+ import DrawingGrid from "Graphs/DrawingGrid";
1921
+ }
1922
+ declare module "Graphs/RadialTreeLayout" {
1923
+ /**
1924
+ * @class Implements a radial tree layout algorithm.
1925
+ * @augments Layout
1926
+ */
1927
+ export class RadialTreeLayout extends Layout {
1928
+ set levelDistance(arg: number);
1929
+ /**
1930
+ * Gets or sets the space to leave between adjacent levels of the tree.
1931
+ * @type {Number}
1932
+ * @summary The space to leave between adjacent levels of the tree.
1933
+ */
1934
+ get levelDistance(): number;
1935
+ set keepRootPosition(arg: boolean);
1936
+ /**
1937
+ * Gets or sets a value indicating whether to keep the root node at its original position.
1938
+ * @type {Boolean}
1939
+ * @summary true if the root node should be kept at its original position, or false otherwise.
1940
+ */
1941
+ get keepRootPosition(): boolean;
1942
+ set direction(arg: number);
1943
+ /**
1944
+ * Gets or sets the orientation of the arranged graph.
1945
+ * @type {LayoutDirection}
1946
+ * @summary A member of the LayoutDirection enumeration.
1947
+ */
1948
+ get direction(): number;
1949
+ set stretchFactor(arg: number);
1950
+ /**
1951
+ * Gets or sets the stretch factor in radial layouts.
1952
+ * @type {Number}
1953
+ * @summary The stretch factor.
1954
+ */
1955
+ get stretchFactor(): number;
1956
+ set reversedLinks(arg: boolean);
1957
+ /**
1958
+ * Gets or sets a value indicating the link direction that relates parent nodes to child nodes.
1959
+ * @type {Boolean}
1960
+ * @summary true to indicate reversed direction (links point to parent nodes), or false otherwise.
1961
+ */
1962
+ get reversedLinks(): boolean;
1963
+ /**
1964
+ * Applies the layout to the specified graph.
1965
+ * @param {Graph} graph The graph to arrange.
1966
+ */
1967
+ arrange(graph: any): any;
1968
+ treeHelper: TreeHelper;
1969
+ tree: any;
1970
+ arrangeLevel(parentLevel: any): any;
1971
+ calcBounds(): any;
1972
+ calcRadius(level: any): any;
1973
+ getType(): any;
1974
+ _levelDistance: number;
1975
+ _keepRootPosition: boolean;
1976
+ _direction: number;
1977
+ _stretchFactor: number;
1978
+ _reversedLinks: boolean;
1979
+ }
1980
+ import { Layout } from "Graphs/Layout";
1981
+ import TreeHelper from "Graphs/TreeHelper";
1982
+ }
1983
+ declare module "@mindfusion/graphs" {
1984
+ import { AssistantPosition, AssistantType, Anchoring, LayoutDirection, TreeLayoutLinkType, MultipleGraphsPlacement, Orientation } from "Graphs/Enum";
1985
+ export { AssistantPosition, AssistantType, Anchoring, LayoutDirection, TreeLayoutLinkType, MultipleGraphsPlacement, Orientation };
1986
+ export { Graph } from "Graphs/Graph";
1987
+ export { PathFinder } from "Graphs/PathFinder";
1988
+ export { BorderedTreeLayout } from "Graphs/BorderedTreeLayout";
1989
+ export { FlowchartLayout } from "Graphs/FlowchartLayout";
1990
+ export { FractalLayout } from "Graphs/FractalLayout";
1991
+ export { LayeredLayout } from "Graphs/LayeredLayout";
1992
+ export { SpringLayout } from "Graphs/SpringLayout";
1993
+ export { TopologicalLayout } from "Graphs/TopologicalLayout";
1994
+ export { TreeLayout } from "Graphs/TreeLayout";
1995
+ export { TreeMapLayout } from "Graphs/TreeMapLayout";
1996
+ export { OrthogonalLayout } from "Graphs/OrthogonalLayout";
1997
+ export { RadialTreeLayout } from "Graphs/RadialTreeLayout";
1998
+ }