extprg-types 1.0.3 → 1.0.4

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.
Files changed (2) hide show
  1. package/index.d.ts +597 -578
  2. package/package.json +1 -1
package/index.d.ts CHANGED
@@ -3,7 +3,7 @@
3
3
 
4
4
  /**
5
5
  * Auto-generated. Do not edit manually.
6
- * 2026-05-07T14:30:53.302Z
6
+ * 2026-05-07T14:48:06.531Z
7
7
  */
8
8
 
9
9
  // ── 第三方类型导入 ──
@@ -19,8 +19,8 @@ import type * as react_dialog from "@radix-ui/react-dialog";
19
19
 
20
20
  // ── 本地类型定义 ──
21
21
  declare class AIEngine {
22
- createTransport(project: Project): Promise<void>;
23
- createChatFetch(project: Project): Promise<typeof fetch>;
22
+ createTransport(project: Project | { _: "Project" | string }): Promise<void>;
23
+ createChatFetch(project: Project | { _: "Project" | string }): Promise<typeof fetch>;
24
24
  getModels(): Promise<void>;
25
25
  readRequestBody(body: BodyInit | null | undefined): Promise<any>;
26
26
  }
@@ -31,31 +31,31 @@ declare class Association extends StageObject {
31
31
  }
32
32
 
33
33
  declare class AutoAlign {
34
- constructor(project: Project);
34
+ constructor(project: Project | { _: "Project" | string });
35
35
  getSelectionOuterRectangle(entities: Entity[]): Promise<Rectangle | null>;
36
- calculateDistanceByRectangle(rectA: Rectangle, rectB: Rectangle): Promise<void>;
37
- alignRectangleToTargetX(selectedRect: Rectangle, otherRect: Rectangle): Promise<number>;
38
- alignRectangleToTargetY(selectedRect: Rectangle, otherRect: Rectangle): Promise<number>;
39
- _addAlignEffectByRect(selectedRect: Rectangle, otherRect: Rectangle): Promise<void>;
40
- getGridSnapDeltaX(rect: Rectangle): Promise<void>;
41
- getGridSnapDeltaY(rect: Rectangle): Promise<void>;
36
+ calculateDistanceByRectangle(rectA: Rectangle | { _: "Rectangle" | string }, rectB: Rectangle | { _: "Rectangle" | string }): Promise<void>;
37
+ alignRectangleToTargetX(selectedRect: Rectangle | { _: "Rectangle" | string }, otherRect: Rectangle | { _: "Rectangle" | string }): Promise<number>;
38
+ alignRectangleToTargetY(selectedRect: Rectangle | { _: "Rectangle" | string }, otherRect: Rectangle | { _: "Rectangle" | string }): Promise<number>;
39
+ _addAlignEffectByRect(selectedRect: Rectangle | { _: "Rectangle" | string }, otherRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
40
+ getGridSnapDeltaX(rect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
41
+ getGridSnapDeltaY(rect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
42
42
  alignAllSelectedToGrid(): Promise<void>;
43
43
  alignAllSelected(): Promise<void>;
44
44
  preAlignAllSelected(): Promise<void>;
45
- onEntityMoveAlignToGrid(selectedEntity: Entity): Promise<void>;
46
- onEntityMoveAlignToGridX(selectedEntity: Entity): Promise<void>;
47
- onEntityMoveAlignToGridY(selectedEntity: Entity): Promise<void>;
48
- onEntityMoveAlignToOtherEntity(selectedEntity: Entity, otherEntities: Entity[], isPreAlign = false): Promise<void>;
49
- _addAlignEffect(selectedEntity: Entity, otherEntity: Entity): Promise<void>;
50
- onEntityMoveAlignToTargetEntityX(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): Promise<number>;
51
- onEntityMoveAlignToTargetEntityY(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): Promise<number>;
52
- calculateDistance(entityA: Entity, entityB: Entity): Promise<void>;
53
- autoLayoutSelectedFastTreeMode(selectedRootEntity: ConnectableEntity): Promise<void>;
45
+ onEntityMoveAlignToGrid(selectedEntity: Entity | { _: "Entity" | string }): Promise<void>;
46
+ onEntityMoveAlignToGridX(selectedEntity: Entity | { _: "Entity" | string }): Promise<void>;
47
+ onEntityMoveAlignToGridY(selectedEntity: Entity | { _: "Entity" | string }): Promise<void>;
48
+ onEntityMoveAlignToOtherEntity(selectedEntity: Entity | { _: "Entity" | string }, otherEntities: Entity[], isPreAlign = false): Promise<void>;
49
+ _addAlignEffect(selectedEntity: Entity | { _: "Entity" | string }, otherEntity: Entity | { _: "Entity" | string }): Promise<void>;
50
+ onEntityMoveAlignToTargetEntityX(selectedEntity: Entity | { _: "Entity" | string }, otherEntity: Entity | { _: "Entity" | string }, isPreAlign = false): Promise<number>;
51
+ onEntityMoveAlignToTargetEntityY(selectedEntity: Entity | { _: "Entity" | string }, otherEntity: Entity | { _: "Entity" | string }, isPreAlign = false): Promise<number>;
52
+ calculateDistance(entityA: Entity | { _: "Entity" | string }, entityB: Entity | { _: "Entity" | string }): Promise<void>;
53
+ autoLayoutSelectedFastTreeMode(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
54
54
  }
55
55
 
56
56
  declare class AutoCompleteManager {
57
57
  currentWindowId: Promise<string | undefined>;
58
- constructor(project: Project);
58
+ constructor(project: Project | { _: "Project" | string });
59
59
  handle;
60
60
  openWindow(node: TextNode, entries: Record<string, string>, onSelect: (value: string) => void, setWindowId: (id: string) => void): Promise<void>;
61
61
  handleLogic(text: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
@@ -70,34 +70,34 @@ declare class AutoCompute {
70
70
  MapVariableFunction: Promise<VariableFunctionMap>;
71
71
  MapOtherFunction: Promise<OtherFunctionMap>;
72
72
  variables;
73
- constructor(project: Project);
73
+ constructor(project: Project | { _: "Project" | string });
74
74
  tickNumber;
75
75
  tick(): Promise<void>;
76
76
  funcTypeTrans(mF: MathFunctionType): Promise<StringFunctionType>;
77
- isTextNodeLogic(node: TextNode): Promise<boolean>;
78
- isSectionLogic(section: Section): Promise<boolean>;
77
+ isTextNodeLogic(node: TextNode | { _: "TextNode" | string }): Promise<boolean>;
78
+ isSectionLogic(section: Section | { _: "Section" | string }): Promise<boolean>;
79
79
  sortEntityByLocation(entities: ConnectableEntity[]): Promise<ConnectableEntity>[];
80
- computeTextNode(node: TextNode): Promise<void>;
81
- computeSection(section: Section): Promise<void>;
82
- computeEdge(edge: LineEdge): Promise<void>;
80
+ computeTextNode(node: TextNode | { _: "TextNode" | string }): Promise<void>;
81
+ computeSection(section: Section | { _: "Section" | string }): Promise<void>;
82
+ computeEdge(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
83
83
  }
84
84
 
85
85
  declare class AutoComputeUtils {
86
- constructor(project: Project);
87
- getParentTextNodes(node: TextNode): Promise<TextNode>[];
88
- getParentEntities(node: TextNode): Promise<ConnectableEntity>[];
89
- getChildTextNodes(node: TextNode): Promise<TextNode>[];
90
- getNodeOneResult(node: TextNode, resultText: string): Promise<void>;
86
+ constructor(project: Project | { _: "Project" | string });
87
+ getParentTextNodes(node: TextNode | { _: "TextNode" | string }): Promise<TextNode>[];
88
+ getParentEntities(node: TextNode | { _: "TextNode" | string }): Promise<ConnectableEntity>[];
89
+ getChildTextNodes(node: TextNode | { _: "TextNode" | string }): Promise<TextNode>[];
90
+ getNodeOneResult(node: TextNode | { _: "TextNode" | string }, resultText: string): Promise<void>;
91
91
  getSectionOneResult(section: Section, resultText: string): Promise<void>;
92
92
  getSectionMultiResult(section: Section, resultTextList: string[]): Promise<void>;
93
- generateMultiResult(node: TextNode, resultTextList: string[]): Promise<void>;
93
+ generateMultiResult(node: TextNode | { _: "TextNode" | string }, resultTextList: string[]): Promise<void>;
94
94
  stringToNumber(str: string): Promise<void>;
95
- isNodeConnectedWithLogicNode(node: ConnectableEntity): Promise<boolean>;
95
+ isNodeConnectedWithLogicNode(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
96
96
  isNameIsLogicNode(name: string): Promise<boolean>;
97
97
  }
98
98
 
99
99
  declare class AutoLayout {
100
- constructor(project: Project);
100
+ constructor(project: Project | { _: "Project" | string });
101
101
  isGravityLayoutStart: Promise<boolean>;
102
102
  tick(): Promise<void>;
103
103
  setGravityLayoutStart(): Promise<void>;
@@ -116,30 +116,30 @@ declare class AutoLayout {
116
116
  }
117
117
 
118
118
  declare class AutoLayoutFastTree {
119
- constructor(project: Project);
120
- getTreeBoundingRectangle(node: ConnectableEntity, skipDashed = false): Promise<Rectangle>;
121
- moveTreeRectTo(treeRoot: ConnectableEntity, targetLocation: Vector, skipDashed = false): Promise<void>;
122
- getSortedChildNodes(_node: ConnectableEntity, childNodes: ConnectableEntity[], direction: "col" | "row" = "col"): Promise<ConnectableEntity>[];
119
+ constructor(project: Project | { _: "Project" | string });
120
+ getTreeBoundingRectangle(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<Rectangle>;
121
+ moveTreeRectTo(treeRoot: ConnectableEntity | { _: "ConnectableEntity" | string }, targetLocation: Vector | { _: "Vector" | string }, skipDashed = false): Promise<void>;
122
+ getSortedChildNodes(_node: ConnectableEntity | { _: "ConnectableEntity" | string }, childNodes: ConnectableEntity[], direction: "col" | "row" = "col"): Promise<ConnectableEntity>[];
123
123
  alignTrees(trees: ConnectableEntity[], direction: "top" | "bottom" | "left" | "right", gap = 10, skipDashed = false): Promise<void>;
124
- adjustChildrenTreesByRootNodeLocation(rootNode: ConnectableEntity, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false): Promise<void>;
125
- resolveSubtreeOverlaps(rootNode: ConnectableEntity, directionGroups: {
124
+ adjustChildrenTreesByRootNodeLocation(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false): Promise<void>;
125
+ resolveSubtreeOverlaps(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, directionGroups: {
126
126
  right?: ConnectableEntity[];
127
127
  left?: ConnectableEntity[];
128
128
  bottom?: ConnectableEntity[];
129
129
  top?: ConnectableEntity[];
130
130
  }, skipDashed = false): Promise<void>;
131
- hasOverlapOrLineIntersection(rootNode: ConnectableEntity, group1: ConnectableEntity[], group2: ConnectableEntity[], dir1: "left" | "right" | "top" | "bottom", dir2: "left" | "right" | "top" | "bottom", skipDashed = false): Promise<boolean>;
132
- autoLayoutFastTreeMode(rootNode: ConnectableEntity): Promise<void>;
133
- treeReverseX(selectedRootEntity: ConnectableEntity): Promise<void>;
134
- treeReverseY(selectedRootEntity: ConnectableEntity): Promise<void>;
135
- treeReverse(selectedRootEntity: ConnectableEntity, direction: "X" | "Y"): Promise<void>;
131
+ hasOverlapOrLineIntersection(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, group1: ConnectableEntity[], group2: ConnectableEntity[], dir1: "left" | "right" | "top" | "bottom", dir2: "left" | "right" | "top" | "bottom", skipDashed = false): Promise<boolean>;
132
+ autoLayoutFastTreeMode(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
133
+ treeReverseX(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
134
+ treeReverseY(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
135
+ treeReverse(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "X" | "Y"): Promise<void>;
136
136
  }
137
137
 
138
138
  declare class AutoSaveBackupService {
139
139
  lastBackupTime;
140
140
  lastBackupHash;
141
141
  lastSaveTime;
142
- constructor(project: Project);
142
+ constructor(project: Project | { _: "Project" | string });
143
143
  tick(): Promise<void>;
144
144
  autoSave(): Promise<void>;
145
145
  autoBackup(): Promise<void>;
@@ -154,24 +154,24 @@ declare class AutoSaveBackupService {
154
154
  }
155
155
 
156
156
  declare class BackgroundRenderer {
157
- constructor(project: Project);
158
- renderDotBackground(viewRect: Rectangle): Promise<void>;
159
- renderHorizonBackground(viewRect: Rectangle): Promise<void>;
160
- renderVerticalBackground(viewRect: Rectangle): Promise<void>;
161
- renderCartesianBackground(viewRect: Rectangle): Promise<void>;
157
+ constructor(project: Project | { _: "Project" | string });
158
+ renderDotBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
159
+ renderHorizonBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
160
+ renderVerticalBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
161
+ renderCartesianBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
162
162
  getCurrentGap(): Promise<number>;
163
- getLocationXIterator(viewRect: Rectangle, currentGap: number): Promise<IterableIterator<number>>;
164
- getLocationYIterator(viewRect: Rectangle, currentGap: number): Promise<IterableIterator<number>>;
163
+ getLocationXIterator(viewRect: Rectangle | { _: "Rectangle" | string }, currentGap: number): Promise<IterableIterator<number>>;
164
+ getLocationYIterator(viewRect: Rectangle | { _: "Rectangle" | string }, currentGap: number): Promise<IterableIterator<number>>;
165
165
  }
166
166
 
167
167
  declare class BaseExporter {
168
- constructor(project: Project);
169
- getTreeTypeString(textNode: TextNode, nodeToStringFunc: (node: TextNode, level: number) => string): Promise<void>;
170
- getNodeChildrenArray(node: TextNode): Promise<ConnectableEntity>[];
168
+ constructor(project: Project | { _: "Project" | string });
169
+ getTreeTypeString(textNode: TextNode | { _: "TextNode" | string }, nodeToStringFunc: (node: TextNode, level: number) => string): Promise<void>;
170
+ getNodeChildrenArray(node: TextNode | { _: "TextNode" | string }): Promise<ConnectableEntity>[];
171
171
  }
172
172
 
173
173
  declare class BaseImporter {
174
- constructor(project: Project);
174
+ constructor(project: Project | { _: "Project" | string });
175
175
  }
176
176
 
177
177
  declare class Camera {
@@ -186,7 +186,7 @@ declare class Camera {
186
186
  savedCameraState: Promise<{ location: Vector; scale: number } | null>;
187
187
  shockMoveDiffLocationsQueue;
188
188
  pageMove(direction: Direction): Promise<void>;
189
- bombMove(targetLocation: Vector, frameCount = 40): Promise<void>;
189
+ bombMove(targetLocation: Vector | { _: "Vector" | string }, frameCount = 40): Promise<void>;
190
190
  tick(): Promise<void>;
191
191
  tickNumber;
192
192
  allowScaleFollowMouseLocationTicks;
@@ -197,14 +197,14 @@ declare class Camera {
197
197
  isStartZoomIn: Promise<boolean>;
198
198
  isStartZoomOut: Promise<boolean>;
199
199
  dealCycleSpace(): Promise<void>;
200
- setLocationByOtherLocation(otherWorldLocation: Vector, viewLocation: Vector): Promise<void>;
200
+ setLocationByOtherLocation(otherWorldLocation: Vector | { _: "Vector" | string }, viewLocation: Vector | { _: "Vector" | string }): Promise<void>;
201
201
  clearMoveCommander(): Promise<void>;
202
202
  stopImmediately(): Promise<void>;
203
203
  dealCameraScaleInTick(): Promise<void>;
204
- constructor(project: Project);
204
+ constructor(project: Project | { _: "Project" | string });
205
205
  reset(): Promise<void>;
206
206
  resetBySelected(): Promise<void>;
207
- resetByRectangle(viewRectangle: Rectangle): Promise<void>;
207
+ resetByRectangle(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
208
208
  resetScale(): Promise<void>;
209
209
  resetLocationToZero(): Promise<void>;
210
210
  saveCameraState(): Promise<void>;
@@ -213,7 +213,7 @@ declare class Camera {
213
213
 
214
214
  declare class Canvas {
215
215
  ctx: Promise<CanvasRenderingContext2D>;
216
- constructor(project: Project, element: HTMLCanvasElement = document.createElement("canvas"));
216
+ constructor(project: Project | { _: "Project" | string }, element: HTMLCanvasElement = document.createElement("canvas"));
217
217
  mount(wrapper: HTMLDivElement): Promise<void>;
218
218
  dispose(): Promise<void>;
219
219
  }
@@ -231,20 +231,20 @@ declare class CollisionBox {
231
231
  shapes: Promise<Shape>[];
232
232
  constructor(shapes: Shape[]);
233
233
  updateShapeList(shapes: Shape[]): void;
234
- isContainsPoint(location: Vector): Promise<boolean>;
235
- isIntersectsWithRectangle(rectangle: Rectangle): Promise<boolean>;
236
- isContainedByRectangle(rectangle: Rectangle): Promise<boolean>;
237
- isIntersectsWithLine(line: Line): Promise<boolean>;
234
+ isContainsPoint(location: Vector | { _: "Vector" | string }): Promise<boolean>;
235
+ isIntersectsWithRectangle(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
236
+ isContainedByRectangle(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
237
+ isIntersectsWithLine(line: Line | { _: "Line" | string }): Promise<boolean>;
238
238
  getRectangle(): Promise<Rectangle>;
239
239
  }
240
240
 
241
241
  declare class CollisionBoxRenderer {
242
- constructor(project: Project);
243
- render(collideBox: CollisionBox, color: Color): Promise<void>;
242
+ constructor(project: Project | { _: "Project" | string });
243
+ render(collideBox: CollisionBox | { _: "CollisionBox" | string }, color: Color | { _: "Color" | string }): Promise<void>;
244
244
  }
245
245
 
246
246
  declare class ComplexityDetector {
247
- constructor(project: Project);
247
+ constructor(project: Project | { _: "Project" | string });
248
248
  detectorCurrentStage(): Promise<CountResultObject>;
249
249
  }
250
250
 
@@ -273,26 +273,26 @@ declare class ConnectPoint extends ConnectableEntity {
273
273
  _isSelected: Promise<boolean>;
274
274
  get isSelected(): Promise<any>;
275
275
  set isSelected(value: boolean);
276
- constructor(project: Project, {
276
+ constructor(project: Project | { _: "Project" | string }, {
277
277
  uuid = crypto.randomUUID() as string,
278
278
  collisionBox = new CollisionBox([
279
279
  new Rectangle(Vector.getZero(), Vector.same(ConnectPoint.CONNECT_POINT_SHRINK_RADIUS * 2)),
280
280
  ]),
281
281
  details = [],
282
282
  }, unknown = false);
283
- move(delta: Vector): void;
284
- moveTo(location: Vector): void;
283
+ move(delta: Vector | { _: "Vector" | string }): void;
284
+ moveTo(location: Vector | { _: "Vector" | string }): void;
285
285
  }
286
286
 
287
287
  declare class ContentSearch {
288
- constructor(project: Project);
288
+ constructor(project: Project | { _: "Project" | string });
289
289
  searchResultNodes: Promise<StageObject>[];
290
290
  isCaseSensitive;
291
291
  searchScope;
292
292
  currentSearchResultIndex;
293
- getStageObjectText(stageObject: StageObject): Promise<string>;
293
+ getStageObjectText(stageObject: StageObject | { _: "StageObject" | string }): Promise<string>;
294
294
  getSelectedObjectsBounds(): Promise<Rectangle | null>;
295
- isObjectInBounds(obj: StageObject, bounds: Rectangle): Promise<boolean>;
295
+ isObjectInBounds(obj: StageObject | { _: "StageObject" | string }, bounds: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
296
296
  startSearch(searchString: string, autoFocus = true): Promise<boolean>;
297
297
  nextSearchResult(): Promise<void>;
298
298
  previousSearchResult(): Promise<void>;
@@ -318,7 +318,7 @@ declare class Controller {
318
318
  resetCountdownTimer(): Promise<void>;
319
319
  isManipulateOverTime(): Promise<void>;
320
320
  edgeHoverTolerance;
321
- constructor(project: Project);
321
+ constructor(project: Project | { _: "Project" | string });
322
322
  dispose(): Promise<void>;
323
323
  mousedown(event: MouseEvent): Promise<void>;
324
324
  mouseup(event: MouseEvent): Promise<void>;
@@ -365,7 +365,7 @@ declare class ControllerCameraClass extends ControllerClass {
365
365
  keyup: Promise<(event: KeyboardEvent) => void>;
366
366
  mousedown;
367
367
  mousemove: Promise<(event: MouseEvent) => void>;
368
- mouseMoveOutWindowForcedShutdown(vectorObject: Vector): Promise<void>;
368
+ mouseMoveOutWindowForcedShutdown(vectorObject: Vector | { _: "Vector" | string }): Promise<void>;
369
369
  mouseup;
370
370
  mousewheel;
371
371
  dealStealthMode(event: WheelEvent): Promise<void>;
@@ -387,7 +387,7 @@ declare class ControllerCameraClass extends ControllerClass {
387
387
  }
388
388
 
389
389
  declare class ControllerClass {
390
- constructor(project: Project);
390
+ constructor(project: Project | { _: "Project" | string });
391
391
  lastMoveLocation: Promise<Vector>;
392
392
  lastClickTime: Promise<number>;
393
393
  lastClickLocation: Promise<Vector>;
@@ -407,7 +407,7 @@ declare class ControllerClass {
407
407
  _touchmove;
408
408
  onePointTouchMoveLocation: Promise<Vector>;
409
409
  _touchend;
410
- mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector): Promise<void>;
410
+ mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector | { _: "Vector" | string }): Promise<void>;
411
411
  }
412
412
 
413
413
  declare class ControllerCuttingClass extends ControllerClass {
@@ -417,7 +417,7 @@ declare class ControllerCuttingClass extends ControllerClass {
417
417
  onControlKeyUp;
418
418
  registerControlKeyEvents(): Promise<void>;
419
419
  unregisterControlKeyEvents(): Promise<void>;
420
- constructor(project: Project);
420
+ constructor(project: Project | { _: "Project" | string });
421
421
  dispose(): Promise<void>;
422
422
  cuttingLine: Promise<Line>;
423
423
  lastMoveLocation;
@@ -431,16 +431,16 @@ declare class ControllerCuttingClass extends ControllerClass {
431
431
  mouseDownEvent(event: MouseEvent): Promise<void>;
432
432
  mousemove: Promise<(event: MouseEvent) => void>;
433
433
  clearIsolationPoint(): Promise<void>;
434
- mouseUpFunction(mouseUpWindowLocation: Vector): Promise<void>;
434
+ mouseUpFunction(mouseUpWindowLocation: Vector | { _: "Vector" | string }): Promise<void>;
435
435
  mouseup: Promise<(event: MouseEvent) => void>;
436
- mouseMoveOutWindowForcedShutdown(outsideLocation: Vector): Promise<void>;
436
+ mouseMoveOutWindowForcedShutdown(outsideLocation: Vector | { _: "Vector" | string }): Promise<void>;
437
437
  updateWarningObjectByCuttingLine(): Promise<void>;
438
438
  addEffectByWarningEntity(): Promise<void>;
439
439
  }
440
440
 
441
441
  declare class ControllerEdgeEditClass extends ControllerClass {
442
- editEdgeText(clickedLineEdge: Edge, selectAll = true): Promise<void>;
443
- editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge, selectAll = true): Promise<void>;
442
+ editEdgeText(clickedLineEdge: Edge | { _: "Edge" | string }, selectAll = true): Promise<void>;
443
+ editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, selectAll = true): Promise<void>;
444
444
  mouseDoubleClick;
445
445
  keydown;
446
446
  }
@@ -454,13 +454,13 @@ declare class ControllerEntityClickSelectAndMoveClass extends ControllerClass {
454
454
  mousedown: Promise<(event: MouseEvent) => void>;
455
455
  mousemove: Promise<(event: MouseEvent) => void>;
456
456
  mouseup: Promise<(event: MouseEvent) => void>;
457
- mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector): void;
457
+ mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector | { _: "Vector" | string }): void;
458
458
  }
459
459
 
460
460
  declare class ControllerEntityCreateClass extends ControllerClass {
461
- constructor(project: Project);
461
+ constructor(project: Project | { _: "Project" | string });
462
462
  mouseDoubleClick;
463
- createConnectPoint(pressLocation: Vector, addToSections: Section[]): Promise<void>;
463
+ createConnectPoint(pressLocation: Vector | { _: "Vector" | string }, addToSections: Section[]): Promise<void>;
464
464
  }
465
465
 
466
466
  declare class ControllerEntityResizeClass extends ControllerClass {
@@ -471,7 +471,7 @@ declare class ControllerEntityResizeClass extends ControllerClass {
471
471
  }
472
472
 
473
473
  declare class ControllerExtensionEntityClickClass extends ControllerClass {
474
- constructor(project: Project);
474
+ constructor(project: Project | { _: "Project" | string });
475
475
  mousedown;
476
476
  }
477
477
 
@@ -495,7 +495,7 @@ declare class ControllerNodeConnectionClass extends ControllerClass {
495
495
  _lastRightMousePressLocation: Promise<Vector>;
496
496
  _isUsing: Promise<boolean>;
497
497
  get isUsing(): Promise<boolean>;
498
- constructor(project: Project);
498
+ constructor(project: Project | { _: "Project" | string });
499
499
  dispose(): Promise<void>;
500
500
  connectFromEntities: Promise<ConnectableEntity>[];
501
501
  connectToEntity: Promise<ConnectableEntity | null>;
@@ -520,24 +520,24 @@ declare class ControllerNodeConnectionClass extends ControllerClass {
520
520
  _hasSourceSparkTriggered;
521
521
  _hasTargetSparkTriggered;
522
522
  getOppositeDirection(direction: Direction): Promise<Direction>;
523
- clickMultiConnect(releaseWorldLocation: Vector): Promise<void>;
523
+ clickMultiConnect(releaseWorldLocation: Vector | { _: "Vector" | string }): Promise<void>;
524
524
  clear(): Promise<void>;
525
525
  updatePreviewDirections(): Promise<void>;
526
526
  directionToRate(direction: Direction | null): Promise<Vector>;
527
527
  getPreviewSourceRectangleRate(): Promise<Vector>;
528
528
  getPreviewTargetRectangleRate(): Promise<Vector>;
529
- dragMultiConnect(connectToEntity: ConnectableEntity, sourceDirection: Direction | null = null, targetDirection: Direction | null = null): Promise<void>;
529
+ dragMultiConnect(connectToEntity: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceDirection: Direction | null = null, targetDirection: Direction | null = null): Promise<void>;
530
530
  isConnecting(): Promise<void>;
531
- addConnectEffect(from: ConnectableEntity, to: ConnectableEntity, sourceRectRate?: Vector, targetRectRate?: Vector): Promise<void>;
531
+ addConnectEffect(from: ConnectableEntity | { _: "ConnectableEntity" | string }, to: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectRate?: Vector | { _: "Vector" | string }, targetRectRate?: Vector | { _: "Vector" | string }): Promise<void>;
532
532
  }
533
533
 
534
534
  declare class ControllerNodeEditClass extends ControllerClass {
535
- constructor(project: Project);
535
+ constructor(project: Project | { _: "Project" | string });
536
536
  mouseDoubleClick;
537
537
  mouseup;
538
538
  mousemove;
539
- editUrlNodeTitle(clickedUrlNode: UrlNode): Promise<void>;
540
- editLatexNode(node: LatexNode): Promise<void>;
539
+ editUrlNodeTitle(clickedUrlNode: UrlNode | { _: "UrlNode" | string }): Promise<void>;
540
+ editLatexNode(node: LatexNode | { _: "LatexNode" | string }): Promise<void>;
541
541
  }
542
542
 
543
543
  declare class ControllerPenStrokeControlClass extends ControllerClass {
@@ -555,7 +555,7 @@ declare class ControllerPenStrokeDrawingClass extends ControllerClass {
555
555
  currentSegments: Promise<PenStrokeSegment>[];
556
556
  isDrawingLine;
557
557
  currentStrokeWidth: Promise<number>;
558
- constructor(project: Project);
558
+ constructor(project: Project | { _: "Project" | string });
559
559
  mousedown;
560
560
  mousemove;
561
561
  mouseup;
@@ -570,7 +570,7 @@ declare class ControllerRectangleSelectClass extends ControllerClass {
570
570
  selectingRectangle: Promise<Rectangle | null>;
571
571
  get isUsing(): Promise<any>;
572
572
  shutDown(): Promise<void>;
573
- mouseMoveOutWindowForcedShutdown(mouseLocation: Vector): Promise<void>;
573
+ mouseMoveOutWindowForcedShutdown(mouseLocation: Vector | { _: "Vector" | string }): Promise<void>;
574
574
  mousedown: Promise<(event: MouseEvent) => void>;
575
575
  mousemove: Promise<(event: MouseEvent) => void>;
576
576
  isSelectDirectionRight;
@@ -579,32 +579,32 @@ declare class ControllerRectangleSelectClass extends ControllerClass {
579
579
  }
580
580
 
581
581
  declare class ControllerSectionEditClass extends ControllerClass {
582
- constructor(project: Project);
582
+ constructor(project: Project | { _: "Project" | string });
583
583
  mouseDoubleClick;
584
584
  mousemove;
585
585
  keydown;
586
- editSectionTitle(section: Section): Promise<void>;
586
+ editSectionTitle(section: Section | { _: "Section" | string }): Promise<void>;
587
587
  }
588
588
 
589
589
  declare class ControllerUtils {
590
590
  autoComplete: Promise<AutoCompleteManager>;
591
- constructor(project: Project);
591
+ constructor(project: Project | { _: "Project" | string });
592
592
  editTextNode(clickedNode: TextNode, selectAll = true): Promise<void>;
593
593
  editNodeDetailsByKeyboard(): Promise<void>;
594
594
  editNodeDetails(clickedNode: Entity): Promise<void>;
595
- addTextNodeByLocation(location: Vector, selectCurrent: boolean = false, autoEdit: boolean = false): Promise<void>;
596
- createConnectPoint(location: Vector): Promise<void>;
595
+ addTextNodeByLocation(location: Vector | { _: "Vector" | string }, selectCurrent: boolean = false, autoEdit: boolean = false): Promise<void>;
596
+ createConnectPoint(location: Vector | { _: "Vector" | string }): Promise<void>;
597
597
  addTextNodeFromCurrentSelectedNode(direction: Direction, selectCurrent = false): Promise<void>;
598
598
  textNodeInEditModeByUUID(uuid: string): Promise<void>;
599
- getClickedStageObject(clickedLocation: Vector): Promise<void>;
600
- isClickedResizeRect(clickedLocation: Vector): Promise<boolean>;
599
+ getClickedStageObject(clickedLocation: Vector | { _: "Vector" | string }): Promise<void>;
600
+ isClickedResizeRect(clickedLocation: Vector | { _: "Vector" | string }): Promise<boolean>;
601
601
  selectedEntityNormalizing(): Promise<void>;
602
602
  }
603
603
 
604
604
  declare class CopyEngine {
605
605
  copyEngineImage: Promise<CopyEngineImage>;
606
606
  copyEngineText: Promise<CopyEngineText>;
607
- constructor(project: Project);
607
+ constructor(project: Project | { _: "Project" | string });
608
608
  copy(): Promise<void>;
609
609
  paste(): Promise<void>;
610
610
  virtualClipboardPaste(): Promise<void>;
@@ -613,7 +613,7 @@ declare class CopyEngine {
613
613
  }
614
614
 
615
615
  declare class CopyEngineImage {
616
- constructor(project: Project);
616
+ constructor(project: Project | { _: "Project" | string });
617
617
  processClipboardImage(): Promise<void>;
618
618
  processImageStandard(): Promise<void>;
619
619
  copyEnginePasteImage(item: Blob): Promise<void>;
@@ -626,7 +626,7 @@ declare class CopyEngineImage {
626
626
  }
627
627
 
628
628
  declare class CopyEngineText {
629
- constructor(project: Project);
629
+ constructor(project: Project | { _: "Project" | string });
630
630
  copyEnginePastePlainText(item: string): Promise<void>;
631
631
  }
632
632
 
@@ -643,8 +643,8 @@ declare class CubicCatmullRomSplineEdge extends Edge {
643
643
  addControlPoint(): Promise<void>;
644
644
  _collisionBox: Promise<CollisionBox>;
645
645
  get collisionBox(): Promise<CollisionBox>;
646
- fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): Promise<CubicCatmullRomSplineEdge>;
647
- constructor(project: Project, {
646
+ fromTwoEntity(project: Project | { _: "Project" | string }, source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<CubicCatmullRomSplineEdge>;
647
+ constructor(project: Project | { _: "Project" | string }, {
648
648
  uuid,
649
649
  source,
650
650
  target,
@@ -698,43 +698,43 @@ declare enum CursorNameEnum {
698
698
  }
699
699
 
700
700
  declare class CurveRenderer {
701
- constructor(project: Project);
702
- renderSolidLine(start: Vector, end: Vector, color: Color, width: number): void;
703
- renderSolidLineMultiple(locations: Vector[], color: Color, width: number): void;
704
- renderPenStroke(stroke: PenStrokeSegment[], color: Color): void;
705
- renderSolidLineMultipleSmoothly(locations: Vector[], color: Color, width: number): void;
701
+ constructor(project: Project | { _: "Project" | string });
702
+ renderSolidLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, width: number): void;
703
+ renderSolidLineMultiple(locations: Vector[], color: Color | { _: "Color" | string }, width: number): void;
704
+ renderPenStroke(stroke: PenStrokeSegment[], color: Color | { _: "Color" | string }): void;
705
+ renderSolidLineMultipleSmoothly(locations: Vector[], color: Color | { _: "Color" | string }, width: number): void;
706
706
  smoothPoints(points: Vector[], tension = 0.5): Promise<void>;
707
- renderSolidLineMultipleWithWidth(locations: Vector[], color: Color, widthList: number[]): void;
708
- renderSolidLineMultipleWithShadow(locations: Vector[], color: Color, width: number, shadowColor: Color, shadowBlur: number): void;
709
- renderDashedLine(start: Vector, end: Vector, color: Color, width: number, dashLength: number): void;
710
- renderDoubleLine(start: Vector, end: Vector, color: Color, width: number, gap: number): void;
711
- renderBezierCurve(curve: CubicBezierCurve, color: Color, width: number): void;
712
- renderDashedBezierCurve(curve: CubicBezierCurve, color: Color, width: number, dashLength: number): void;
713
- renderDoubleBezierCurve(curve: CubicBezierCurve, color: Color, width: number, gap: number): void;
714
- renderSymmetryCurve(curve: SymmetryCurve, color: Color, width: number): void;
715
- renderGradientLine(start: Vector, end: Vector, startColor: Color, endColor: Color, width: number): void;
716
- renderGradientBezierCurve(curve: CubicBezierCurve, startColor: Color, endColor: Color, width: number): void;
707
+ renderSolidLineMultipleWithWidth(locations: Vector[], color: Color | { _: "Color" | string }, widthList: number[]): void;
708
+ renderSolidLineMultipleWithShadow(locations: Vector[], color: Color | { _: "Color" | string }, width: number, shadowColor: Color | { _: "Color" | string }, shadowBlur: number): void;
709
+ renderDashedLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, width: number, dashLength: number): void;
710
+ renderDoubleLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, width: number, gap: number): void;
711
+ renderBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
712
+ renderDashedBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number, dashLength: number): void;
713
+ renderDoubleBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number, gap: number): void;
714
+ renderSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
715
+ renderGradientLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, startColor: Color | { _: "Color" | string }, endColor: Color | { _: "Color" | string }, width: number): void;
716
+ renderGradientBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, startColor: Color | { _: "Color" | string }, endColor: Color | { _: "Color" | string }, width: number): void;
717
717
  }
718
718
 
719
719
  declare class DeleteManager {
720
720
  deleteHandlers;
721
721
  registerHandler<T extends StageObject>(constructor: Constructor<T>, handler: DeleteHandler<T>): Promise<void>;
722
- constructor(project: Project);
722
+ constructor(project: Project | { _: "Project" | string });
723
723
  deleteEntities(deleteNodes: Entity[]): Promise<void>;
724
- findDeleteHandler(object: StageObject): Promise<void>;
725
- deleteSvgNode(entity: SvgNode): Promise<void>;
726
- deleteLatexNode(entity: LatexNode): Promise<void>;
724
+ findDeleteHandler(object: StageObject | { _: "StageObject" | string }): Promise<void>;
725
+ deleteSvgNode(entity: SvgNode | { _: "SvgNode" | string }): Promise<void>;
726
+ deleteLatexNode(entity: LatexNode | { _: "LatexNode" | string }): Promise<void>;
727
727
  deleteReferenceBlockNode(entity: ReferenceBlockNode): Promise<void>;
728
728
  deleteExtensionEntity(entity: ExtensionEntity): Promise<void>;
729
- deletePenStroke(penStroke: PenStroke): Promise<void>;
730
- deleteSection(entity: Section): Promise<void>;
731
- deleteImageNode(entity: ImageNode): Promise<void>;
732
- deleteUrlNode(entity: UrlNode): Promise<void>;
733
- deleteConnectPoint(entity: ConnectPoint): Promise<void>;
734
- deleteTextNode(entity: TextNode): Promise<void>;
735
- deleteEntityAfterClearAssociation(entity: ConnectableEntity): Promise<void>;
736
- deleteEdge(deleteEdge: Edge): Promise<boolean>;
737
- deleteMultiTargetUndirectedEdge(edge: MultiTargetUndirectedEdge): Promise<void>;
729
+ deletePenStroke(penStroke: PenStroke | { _: "PenStroke" | string }): Promise<void>;
730
+ deleteSection(entity: Section | { _: "Section" | string }): Promise<void>;
731
+ deleteImageNode(entity: ImageNode | { _: "ImageNode" | string }): Promise<void>;
732
+ deleteUrlNode(entity: UrlNode | { _: "UrlNode" | string }): Promise<void>;
733
+ deleteConnectPoint(entity: ConnectPoint | { _: "ConnectPoint" | string }): Promise<void>;
734
+ deleteTextNode(entity: TextNode | { _: "TextNode" | string }): Promise<void>;
735
+ deleteEntityAfterClearAssociation(entity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
736
+ deleteEdge(deleteEdge: Edge | { _: "Edge" | string }): Promise<boolean>;
737
+ deleteMultiTargetUndirectedEdge(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }): Promise<void>;
738
738
  }
739
739
 
740
740
  declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>);
@@ -757,17 +757,17 @@ declare enum Direction {
757
757
  }
758
758
 
759
759
  declare class DrawingControllerRenderer {
760
- constructor(project: Project);
760
+ constructor(project: Project | { _: "Project" | string });
761
761
  renderTempDrawing(): Promise<void>;
762
- renderTrace(currentStrokeColor: Color): Promise<void>;
763
- renderMouse(currentStrokeColor: Color): Promise<void>;
764
- renderAdjusting(currentStrokeColor: Color): Promise<void>;
762
+ renderTrace(currentStrokeColor: Color | { _: "Color" | string }): Promise<void>;
763
+ renderMouse(currentStrokeColor: Color | { _: "Color" | string }): Promise<void>;
764
+ renderAdjusting(currentStrokeColor: Color | { _: "Color" | string }): Promise<void>;
765
765
  renderAxisMouse(): Promise<void>;
766
766
  diffAngle;
767
767
  rotateUpAngle(): Promise<void>;
768
768
  rotateDownAngle(): Promise<void>;
769
- renderAngleMouse(mouseLocation: Vector): Promise<void>;
770
- renderLine(lineStart: Vector, lineEnd: Vector): Promise<void>;
769
+ renderAngleMouse(mouseLocation: Vector | { _: "Vector" | string }): Promise<void>;
770
+ renderLine(lineStart: Vector | { _: "Vector" | string }, lineEnd: Vector | { _: "Vector" | string }): Promise<void>;
771
771
  }
772
772
 
773
773
  declare class Edge extends ConnectableAssociation {
@@ -784,14 +784,14 @@ declare class Edge extends ConnectableAssociation {
784
784
  get targetLocation(): Promise<Vector>;
785
785
  targetRectangleRate: Promise<Vector>;
786
786
  sourceRectangleRate: Promise<Vector>;
787
- getCenterLine(source: ConnectableEntity, target: ConnectableEntity): Promise<Line>;
788
- getNormalVectorByRate(rate: Vector): Promise<Vector | null>;
789
- getExactEdgePositionByRate(rect: Rectangle, rate: Vector): Promise<Vector | null>;
787
+ getCenterLine(source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Line>;
788
+ getNormalVectorByRate(rate: Vector | { _: "Vector" | string }): Promise<Vector | null>;
789
+ getExactEdgePositionByRate(rect: Rectangle | { _: "Rectangle" | string }, rate: Vector | { _: "Vector" | string }): Promise<Vector | null>;
790
790
  adjustSizeByText(): void;
791
791
  rename(text: string): Promise<void>;
792
- isIntersectsWithRectangle(rectangle: Rectangle): Promise<boolean>;
793
- isIntersectsWithLocation(location: Vector): Promise<boolean>;
794
- isIntersectsWithLine(line: Line): Promise<boolean>;
792
+ isIntersectsWithRectangle(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
793
+ isIntersectsWithLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
794
+ isIntersectsWithLine(line: Line | { _: "Line" | string }): Promise<boolean>;
795
795
  isLeftToRight(): Promise<boolean>;
796
796
  isRightToLeft(): Promise<boolean>;
797
797
  isTopToBottom(): Promise<boolean>;
@@ -801,47 +801,47 @@ declare class Edge extends ConnectableAssociation {
801
801
 
802
802
  declare class EdgeRenderer {
803
803
  currentRenderer: Promise<EdgeRendererClass>;
804
- constructor(project: Project);
804
+ constructor(project: Project | { _: "Project" | string });
805
805
  checkRendererBySettings(lineStyle: Settings["lineStyle"]): Promise<void>;
806
806
  updateRenderer(style: Settings["lineStyle"]): Promise<void>;
807
- renderLineEdge(edge: LineEdge): Promise<void>;
808
- renderCrEdge(edge: CubicCatmullRomSplineEdge): Promise<void>;
809
- getMinNonCollapseParentSection(innerEntity: ConnectableEntity): Promise<Section>;
810
- getEdgeView(edge: LineEdge): Promise<LineEdge>;
811
- getEdgeSvg(edge: LineEdge): Promise<React.ReactNode>;
812
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): Promise<void>;
813
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<void>;
814
- getCuttingEffects(edge: Edge): Promise<void>;
815
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<void>;
816
- renderArrowHead(endPoint: Vector, direction: Vector, size: number, color: Color): Promise<void>;
817
- generateArrowHeadSvg(endPoint: Vector, direction: Vector, size: number, edgeColor: Color): Promise<React.ReactNode>;
807
+ renderLineEdge(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
808
+ renderCrEdge(edge: CubicCatmullRomSplineEdge | { _: "CubicCatmullRomSplineEdge" | string }): Promise<void>;
809
+ getMinNonCollapseParentSection(innerEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Section>;
810
+ getEdgeView(edge: LineEdge | { _: "LineEdge" | string }): Promise<LineEdge>;
811
+ getEdgeSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
812
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): Promise<void>;
813
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<void>;
814
+ getCuttingEffects(edge: Edge | { _: "Edge" | string }): Promise<void>;
815
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<void>;
816
+ renderArrowHead(endPoint: Vector | { _: "Vector" | string }, direction: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string }): Promise<void>;
817
+ generateArrowHeadSvg(endPoint: Vector | { _: "Vector" | string }, direction: Vector | { _: "Vector" | string }, size: number, edgeColor: Color | { _: "Color" | string }): Promise<React.ReactNode>;
818
818
  }
819
819
 
820
820
  declare class EdgeRendererClass {
821
821
  constructor();
822
- isCycleState(edge: LineEdge): Promise<boolean>;
823
- isNormalState(edge: LineEdge): Promise<boolean>;
824
- renderNormalState(edge: LineEdge): void;
825
- renderShiftingState(edge: LineEdge): void;
826
- renderCycleState(edge: LineEdge): void;
827
- getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
828
- getShiftingStageSvg(edge: LineEdge): Promise<React.ReactNode>;
829
- getCycleStageSvg(edge: LineEdge): Promise<React.ReactNode>;
830
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
831
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
832
- getCuttingEffects(edge: Edge): Promise<Effect>[];
833
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
822
+ isCycleState(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
823
+ isNormalState(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
824
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
825
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
826
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
827
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
828
+ getShiftingStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
829
+ getCycleStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
830
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
831
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
832
+ getCuttingEffects(edge: Edge | { _: "Edge" | string }): Promise<Effect>[];
833
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
834
834
  }
835
835
 
836
836
  declare class Effect {
837
- constructor(timeProgress: ProgressNumber, delay: number = 0);
837
+ constructor(timeProgress: ProgressNumber | { _: "ProgressNumber" | string }, delay: number = 0);
838
838
  subEffects: Promise<Effect>[];
839
- tick(project: Project): void;
840
- render(project: Project): void;
839
+ tick(project: Project | { _: "Project" | string }): void;
840
+ render(project: Project | { _: "Project" | string }): void;
841
841
  }
842
842
 
843
843
  declare class Effects {
844
- constructor(project: Project);
844
+ constructor(project: Project | { _: "Project" | string });
845
845
  effects: Promise<Effect>[];
846
846
  addEffect(effect: Effect): Promise<void>;
847
847
  get effectsCount(): Promise<any>;
@@ -850,15 +850,15 @@ declare class Effects {
850
850
  }
851
851
 
852
852
  declare class Entity extends StageObject {
853
- move(delta: Vector): void;
853
+ move(delta: Vector | { _: "Vector" | string }): void;
854
854
  isAlignExcluded;
855
- moveTo(location: Vector): void;
855
+ moveTo(location: Vector | { _: "Vector" | string }): void;
856
856
  details: Promise<Value>;
857
857
  isMouseHover: Promise<boolean>;
858
858
  detailsButtonRectangle(): Promise<Rectangle>;
859
- isMouseInDetailsButton(mouseWorldLocation: Vector): Promise<boolean>;
859
+ isMouseInDetailsButton(mouseWorldLocation: Vector | { _: "Vector" | string }): Promise<boolean>;
860
860
  referenceButtonCircle(): Promise<Circle>;
861
- isMouseInReferenceButton(mouseWorldLocation: Vector): Promise<boolean>;
861
+ isMouseInReferenceButton(mouseWorldLocation: Vector | { _: "Vector" | string }): Promise<boolean>;
862
862
  updateFatherSectionByMove(): Promise<void>;
863
863
  updateOtherEntityLocationByMove(): Promise<void>;
864
864
  collideWithOtherEntity(other: Entity): Promise<void>;
@@ -867,48 +867,67 @@ declare class Entity extends StageObject {
867
867
  }
868
868
 
869
869
  declare class EntityDetailsButtonRenderer {
870
- constructor(project: Project);
871
- render(entity: Entity): Promise<void>;
870
+ constructor(project: Project | { _: "Project" | string });
871
+ render(entity: Entity | { _: "Entity" | string }): Promise<void>;
872
872
  }
873
873
 
874
874
  declare class EntityMoveManager {
875
- constructor(project: Project);
875
+ constructor(project: Project | { _: "Project" | string });
876
876
  moveAccelerateCommander: Promise<Vector>;
877
877
  moveSpeed: Promise<Vector>;
878
878
  frictionExponent;
879
879
  tick(): Promise<void>;
880
- continuousMoveKeyPress(direction: Vector): Promise<void>;
881
- continuousMoveKeyRelease(direction: Vector): Promise<void>;
880
+ continuousMoveKeyPress(direction: Vector | { _: "Vector" | string }): Promise<void>;
881
+ continuousMoveKeyRelease(direction: Vector | { _: "Vector" | string }): Promise<void>;
882
882
  stopImmediately(): Promise<void>;
883
- canMoveEntity(entity: Entity): Promise<boolean>;
884
- moveEntityUtils(entity: Entity, delta: Vector, isAutoAdjustSection: boolean = true): Promise<void>;
885
- jumpMoveEntityUtils(entity: Entity, delta: Vector): Promise<void>;
886
- moveEntityToUtils(entity: Entity, location: Vector): Promise<void>;
887
- moveSelectedEntities(delta: Vector, isAutoAdjustSection: boolean = true): Promise<void>;
888
- jumpMoveSelectedConnectableEntities(delta: Vector): Promise<void>;
889
- moveEntitiesWithChildren(delta: Vector, skipDashed = true): Promise<void>;
890
- moveWithChildren(node: ConnectableEntity, delta: Vector, skipDashed = false): Promise<void>;
883
+ canMoveEntity(entity: Entity | { _: "Entity" | string }): Promise<boolean>;
884
+ moveEntityUtils(entity: Entity | { _: "Entity" | string }, delta: Vector | { _: "Vector" | string }, isAutoAdjustSection: boolean = true): Promise<void>;
885
+ jumpMoveEntityUtils(entity: Entity | { _: "Entity" | string }, delta: Vector | { _: "Vector" | string }): Promise<void>;
886
+ moveEntityToUtils(entity: Entity | { _: "Entity" | string }, location: Vector | { _: "Vector" | string }): Promise<void>;
887
+ moveSelectedEntities(delta: Vector | { _: "Vector" | string }, isAutoAdjustSection: boolean = true): Promise<void>;
888
+ jumpMoveSelectedConnectableEntities(delta: Vector | { _: "Vector" | string }): Promise<void>;
889
+ moveEntitiesWithChildren(delta: Vector | { _: "Vector" | string }, skipDashed = true): Promise<void>;
890
+ moveWithChildren(node: ConnectableEntity | { _: "ConnectableEntity" | string }, delta: Vector | { _: "Vector" | string }, skipDashed = false): Promise<void>;
891
891
  }
892
892
 
893
893
  declare class EntityRenderer {
894
894
  sectionSortedZIndex: Promise<Section>[];
895
895
  extensionEntityRenderer: Promise<ExtensionEntityRenderer>;
896
- constructor(project: Project);
896
+ constructor(project: Project | { _: "Project" | string });
897
897
  sortSectionsByZIndex(): Promise<void>;
898
898
  tickNumber;
899
- renderAllSectionsBackground(viewRectangle: Rectangle): Promise<void>;
900
- renderAllSectionsBigTitle(viewRectangle: Rectangle): Promise<void>;
901
- shouldSkipEntity(entity: Entity, viewRectangle: Rectangle): Promise<boolean>;
902
- isBackgroundImageNode(entity: Entity): Promise<boolean>;
903
- renderAllEntities(viewRectangle: Rectangle): Promise<void>;
904
- renderEntity(entity: Entity): Promise<void>;
905
- renderEntityDebug(entity: Entity): Promise<void>;
906
- renderConnectPoint(connectPoint: ConnectPoint): Promise<void>;
907
- renderImageNode(imageNode: ImageNode): Promise<void>;
908
- renderPenStroke(penStroke: PenStroke): Promise<void>;
909
- renderEntityDetails(entity: Entity): Promise<void>;
910
- _renderEntityDetails(entity: Entity, limitLiens: number): Promise<void>;
911
- renderEntityTagShap(entity: Entity): Promise<void>;
899
+ renderAllSectionsBackground(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
900
+ renderAllSectionsBigTitle(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
901
+ shouldSkipEntity(entity: Entity | { _: "Entity" | string }, viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
902
+ isBackgroundImageNode(entity: Entity | { _: "Entity" | string }): Promise<boolean>;
903
+ renderAllEntities(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
904
+ renderEntity(entity: Entity | { _: "Entity" | string }): Promise<void>;
905
+ renderEntityDebug(entity: Entity | { _: "Entity" | string }): Promise<void>;
906
+ renderConnectPoint(connectPoint: ConnectPoint | { _: "ConnectPoint" | string }): Promise<void>;
907
+ renderImageNode(imageNode: ImageNode | { _: "ImageNode" | string }): Promise<void>;
908
+ renderPenStroke(penStroke: PenStroke | { _: "PenStroke" | string }): Promise<void>;
909
+ renderEntityDetails(entity: Entity | { _: "Entity" | string }): Promise<void>;
910
+ _renderEntityDetails(entity: Entity | { _: "Entity" | string }, limitLiens: number): Promise<void>;
911
+ renderEntityTagShap(entity: Entity | { _: "Entity" | string }): Promise<void>;
912
+ }
913
+
914
+ declare class Extension extends Tab {
915
+ metadata: Promise<PrgMetadata>;
916
+ readmeContent: Promise<string>;
917
+ code: Promise<string>;
918
+ iconBlobUrl: Promise<string | null>;
919
+ iconRawData: Promise<Uint8Array | null>;
920
+ iconFileName: Promise<string | null>;
921
+ stage: Promise<any>[];
922
+ _uri: Promise<URI>;
923
+ _component: Promise<React.ComponentType | null>;
924
+ constructor(uri: URI);
925
+ get uri(): Promise<any>;
926
+ init(): Promise<void>;
927
+ getComponent(): Promise<React.ComponentType>;
928
+ render(): Promise<React.ReactNode>;
929
+ get icon(): Promise<any>;
930
+ get title(): Promise<any>;
912
931
  }
913
932
 
914
933
  declare class ExtensionEntity extends ConnectableEntity {
@@ -923,7 +942,7 @@ declare class ExtensionEntity extends ConnectableEntity {
923
942
  _isDirty;
924
943
  _isRendering;
925
944
  _renderFailed;
926
- constructor(project: Project, {
945
+ constructor(project: Project | { _: "Project" | string }, {
927
946
  uuid = crypto.randomUUID(),
928
947
  extensionId = "",
929
948
  typeName = "",
@@ -939,8 +958,8 @@ declare class ExtensionEntity extends ConnectableEntity {
939
958
  get rectangle(): Promise<Rectangle>;
940
959
  get location(): Promise<Vector>;
941
960
  set location(v: Vector);
942
- move(delta: Vector): void;
943
- moveTo(location: Vector): void;
961
+ move(delta: Vector | { _: "Vector" | string }): void;
962
+ moveTo(location: Vector | { _: "Vector" | string }): void;
944
963
  markDirty(): Promise<void>;
945
964
  setCustomData(data: any): Promise<void>;
946
965
  }
@@ -951,13 +970,13 @@ declare interface ExtensionEntityConfig {
951
970
  }
952
971
 
953
972
  declare class ExtensionEntityRenderer {
954
- constructor(project: Project);
955
- render(entity: ExtensionEntity): Promise<void>;
973
+ constructor(project: Project | { _: "Project" | string });
974
+ render(entity: ExtensionEntity | { _: "ExtensionEntity" | string }): Promise<void>;
956
975
  drawPendingBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number): Promise<void>;
957
976
  drawErrorBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, text: string, extensionId: string, color: string): Promise<void>;
958
- drawCollisionBox(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number): Promise<void>;
959
- renderSelectionOutline(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number): Promise<void>;
960
- triggerWorkerRender(entity: ExtensionEntity): Promise<void>;
977
+ drawCollisionBox(ctx: CanvasRenderingContext2D, entity: ExtensionEntity | { _: "ExtensionEntity" | string }, scale: number): Promise<void>;
978
+ renderSelectionOutline(ctx: CanvasRenderingContext2D, entity: ExtensionEntity | { _: "ExtensionEntity" | string }, scale: number): Promise<void>;
979
+ triggerWorkerRender(entity: ExtensionEntity | { _: "ExtensionEntity" | string }): Promise<void>;
961
980
  }
962
981
 
963
982
  declare interface FileSystemProvider {
@@ -971,7 +990,7 @@ declare interface FileSystemProvider {
971
990
  }
972
991
 
973
992
  declare class GenerateFromFolder {
974
- constructor(project: Project);
993
+ constructor(project: Project | { _: "Project" | string });
975
994
  generateFromFolder(folderPath: string): Promise<void>;
976
995
  generateTreeFromFolder(folderPath: string): Promise<void>;
977
996
  getColorByPath(path: string): Promise<Color>;
@@ -979,33 +998,33 @@ declare class GenerateFromFolder {
979
998
  }
980
999
 
981
1000
  declare class GraphImporter extends BaseImporter {
982
- constructor(project: Project);
983
- import(text: string, diffLocation: Vector = Vector.getZero()): void;
1001
+ constructor(project: Project | { _: "Project" | string });
1002
+ import(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
984
1003
  }
985
1004
 
986
1005
  declare class GraphMethods {
987
- constructor(project: Project);
988
- isTree(node: ConnectableEntity, skipDashed = false): Promise<boolean>;
989
- getNodeDisplayName(node: ConnectableEntity): Promise<string>;
990
- validateTreeStructure(rootNode: ConnectableEntity, skipDashed = false): Promise<TreeValidationResult>;
991
- nodeChildrenArray(node: ConnectableEntity, skipDashed = false): Promise<ConnectableEntity>[];
992
- nodeParentArray(node: ConnectableEntity, skipDashed = false): Promise<ConnectableEntity>[];
993
- edgeChildrenArray(node: ConnectableEntity): Promise<Edge>[];
994
- edgeParentArray(node: ConnectableEntity): Promise<Edge>[];
1006
+ constructor(project: Project | { _: "Project" | string });
1007
+ isTree(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<boolean>;
1008
+ getNodeDisplayName(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<string>;
1009
+ validateTreeStructure(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<TreeValidationResult>;
1010
+ nodeChildrenArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<ConnectableEntity>[];
1011
+ nodeParentArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<ConnectableEntity>[];
1012
+ edgeChildrenArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1013
+ edgeParentArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
995
1014
  getReversedEdgeDict(skipDashed = false): Promise<Record<string, string>>;
996
- isCurrentNodeInTreeStructAndNotRoot(node: ConnectableEntity): Promise<boolean>;
997
- getRoots(node: ConnectableEntity, skipDashed = false): Promise<ConnectableEntity>[];
998
- isConnected(node: ConnectableEntity, target: ConnectableEntity): Promise<boolean>;
999
- getSuccessorSet(node: ConnectableEntity, isHaveSelf: boolean = true, skipDashed = false): Promise<ConnectableEntity>[];
1000
- getOneStepSuccessorSet(node: ConnectableEntity): Promise<ConnectableEntity>[];
1001
- getEdgesBetween(node1: ConnectableEntity, node2: ConnectableEntity): Promise<Edge>[];
1002
- getEdgeFromTwoEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity): Promise<Edge | null>;
1003
- getHyperEdgesByNode(node: ConnectableEntity): Promise<MultiTargetUndirectedEdge>[];
1004
- getOutgoingEdges(node: ConnectableEntity): Promise<Edge>[];
1005
- getIncomingEdges(node: ConnectableEntity): Promise<Edge>[];
1006
- getNodesConnectedByHyperEdges(node: ConnectableEntity): Promise<ConnectableEntity>[];
1007
- nodeChildrenArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): Promise<ConnectableEntity>[];
1008
- nodeParentArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): Promise<ConnectableEntity>[];
1015
+ isCurrentNodeInTreeStructAndNotRoot(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
1016
+ getRoots(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<ConnectableEntity>[];
1017
+ isConnected(node: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
1018
+ getSuccessorSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }, isHaveSelf: boolean = true, skipDashed = false): Promise<ConnectableEntity>[];
1019
+ getOneStepSuccessorSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1020
+ getEdgesBetween(node1: ConnectableEntity | { _: "ConnectableEntity" | string }, node2: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1021
+ getEdgeFromTwoEntity(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge | null>;
1022
+ getHyperEdgesByNode(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<MultiTargetUndirectedEdge>[];
1023
+ getOutgoingEdges(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1024
+ getIncomingEdges(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1025
+ getNodesConnectedByHyperEdges(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1026
+ nodeChildrenArrayWithinSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }, nodeSet: Set<string>): Promise<ConnectableEntity>[];
1027
+ nodeParentArrayWithinSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }, nodeSet: Set<string>): Promise<ConnectableEntity>[];
1009
1028
  getTreeRootByNodes(nodes: ConnectableEntity[]): Promise<ConnectableEntity | null>;
1010
1029
  isTreeByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
1011
1030
  isDAGByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
@@ -1015,7 +1034,7 @@ declare class HistoryManager extends HistoryManagerAbs {
1015
1034
  memoryEfficient: Promise<HistoryManagerAbs>;
1016
1035
  timeEfficient: Promise<HistoryManagerAbs>;
1017
1036
  currentManager: Promise<HistoryManagerAbs>;
1018
- constructor(project: Project);
1037
+ constructor(project: Project | { _: "Project" | string });
1019
1038
  recordStep(): void;
1020
1039
  undo(): void;
1021
1040
  redo(): void;
@@ -1036,7 +1055,7 @@ declare class ImageNode extends ConnectableEntity implements ResizeAble {
1036
1055
  set isSelected(value: boolean);
1037
1056
  bitmap: Promise<ImageBitmap | undefined>;
1038
1057
  state: Promise<"loading" | "success" | "notFound">;
1039
- constructor(project: Project, {
1058
+ constructor(project: Project | { _: "Project" | string }, {
1040
1059
  uuid = crypto.randomUUID() as string,
1041
1060
  collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), Vector.getZero())]),
1042
1061
  details = [],
@@ -1047,30 +1066,30 @@ declare class ImageNode extends ConnectableEntity implements ResizeAble {
1047
1066
  scaleUpdate(scaleDiff: number): Promise<void>;
1048
1067
  get rectangle(): Promise<Rectangle>;
1049
1068
  get geometryCenter(): Promise<any>;
1050
- move(delta: Vector): void;
1051
- moveTo(location: Vector): void;
1069
+ move(delta: Vector | { _: "Vector" | string }): void;
1070
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1052
1071
  reverseColors(): Promise<void>;
1053
1072
  swapRedBlueChannels(): Promise<void>;
1054
- resizeHandle(delta: Vector): Promise<void>;
1073
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
1055
1074
  getResizeHandleRect(): Promise<Rectangle>;
1056
1075
  }
1057
1076
 
1058
1077
  declare class ImageRenderer {
1059
- constructor(project: Project);
1060
- renderImageElement(source: Exclude<CanvasImageSource, VideoFrame | SVGElement>, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
1061
- renderImageBitmap(bitmap: ImageBitmap | undefined, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
1078
+ constructor(project: Project | { _: "Project" | string });
1079
+ renderImageElement(source: Exclude<CanvasImageSource, VideoFrame | SVGElement>, location: Vector | { _: "Vector" | string }, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
1080
+ renderImageBitmap(bitmap: ImageBitmap | undefined, location: Vector | { _: "Vector" | string }, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
1062
1081
  }
1063
1082
 
1064
1083
  declare class InputElement {
1065
- input(location: Vector, defaultValue: string, onChange: (value: string) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}): Promise<string>;
1084
+ input(location: Vector | { _: "Vector" | string }, defaultValue: string, onChange: (value: string) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}): Promise<string>;
1066
1085
  textarea(defaultValue: string, onChange: (value: string, element: HTMLTextAreaElement) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}, selectAllWhenCreated = true): Promise<string>;
1067
1086
  addSuccessEffect(): Promise<void>;
1068
1087
  addFailEffect(withToast = true): Promise<void>;
1069
- constructor(project: Project);
1088
+ constructor(project: Project | { _: "Project" | string });
1070
1089
  }
1071
1090
 
1072
1091
  declare class KeyBindHintEngine {
1073
- constructor(project: Project);
1092
+ constructor(project: Project | { _: "Project" | string });
1074
1093
  ITEMS_PER_PAGE;
1075
1094
  currentPage;
1076
1095
  currentModifierCombo: Promise<string>;
@@ -1104,7 +1123,7 @@ declare type KeyBindIcon = ForwardRefExoticComponent<Omit<LucideProps, "ref"> &
1104
1123
  declare type KeyBindWhen = (project?: Project) => boolean | Promise<boolean>;
1105
1124
 
1106
1125
  declare class KeyboardOnlyEngine {
1107
- constructor(project: Project);
1126
+ constructor(project: Project | { _: "Project" | string });
1108
1127
  openning;
1109
1128
  setOpenning(value: boolean): Promise<void>;
1110
1129
  isOpenning(): Promise<void>;
@@ -1120,7 +1139,7 @@ declare class KeyboardOnlyGraphEngine {
1120
1139
  targetLocationController;
1121
1140
  virtualTargetLocation(): Promise<Vector>;
1122
1141
  tick(): Promise<void>;
1123
- constructor(project: Project);
1142
+ constructor(project: Project | { _: "Project" | string });
1124
1143
  isEnableVirtualCreate(): Promise<boolean>;
1125
1144
  _isCreating;
1126
1145
  _creatingFromUUID: Promise<string | null>;
@@ -1130,25 +1149,25 @@ declare class KeyboardOnlyGraphEngine {
1130
1149
  lastPressTabTime;
1131
1150
  getPressTabTimeInterval(): Promise<number>;
1132
1151
  createFinished(): Promise<void>;
1133
- moveVirtualTarget(delta: Vector): void;
1152
+ moveVirtualTarget(delta: Vector | { _: "Vector" | string }): void;
1134
1153
  createCancel(): void;
1135
1154
  isTargetLocationHaveEntity(): Promise<boolean>;
1136
1155
  }
1137
1156
 
1138
1157
  declare class KeyboardOnlyTreeEngine {
1139
- constructor(project: Project);
1140
- getNodePreDirection(node: ConnectableEntity): Promise<"right" | "left" | "down" | "up">;
1158
+ constructor(project: Project | { _: "Project" | string });
1159
+ getNodePreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<"right" | "left" | "down" | "up">;
1141
1160
  preDirectionCacheMap: Promise<Map<string, "right" | "left" | "down" | "up">>;
1142
- getGrowthLineStart(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
1143
- getGrowthLineEnd(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
1144
- findConnectTargetByGrowthLine(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Promise<ConnectableEntity | null>;
1161
+ getGrowthLineStart(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
1162
+ getGrowthLineEnd(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
1163
+ findConnectTargetByGrowthLine(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "right" | "left" | "down" | "up"): Promise<ConnectableEntity | null>;
1145
1164
  changePreDirection(nodes: ConnectableEntity[], direction: "right" | "left" | "down" | "up"): void;
1146
- addNodeEffectByPreDirection(node: ConnectableEntity): void;
1165
+ addNodeEffectByPreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | string }): void;
1147
1166
  onDeepGenerateNode(defaultText = "新节点", selectAll = true): Promise<void>;
1148
1167
  onBroadGenerateNode(): Promise<void>;
1149
- adjustTreeNode(entity: ConnectableEntity, withEffect = true): Promise<void>;
1168
+ adjustTreeNode(entity: ConnectableEntity | { _: "ConnectableEntity" | string }, withEffect = true): Promise<void>;
1150
1169
  onDeleteCurrentNode(): Promise<void>;
1151
- calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity, preDirection: "right" | "left" | "down" | "up"): Promise<number>;
1170
+ calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity | { _: "ConnectableEntity" | string }, preDirection: "right" | "left" | "down" | "up"): Promise<number>;
1152
1171
  }
1153
1172
 
1154
1173
  declare class LatexNode extends ConnectableEntity {
@@ -1167,7 +1186,7 @@ declare class LatexNode extends ConnectableEntity {
1167
1186
  set isSelected(value: boolean);
1168
1187
  get rectangle(): Promise<Rectangle>;
1169
1188
  get geometryCenter(): Promise<Vector>;
1170
- constructor(project: Project, {
1189
+ constructor(project: Project | { _: "Project" | string }, {
1171
1190
  uuid = crypto.randomUUID(),
1172
1191
  details = [],
1173
1192
  latexSource = "",
@@ -1183,25 +1202,25 @@ declare class LatexNode extends ConnectableEntity {
1183
1202
  fontScaleLevel?: number;
1184
1203
  });
1185
1204
  getScale(): Promise<number>;
1186
- increaseFontSize(anchorRate?: Vector): void;
1187
- decreaseFontSize(anchorRate?: Vector): void;
1188
- updateCollisionBoxByScale(anchorRate?: Vector): void;
1189
- _adjustLocationToKeepAnchor(oldRect: Rectangle, anchorRate: Vector): void;
1205
+ increaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
1206
+ decreaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
1207
+ updateCollisionBoxByScale(anchorRate?: Vector | { _: "Vector" | string }): void;
1208
+ _adjustLocationToKeepAnchor(oldRect: Rectangle | { _: "Rectangle" | string }, anchorRate: Vector | { _: "Vector" | string }): void;
1190
1209
  updateLatex(newLatex: string, colorCss?: string): Promise<void>;
1191
1210
  reRenderWithColor(colorCss: string): Promise<void>;
1192
1211
  renderLatexToImage(latex: string, colorCss: string = "#000000"): Promise<void>;
1193
- move(delta: Vector): void;
1194
- moveTo(location: Vector): void;
1212
+ move(delta: Vector | { _: "Vector" | string }): void;
1213
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1195
1214
  }
1196
1215
 
1197
1216
  declare class LatexNodeRenderer {
1198
- constructor(project: Project);
1199
- getTargetColorCss(node: LatexNode): Promise<string>;
1200
- render(node: LatexNode): Promise<void>;
1217
+ constructor(project: Project | { _: "Project" | string });
1218
+ getTargetColorCss(node: LatexNode | { _: "LatexNode" | string }): Promise<string>;
1219
+ render(node: LatexNode | { _: "LatexNode" | string }): Promise<void>;
1201
1220
  }
1202
1221
 
1203
1222
  declare class LayoutManager {
1204
- constructor(project: Project);
1223
+ constructor(project: Project | { _: "Project" | string });
1205
1224
  alignLeft(): Promise<void>;
1206
1225
  alignRight(): Promise<void>;
1207
1226
  alignTop(): Promise<void>;
@@ -1227,7 +1246,7 @@ declare class LineEdge extends Edge {
1227
1246
  get shiftingIndex(): Promise<number>;
1228
1247
  set shiftingIndex(value: number);
1229
1248
  _shiftingIndex: Promise<number>;
1230
- constructor(project: Project, {
1249
+ constructor(project: Project | { _: "Project" | string }, {
1231
1250
  associationList = [] as ConnectableEntity[],
1232
1251
  text = "",
1233
1252
  uuid = crypto.randomUUID() as string,
@@ -1236,7 +1255,7 @@ declare class LineEdge extends Edge {
1236
1255
  targetRectangleRate = Vector.same(0.5),
1237
1256
  lineType = "solid",
1238
1257
  }, unknown = false);
1239
- fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): Promise<LineEdge>;
1258
+ fromTwoEntity(project: Project | { _: "Project" | string }, source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<LineEdge>;
1240
1259
  rename(text: string): Promise<void>;
1241
1260
  get edgeWidth(): Promise<number>;
1242
1261
  get textFontSize(): Promise<number>;
@@ -1333,13 +1352,13 @@ declare enum LogicNodeNameEnum {
1333
1352
  }
1334
1353
 
1335
1354
  declare class MarkdownExporter extends BaseExporter {
1336
- export(textNode: TextNode): Promise<string>;
1337
- getNodeMarkdown(node: TextNode, level: number): Promise<string>;
1355
+ export(textNode: TextNode | { _: "TextNode" | string }): Promise<string>;
1356
+ getNodeMarkdown(node: TextNode | { _: "TextNode" | string }, level: number): Promise<string>;
1338
1357
  }
1339
1358
 
1340
1359
  declare class MarkdownImporter extends BaseImporter {
1341
- constructor(project: Project);
1342
- import(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true): void;
1360
+ constructor(project: Project | { _: "Project" | string });
1361
+ import(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): void;
1343
1362
  }
1344
1363
 
1345
1364
  declare interface MarkdownNode {
@@ -1349,13 +1368,13 @@ declare interface MarkdownNode {
1349
1368
  }
1350
1369
 
1351
1370
  declare class MermaidExporter {
1352
- constructor(project: Project);
1371
+ constructor(project: Project | { _: "Project" | string });
1353
1372
  export(entities: Entity[]): Promise<string>;
1354
1373
  }
1355
1374
 
1356
1375
  declare class MermaidImporter extends BaseImporter {
1357
- constructor(project: Project);
1358
- import(text: string, diffLocation: Vector = Vector.getZero()): void;
1376
+ constructor(project: Project | { _: "Project" | string });
1377
+ import(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1359
1378
  normalizeLine(line: string): Promise<string>;
1360
1379
  decodeMermaidText(value: string): Promise<string>;
1361
1380
  sanitizeLabel(raw: string | undefined): Promise<string | undefined>;
@@ -1363,7 +1382,7 @@ declare class MermaidImporter extends BaseImporter {
1363
1382
  }
1364
1383
 
1365
1384
  declare class MouseInteraction {
1366
- constructor(project: Project);
1385
+ constructor(project: Project | { _: "Project" | string });
1367
1386
  _hoverEdges: Promise<Edge>[];
1368
1387
  _hoverSections: Promise<Section>[];
1369
1388
  _hoverConnectPoints: Promise<ConnectPoint>[];
@@ -1375,12 +1394,12 @@ declare class MouseInteraction {
1375
1394
  get firstHoverSection(): Promise<Section | undefined>;
1376
1395
  get hoverMultiTargetEdges(): Promise<MultiTargetUndirectedEdge>[];
1377
1396
  get firstHoverMultiTargetEdge(): Promise<MultiTargetUndirectedEdge | undefined>;
1378
- updateByMouseMove(mouseWorldLocation: Vector): void;
1397
+ updateByMouseMove(mouseWorldLocation: Vector | { _: "Vector" | string }): void;
1379
1398
  }
1380
1399
 
1381
1400
  declare class MultiTargetEdgeMove {
1382
- constructor(project: Project);
1383
- moveMultiTargetEdge(diffLocation: Vector): Promise<void>;
1401
+ constructor(project: Project | { _: "Project" | string });
1402
+ moveMultiTargetEdge(diffLocation: Vector | { _: "Vector" | string }): Promise<void>;
1384
1403
  }
1385
1404
 
1386
1405
  declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
@@ -1394,7 +1413,7 @@ declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
1394
1413
  renderType: Promise<MultiTargetUndirectedEdgeRenderType>;
1395
1414
  padding: Promise<number>;
1396
1415
  rename(text: string): Promise<void>;
1397
- constructor(project: Project, {
1416
+ constructor(project: Project | { _: "Project" | string }, {
1398
1417
  associationList = [] as ConnectableEntity[],
1399
1418
  text = "",
1400
1419
  uuid = crypto.randomUUID() as string,
@@ -1417,47 +1436,47 @@ declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
1417
1436
  }, unknown = false);
1418
1437
  get centerLocation(): Promise<Vector>;
1419
1438
  get textRectangle(): Promise<Rectangle>;
1420
- createFromSomeEntity(project: Project, entities: ConnectableEntity[]): Promise<void>;
1439
+ createFromSomeEntity(project: Project | { _: "Project" | string }, entities: ConnectableEntity[]): Promise<void>;
1421
1440
  _isSelected: Promise<boolean>;
1422
1441
  get isSelected(): Promise<boolean>;
1423
1442
  set isSelected(value: boolean);
1424
1443
  }
1425
1444
 
1426
1445
  declare class MultiTargetUndirectedEdgeRenderer {
1427
- constructor(project: Project);
1428
- render(edge: MultiTargetUndirectedEdge): Promise<void>;
1429
- renderLineShape(edge: MultiTargetUndirectedEdge, edgeColor: Color, centerLocation: Vector): void;
1430
- renderConvexShape(edge: MultiTargetUndirectedEdge, edgeColor: Color): void;
1431
- renderCircle(edge: MultiTargetUndirectedEdge, edgeColor: Color): void;
1446
+ constructor(project: Project | { _: "Project" | string });
1447
+ render(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }): Promise<void>;
1448
+ renderLineShape(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, edgeColor: Color | { _: "Color" | string }, centerLocation: Vector | { _: "Vector" | string }): void;
1449
+ renderConvexShape(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, edgeColor: Color | { _: "Color" | string }): void;
1450
+ renderCircle(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, edgeColor: Color | { _: "Color" | string }): void;
1432
1451
  }
1433
1452
 
1434
1453
  declare class NodeAdder {
1435
- constructor(project: Project);
1436
- addTextNodeByClick(clickWorldLocation: Vector, addToSections: Section[], selectCurrent = false, shouldRecordHistory = true, options?: {
1454
+ constructor(project: Project | { _: "Project" | string });
1455
+ addTextNodeByClick(clickWorldLocation: Vector | { _: "Vector" | string }, addToSections: Section[], selectCurrent = false, shouldRecordHistory = true, options?: {
1437
1456
  overrideFontScaleLevel?: number;
1438
1457
  }): Promise<string>;
1439
1458
  addTextNodeFromCurrentSelectedNode(direction: Direction, addToSections: Section[], selectCurrent = false): Promise<string>;
1440
1459
  getAutoName(): Promise<string>;
1441
1460
  getAutoColor(): Promise<Color>;
1442
- addConnectPoint(clickWorldLocation: Vector, addToSections: Section[]): Promise<string>;
1443
- addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero()): void;
1444
- addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero()): void;
1445
- addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero()): void;
1446
- addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true): Promise<void>;
1461
+ addConnectPoint(clickWorldLocation: Vector | { _: "Vector" | string }, addToSections: Section[]): Promise<string>;
1462
+ addNodeGraphByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1463
+ addNodeTreeByText(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1464
+ addNodeMermaidByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1465
+ addNodeByMarkdown(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): Promise<void>;
1447
1466
  getIndentLevel(line: string, indention: number): Promise<number>;
1448
1467
  }
1449
1468
 
1450
1469
  declare class NodeConnector {
1451
- constructor(project: Project);
1452
- isConnectable(fromNode: ConnectableEntity, toNode: ConnectableEntity): Promise<boolean>;
1453
- connectConnectableEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, text: string = "", targetRectRate?: [number, number], sourceRectRate?: [number, number]): void;
1454
- connectEntityFast(fromNode: ConnectableEntity, toNode: ConnectableEntity, text: string = ""): void;
1455
- addCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity): void;
1470
+ constructor(project: Project | { _: "Project" | string });
1471
+ isConnectable(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
1472
+ connectConnectableEntity(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, text: string = "", targetRectRate?: [number, number], sourceRectRate?: [number, number]): void;
1473
+ connectEntityFast(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, text: string = ""): void;
1474
+ addCrEdge(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): void;
1456
1475
  reverseEdges(edges: LineEdge[]): Promise<void>;
1457
- changeEdgeTarget(edge: LineEdge, newTarget: ConnectableEntity): Promise<void>;
1458
- changeEdgeSource(edge: LineEdge, newSource: ConnectableEntity): Promise<void>;
1459
- changeSelectedEdgeTarget(newTarget: ConnectableEntity): Promise<void>;
1460
- changeSelectedEdgeSource(newSource: ConnectableEntity): Promise<void>;
1476
+ changeEdgeTarget(edge: LineEdge | { _: "LineEdge" | string }, newTarget: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1477
+ changeEdgeSource(edge: LineEdge | { _: "LineEdge" | string }, newSource: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1478
+ changeSelectedEdgeTarget(newTarget: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1479
+ changeSelectedEdgeSource(newSource: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1461
1480
  }
1462
1481
 
1463
1482
  declare class PenStroke extends Entity {
@@ -1465,24 +1484,24 @@ declare class PenStroke extends Entity {
1465
1484
  isHiddenBySectionCollapse: Promise<boolean>;
1466
1485
  collisionBox: Promise<CollisionBox>;
1467
1486
  uuid: Promise<string>;
1468
- move(delta: Vector): void;
1469
- moveTo(location: Vector): void;
1487
+ move(delta: Vector | { _: "Vector" | string }): void;
1488
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1470
1489
  updateCollisionBoxBySegmentList(): Promise<void>;
1471
1490
  segments: Promise<PenStrokeSegment>[];
1472
1491
  color: Promise<Color>;
1473
1492
  getPath(): Promise<Vector>[];
1474
- constructor(project: Project, { uuid = crypto.randomUUID() as string, segments = [] as PenStrokeSegment[], color = Color.White });
1493
+ constructor(project: Project | { _: "Project" | string }, { uuid = crypto.randomUUID() as string, segments = [] as PenStrokeSegment[], color = Color.White });
1475
1494
  getCollisionBoxFromSegmentList(segmentList: PenStrokeSegment[]): Promise<CollisionBox>;
1476
1495
  }
1477
1496
 
1478
1497
  declare class PenStrokeSegment {
1479
1498
  location: Promise<Vector>;
1480
1499
  pressure: Promise<number>;
1481
- constructor(location: Vector, pressure: number);
1500
+ constructor(location: Vector | { _: "Vector" | string }, pressure: number);
1482
1501
  }
1483
1502
 
1484
1503
  declare class PlainTextExporter {
1485
- constructor(project: Project);
1504
+ constructor(project: Project | { _: "Project" | string });
1486
1505
  export(nodes: Entity[]): Promise<string>;
1487
1506
  }
1488
1507
 
@@ -1634,7 +1653,7 @@ declare type RecentFile = {
1634
1653
  }
1635
1654
 
1636
1655
  declare class RectangleSelect {
1637
- constructor(project: Project);
1656
+ constructor(project: Project | { _: "Project" | string });
1638
1657
  selectStartLocation;
1639
1658
  selectEndLocation;
1640
1659
  getSelectStartLocation(): Promise<Vector>;
@@ -1644,11 +1663,11 @@ declare class RectangleSelect {
1644
1663
  isSelectDirectionRight;
1645
1664
  getRectangle(): Promise<Rectangle | null>;
1646
1665
  shutDown(): Promise<void>;
1647
- startSelecting(worldLocation: Vector): Promise<void>;
1648
- moveSelecting(newEndLocation: Vector): Promise<void>;
1666
+ startSelecting(worldLocation: Vector | { _: "Vector" | string }): Promise<void>;
1667
+ moveSelecting(newEndLocation: Vector | { _: "Vector" | string }): Promise<void>;
1649
1668
  endSelecting(): Promise<void>;
1650
1669
  updateStageObjectByMove(): Promise<void>;
1651
- isSelectWithEntity(entity: StageObject): Promise<void>;
1670
+ isSelectWithEntity(entity: StageObject | { _: "StageObject" | string }): Promise<void>;
1652
1671
  getSelectMode(): Promise<"contain" | "intersect">;
1653
1672
  getSelectMoveDistance(): Promise<number>;
1654
1673
  }
@@ -1664,7 +1683,7 @@ declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble
1664
1683
  _isSelected: Promise<boolean>;
1665
1684
  bitmap: Promise<ImageBitmap | undefined>;
1666
1685
  state: Promise<"loading" | "success" | "notFound">;
1667
- constructor(project: Project, {
1686
+ constructor(project: Project | { _: "Project" | string }, {
1668
1687
  uuid = crypto.randomUUID() as string,
1669
1688
  collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), new Vector(400, 200))]),
1670
1689
  fileName = "",
@@ -1681,33 +1700,33 @@ declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble
1681
1700
  scaleUpdate(scaleDiff: number): Promise<void>;
1682
1701
  get rectangle(): Promise<Rectangle>;
1683
1702
  get geometryCenter(): Promise<any>;
1684
- move(delta: Vector): void;
1685
- moveTo(location: Vector): void;
1703
+ move(delta: Vector | { _: "Vector" | string }): void;
1704
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1686
1705
  refresh(): Promise<void>;
1687
1706
  goToSource(): Promise<void>;
1688
- focusSectionInProject(project: Project): Promise<void>;
1689
- resizeHandle(delta: Vector): Promise<void>;
1707
+ focusSectionInProject(project: Project | { _: "Project" | string }): Promise<void>;
1708
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
1690
1709
  getResizeHandleRect(): Promise<Rectangle>;
1691
1710
  }
1692
1711
 
1693
1712
  declare class ReferenceBlockRenderer {
1694
- constructor(project: Project);
1695
- render(referenceBlockNode: ReferenceBlockNode): Promise<void>;
1696
- renderBrackets(rect: Rectangle, color: Color): Promise<void>;
1697
- renderSourceSectionBorder(section: Section, countNumber: number, color: Color = new Color(118, 78, 209)): Promise<void>;
1713
+ constructor(project: Project | { _: "Project" | string });
1714
+ render(referenceBlockNode: ReferenceBlockNode | { _: "ReferenceBlockNode" | string }): Promise<void>;
1715
+ renderBrackets(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }): Promise<void>;
1716
+ renderSourceSectionBorder(section: Section | { _: "Section" | string }, countNumber: number, color: Color | { _: "Color" | string } = new Color(118, 78, 209)): Promise<void>;
1698
1717
  }
1699
1718
 
1700
1719
  declare class ReferenceManager {
1701
- constructor(project: Project);
1720
+ constructor(project: Project | { _: "Project" | string });
1702
1721
  referenceBlockTextParser(text: string): Promise<parserResult>;
1703
- onClickReferenceNumber(clickLocation: Vector): Promise<void>;
1722
+ onClickReferenceNumber(clickLocation: Vector | { _: "Vector" | string }): Promise<void>;
1704
1723
  buildSectionName2SectionMap(sectionNames: string[]): Promise<Record<string, Section>>;
1705
1724
  updateOneSectionReferenceInfo(recentFiles: RecentFileManager.RecentFile[], sectionName: string): Promise<void>;
1706
1725
  updateCurrentProjectReference(): Promise<void>;
1707
- checkReferenceBlockInProject(project: Project, fileName: string, sectionName: string): Promise<void>;
1726
+ checkReferenceBlockInProject(project: Project | { _: "Project" | string }, fileName: string, sectionName: string): Promise<void>;
1708
1727
  insertRefDataToSourcePrgFile(fileName: string, sectionName: string): Promise<void>;
1709
1728
  jumpToReferenceLocation(fileName: string, referenceBlockNodeSectionName: string): Promise<void>;
1710
- openSectionReferencePanel(section: Section): Promise<void>;
1729
+ openSectionReferencePanel(section: Section | { _: "Section" | string }): Promise<void>;
1711
1730
  }
1712
1731
 
1713
1732
  declare class Renderer {
@@ -1724,14 +1743,14 @@ declare class Renderer {
1724
1743
  frameIndex;
1725
1744
  fps;
1726
1745
  resizeWindow(newW: number, newH: number): Promise<void>;
1727
- constructor(project: Project);
1746
+ constructor(project: Project | { _: "Project" | string });
1728
1747
  tick(): Promise<void>;
1729
1748
  tick_(): Promise<void>;
1730
- renderViewElements(_viewRectangle: Rectangle): Promise<void>;
1749
+ renderViewElements(_viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1731
1750
  renderZoomLevelStage(): Promise<void>;
1732
- renderMainStageElements(viewRectangle: Rectangle): Promise<void>;
1733
- renderStageElementsWithoutReactions(viewRectangle: Rectangle): Promise<void>;
1734
- isOverView(viewRectangle: Rectangle, entity: StageObject): Promise<boolean>;
1751
+ renderMainStageElements(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1752
+ renderStageElementsWithoutReactions(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1753
+ isOverView(viewRectangle: Rectangle | { _: "Rectangle" | string }, entity: StageObject | { _: "StageObject" | string }): Promise<boolean>;
1735
1754
  renderCenterPointer(): Promise<void>;
1736
1755
  renderHoverCollisionBox(): Promise<void>;
1737
1756
  renderSelectingRectangle(): Promise<void>;
@@ -1740,37 +1759,37 @@ declare class Renderer {
1740
1759
  renderCrosshairOnHoverImage(): Promise<void>;
1741
1760
  renderKeyboardOnly(): Promise<void>;
1742
1761
  rendererLayerMovingLine(): Promise<void>;
1743
- renderJumpLine(startLocation: Vector, endLocation: Vector): Promise<void>;
1762
+ renderJumpLine(startLocation: Vector | { _: "Vector" | string }, endLocation: Vector | { _: "Vector" | string }): Promise<void>;
1744
1763
  renderWarningStageObjects(): Promise<void>;
1745
1764
  renderTags(): Promise<void>;
1746
- renderEntities(viewRectangle: Rectangle): Promise<void>;
1747
- renderEdges(viewRectangle: Rectangle): Promise<void>;
1765
+ renderEntities(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1766
+ renderEdges(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1748
1767
  renderBackground(): Promise<void>;
1749
1768
  updateFPS(): Promise<void>;
1750
1769
  renderDebugDetails(): Promise<void>;
1751
1770
  renderSpecialKeys(): Promise<void>;
1752
- transformWorld2View(location: Vector): Promise<Vector>;
1753
- transformWorld2View(rectangle: Rectangle): Promise<Rectangle>;
1771
+ transformWorld2View(location: Vector | { _: "Vector" | string }): Promise<Vector>;
1772
+ transformWorld2View(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Rectangle>;
1754
1773
  transformWorld2View(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
1755
- transformView2World(location: Vector): Promise<Vector>;
1756
- transformView2World(rectangle: Rectangle): Promise<Rectangle>;
1774
+ transformView2World(location: Vector | { _: "Vector" | string }): Promise<Vector>;
1775
+ transformView2World(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Rectangle>;
1757
1776
  transformView2World(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
1758
1777
  getCoverWorldRectangle(): Promise<Rectangle>;
1759
1778
  }
1760
1779
 
1761
1780
  declare class RenderUtils {
1762
- constructor(project: Project);
1763
- renderPixel(location: Vector, color: Color): Promise<void>;
1764
- renderArrow(direction: Vector, location: Vector, color: Color, size: number): Promise<void>;
1781
+ constructor(project: Project | { _: "Project" | string });
1782
+ renderPixel(location: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }): Promise<void>;
1783
+ renderArrow(direction: Vector | { _: "Vector" | string }, location: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, size: number): Promise<void>;
1765
1784
  }
1766
1785
 
1767
1786
  declare interface ResizeAble {
1768
- resizeHandle(delta: Vector): void;
1787
+ resizeHandle(delta: Vector | { _: "Vector" | string }): void;
1769
1788
  getResizeHandleRect(): Promise<Rectangle>;
1770
1789
  }
1771
1790
 
1772
1791
  declare class SearchContentHighlightRenderer {
1773
- constructor(project: Project);
1792
+ constructor(project: Project | { _: "Project" | string });
1774
1793
  render(frameTickIndex: number): Promise<void>;
1775
1794
  }
1776
1795
 
@@ -1791,7 +1810,7 @@ declare class Section extends ConnectableEntity {
1791
1810
  isCollapsed: Promise<boolean>;
1792
1811
  locked: Promise<boolean>;
1793
1812
  isHiddenBySectionCollapse;
1794
- constructor(project: Project, {
1813
+ constructor(project: Project | { _: "Project" | string }, {
1795
1814
  uuid = crypto.randomUUID() as string,
1796
1815
  text = "",
1797
1816
  collisionBox = new CollisionBox([new Rectangle(new Vector(0, 0), new Vector(0, 0))]),
@@ -1802,7 +1821,7 @@ declare class Section extends ConnectableEntity {
1802
1821
  children = [] as Entity[],
1803
1822
  details = [] as Value,
1804
1823
  } = {}, unknown = false);
1805
- fromEntities(project: Project, entities: Entity[]): Promise<Section>;
1824
+ fromEntities(project: Project | { _: "Project" | string }, entities: Entity[]): Promise<Section>;
1806
1825
  rename(newName: string): Promise<void>;
1807
1826
  adjustLocationAndSize(): Promise<void>;
1808
1827
  adjustChildrenStateByCollapse(parentCollapsed = false): Promise<void>;
@@ -1810,58 +1829,58 @@ declare class Section extends ConnectableEntity {
1810
1829
  set isSelected(value: boolean);
1811
1830
  get rectangle(): Promise<Rectangle>;
1812
1831
  get geometryCenter(): Promise<any>;
1813
- move(delta: Vector): void;
1814
- collideWithOtherEntity(other: Entity): void;
1815
- moveTo(location: Vector): void;
1832
+ move(delta: Vector | { _: "Vector" | string }): void;
1833
+ collideWithOtherEntity(other: Entity | { _: "Entity" | string }): void;
1834
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1816
1835
  }
1817
1836
 
1818
1837
  declare class SectionCollisionSolver {
1819
- constructor(project: Project);
1820
- solveOverlaps(grownSection: Section, visited: Set<string> = new Set()): void;
1821
- updateAncestorsAfterShift(entity: Entity, visited: Set<string>): void;
1822
- getSiblingsSections(section: Section): Promise<Section>[];
1823
- computePushDelta(grownRect: Rectangle, siblingRect: Rectangle): Promise<Vector>;
1824
- rawShiftEntityTree(entity: Entity, delta: Vector): void;
1838
+ constructor(project: Project | { _: "Project" | string });
1839
+ solveOverlaps(grownSection: Section | { _: "Section" | string }, visited: Set<string> = new Set()): void;
1840
+ updateAncestorsAfterShift(entity: Entity | { _: "Entity" | string }, visited: Set<string>): void;
1841
+ getSiblingsSections(section: Section | { _: "Section" | string }): Promise<Section>[];
1842
+ computePushDelta(grownRect: Rectangle | { _: "Rectangle" | string }, siblingRect: Rectangle | { _: "Rectangle" | string }): Promise<Vector>;
1843
+ rawShiftEntityTree(entity: Entity | { _: "Entity" | string }, delta: Vector | { _: "Vector" | string }): void;
1825
1844
  }
1826
1845
 
1827
1846
  declare class SectionInOutManager {
1828
- constructor(project: Project);
1829
- goInSection(entities: Entity[], section: Section): Promise<void>;
1847
+ constructor(project: Project | { _: "Project" | string });
1848
+ goInSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
1830
1849
  goInSections(entities: Entity[], sections: Section[]): Promise<void>;
1831
- goOutSection(entities: Entity[], section: Section): Promise<void>;
1832
- entityDropParent(entity: Entity): Promise<void>;
1833
- sectionDropChild(section: Section, entity: Entity): Promise<void>;
1834
- convertSectionToTextNode(section: Section): Promise<void>;
1850
+ goOutSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
1851
+ entityDropParent(entity: Entity | { _: "Entity" | string }): Promise<void>;
1852
+ sectionDropChild(section: Section | { _: "Section" | string }, entity: Entity | { _: "Entity" | string }): Promise<void>;
1853
+ convertSectionToTextNode(section: Section | { _: "Section" | string }): Promise<void>;
1835
1854
  }
1836
1855
 
1837
1856
  declare class SectionMethods {
1838
- constructor(project: Project);
1839
- getFatherSections(entity: Entity): Promise<Section>[];
1840
- isObjectBeLockedBySection(object: StageObject): Promise<boolean>;
1841
- getFatherSectionsList(entity: Entity): Promise<Section>[];
1842
- getSectionsByInnerLocation(location: Vector): Promise<Section>[];
1857
+ constructor(project: Project | { _: "Project" | string });
1858
+ getFatherSections(entity: Entity | { _: "Entity" | string }): Promise<Section>[];
1859
+ isObjectBeLockedBySection(object: StageObject | { _: "StageObject" | string }): Promise<boolean>;
1860
+ getFatherSectionsList(entity: Entity | { _: "Entity" | string }): Promise<Section>[];
1861
+ getSectionsByInnerLocation(location: Vector | { _: "Vector" | string }): Promise<Section>[];
1843
1862
  deeperSections(sections: Section[]): Promise<Section>[];
1844
1863
  shallowerSection(sections: Section[]): Promise<Section>[];
1845
1864
  shallowerNotSectionEntities(entities: Entity[]): Promise<Entity>[];
1846
- isEntityInSection(entity: Entity, section: Section): Promise<boolean>;
1847
- isEntityInSection_fake(entity: Entity, section: Section): Promise<boolean>;
1848
- _isEntityInSection(entity: Entity, section: Section, deep = 0): Promise<boolean>;
1849
- isTreePack(rootNode: Section): Promise<void>;
1850
- getSectionMaxDeep(section: Section): Promise<number>;
1865
+ isEntityInSection(entity: Entity | { _: "Entity" | string }, section: Section | { _: "Section" | string }): Promise<boolean>;
1866
+ isEntityInSection_fake(entity: Entity | { _: "Entity" | string }, section: Section | { _: "Section" | string }): Promise<boolean>;
1867
+ _isEntityInSection(entity: Entity | { _: "Entity" | string }, section: Section | { _: "Section" | string }, deep = 0): Promise<boolean>;
1868
+ isTreePack(rootNode: Section | { _: "Section" | string }): Promise<void>;
1869
+ getSectionMaxDeep(section: Section | { _: "Section" | string }): Promise<number>;
1851
1870
  getAllEntitiesInSelectedSectionsOrEntities(selectedEntities: Entity[]): Promise<Entity>[];
1852
1871
  getSortedSectionsByZ(sections: Section[]): Promise<Section>[];
1853
1872
  }
1854
1873
 
1855
1874
  declare class SectionPackManager {
1856
- constructor(project: Project);
1875
+ constructor(project: Project | { _: "Project" | string });
1857
1876
  packSection(): void;
1858
- modifyHiddenDfs(section: Section, isCollapsed: boolean): Promise<void>;
1877
+ modifyHiddenDfs(section: Section | { _: "Section" | string }, isCollapsed: boolean): Promise<void>;
1859
1878
  unpackSection(): void;
1860
1879
  switchCollapse(): void;
1861
1880
  textNodeToSection(): void;
1862
- textNodeTreeToSection(rootNode: TextNode): void;
1863
- textNodeTreeToSectionNoDeep(rootNode: TextNode): void;
1864
- targetTextNodeToSection(textNode: TextNode, ignoreEdges: boolean = false, addConnectPoints: boolean = false): Promise<Section>;
1881
+ textNodeTreeToSection(rootNode: TextNode | { _: "TextNode" | string }): void;
1882
+ textNodeTreeToSectionNoDeep(rootNode: TextNode | { _: "TextNode" | string }): void;
1883
+ targetTextNodeToSection(textNode: TextNode | { _: "TextNode" | string }, ignoreEdges: boolean = false, addConnectPoints: boolean = false): Promise<Section>;
1865
1884
  unpackSelectedSections(): Promise<void>;
1866
1885
  unpackSections(entities: Entity[]): Promise<void>;
1867
1886
  packEntityToSection(addEntities: Entity[]): Promise<void>;
@@ -1871,38 +1890,38 @@ declare class SectionPackManager {
1871
1890
  }
1872
1891
 
1873
1892
  declare class SectionRenderer {
1874
- constructor(project: Project);
1875
- renderCollapsed(section: Section): Promise<void>;
1876
- renderNoCollapse(section: Section): Promise<void>;
1877
- renderBackgroundColor(section: Section): Promise<void>;
1878
- renderBigCoveredTitle(section: Section): Promise<void>;
1879
- renderTopTitle(section: Section): Promise<void>;
1880
- render(section: Section): void;
1893
+ constructor(project: Project | { _: "Project" | string });
1894
+ renderCollapsed(section: Section | { _: "Section" | string }): Promise<void>;
1895
+ renderNoCollapse(section: Section | { _: "Section" | string }): Promise<void>;
1896
+ renderBackgroundColor(section: Section | { _: "Section" | string }): Promise<void>;
1897
+ renderBigCoveredTitle(section: Section | { _: "Section" | string }): Promise<void>;
1898
+ renderTopTitle(section: Section | { _: "Section" | string }): Promise<void>;
1899
+ render(section: Section | { _: "Section" | string }): void;
1881
1900
  }
1882
1901
 
1883
1902
  declare class SelectChangeEngine {
1884
1903
  lastSelectNodeByKeyboardUUID;
1885
- constructor(project: Project);
1904
+ constructor(project: Project | { _: "Project" | string });
1886
1905
  selectUp(addSelect = false): Promise<void>;
1887
1906
  selectDown(addSelect = false): Promise<void>;
1888
1907
  selectLeft(addSelect = false): Promise<void>;
1889
1908
  selectRight(addSelect = false): Promise<void>;
1890
- navigateInDirection(selectedNode: ConnectableEntity, direction: Direction): Promise<ConnectableEntity | null>;
1891
- getSameLevelCandidates(parentSection: Section, excludeNode: ConnectableEntity): Promise<ConnectableEntity>[];
1892
- getTopLevelCandidates(excludeNode: ConnectableEntity): Promise<ConnectableEntity>[];
1909
+ navigateInDirection(selectedNode: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: Direction): Promise<ConnectableEntity | null>;
1910
+ getSameLevelCandidates(parentSection: Section | { _: "Section" | string }, excludeNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1911
+ getTopLevelCandidates(excludeNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1893
1912
  expandSelect(isKeepExpand = false, reversed: boolean = false): Promise<void>;
1894
- afterSelect(selectedNodeRect: ConnectableEntity, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true): Promise<void>;
1913
+ afterSelect(selectedNodeRect: ConnectableEntity | { _: "ConnectableEntity" | string }, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true): Promise<void>;
1895
1914
  getCurrentSelectedNode(): Promise<ConnectableEntity | null>;
1896
- addEffect(selectedNodeRect: Rectangle, newSelectNodeRect: Rectangle): Promise<void>;
1897
- getMostNearConnectableEntity(nodes: ConnectableEntity[], location: Vector): Promise<ConnectableEntity | null>;
1898
- selectMostNearLocationNode(location: Vector): Promise<ConnectableEntity | null>;
1899
- collectNodesInStrip(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
1900
- getMostNearInStripByDh(nodes: ConnectableEntity[], nodeRect: Rectangle, direction: Direction): Promise<ConnectableEntity | null>;
1901
- collectFanNodes(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
1902
- collectTopNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1903
- collectBottomNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1904
- collectLeftNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1905
- collectRightNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1915
+ addEffect(selectedNodeRect: Rectangle | { _: "Rectangle" | string }, newSelectNodeRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1916
+ getMostNearConnectableEntity(nodes: ConnectableEntity[], location: Vector | { _: "Vector" | string }): Promise<ConnectableEntity | null>;
1917
+ selectMostNearLocationNode(location: Vector | { _: "Vector" | string }): Promise<ConnectableEntity | null>;
1918
+ collectNodesInStrip(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
1919
+ getMostNearInStripByDh(nodes: ConnectableEntity[], nodeRect: Rectangle | { _: "Rectangle" | string }, direction: Direction): Promise<ConnectableEntity | null>;
1920
+ collectFanNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
1921
+ collectTopNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1922
+ collectBottomNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1923
+ collectLeftNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1924
+ collectRightNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1906
1925
  }
1907
1926
 
1908
1927
  declare namespace Serialized {
@@ -1924,7 +1943,7 @@ declare type TextNode = Entity & {
1924
1943
  color: Color;
1925
1944
  sizeAdjust: TextNodeSizeAdjust;
1926
1945
  };
1927
- function isTextNode(obj: StageObject): obj is TextNode;
1946
+ function isTextNode(obj: StageObject | { _: "StageObject" | string }): obj is TextNode;
1928
1947
  declare type Section = Entity & {
1929
1948
  type: "core:section";
1930
1949
  size: Vector;
@@ -1935,18 +1954,18 @@ declare type Section = Entity & {
1935
1954
  isHidden: boolean;
1936
1955
  isCollapsed: boolean;
1937
1956
  };
1938
- function isSection(obj: StageObject): obj is Section;
1957
+ function isSection(obj: StageObject | { _: "StageObject" | string }): obj is Section;
1939
1958
  declare type ConnectPoint = Entity & {
1940
1959
  type: "core:connect_point";
1941
1960
  };
1942
- function isConnectPoint(obj: StageObject): obj is ConnectPoint;
1961
+ function isConnectPoint(obj: StageObject | { _: "StageObject" | string }): obj is ConnectPoint;
1943
1962
  declare type ImageNode = Entity & {
1944
1963
  path: string;
1945
1964
  size: Vector;
1946
1965
  scale: number;
1947
1966
  type: "core:image_node";
1948
1967
  };
1949
- function isImageNode(obj: StageObject): obj is ImageNode;
1968
+ function isImageNode(obj: StageObject | { _: "StageObject" | string }): obj is ImageNode;
1950
1969
  declare type UrlNode = Entity & {
1951
1970
  url: string;
1952
1971
  title: string;
@@ -1954,7 +1973,7 @@ declare type UrlNode = Entity & {
1954
1973
  color: Color;
1955
1974
  type: "core:url_node";
1956
1975
  };
1957
- function isUrlNode(obj: StageObject): obj is UrlNode;
1976
+ function isUrlNode(obj: StageObject | { _: "StageObject" | string }): obj is UrlNode;
1958
1977
  declare type PortalNode = Entity & {
1959
1978
  // 连接的文件
1960
1979
  portalFilePath: string;
@@ -1968,13 +1987,13 @@ declare type PortalNode = Entity & {
1968
1987
  color: Color;
1969
1988
  type: "core:portal_node";
1970
1989
  };
1971
- function isPortalNode(obj: StageObject): obj is PortalNode;
1990
+ function isPortalNode(obj: StageObject | { _: "StageObject" | string }): obj is PortalNode;
1972
1991
  declare type PenStroke = Entity & {
1973
1992
  type: "core:pen_stroke";
1974
1993
  content: string;
1975
1994
  color: Color;
1976
1995
  };
1977
- function isPenStroke(obj: StageObject): obj is PenStroke;
1996
+ function isPenStroke(obj: StageObject | { _: "StageObject" | string }): obj is PenStroke;
1978
1997
  declare type SvgNode = Entity & {
1979
1998
  type: "core:svg_node";
1980
1999
  content: string;
@@ -1982,7 +2001,7 @@ declare type SvgNode = Entity & {
1982
2001
  color: Color;
1983
2002
  scale: number;
1984
2003
  };
1985
- function isSvgNode(obj: StageObject): obj is SvgNode;
2004
+ function isSvgNode(obj: StageObject | { _: "StageObject" | string }): obj is SvgNode;
1986
2005
  declare type Association = StageObject & {
1987
2006
  text: string;
1988
2007
  color: Color;
@@ -1998,21 +2017,21 @@ declare type MultiTargetUndirectedEdge = Association & {
1998
2017
  padding: number;
1999
2018
  renderType: MultiTargetUndirectedEdgeRenderType;
2000
2019
  };
2001
- function isMultiTargetUndirectedEdge(obj: StageObject): obj is MultiTargetUndirectedEdge;
2020
+ function isMultiTargetUndirectedEdge(obj: StageObject | { _: "StageObject" | string }): obj is MultiTargetUndirectedEdge;
2002
2021
  declare type Edge = Association & {
2003
2022
  source: string;
2004
2023
  target: string;
2005
2024
  sourceRectRate: [number, number]; // 默认中心 0.5, 0.5
2006
2025
  targetRectRate: [number, number]; // 默认中心 0.5, 0.5
2007
2026
  };
2008
- function isEdge(obj: StageObject): obj is Edge;
2027
+ function isEdge(obj: StageObject | { _: "StageObject" | string }): obj is Edge;
2009
2028
  declare type LineEdge = Edge & {
2010
2029
  type: "core:line_edge";
2011
2030
  color: Color;
2012
2031
  text: string;
2013
2032
  };
2014
- function isLineEdge(obj: StageObject): obj is LineEdge;
2015
- function isCubicCatmullRomSplineEdge(obj: StageObject): obj is CubicCatmullRomSplineEdge;
2033
+ function isLineEdge(obj: StageObject | { _: "StageObject" | string }): obj is LineEdge;
2034
+ function isCubicCatmullRomSplineEdge(obj: StageObject | { _: "StageObject" | string }): obj is CubicCatmullRomSplineEdge;
2016
2035
  declare type CubicCatmullRomSplineEdge = Edge & {
2017
2036
  type: "core:cublic_catmull_rom_spline_edge";
2018
2037
  text: string;
@@ -2021,7 +2040,7 @@ declare type CubicCatmullRomSplineEdge = Edge & {
2021
2040
  tension: number;
2022
2041
  };
2023
2042
  declare type CoreEntity = TextNode | Section | ConnectPoint | ImageNode | UrlNode | PenStroke | PortalNode | SvgNode;
2024
- function isCoreEntity(obj: StageObject): obj is CoreEntity;
2043
+ function isCoreEntity(obj: StageObject | { _: "StageObject" | string }): obj is CoreEntity;
2025
2044
  declare type CoreAssociation = LineEdge | CubicCatmullRomSplineEdge | MultiTargetUndirectedEdge;
2026
2045
  declare type File = {
2027
2046
  version: typeof Project.latestVersion;
@@ -2039,19 +2058,19 @@ declare interface Service {
2039
2058
  declare type Settings = z.infer<typeof settingsSchema>;
2040
2059
 
2041
2060
  declare class ShapeRenderer {
2042
- constructor(project: Project);
2043
- renderCircle(centerLocation: Vector, radius: number, color: Color, strokeColor: Color, strokeWidth: number): void;
2044
- renderArc(centerLocation: Vector, radius: number, angle1: number, angle2: number, strokeColor: Color, strokeWidth: number): void;
2045
- renderRectFromCenter(centerLocation: Vector, width: number, height: number, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0): void;
2046
- renderRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0): Promise<void>;
2047
- renderDashedRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0, dashLength = 5): Promise<void>;
2048
- renderRectWithShadow(rect: Rectangle, fillColor: Color, strokeColor: Color, strokeWidth: number, shadowColor: Color, shadowBlur: number, shadowOffsetX: number = 0, shadowOffsetY: number = 0, radius: number = 0): Promise<void>;
2049
- renderPolygonAndFill(points: Vector[], fillColor: Color, strokeColor: Color, strokeWidth: number, lineJoin: "round" | "bevel" = "round"): void;
2050
- renderTriangleFromCenter(centerLocation: Vector, size: number, rotation: number, fillColor: Color, strokeColor: Color, strokeWidth: number): void;
2051
- renderSquareFromCenter(centerLocation: Vector, size: number, rotation: number, fillColor: Color, strokeColor: Color, strokeWidth: number): void;
2052
- renderCircleTransition(viewLocation: Vector, radius: number, centerColor: Color): Promise<void>;
2053
- renderCameraShapeBorder(rect: Rectangle, borderColor: Color, borderWidth: number): Promise<void>;
2054
- renderResizeArrow(rect: Rectangle, color: Color, strokeWidth: number): Promise<void>;
2061
+ constructor(project: Project | { _: "Project" | string });
2062
+ renderCircle(centerLocation: Vector | { _: "Vector" | string }, radius: number, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2063
+ renderArc(centerLocation: Vector | { _: "Vector" | string }, radius: number, angle1: number, angle2: number, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2064
+ renderRectFromCenter(centerLocation: Vector | { _: "Vector" | string }, width: number, height: number, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, radius: number = 0): void;
2065
+ renderRect(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, radius: number = 0): Promise<void>;
2066
+ renderDashedRect(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, radius: number = 0, dashLength = 5): Promise<void>;
2067
+ renderRectWithShadow(rect: Rectangle | { _: "Rectangle" | string }, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, shadowColor: Color | { _: "Color" | string }, shadowBlur: number, shadowOffsetX: number = 0, shadowOffsetY: number = 0, radius: number = 0): Promise<void>;
2068
+ renderPolygonAndFill(points: Vector[], fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, lineJoin: "round" | "bevel" = "round"): void;
2069
+ renderTriangleFromCenter(centerLocation: Vector | { _: "Vector" | string }, size: number, rotation: number, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2070
+ renderSquareFromCenter(centerLocation: Vector | { _: "Vector" | string }, size: number, rotation: number, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2071
+ renderCircleTransition(viewLocation: Vector | { _: "Vector" | string }, radius: number, centerColor: Color | { _: "Color" | string }): Promise<void>;
2072
+ renderCameraShapeBorder(rect: Rectangle | { _: "Rectangle" | string }, borderColor: Color | { _: "Color" | string }, borderWidth: number): Promise<void>;
2073
+ renderResizeArrow(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }, strokeWidth: number): Promise<void>;
2055
2074
  }
2056
2075
 
2057
2076
  declare class StageExport {
@@ -2059,36 +2078,36 @@ declare class StageExport {
2059
2078
  markdownExporter: Promise<MarkdownExporter>;
2060
2079
  tabExporter: Promise<TabExporter>;
2061
2080
  mermaidExporter: Promise<MermaidExporter>;
2062
- constructor(project: Project);
2081
+ constructor(project: Project | { _: "Project" | string });
2063
2082
  getPlainTextByEntities(nodes: Entity[]): Promise<void>;
2064
- getMarkdownStringByTextNode(textNode: TextNode): Promise<void>;
2065
- getTabStringByTextNode(textNode: TextNode): Promise<void>;
2083
+ getMarkdownStringByTextNode(textNode: TextNode | { _: "TextNode" | string }): Promise<void>;
2084
+ getTabStringByTextNode(textNode: TextNode | { _: "TextNode" | string }): Promise<void>;
2066
2085
  getMermaidTextByEntities(entities: Entity[]): Promise<string>;
2067
2086
  }
2068
2087
 
2069
2088
  declare class StageExportPng {
2070
- constructor(project: Project);
2089
+ constructor(project: Project | { _: "Project" | string });
2071
2090
  exportStage_(emitter: EventEmitter<EventMap>, signal: AbortSignal, sleepTime: number): Promise<void>;
2072
2091
  exportStage(signal: AbortSignal, sleepTime: number = 2): Promise<void>;
2073
2092
  generateCanvasNode(): Promise<HTMLCanvasElement>;
2074
2093
  }
2075
2094
 
2076
2095
  declare class StageExportSvg {
2077
- constructor(project: Project);
2096
+ constructor(project: Project | { _: "Project" | string });
2078
2097
  svgConfig: Promise<SvgExportConfig>;
2079
2098
  exportContext: Promise<{
2080
2099
  outputDir: string;
2081
2100
  imageMap: Map<string, string>; // attachmentId -> relative file path
2082
2101
  } | null>;
2083
2102
  setConfig(config: SvgExportConfig): Promise<void>;
2084
- dumpNode(node: TextNode): Promise<void>;
2085
- dumpSection(section: Section): Promise<void>;
2086
- dumpSectionBase(section: Section): Promise<void>;
2087
- dumpEdge(edge: LineEdge): Promise<React.ReactNode>;
2088
- dumpEntityDetails(entity: Entity): Promise<React.ReactNode>;
2089
- getEntityDetailsDataAttribute(entity: Entity): Promise<string | undefined>;
2090
- dumpUrlNode(node: UrlNode): Promise<void>;
2091
- dumpImageNode(node: ImageNode, svgConfigObject: SvgExportConfig): Promise<void>;
2103
+ dumpNode(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2104
+ dumpSection(section: Section | { _: "Section" | string }): Promise<void>;
2105
+ dumpSectionBase(section: Section | { _: "Section" | string }): Promise<void>;
2106
+ dumpEdge(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2107
+ dumpEntityDetails(entity: Entity | { _: "Entity" | string }): Promise<React.ReactNode>;
2108
+ getEntityDetailsDataAttribute(entity: Entity | { _: "Entity" | string }): Promise<string | undefined>;
2109
+ dumpUrlNode(node: UrlNode | { _: "UrlNode" | string }): Promise<void>;
2110
+ dumpImageNode(node: ImageNode | { _: "ImageNode" | string }, svgConfigObject: SvgExportConfig): Promise<void>;
2092
2111
  getEntitiesOuterRectangle(entities: Entity[], padding: number): Promise<Rectangle>;
2093
2112
  dumpSelected(): Promise<React.ReactNode>;
2094
2113
  dumpStage(): Promise<React.ReactNode>;
@@ -2103,16 +2122,16 @@ declare class StageImport {
2103
2122
  treeImporter: Promise<TreeImporter>;
2104
2123
  mermaidImporter: Promise<MermaidImporter>;
2105
2124
  markdownImporter: Promise<MarkdownImporter>;
2106
- constructor(project: Project);
2107
- addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero()): Promise<void>;
2108
- addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero()): Promise<void>;
2125
+ constructor(project: Project | { _: "Project" | string });
2126
+ addNodeGraphByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): Promise<void>;
2127
+ addNodeTreeByText(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): Promise<void>;
2109
2128
  addNodeTreeByTextFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
2110
- addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero()): Promise<void>;
2111
- addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true): Promise<void>;
2129
+ addNodeMermaidByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): Promise<void>;
2130
+ addNodeByMarkdown(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): Promise<void>;
2112
2131
  }
2113
2132
 
2114
2133
  declare class StageManager {
2115
- constructor(project: Project);
2134
+ constructor(project: Project | { _: "Project" | string });
2116
2135
  get(uuid: string): Promise<void>;
2117
2136
  isEmpty(): Promise<boolean>;
2118
2137
  getTextNodes(): Promise<TextNode>[];
@@ -2129,12 +2148,12 @@ declare class StageManager {
2129
2148
  getEntities(): Promise<Entity>[];
2130
2149
  getEntitiesByUUIDs(uuids: string[]): Promise<Entity>[];
2131
2150
  isNoEntity(): Promise<boolean>;
2132
- delete(stageObject: StageObject): Promise<void>;
2151
+ delete(stageObject: StageObject | { _: "StageObject" | string }): Promise<void>;
2133
2152
  getAssociations(): Promise<Association>[];
2134
2153
  getEdges(): Promise<Edge>[];
2135
2154
  getLineEdges(): Promise<LineEdge>[];
2136
2155
  getCrEdges(): Promise<CubicCatmullRomSplineEdge>[];
2137
- add(stageObject: StageObject): Promise<void>;
2156
+ add(stageObject: StageObject | { _: "StageObject" | string }): Promise<void>;
2138
2157
  updateReferences(): Promise<void>;
2139
2158
  getTextNodeByUUID(uuid: string): Promise<TextNode | null>;
2140
2159
  getConnectableEntityByUUID(uuid: string): Promise<ConnectableEntity | null>;
@@ -2143,29 +2162,29 @@ declare class StageManager {
2143
2162
  getCenter(): Promise<Vector>;
2144
2163
  getSize(): Promise<Vector>;
2145
2164
  getBoundingRectangle(): Promise<Rectangle>;
2146
- findTextNodeByLocation(location: Vector): Promise<TextNode | null>;
2147
- findLineEdgeByLocation(location: Vector): Promise<LineEdge | null>;
2148
- findAssociationByLocation(location: Vector): Promise<Association | null>;
2149
- findSectionByLocation(location: Vector): Promise<Section | null>;
2150
- findImageNodeByLocation(location: Vector): Promise<ImageNode | null>;
2151
- findConnectableEntityByLocation(location: Vector): Promise<ConnectableEntity | null>;
2152
- findEntityByLocation(location: Vector): Promise<Entity | null>;
2153
- findConnectPointByLocation(location: Vector): Promise<ConnectPoint | null>;
2165
+ findTextNodeByLocation(location: Vector | { _: "Vector" | string }): Promise<TextNode | null>;
2166
+ findLineEdgeByLocation(location: Vector | { _: "Vector" | string }): Promise<LineEdge | null>;
2167
+ findAssociationByLocation(location: Vector | { _: "Vector" | string }): Promise<Association | null>;
2168
+ findSectionByLocation(location: Vector | { _: "Vector" | string }): Promise<Section | null>;
2169
+ findImageNodeByLocation(location: Vector | { _: "Vector" | string }): Promise<ImageNode | null>;
2170
+ findConnectableEntityByLocation(location: Vector | { _: "Vector" | string }): Promise<ConnectableEntity | null>;
2171
+ findEntityByLocation(location: Vector | { _: "Vector" | string }): Promise<Entity | null>;
2172
+ findConnectPointByLocation(location: Vector | { _: "Vector" | string }): Promise<ConnectPoint | null>;
2154
2173
  isHaveEntitySelected(): Promise<boolean>;
2155
2174
  getSelectedEntities(): Promise<Entity>[];
2156
2175
  getSelectedAssociations(): Promise<Association>[];
2157
2176
  getSelectedStageObjects(): Promise<StageObject>[];
2158
2177
  getBoundingBoxOfSelected(): Promise<Rectangle>;
2159
- isEntityOnLocation(location: Vector): Promise<boolean>;
2160
- isAssociationOnLocation(location: Vector): Promise<boolean>;
2178
+ isEntityOnLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
2179
+ isAssociationOnLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
2161
2180
  deleteEntities(deleteNodes: Entity[]): Promise<void>;
2162
2181
  deleteSelectedStageObjects(): Promise<void>;
2163
2182
  deleteAssociation(deleteAssociation: Association): Promise<boolean>;
2164
2183
  deleteEdge(deleteEdge: Edge): Promise<boolean>;
2165
2184
  w;
2166
- connectEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, isCrEdge: boolean = false): Promise<void>;
2167
- connectMultipleEntities(fromNodes: ConnectableEntity[], toNode: ConnectableEntity, isCrEdge: boolean = false, sourceRectRate?: [number, number], targetRectRate?: [number, number]): Promise<void>;
2168
- reverseNodeEdges(connectEntity: ConnectableEntity): Promise<void>;
2185
+ connectEntity(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, isCrEdge: boolean = false): Promise<void>;
2186
+ connectMultipleEntities(fromNodes: ConnectableEntity[], toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, isCrEdge: boolean = false, sourceRectRate?: [number, number], targetRectRate?: [number, number]): Promise<void>;
2187
+ reverseNodeEdges(connectEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
2169
2188
  reverseSelectedNodeEdge(): Promise<void>;
2170
2189
  reverseSelectedEdges(): Promise<void>;
2171
2190
  generateNodeTreeByText(text: string, indention: number = 4, location = this.project.camera.location): Promise<void>;
@@ -2174,12 +2193,12 @@ declare class StageManager {
2174
2193
  generateNodeByMarkdown(text: string, location = this.project.camera.location, autoLayout = true): Promise<void>;
2175
2194
  packEntityToSection(addEntities: Entity[]): Promise<void>;
2176
2195
  packEntityToSectionBySelected(): Promise<void>;
2177
- goInSection(entities: Entity[], section: Section): Promise<void>;
2178
- goOutSection(entities: Entity[], section: Section): Promise<void>;
2196
+ goInSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
2197
+ goOutSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
2179
2198
  packSelectedSection(): Promise<void>;
2180
2199
  unpackSelectedSection(): Promise<void>;
2181
2200
  sectionSwitchCollapse(): Promise<void>;
2182
- connectEntityByCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity): Promise<void>;
2201
+ connectEntityByCrEdge(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
2183
2202
  refreshAllStageObjects(): Promise<void>;
2184
2203
  refreshSelected(): Promise<void>;
2185
2204
  changeSelectedEdgeConnectLocation(direction: Direction | null, isSource: boolean = false): Promise<void>;
@@ -2196,9 +2215,9 @@ declare class StageManager {
2196
2215
  }
2197
2216
 
2198
2217
  declare class StageNodeRotate {
2199
- constructor(project: Project);
2200
- moveEdges(lastMoveLocation: Vector, diffLocation: Vector): Promise<void>;
2201
- rotateNodeDfs(rotateCenterNode: ConnectableEntity, currentNode: ConnectableEntity, degrees: number, visitedUUIDs: string[]): void;
2218
+ constructor(project: Project | { _: "Project" | string });
2219
+ moveEdges(lastMoveLocation: Vector | { _: "Vector" | string }, diffLocation: Vector | { _: "Vector" | string }): Promise<void>;
2220
+ rotateNodeDfs(rotateCenterNode: ConnectableEntity | { _: "ConnectableEntity" | string }, currentNode: ConnectableEntity | { _: "ConnectableEntity" | string }, degrees: number, visitedUUIDs: string[]): void;
2202
2221
  }
2203
2222
 
2204
2223
  declare class StageObject {
@@ -2213,14 +2232,14 @@ declare class StageObject {
2213
2232
  }
2214
2233
 
2215
2234
  declare class StageObjectColorManager {
2216
- constructor(project: Project);
2217
- setSelectedStageObjectColor(color: Color): Promise<void>;
2235
+ constructor(project: Project | { _: "Project" | string });
2236
+ setSelectedStageObjectColor(color: Color | { _: "Color" | string }): Promise<void>;
2218
2237
  darkenNodeColor(): Promise<void>;
2219
2238
  lightenNodeColor(): Promise<void>;
2220
2239
  }
2221
2240
 
2222
2241
  declare class StageObjectSelectCounter {
2223
- constructor(project: Project);
2242
+ constructor(project: Project | { _: "Project" | string });
2224
2243
  selectedStageObjectCount;
2225
2244
  selectedEntityCount;
2226
2245
  selectedAssociationCount;
@@ -2240,39 +2259,39 @@ declare class StageStyleManager {
2240
2259
  }
2241
2260
 
2242
2261
  declare class StageSyncAssociationManager {
2243
- constructor(project: Project);
2262
+ constructor(project: Project | { _: "Project" | string });
2244
2263
  createTwinsFromSelectedEntities(): void;
2245
2264
  getSyncAssociations(): Promise<SyncAssociation>[];
2246
- getSyncAssociationsByMember(member: StageObject): Promise<SyncAssociation>[];
2247
- getSyncSiblings(member: StageObject): Promise<StageObject>[];
2248
- createTwinTextNode(source: TextNode): Promise<TextNode>;
2249
- syncFrom(source: StageObject, key: SyncableKey, syncingSet: Set<string> = new Set()): void;
2250
- onStageObjectDeleted(deleted: StageObject): void;
2265
+ getSyncAssociationsByMember(member: StageObject | { _: "StageObject" | string }): Promise<SyncAssociation>[];
2266
+ getSyncSiblings(member: StageObject | { _: "StageObject" | string }): Promise<StageObject>[];
2267
+ createTwinTextNode(source: TextNode | { _: "TextNode" | string }): Promise<TextNode>;
2268
+ syncFrom(source: StageObject | { _: "StageObject" | string }, key: SyncableKey, syncingSet: Set<string> = new Set()): void;
2269
+ onStageObjectDeleted(deleted: StageObject | { _: "StageObject" | string }): void;
2251
2270
  }
2252
2271
 
2253
2272
  declare class StageUtils {
2254
- constructor(project: Project);
2273
+ constructor(project: Project | { _: "Project" | string });
2255
2274
  replaceAutoNameWithoutStage(template: string): Promise<string>;
2256
- replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject): Promise<string>;
2275
+ replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject | { _: "StageObject" | string }): Promise<string>;
2257
2276
  isNameConflictWithTextNodes(name: string): Promise<boolean>;
2258
2277
  isNameConflictWithSections(name: string): Promise<boolean>;
2259
2278
  }
2260
2279
 
2261
2280
  declare class StraightEdgeRenderer extends EdgeRendererClass {
2262
- constructor(project: Project);
2263
- getCuttingEffects(edge: LineEdge): Promise<Effect>[];
2264
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
2265
- renderLine(start: Vector, end: Vector, edge: LineEdge, width: number): void;
2266
- renderNormalState(edge: LineEdge): void;
2267
- getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
2281
+ constructor(project: Project | { _: "Project" | string });
2282
+ getCuttingEffects(edge: LineEdge | { _: "LineEdge" | string }): Promise<Effect>[];
2283
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
2284
+ renderLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, edge: LineEdge | { _: "LineEdge" | string }, width: number): void;
2285
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
2286
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2268
2287
  getCycleStageSvg(): Promise<React.ReactNode>;
2269
2288
  getShiftingStageSvg(): Promise<React.ReactNode>;
2270
- renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone(), size = 15): Promise<void>;
2271
- shouldRenderTargetArrow(edge: LineEdge): Promise<boolean>;
2272
- renderShiftingState(edge: LineEdge): void;
2273
- renderCycleState(edge: LineEdge): void;
2274
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
2275
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
2289
+ renderArrowHead(edge: LineEdge | { _: "LineEdge" | string }, direction: Vector | { _: "Vector" | string }, endPoint = edge.bodyLine.end.clone(), size = 15): Promise<void>;
2290
+ shouldRenderTargetArrow(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
2291
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
2292
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
2293
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
2294
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
2276
2295
  }
2277
2296
 
2278
2297
  declare class SvgNode extends ConnectableEntity implements ResizeAble {
@@ -2284,7 +2303,7 @@ declare class SvgNode extends ConnectableEntity implements ResizeAble {
2284
2303
  isHiddenBySectionCollapse: Promise<boolean>;
2285
2304
  originalSize: Promise<Vector>;
2286
2305
  image: Promise<HTMLImageElement>;
2287
- constructor(project: Project, {
2306
+ constructor(project: Project | { _: "Project" | string }, {
2288
2307
  uuid = crypto.randomUUID(),
2289
2308
  details = [],
2290
2309
  attachmentId = "",
@@ -2294,42 +2313,42 @@ declare class SvgNode extends ConnectableEntity implements ResizeAble {
2294
2313
  });
2295
2314
  get geometryCenter(): Promise<Vector>;
2296
2315
  scaleUpdate(scaleDiff: number): Promise<void>;
2297
- move(delta: Vector): void;
2298
- moveTo(location: Vector): void;
2299
- changeColor(newColor: Color, mode: "fill" | "stroke" = "fill"): Promise<void>;
2300
- resizeHandle(delta: Vector): Promise<void>;
2316
+ move(delta: Vector | { _: "Vector" | string }): void;
2317
+ moveTo(location: Vector | { _: "Vector" | string }): void;
2318
+ changeColor(newColor: Color | { _: "Color" | string }, mode: "fill" | "stroke" = "fill"): Promise<void>;
2319
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
2301
2320
  getResizeHandleRect(): Promise<Rectangle>;
2302
2321
  }
2303
2322
 
2304
2323
  declare class SvgNodeRenderer {
2305
- constructor(project: Project);
2306
- render(svgNode: SvgNode): Promise<void>;
2324
+ constructor(project: Project | { _: "Project" | string });
2325
+ render(svgNode: SvgNode | { _: "SvgNode" | string }): Promise<void>;
2307
2326
  }
2308
2327
 
2309
2328
  declare class SvgRenderer {
2310
2329
  svgCache: Promise<{ [key: string]: HTMLImageElement }>;
2311
- constructor(project: Project);
2312
- renderSvgFromLeftTop(svg: string, location: Vector, width: number, height: number): void;
2313
- renderSvgFromCenter(svg: string, centerLocation: Vector, width: number, height: number): void;
2314
- renderSvgFromLeftTopWithoutSize(svg: string, location: Vector, scaleNumber = 1): void;
2315
- renderSvgFromCenterWithoutSize(svg: string, centerLocation: Vector): void;
2330
+ constructor(project: Project | { _: "Project" | string });
2331
+ renderSvgFromLeftTop(svg: string, location: Vector | { _: "Vector" | string }, width: number, height: number): void;
2332
+ renderSvgFromCenter(svg: string, centerLocation: Vector | { _: "Vector" | string }, width: number, height: number): void;
2333
+ renderSvgFromLeftTopWithoutSize(svg: string, location: Vector | { _: "Vector" | string }, scaleNumber = 1): void;
2334
+ renderSvgFromCenterWithoutSize(svg: string, centerLocation: Vector | { _: "Vector" | string }): void;
2316
2335
  }
2317
2336
 
2318
2337
  declare class SymmetryCurveEdgeRenderer extends EdgeRendererClass {
2319
- constructor(project: Project);
2320
- shouldRenderTargetArrow(edge: LineEdge): Promise<boolean>;
2321
- getCuttingEffects(edge: LineEdge): Promise<Effect>[];
2322
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
2323
- renderNormalState(edge: LineEdge): void;
2324
- renderShiftingState(edge: LineEdge): void;
2325
- renderCycleState(edge: LineEdge): void;
2326
- getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
2338
+ constructor(project: Project | { _: "Project" | string });
2339
+ shouldRenderTargetArrow(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
2340
+ getCuttingEffects(edge: LineEdge | { _: "LineEdge" | string }): Promise<Effect>[];
2341
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
2342
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
2343
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
2344
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
2345
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2327
2346
  getCycleStageSvg(): Promise<React.ReactNode>;
2328
2347
  getShiftingStageSvg(): Promise<React.ReactNode>;
2329
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
2330
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
2331
- renderArrowCurve(curve: SymmetryCurve, color: Color, width = 2, edge?: LineEdge): void;
2332
- renderText(curve: SymmetryCurve, edge: LineEdge): void;
2348
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
2349
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
2350
+ renderArrowCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width = 2, edge?: LineEdge | { _: "LineEdge" | string }): void;
2351
+ renderText(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, edge: LineEdge | { _: "LineEdge" | string }): void;
2333
2352
  }
2334
2353
 
2335
2354
  declare type SyncableKey = "text" | "color" | "details";
@@ -2343,7 +2362,7 @@ declare class SyncAssociation extends Association {
2343
2362
  _isSelected: Promise<boolean>;
2344
2363
  get isSelected(): Promise<boolean>;
2345
2364
  set isSelected(value: boolean);
2346
- constructor(project: Project, {
2365
+ constructor(project: Project | { _: "Project" | string }, {
2347
2366
  uuid = crypto.randomUUID() as string,
2348
2367
  keys = ["text", "color", "details"] as SyncableKey[],
2349
2368
  associationList = [] as StageObject[],
@@ -2354,7 +2373,7 @@ declare class SyncAssociation extends Association {
2354
2373
  associationList?: StageObject[];
2355
2374
  color?: Color;
2356
2375
  }, unknown = false);
2357
- applyFrom(source: StageObject): void;
2376
+ applyFrom(source: StageObject | { _: "StageObject" | string }): void;
2358
2377
  }
2359
2378
 
2360
2379
  declare class Tab extends React.Component<Record<string, never>, Record<string, never>> {
@@ -2385,12 +2404,12 @@ declare class Tab extends React.Component<Record<string, never>, Record<string,
2385
2404
  }
2386
2405
 
2387
2406
  declare class TabExporter extends BaseExporter {
2388
- export(textNode: TextNode): Promise<string>;
2389
- getTabText(node: TextNode, level: number): Promise<string>;
2407
+ export(textNode: TextNode | { _: "TextNode" | string }): Promise<string>;
2408
+ getTabText(node: TextNode | { _: "TextNode" | string }, level: number): Promise<string>;
2390
2409
  }
2391
2410
 
2392
2411
  declare class TagManager {
2393
- constructor(project: Project);
2412
+ constructor(project: Project | { _: "Project" | string });
2394
2413
  tagSet: Promise<Set<string>>;
2395
2414
  reset(uuids: string[]): Promise<void>;
2396
2415
  addTag(uuid: string): Promise<void>;
@@ -2422,7 +2441,7 @@ declare class TextNode extends ConnectableEntity implements ResizeAble {
2422
2441
  get isEditing(): Promise<any>;
2423
2442
  set isEditing(value: boolean);
2424
2443
  isHiddenBySectionCollapse;
2425
- constructor(project: Project, {
2444
+ constructor(project: Project | { _: "Project" | string }, {
2426
2445
  uuid = crypto.randomUUID() as string,
2427
2446
  text = "",
2428
2447
  details = [],
@@ -2446,47 +2465,47 @@ declare class TextNode extends ConnectableEntity implements ResizeAble {
2446
2465
  getBorderRadius(): Promise<number>;
2447
2466
  updateFontSizeCache(): void;
2448
2467
  setFontScaleLevel(level: number): Promise<void>;
2449
- increaseFontSize(anchorRate?: Vector): void;
2450
- decreaseFontSize(anchorRate?: Vector): void;
2451
- _adjustLocationToKeepAnchor(oldRect: Rectangle, anchorRate: Vector): void;
2468
+ increaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
2469
+ decreaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
2470
+ _adjustLocationToKeepAnchor(oldRect: Rectangle | { _: "Rectangle" | string }, anchorRate: Vector | { _: "Vector" | string }): void;
2452
2471
  adjustSizeByText(): Promise<void>;
2453
2472
  adjustHeightByText(): Promise<void>;
2454
2473
  forceAdjustSizeByText(): Promise<void>;
2455
2474
  rename(text: string): Promise<void>;
2456
- resizeHandle(delta: Vector): Promise<void>;
2475
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
2457
2476
  resizeWidthTo(width: number): Promise<void>;
2458
2477
  getResizeHandleRect(): Promise<Rectangle>;
2459
- move(delta: Vector): Promise<void>;
2478
+ move(delta: Vector | { _: "Vector" | string }): Promise<void>;
2460
2479
  collideWithOtherEntity(other: Entity): void;
2461
- moveTo(location: Vector): Promise<void>;
2480
+ moveTo(location: Vector | { _: "Vector" | string }): Promise<void>;
2462
2481
  }
2463
2482
 
2464
2483
  declare class TextNodeRenderer {
2465
- constructor(project: Project);
2466
- renderTextNode(node: TextNode): Promise<void>;
2467
- renderKeyboardTreeHint(node: TextNode): void;
2468
- renderLogicNodeWarningTrap(node: TextNode): Promise<void>;
2469
- renderTextNodeTextLayer(node: TextNode): Promise<void>;
2484
+ constructor(project: Project | { _: "Project" | string });
2485
+ renderTextNode(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2486
+ renderKeyboardTreeHint(node: TextNode | { _: "TextNode" | string }): void;
2487
+ renderLogicNodeWarningTrap(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2488
+ renderTextNodeTextLayer(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2470
2489
  }
2471
2490
 
2472
2491
  declare class TextRenderer {
2473
2492
  cache;
2474
- constructor(project: Project);
2493
+ constructor(project: Project | { _: "Project" | string });
2475
2494
  hash(text: string, size: number): Promise<string>;
2476
2495
  getCache(text: string, size: number): Promise<void>;
2477
2496
  getCacheNearestSize(text: string, size: number): Promise<ImageBitmap | undefined>;
2478
- buildCache(text: string, size: number, color: Color): Promise<CanvasImageSource>;
2479
- renderText(text: string, location: Vector, size: number, color: Color = Color.White): void;
2480
- renderTempText(text: string, location: Vector, size: number, color: Color = Color.White): void;
2481
- renderTextFromCenter(text: string, centerLocation: Vector, size: number, color: Color = Color.White): void;
2482
- renderTempTextFromCenter(text: string, centerLocation: Vector, size: number, color: Color = Color.White): void;
2483
- renderTextInRectangle(text: string, rectangle: Rectangle, color: Color): void;
2484
- getFontSizeByRectangleSize(text: string, rectangle: Rectangle): Promise<Vector>;
2485
- renderMultiLineText(text: string, location: Vector, fontSize: number, limitWidth: number, color: Color = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2486
- renderTempMultiLineText(text: string, location: Vector, fontSize: number, limitWidth: number, color: Color = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2487
- renderMultiLineTextFromCenterWithStroke(text: string, centerLocation: Vector, size: number, fillColor: Color, strokeColor: Color, limitWidth: number = Infinity, lineHeight: number = 1.2): void;
2488
- renderMultiLineTextFromCenter(text: string, centerLocation: Vector, size: number, limitWidth: number, color: Color, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2489
- renderTempMultiLineTextFromCenter(text: string, centerLocation: Vector, size: number, limitWidth: number, color: Color, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2497
+ buildCache(text: string, size: number, color: Color | { _: "Color" | string }): Promise<CanvasImageSource>;
2498
+ renderText(text: string, location: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2499
+ renderTempText(text: string, location: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2500
+ renderTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2501
+ renderTempTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2502
+ renderTextInRectangle(text: string, rectangle: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }): void;
2503
+ getFontSizeByRectangleSize(text: string, rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Vector>;
2504
+ renderMultiLineText(text: string, location: Vector | { _: "Vector" | string }, fontSize: number, limitWidth: number, color: Color | { _: "Color" | string } = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2505
+ renderTempMultiLineText(text: string, location: Vector | { _: "Vector" | string }, fontSize: number, limitWidth: number, color: Color | { _: "Color" | string } = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2506
+ renderMultiLineTextFromCenterWithStroke(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, limitWidth: number = Infinity, lineHeight: number = 1.2): void;
2507
+ renderMultiLineTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, limitWidth: number, color: Color | { _: "Color" | string }, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2508
+ renderTempMultiLineTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, limitWidth: number, color: Color | { _: "Color" | string }, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2490
2509
  textArrayCache: Promise<LruCache<string, string[]>>;
2491
2510
  textToTextArrayWrapCache(text: string, fontSize: number, limitWidth: number): Promise<string>[];
2492
2511
  textToTextArray(text: string, fontSize: number, limitWidth: number): Promise<string>[];
@@ -2496,8 +2515,8 @@ declare class TextRenderer {
2496
2515
  declare const transformedKeys;
2497
2516
 
2498
2517
  declare class TreeImporter extends BaseImporter {
2499
- constructor(project: Project);
2500
- import(text: string, indention: number, diffLocation: Vector = Vector.getZero()): void;
2518
+ constructor(project: Project | { _: "Project" | string });
2519
+ import(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
2501
2520
  importFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
2502
2521
  getIndentLevel(line: string, indention: number): Promise<number>;
2503
2522
  }
@@ -2531,10 +2550,10 @@ declare class UrlNode extends ConnectableEntity {
2531
2550
  get titleRectangle(): Promise<Rectangle>;
2532
2551
  get urlRectangle(): Promise<Rectangle>;
2533
2552
  get rectangle(): Promise<Rectangle>;
2534
- move(delta: Vector): void;
2535
- moveTo(location: Vector): void;
2553
+ move(delta: Vector | { _: "Vector" | string }): void;
2554
+ moveTo(location: Vector | { _: "Vector" | string }): void;
2536
2555
  isHiddenBySectionCollapse: Promise<boolean>;
2537
- constructor(project: Project, {
2556
+ constructor(project: Project | { _: "Project" | string }, {
2538
2557
  uuid = crypto.randomUUID() as string,
2539
2558
  title = "",
2540
2559
  details = [],
@@ -2547,47 +2566,47 @@ declare class UrlNode extends ConnectableEntity {
2547
2566
  }
2548
2567
 
2549
2568
  declare class UrlNodeRenderer {
2550
- constructor(project: Project);
2551
- render(urlNode: UrlNode): void;
2552
- renderHoverState(urlNode: UrlNode): void;
2569
+ constructor(project: Project | { _: "Project" | string });
2570
+ render(urlNode: UrlNode | { _: "UrlNode" | string }): void;
2571
+ renderHoverState(urlNode: UrlNode | { _: "UrlNode" | string }): void;
2553
2572
  }
2554
2573
 
2555
2574
  declare class VerticalPolyEdgeRenderer extends EdgeRendererClass {
2556
- constructor(project: Project);
2557
- getCuttingEffects(edge: LineEdge): Promise<Effect>[];
2558
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
2559
- getVerticalDirection(edge: LineEdge): Promise<Vector>;
2575
+ constructor(project: Project | { _: "Project" | string });
2576
+ getCuttingEffects(edge: LineEdge | { _: "LineEdge" | string }): Promise<Effect>[];
2577
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
2578
+ getVerticalDirection(edge: LineEdge | { _: "LineEdge" | string }): Promise<Vector>;
2560
2579
  fixedLength: Promise<number>;
2561
- renderTest(edge: LineEdge): Promise<void>;
2580
+ renderTest(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
2562
2581
  gaussianFunction(x: number): Promise<void>;
2563
- renderNormalState(edge: LineEdge): void;
2564
- renderShiftingState(edge: LineEdge): void;
2565
- shouldRenderTargetArrow(edge: LineEdge): Promise<boolean>;
2566
- renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone()): Promise<void>;
2567
- renderCycleState(edge: LineEdge): void;
2568
- getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
2582
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
2583
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
2584
+ shouldRenderTargetArrow(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
2585
+ renderArrowHead(edge: LineEdge | { _: "LineEdge" | string }, direction: Vector | { _: "Vector" | string }, endPoint = edge.bodyLine.end.clone()): Promise<void>;
2586
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
2587
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2569
2588
  getCycleStageSvg(): Promise<React.ReactNode>;
2570
2589
  getShiftingStageSvg(): Promise<React.ReactNode>;
2571
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
2572
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
2590
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
2591
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
2573
2592
  }
2574
2593
 
2575
2594
  declare class WorldRenderUtils {
2576
- constructor(project: Project);
2577
- renderCubicCatmullRomSpline(spline: CubicCatmullRomSpline, color: Color, width: number): void;
2578
- renderBezierCurve(curve: CubicBezierCurve, color: Color, width: number): void;
2579
- renderSymmetryCurve(curve: SymmetryCurve, color: Color, width: number): void;
2580
- renderDashedSymmetryCurve(curve: SymmetryCurve, color: Color, width: number, dashLength: number): void;
2581
- renderDoubleSymmetryCurve(curve: SymmetryCurve, color: Color, width: number, gap: number): void;
2582
- renderLaser(start: Vector, end: Vector, width: number, color: Color): void;
2583
- renderPrismaticBlock(centerLocation: Vector, radius: number, color: Color, strokeColor: Color, strokeWidth: number): void;
2584
- renderRectangleFlash(rectangle: Rectangle, shadowColor: Color, shadowBlur: number, roundedRadius = 0): Promise<void>;
2585
- renderCuttingFlash(start: Vector, end: Vector, width: number, shadowColor: Color): void;
2595
+ constructor(project: Project | { _: "Project" | string });
2596
+ renderCubicCatmullRomSpline(spline: CubicCatmullRomSpline | { _: "CubicCatmullRomSpline" | string }, color: Color | { _: "Color" | string }, width: number): void;
2597
+ renderBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
2598
+ renderSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
2599
+ renderDashedSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number, dashLength: number): void;
2600
+ renderDoubleSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number, gap: number): void;
2601
+ renderLaser(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, width: number, color: Color | { _: "Color" | string }): void;
2602
+ renderPrismaticBlock(centerLocation: Vector | { _: "Vector" | string }, radius: number, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2603
+ renderRectangleFlash(rectangle: Rectangle | { _: "Rectangle" | string }, shadowColor: Color | { _: "Color" | string }, shadowBlur: number, roundedRadius = 0): Promise<void>;
2604
+ renderCuttingFlash(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, width: number, shadowColor: Color | { _: "Color" | string }): void;
2586
2605
  }
2587
2606
 
2588
2607
  // ── 扩展宿主 API ──
2589
2608
 
2590
- export declare function extensionHostApiFactory(extension: Extension): {
2609
+ export declare function extensionHostApiFactory(extension: Extension | { _: "Extension" | string }): {
2591
2610
  toast(message: string): Promise<void>;
2592
2611
  toast_success(message: string): Promise<void>;
2593
2612
  toast_error(message: string): Promise<void>;
@@ -2611,7 +2630,7 @@ export declare function extensionHostApiFactory(extension: Extension): {
2611
2630
  tabs_getAllProjects(): Promise<Promise<Project>[]>;
2612
2631
  tabs_getCurrent(): Promise<Promise<Tab | null>>;
2613
2632
  tabs_getCurrentProject(): Promise<Promise<Project | null>>;
2614
- entity_registerType(typeName: string, initialData: any, collisionBox: CollisionBox, renderFn: (data: any) => Promise<ImageBitmap>): Promise<void>;
2633
+ entity_registerType(typeName: string, initialData: any, collisionBox: CollisionBox | { _: "CollisionBox" | string }, renderFn: (data: any) => Promise<ImageBitmap>): Promise<void>;
2615
2634
  entity_onClick(typeName: string, handler: (payload: ClickEventPayload) => void): Promise<void>;
2616
2635
  entity_create(typeName: string, data: any, location: { x: number; y: number }): Promise<Promise<ExtensionEntity>>;
2617
2636
  };