extprg-types 1.0.4 → 1.0.5

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 +578 -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:48:06.531Z
6
+ * 2026-05-07T14:51:42.038Z
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 | { _: "Project" | string }): Promise<void>;
23
- createChatFetch(project: Project | { _: "Project" | string }): 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 | { _: "Project" | string });
34
+ constructor(project: Project | { _: "Project" | (string & {}) });
35
35
  getSelectionOuterRectangle(entities: Entity[]): Promise<Rectangle | null>;
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>;
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 | { _: "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>;
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 | { _: "Project" | string });
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 | { _: "Project" | string });
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 | { _: "TextNode" | string }): Promise<boolean>;
78
- isSectionLogic(section: Section | { _: "Section" | string }): 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 | { _: "TextNode" | string }): Promise<void>;
81
- computeSection(section: Section | { _: "Section" | string }): Promise<void>;
82
- computeEdge(edge: LineEdge | { _: "LineEdge" | string }): 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 | { _: "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>;
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 | { _: "TextNode" | string }, 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 | { _: "ConnectableEntity" | string }): 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 | { _: "Project" | string });
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 | { _: "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>[];
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 | { _: "ConnectableEntity" | string }, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false): Promise<void>;
125
- resolveSubtreeOverlaps(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, 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 | { _: "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>;
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 | { _: "Project" | string });
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 | { _: "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>;
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 | { _: "Rectangle" | string }, currentGap: number): Promise<IterableIterator<number>>;
164
- getLocationYIterator(viewRect: Rectangle | { _: "Rectangle" | string }, 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 | { _: "Project" | string });
169
- getTreeTypeString(textNode: TextNode | { _: "TextNode" | string }, nodeToStringFunc: (node: TextNode, level: number) => string): Promise<void>;
170
- getNodeChildrenArray(node: TextNode | { _: "TextNode" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }, 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 | { _: "Vector" | string }, viewLocation: Vector | { _: "Vector" | string }): 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 | { _: "Project" | string });
204
+ constructor(project: Project | { _: "Project" | (string & {}) });
205
205
  reset(): Promise<void>;
206
206
  resetBySelected(): Promise<void>;
207
- resetByRectangle(viewRectangle: Rectangle | { _: "Rectangle" | string }): 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 | { _: "Project" | string }, 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 | { _: "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>;
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 | { _: "Project" | string });
243
- render(collideBox: CollisionBox | { _: "CollisionBox" | string }, color: Color | { _: "Color" | string }): 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 | { _: "Project" | string });
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 | { _: "Project" | string }, {
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 | { _: "Vector" | string }): void;
284
- moveTo(location: Vector | { _: "Vector" | string }): 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 | { _: "Project" | string });
288
+ constructor(project: Project | { _: "Project" | (string & {}) });
289
289
  searchResultNodes: Promise<StageObject>[];
290
290
  isCaseSensitive;
291
291
  searchScope;
292
292
  currentSearchResultIndex;
293
- getStageObjectText(stageObject: StageObject | { _: "StageObject" | string }): Promise<string>;
293
+ getStageObjectText(stageObject: StageObject | { _: "StageObject" | (string & {}) }): Promise<string>;
294
294
  getSelectedObjectsBounds(): Promise<Rectangle | null>;
295
- isObjectInBounds(obj: StageObject | { _: "StageObject" | string }, bounds: Rectangle | { _: "Rectangle" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }): Promise<void>;
434
+ mouseUpFunction(mouseUpWindowLocation: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
435
435
  mouseup: Promise<(event: MouseEvent) => void>;
436
- mouseMoveOutWindowForcedShutdown(outsideLocation: Vector | { _: "Vector" | string }): 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 | { _: "Edge" | string }, selectAll = true): Promise<void>;
443
- editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, 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 | { _: "Vector" | string }): void;
457
+ mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector | { _: "Vector" | (string & {}) }): void;
458
458
  }
459
459
 
460
460
  declare class ControllerEntityCreateClass extends ControllerClass {
461
- constructor(project: Project | { _: "Project" | string });
461
+ constructor(project: Project | { _: "Project" | (string & {}) });
462
462
  mouseDoubleClick;
463
- createConnectPoint(pressLocation: Vector | { _: "Vector" | string }, 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 | { _: "Project" | string });
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 | { _: "Project" | string });
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 | { _: "Vector" | string }): 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 | { _: "ConnectableEntity" | string }, 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 | { _: "ConnectableEntity" | string }, to: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectRate?: Vector | { _: "Vector" | string }, targetRectRate?: Vector | { _: "Vector" | string }): 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 | { _: "Project" | string });
535
+ constructor(project: Project | { _: "Project" | (string & {}) });
536
536
  mouseDoubleClick;
537
537
  mouseup;
538
538
  mousemove;
539
- editUrlNodeTitle(clickedUrlNode: UrlNode | { _: "UrlNode" | string }): Promise<void>;
540
- editLatexNode(node: LatexNode | { _: "LatexNode" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }): 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 | { _: "Project" | string });
582
+ constructor(project: Project | { _: "Project" | (string & {}) });
583
583
  mouseDoubleClick;
584
584
  mousemove;
585
585
  keydown;
586
- editSectionTitle(section: Section | { _: "Section" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }, selectCurrent: boolean = false, autoEdit: boolean = false): Promise<void>;
596
- createConnectPoint(location: Vector | { _: "Vector" | string }): 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 | { _: "Vector" | string }): Promise<void>;
600
- isClickedResizeRect(clickedLocation: Vector | { _: "Vector" | string }): 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 | { _: "Project" | string });
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 | { _: "Project" | string });
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 | { _: "Project" | string });
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 | { _: "Project" | string }, source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<CubicCatmullRomSplineEdge>;
647
- constructor(project: Project | { _: "Project" | string }, {
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 | { _: "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;
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 | { _: "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;
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 | { _: "Project" | string });
722
+ constructor(project: Project | { _: "Project" | (string & {}) });
723
723
  deleteEntities(deleteNodes: Entity[]): 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>;
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 | { _: "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>;
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 | { _: "Project" | string });
760
+ constructor(project: Project | { _: "Project" | (string & {}) });
761
761
  renderTempDrawing(): 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>;
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 | { _: "Vector" | string }): Promise<void>;
770
- renderLine(lineStart: Vector | { _: "Vector" | string }, lineEnd: Vector | { _: "Vector" | string }): 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 | { _: "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>;
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 | { _: "Rectangle" | string }): Promise<boolean>;
793
- isIntersectsWithLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
794
- isIntersectsWithLine(line: Line | { _: "Line" | string }): 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 | { _: "Project" | string });
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 | { _: "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>;
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 | { _: "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>[];
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 | { _: "ProgressNumber" | string }, delay: number = 0);
837
+ constructor(timeProgress: ProgressNumber | { _: "ProgressNumber" | (string & {}) }, delay: number = 0);
838
838
  subEffects: Promise<Effect>[];
839
- tick(project: Project | { _: "Project" | string }): void;
840
- render(project: Project | { _: "Project" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }): void;
853
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
854
854
  isAlignExcluded;
855
- moveTo(location: Vector | { _: "Vector" | string }): 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 | { _: "Vector" | string }): Promise<boolean>;
859
+ isMouseInDetailsButton(mouseWorldLocation: Vector | { _: "Vector" | (string & {}) }): Promise<boolean>;
860
860
  referenceButtonCircle(): Promise<Circle>;
861
- isMouseInReferenceButton(mouseWorldLocation: Vector | { _: "Vector" | string }): 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,48 @@ declare class Entity extends StageObject {
867
867
  }
868
868
 
869
869
  declare class EntityDetailsButtonRenderer {
870
- constructor(project: Project | { _: "Project" | string });
871
- render(entity: Entity | { _: "Entity" | string }): 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 | { _: "Project" | string });
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 | { _: "Vector" | string }): Promise<void>;
881
- continuousMoveKeyRelease(direction: Vector | { _: "Vector" | string }): 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 | { _: "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>;
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 | { _: "Project" | string });
896
+ constructor(project: Project | { _: "Project" | (string & {}) });
897
897
  sortSectionsByZIndex(): Promise<void>;
898
898
  tickNumber;
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>;
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
912
  }
913
913
 
914
914
  declare class Extension extends Tab {
@@ -942,7 +942,7 @@ declare class ExtensionEntity extends ConnectableEntity {
942
942
  _isDirty;
943
943
  _isRendering;
944
944
  _renderFailed;
945
- constructor(project: Project | { _: "Project" | string }, {
945
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
946
946
  uuid = crypto.randomUUID(),
947
947
  extensionId = "",
948
948
  typeName = "",
@@ -958,8 +958,8 @@ declare class ExtensionEntity extends ConnectableEntity {
958
958
  get rectangle(): Promise<Rectangle>;
959
959
  get location(): Promise<Vector>;
960
960
  set location(v: Vector);
961
- move(delta: Vector | { _: "Vector" | string }): void;
962
- moveTo(location: Vector | { _: "Vector" | string }): void;
961
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
962
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
963
963
  markDirty(): Promise<void>;
964
964
  setCustomData(data: any): Promise<void>;
965
965
  }
@@ -970,13 +970,13 @@ declare interface ExtensionEntityConfig {
970
970
  }
971
971
 
972
972
  declare class ExtensionEntityRenderer {
973
- constructor(project: Project | { _: "Project" | string });
974
- render(entity: ExtensionEntity | { _: "ExtensionEntity" | string }): Promise<void>;
973
+ constructor(project: Project | { _: "Project" | (string & {}) });
974
+ render(entity: ExtensionEntity | { _: "ExtensionEntity" | (string & {}) }): Promise<void>;
975
975
  drawPendingBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number): Promise<void>;
976
976
  drawErrorBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, text: string, extensionId: string, color: string): 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>;
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>;
980
980
  }
981
981
 
982
982
  declare interface FileSystemProvider {
@@ -990,7 +990,7 @@ declare interface FileSystemProvider {
990
990
  }
991
991
 
992
992
  declare class GenerateFromFolder {
993
- constructor(project: Project | { _: "Project" | string });
993
+ constructor(project: Project | { _: "Project" | (string & {}) });
994
994
  generateFromFolder(folderPath: string): Promise<void>;
995
995
  generateTreeFromFolder(folderPath: string): Promise<void>;
996
996
  getColorByPath(path: string): Promise<Color>;
@@ -998,33 +998,33 @@ declare class GenerateFromFolder {
998
998
  }
999
999
 
1000
1000
  declare class GraphImporter extends BaseImporter {
1001
- constructor(project: Project | { _: "Project" | string });
1002
- import(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1001
+ constructor(project: Project | { _: "Project" | (string & {}) });
1002
+ import(text: string, diffLocation: Vector | { _: "Vector" | (string & {}) } = Vector.getZero()): void;
1003
1003
  }
1004
1004
 
1005
1005
  declare class GraphMethods {
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>[];
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>[];
1014
1014
  getReversedEdgeDict(skipDashed = false): Promise<Record<string, string>>;
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>[];
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>[];
1028
1028
  getTreeRootByNodes(nodes: ConnectableEntity[]): Promise<ConnectableEntity | null>;
1029
1029
  isTreeByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
1030
1030
  isDAGByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
@@ -1034,7 +1034,7 @@ declare class HistoryManager extends HistoryManagerAbs {
1034
1034
  memoryEfficient: Promise<HistoryManagerAbs>;
1035
1035
  timeEfficient: Promise<HistoryManagerAbs>;
1036
1036
  currentManager: Promise<HistoryManagerAbs>;
1037
- constructor(project: Project | { _: "Project" | string });
1037
+ constructor(project: Project | { _: "Project" | (string & {}) });
1038
1038
  recordStep(): void;
1039
1039
  undo(): void;
1040
1040
  redo(): void;
@@ -1055,7 +1055,7 @@ declare class ImageNode extends ConnectableEntity implements ResizeAble {
1055
1055
  set isSelected(value: boolean);
1056
1056
  bitmap: Promise<ImageBitmap | undefined>;
1057
1057
  state: Promise<"loading" | "success" | "notFound">;
1058
- constructor(project: Project | { _: "Project" | string }, {
1058
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
1059
1059
  uuid = crypto.randomUUID() as string,
1060
1060
  collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), Vector.getZero())]),
1061
1061
  details = [],
@@ -1066,30 +1066,30 @@ declare class ImageNode extends ConnectableEntity implements ResizeAble {
1066
1066
  scaleUpdate(scaleDiff: number): Promise<void>;
1067
1067
  get rectangle(): Promise<Rectangle>;
1068
1068
  get geometryCenter(): Promise<any>;
1069
- move(delta: Vector | { _: "Vector" | string }): void;
1070
- moveTo(location: Vector | { _: "Vector" | string }): void;
1069
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
1070
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
1071
1071
  reverseColors(): Promise<void>;
1072
1072
  swapRedBlueChannels(): Promise<void>;
1073
- resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
1073
+ resizeHandle(delta: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1074
1074
  getResizeHandleRect(): Promise<Rectangle>;
1075
1075
  }
1076
1076
 
1077
1077
  declare class ImageRenderer {
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>;
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>;
1081
1081
  }
1082
1082
 
1083
1083
  declare class InputElement {
1084
- input(location: Vector | { _: "Vector" | string }, 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>;
1085
1085
  textarea(defaultValue: string, onChange: (value: string, element: HTMLTextAreaElement) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}, selectAllWhenCreated = true): Promise<string>;
1086
1086
  addSuccessEffect(): Promise<void>;
1087
1087
  addFailEffect(withToast = true): Promise<void>;
1088
- constructor(project: Project | { _: "Project" | string });
1088
+ constructor(project: Project | { _: "Project" | (string & {}) });
1089
1089
  }
1090
1090
 
1091
1091
  declare class KeyBindHintEngine {
1092
- constructor(project: Project | { _: "Project" | string });
1092
+ constructor(project: Project | { _: "Project" | (string & {}) });
1093
1093
  ITEMS_PER_PAGE;
1094
1094
  currentPage;
1095
1095
  currentModifierCombo: Promise<string>;
@@ -1123,7 +1123,7 @@ declare type KeyBindIcon = ForwardRefExoticComponent<Omit<LucideProps, "ref"> &
1123
1123
  declare type KeyBindWhen = (project?: Project) => boolean | Promise<boolean>;
1124
1124
 
1125
1125
  declare class KeyboardOnlyEngine {
1126
- constructor(project: Project | { _: "Project" | string });
1126
+ constructor(project: Project | { _: "Project" | (string & {}) });
1127
1127
  openning;
1128
1128
  setOpenning(value: boolean): Promise<void>;
1129
1129
  isOpenning(): Promise<void>;
@@ -1139,7 +1139,7 @@ declare class KeyboardOnlyGraphEngine {
1139
1139
  targetLocationController;
1140
1140
  virtualTargetLocation(): Promise<Vector>;
1141
1141
  tick(): Promise<void>;
1142
- constructor(project: Project | { _: "Project" | string });
1142
+ constructor(project: Project | { _: "Project" | (string & {}) });
1143
1143
  isEnableVirtualCreate(): Promise<boolean>;
1144
1144
  _isCreating;
1145
1145
  _creatingFromUUID: Promise<string | null>;
@@ -1149,25 +1149,25 @@ declare class KeyboardOnlyGraphEngine {
1149
1149
  lastPressTabTime;
1150
1150
  getPressTabTimeInterval(): Promise<number>;
1151
1151
  createFinished(): Promise<void>;
1152
- moveVirtualTarget(delta: Vector | { _: "Vector" | string }): void;
1152
+ moveVirtualTarget(delta: Vector | { _: "Vector" | (string & {}) }): void;
1153
1153
  createCancel(): void;
1154
1154
  isTargetLocationHaveEntity(): Promise<boolean>;
1155
1155
  }
1156
1156
 
1157
1157
  declare class KeyboardOnlyTreeEngine {
1158
- constructor(project: Project | { _: "Project" | string });
1159
- getNodePreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<"right" | "left" | "down" | "up">;
1158
+ constructor(project: Project | { _: "Project" | (string & {}) });
1159
+ getNodePreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }): Promise<"right" | "left" | "down" | "up">;
1160
1160
  preDirectionCacheMap: Promise<Map<string, "right" | "left" | "down" | "up">>;
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>;
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>;
1164
1164
  changePreDirection(nodes: ConnectableEntity[], direction: "right" | "left" | "down" | "up"): void;
1165
- addNodeEffectByPreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | string }): void;
1165
+ addNodeEffectByPreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }): void;
1166
1166
  onDeepGenerateNode(defaultText = "新节点", selectAll = true): Promise<void>;
1167
1167
  onBroadGenerateNode(): Promise<void>;
1168
- adjustTreeNode(entity: ConnectableEntity | { _: "ConnectableEntity" | string }, withEffect = true): Promise<void>;
1168
+ adjustTreeNode(entity: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }, withEffect = true): Promise<void>;
1169
1169
  onDeleteCurrentNode(): Promise<void>;
1170
- calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity | { _: "ConnectableEntity" | string }, preDirection: "right" | "left" | "down" | "up"): Promise<number>;
1170
+ calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }, preDirection: "right" | "left" | "down" | "up"): Promise<number>;
1171
1171
  }
1172
1172
 
1173
1173
  declare class LatexNode extends ConnectableEntity {
@@ -1186,7 +1186,7 @@ declare class LatexNode extends ConnectableEntity {
1186
1186
  set isSelected(value: boolean);
1187
1187
  get rectangle(): Promise<Rectangle>;
1188
1188
  get geometryCenter(): Promise<Vector>;
1189
- constructor(project: Project | { _: "Project" | string }, {
1189
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
1190
1190
  uuid = crypto.randomUUID(),
1191
1191
  details = [],
1192
1192
  latexSource = "",
@@ -1202,25 +1202,25 @@ declare class LatexNode extends ConnectableEntity {
1202
1202
  fontScaleLevel?: number;
1203
1203
  });
1204
1204
  getScale(): Promise<number>;
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;
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;
1209
1209
  updateLatex(newLatex: string, colorCss?: string): Promise<void>;
1210
1210
  reRenderWithColor(colorCss: string): Promise<void>;
1211
1211
  renderLatexToImage(latex: string, colorCss: string = "#000000"): Promise<void>;
1212
- move(delta: Vector | { _: "Vector" | string }): void;
1213
- moveTo(location: Vector | { _: "Vector" | string }): void;
1212
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
1213
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
1214
1214
  }
1215
1215
 
1216
1216
  declare class LatexNodeRenderer {
1217
- constructor(project: Project | { _: "Project" | string });
1218
- getTargetColorCss(node: LatexNode | { _: "LatexNode" | string }): Promise<string>;
1219
- render(node: LatexNode | { _: "LatexNode" | string }): Promise<void>;
1217
+ constructor(project: Project | { _: "Project" | (string & {}) });
1218
+ getTargetColorCss(node: LatexNode | { _: "LatexNode" | (string & {}) }): Promise<string>;
1219
+ render(node: LatexNode | { _: "LatexNode" | (string & {}) }): Promise<void>;
1220
1220
  }
1221
1221
 
1222
1222
  declare class LayoutManager {
1223
- constructor(project: Project | { _: "Project" | string });
1223
+ constructor(project: Project | { _: "Project" | (string & {}) });
1224
1224
  alignLeft(): Promise<void>;
1225
1225
  alignRight(): Promise<void>;
1226
1226
  alignTop(): Promise<void>;
@@ -1246,7 +1246,7 @@ declare class LineEdge extends Edge {
1246
1246
  get shiftingIndex(): Promise<number>;
1247
1247
  set shiftingIndex(value: number);
1248
1248
  _shiftingIndex: Promise<number>;
1249
- constructor(project: Project | { _: "Project" | string }, {
1249
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
1250
1250
  associationList = [] as ConnectableEntity[],
1251
1251
  text = "",
1252
1252
  uuid = crypto.randomUUID() as string,
@@ -1255,7 +1255,7 @@ declare class LineEdge extends Edge {
1255
1255
  targetRectangleRate = Vector.same(0.5),
1256
1256
  lineType = "solid",
1257
1257
  }, unknown = false);
1258
- fromTwoEntity(project: Project | { _: "Project" | string }, source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<LineEdge>;
1258
+ fromTwoEntity(project: Project | { _: "Project" | (string & {}) }, source: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }, target: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }): Promise<LineEdge>;
1259
1259
  rename(text: string): Promise<void>;
1260
1260
  get edgeWidth(): Promise<number>;
1261
1261
  get textFontSize(): Promise<number>;
@@ -1352,13 +1352,13 @@ declare enum LogicNodeNameEnum {
1352
1352
  }
1353
1353
 
1354
1354
  declare class MarkdownExporter extends BaseExporter {
1355
- export(textNode: TextNode | { _: "TextNode" | string }): Promise<string>;
1356
- getNodeMarkdown(node: TextNode | { _: "TextNode" | string }, level: number): Promise<string>;
1355
+ export(textNode: TextNode | { _: "TextNode" | (string & {}) }): Promise<string>;
1356
+ getNodeMarkdown(node: TextNode | { _: "TextNode" | (string & {}) }, level: number): Promise<string>;
1357
1357
  }
1358
1358
 
1359
1359
  declare class MarkdownImporter extends BaseImporter {
1360
- constructor(project: Project | { _: "Project" | string });
1361
- import(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): void;
1360
+ constructor(project: Project | { _: "Project" | (string & {}) });
1361
+ import(markdownText: string, diffLocation: Vector | { _: "Vector" | (string & {}) } = Vector.getZero(), autoLayout = true): void;
1362
1362
  }
1363
1363
 
1364
1364
  declare interface MarkdownNode {
@@ -1368,13 +1368,13 @@ declare interface MarkdownNode {
1368
1368
  }
1369
1369
 
1370
1370
  declare class MermaidExporter {
1371
- constructor(project: Project | { _: "Project" | string });
1371
+ constructor(project: Project | { _: "Project" | (string & {}) });
1372
1372
  export(entities: Entity[]): Promise<string>;
1373
1373
  }
1374
1374
 
1375
1375
  declare class MermaidImporter extends BaseImporter {
1376
- constructor(project: Project | { _: "Project" | string });
1377
- import(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1376
+ constructor(project: Project | { _: "Project" | (string & {}) });
1377
+ import(text: string, diffLocation: Vector | { _: "Vector" | (string & {}) } = Vector.getZero()): void;
1378
1378
  normalizeLine(line: string): Promise<string>;
1379
1379
  decodeMermaidText(value: string): Promise<string>;
1380
1380
  sanitizeLabel(raw: string | undefined): Promise<string | undefined>;
@@ -1382,7 +1382,7 @@ declare class MermaidImporter extends BaseImporter {
1382
1382
  }
1383
1383
 
1384
1384
  declare class MouseInteraction {
1385
- constructor(project: Project | { _: "Project" | string });
1385
+ constructor(project: Project | { _: "Project" | (string & {}) });
1386
1386
  _hoverEdges: Promise<Edge>[];
1387
1387
  _hoverSections: Promise<Section>[];
1388
1388
  _hoverConnectPoints: Promise<ConnectPoint>[];
@@ -1394,12 +1394,12 @@ declare class MouseInteraction {
1394
1394
  get firstHoverSection(): Promise<Section | undefined>;
1395
1395
  get hoverMultiTargetEdges(): Promise<MultiTargetUndirectedEdge>[];
1396
1396
  get firstHoverMultiTargetEdge(): Promise<MultiTargetUndirectedEdge | undefined>;
1397
- updateByMouseMove(mouseWorldLocation: Vector | { _: "Vector" | string }): void;
1397
+ updateByMouseMove(mouseWorldLocation: Vector | { _: "Vector" | (string & {}) }): void;
1398
1398
  }
1399
1399
 
1400
1400
  declare class MultiTargetEdgeMove {
1401
- constructor(project: Project | { _: "Project" | string });
1402
- moveMultiTargetEdge(diffLocation: Vector | { _: "Vector" | string }): Promise<void>;
1401
+ constructor(project: Project | { _: "Project" | (string & {}) });
1402
+ moveMultiTargetEdge(diffLocation: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1403
1403
  }
1404
1404
 
1405
1405
  declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
@@ -1413,7 +1413,7 @@ declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
1413
1413
  renderType: Promise<MultiTargetUndirectedEdgeRenderType>;
1414
1414
  padding: Promise<number>;
1415
1415
  rename(text: string): Promise<void>;
1416
- constructor(project: Project | { _: "Project" | string }, {
1416
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
1417
1417
  associationList = [] as ConnectableEntity[],
1418
1418
  text = "",
1419
1419
  uuid = crypto.randomUUID() as string,
@@ -1436,47 +1436,47 @@ declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
1436
1436
  }, unknown = false);
1437
1437
  get centerLocation(): Promise<Vector>;
1438
1438
  get textRectangle(): Promise<Rectangle>;
1439
- createFromSomeEntity(project: Project | { _: "Project" | string }, entities: ConnectableEntity[]): Promise<void>;
1439
+ createFromSomeEntity(project: Project | { _: "Project" | (string & {}) }, entities: ConnectableEntity[]): Promise<void>;
1440
1440
  _isSelected: Promise<boolean>;
1441
1441
  get isSelected(): Promise<boolean>;
1442
1442
  set isSelected(value: boolean);
1443
1443
  }
1444
1444
 
1445
1445
  declare class MultiTargetUndirectedEdgeRenderer {
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;
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;
1451
1451
  }
1452
1452
 
1453
1453
  declare class NodeAdder {
1454
- constructor(project: Project | { _: "Project" | string });
1455
- addTextNodeByClick(clickWorldLocation: Vector | { _: "Vector" | string }, 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?: {
1456
1456
  overrideFontScaleLevel?: number;
1457
1457
  }): Promise<string>;
1458
1458
  addTextNodeFromCurrentSelectedNode(direction: Direction, addToSections: Section[], selectCurrent = false): Promise<string>;
1459
1459
  getAutoName(): Promise<string>;
1460
1460
  getAutoColor(): Promise<Color>;
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>;
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>;
1466
1466
  getIndentLevel(line: string, indention: number): Promise<number>;
1467
1467
  }
1468
1468
 
1469
1469
  declare class NodeConnector {
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;
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;
1475
1475
  reverseEdges(edges: LineEdge[]): 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>;
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>;
1480
1480
  }
1481
1481
 
1482
1482
  declare class PenStroke extends Entity {
@@ -1484,24 +1484,24 @@ declare class PenStroke extends Entity {
1484
1484
  isHiddenBySectionCollapse: Promise<boolean>;
1485
1485
  collisionBox: Promise<CollisionBox>;
1486
1486
  uuid: Promise<string>;
1487
- move(delta: Vector | { _: "Vector" | string }): void;
1488
- moveTo(location: Vector | { _: "Vector" | string }): void;
1487
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
1488
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
1489
1489
  updateCollisionBoxBySegmentList(): Promise<void>;
1490
1490
  segments: Promise<PenStrokeSegment>[];
1491
1491
  color: Promise<Color>;
1492
1492
  getPath(): Promise<Vector>[];
1493
- constructor(project: Project | { _: "Project" | string }, { 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 });
1494
1494
  getCollisionBoxFromSegmentList(segmentList: PenStrokeSegment[]): Promise<CollisionBox>;
1495
1495
  }
1496
1496
 
1497
1497
  declare class PenStrokeSegment {
1498
1498
  location: Promise<Vector>;
1499
1499
  pressure: Promise<number>;
1500
- constructor(location: Vector | { _: "Vector" | string }, pressure: number);
1500
+ constructor(location: Vector | { _: "Vector" | (string & {}) }, pressure: number);
1501
1501
  }
1502
1502
 
1503
1503
  declare class PlainTextExporter {
1504
- constructor(project: Project | { _: "Project" | string });
1504
+ constructor(project: Project | { _: "Project" | (string & {}) });
1505
1505
  export(nodes: Entity[]): Promise<string>;
1506
1506
  }
1507
1507
 
@@ -1653,7 +1653,7 @@ declare type RecentFile = {
1653
1653
  }
1654
1654
 
1655
1655
  declare class RectangleSelect {
1656
- constructor(project: Project | { _: "Project" | string });
1656
+ constructor(project: Project | { _: "Project" | (string & {}) });
1657
1657
  selectStartLocation;
1658
1658
  selectEndLocation;
1659
1659
  getSelectStartLocation(): Promise<Vector>;
@@ -1663,11 +1663,11 @@ declare class RectangleSelect {
1663
1663
  isSelectDirectionRight;
1664
1664
  getRectangle(): Promise<Rectangle | null>;
1665
1665
  shutDown(): Promise<void>;
1666
- startSelecting(worldLocation: Vector | { _: "Vector" | string }): Promise<void>;
1667
- moveSelecting(newEndLocation: Vector | { _: "Vector" | string }): Promise<void>;
1666
+ startSelecting(worldLocation: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1667
+ moveSelecting(newEndLocation: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1668
1668
  endSelecting(): Promise<void>;
1669
1669
  updateStageObjectByMove(): Promise<void>;
1670
- isSelectWithEntity(entity: StageObject | { _: "StageObject" | string }): Promise<void>;
1670
+ isSelectWithEntity(entity: StageObject | { _: "StageObject" | (string & {}) }): Promise<void>;
1671
1671
  getSelectMode(): Promise<"contain" | "intersect">;
1672
1672
  getSelectMoveDistance(): Promise<number>;
1673
1673
  }
@@ -1683,7 +1683,7 @@ declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble
1683
1683
  _isSelected: Promise<boolean>;
1684
1684
  bitmap: Promise<ImageBitmap | undefined>;
1685
1685
  state: Promise<"loading" | "success" | "notFound">;
1686
- constructor(project: Project | { _: "Project" | string }, {
1686
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
1687
1687
  uuid = crypto.randomUUID() as string,
1688
1688
  collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), new Vector(400, 200))]),
1689
1689
  fileName = "",
@@ -1700,33 +1700,33 @@ declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble
1700
1700
  scaleUpdate(scaleDiff: number): Promise<void>;
1701
1701
  get rectangle(): Promise<Rectangle>;
1702
1702
  get geometryCenter(): Promise<any>;
1703
- move(delta: Vector | { _: "Vector" | string }): void;
1704
- moveTo(location: Vector | { _: "Vector" | string }): void;
1703
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
1704
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
1705
1705
  refresh(): Promise<void>;
1706
1706
  goToSource(): Promise<void>;
1707
- focusSectionInProject(project: Project | { _: "Project" | string }): Promise<void>;
1708
- resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
1707
+ focusSectionInProject(project: Project | { _: "Project" | (string & {}) }): Promise<void>;
1708
+ resizeHandle(delta: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1709
1709
  getResizeHandleRect(): Promise<Rectangle>;
1710
1710
  }
1711
1711
 
1712
1712
  declare class ReferenceBlockRenderer {
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>;
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>;
1717
1717
  }
1718
1718
 
1719
1719
  declare class ReferenceManager {
1720
- constructor(project: Project | { _: "Project" | string });
1720
+ constructor(project: Project | { _: "Project" | (string & {}) });
1721
1721
  referenceBlockTextParser(text: string): Promise<parserResult>;
1722
- onClickReferenceNumber(clickLocation: Vector | { _: "Vector" | string }): Promise<void>;
1722
+ onClickReferenceNumber(clickLocation: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1723
1723
  buildSectionName2SectionMap(sectionNames: string[]): Promise<Record<string, Section>>;
1724
1724
  updateOneSectionReferenceInfo(recentFiles: RecentFileManager.RecentFile[], sectionName: string): Promise<void>;
1725
1725
  updateCurrentProjectReference(): Promise<void>;
1726
- checkReferenceBlockInProject(project: Project | { _: "Project" | string }, fileName: string, sectionName: string): Promise<void>;
1726
+ checkReferenceBlockInProject(project: Project | { _: "Project" | (string & {}) }, fileName: string, sectionName: string): Promise<void>;
1727
1727
  insertRefDataToSourcePrgFile(fileName: string, sectionName: string): Promise<void>;
1728
1728
  jumpToReferenceLocation(fileName: string, referenceBlockNodeSectionName: string): Promise<void>;
1729
- openSectionReferencePanel(section: Section | { _: "Section" | string }): Promise<void>;
1729
+ openSectionReferencePanel(section: Section | { _: "Section" | (string & {}) }): Promise<void>;
1730
1730
  }
1731
1731
 
1732
1732
  declare class Renderer {
@@ -1743,14 +1743,14 @@ declare class Renderer {
1743
1743
  frameIndex;
1744
1744
  fps;
1745
1745
  resizeWindow(newW: number, newH: number): Promise<void>;
1746
- constructor(project: Project | { _: "Project" | string });
1746
+ constructor(project: Project | { _: "Project" | (string & {}) });
1747
1747
  tick(): Promise<void>;
1748
1748
  tick_(): Promise<void>;
1749
- renderViewElements(_viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1749
+ renderViewElements(_viewRectangle: Rectangle | { _: "Rectangle" | (string & {}) }): Promise<void>;
1750
1750
  renderZoomLevelStage(): Promise<void>;
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>;
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>;
1754
1754
  renderCenterPointer(): Promise<void>;
1755
1755
  renderHoverCollisionBox(): Promise<void>;
1756
1756
  renderSelectingRectangle(): Promise<void>;
@@ -1759,37 +1759,37 @@ declare class Renderer {
1759
1759
  renderCrosshairOnHoverImage(): Promise<void>;
1760
1760
  renderKeyboardOnly(): Promise<void>;
1761
1761
  rendererLayerMovingLine(): Promise<void>;
1762
- renderJumpLine(startLocation: Vector | { _: "Vector" | string }, endLocation: Vector | { _: "Vector" | string }): Promise<void>;
1762
+ renderJumpLine(startLocation: Vector | { _: "Vector" | (string & {}) }, endLocation: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
1763
1763
  renderWarningStageObjects(): Promise<void>;
1764
1764
  renderTags(): Promise<void>;
1765
- renderEntities(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1766
- renderEdges(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1765
+ renderEntities(viewRectangle: Rectangle | { _: "Rectangle" | (string & {}) }): Promise<void>;
1766
+ renderEdges(viewRectangle: Rectangle | { _: "Rectangle" | (string & {}) }): Promise<void>;
1767
1767
  renderBackground(): Promise<void>;
1768
1768
  updateFPS(): Promise<void>;
1769
1769
  renderDebugDetails(): Promise<void>;
1770
1770
  renderSpecialKeys(): Promise<void>;
1771
- transformWorld2View(location: Vector | { _: "Vector" | string }): Promise<Vector>;
1772
- transformWorld2View(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Rectangle>;
1771
+ transformWorld2View(location: Vector | { _: "Vector" | (string & {}) }): Promise<Vector>;
1772
+ transformWorld2View(rectangle: Rectangle | { _: "Rectangle" | (string & {}) }): Promise<Rectangle>;
1773
1773
  transformWorld2View(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
1774
- transformView2World(location: Vector | { _: "Vector" | string }): Promise<Vector>;
1775
- transformView2World(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Rectangle>;
1774
+ transformView2World(location: Vector | { _: "Vector" | (string & {}) }): Promise<Vector>;
1775
+ transformView2World(rectangle: Rectangle | { _: "Rectangle" | (string & {}) }): Promise<Rectangle>;
1776
1776
  transformView2World(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
1777
1777
  getCoverWorldRectangle(): Promise<Rectangle>;
1778
1778
  }
1779
1779
 
1780
1780
  declare class RenderUtils {
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>;
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>;
1784
1784
  }
1785
1785
 
1786
1786
  declare interface ResizeAble {
1787
- resizeHandle(delta: Vector | { _: "Vector" | string }): void;
1787
+ resizeHandle(delta: Vector | { _: "Vector" | (string & {}) }): void;
1788
1788
  getResizeHandleRect(): Promise<Rectangle>;
1789
1789
  }
1790
1790
 
1791
1791
  declare class SearchContentHighlightRenderer {
1792
- constructor(project: Project | { _: "Project" | string });
1792
+ constructor(project: Project | { _: "Project" | (string & {}) });
1793
1793
  render(frameTickIndex: number): Promise<void>;
1794
1794
  }
1795
1795
 
@@ -1810,7 +1810,7 @@ declare class Section extends ConnectableEntity {
1810
1810
  isCollapsed: Promise<boolean>;
1811
1811
  locked: Promise<boolean>;
1812
1812
  isHiddenBySectionCollapse;
1813
- constructor(project: Project | { _: "Project" | string }, {
1813
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
1814
1814
  uuid = crypto.randomUUID() as string,
1815
1815
  text = "",
1816
1816
  collisionBox = new CollisionBox([new Rectangle(new Vector(0, 0), new Vector(0, 0))]),
@@ -1821,7 +1821,7 @@ declare class Section extends ConnectableEntity {
1821
1821
  children = [] as Entity[],
1822
1822
  details = [] as Value,
1823
1823
  } = {}, unknown = false);
1824
- fromEntities(project: Project | { _: "Project" | string }, entities: Entity[]): Promise<Section>;
1824
+ fromEntities(project: Project | { _: "Project" | (string & {}) }, entities: Entity[]): Promise<Section>;
1825
1825
  rename(newName: string): Promise<void>;
1826
1826
  adjustLocationAndSize(): Promise<void>;
1827
1827
  adjustChildrenStateByCollapse(parentCollapsed = false): Promise<void>;
@@ -1829,58 +1829,58 @@ declare class Section extends ConnectableEntity {
1829
1829
  set isSelected(value: boolean);
1830
1830
  get rectangle(): Promise<Rectangle>;
1831
1831
  get geometryCenter(): Promise<any>;
1832
- move(delta: Vector | { _: "Vector" | string }): void;
1833
- collideWithOtherEntity(other: Entity | { _: "Entity" | string }): void;
1834
- moveTo(location: Vector | { _: "Vector" | string }): void;
1832
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
1833
+ collideWithOtherEntity(other: Entity | { _: "Entity" | (string & {}) }): void;
1834
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
1835
1835
  }
1836
1836
 
1837
1837
  declare class SectionCollisionSolver {
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;
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;
1844
1844
  }
1845
1845
 
1846
1846
  declare class SectionInOutManager {
1847
- constructor(project: Project | { _: "Project" | string });
1848
- goInSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
1847
+ constructor(project: Project | { _: "Project" | (string & {}) });
1848
+ goInSection(entities: Entity[], section: Section | { _: "Section" | (string & {}) }): Promise<void>;
1849
1849
  goInSections(entities: Entity[], sections: 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>;
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>;
1854
1854
  }
1855
1855
 
1856
1856
  declare class SectionMethods {
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>[];
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>[];
1862
1862
  deeperSections(sections: Section[]): Promise<Section>[];
1863
1863
  shallowerSection(sections: Section[]): Promise<Section>[];
1864
1864
  shallowerNotSectionEntities(entities: Entity[]): Promise<Entity>[];
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>;
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>;
1870
1870
  getAllEntitiesInSelectedSectionsOrEntities(selectedEntities: Entity[]): Promise<Entity>[];
1871
1871
  getSortedSectionsByZ(sections: Section[]): Promise<Section>[];
1872
1872
  }
1873
1873
 
1874
1874
  declare class SectionPackManager {
1875
- constructor(project: Project | { _: "Project" | string });
1875
+ constructor(project: Project | { _: "Project" | (string & {}) });
1876
1876
  packSection(): void;
1877
- modifyHiddenDfs(section: Section | { _: "Section" | string }, isCollapsed: boolean): Promise<void>;
1877
+ modifyHiddenDfs(section: Section | { _: "Section" | (string & {}) }, isCollapsed: boolean): Promise<void>;
1878
1878
  unpackSection(): void;
1879
1879
  switchCollapse(): void;
1880
1880
  textNodeToSection(): void;
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>;
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>;
1884
1884
  unpackSelectedSections(): Promise<void>;
1885
1885
  unpackSections(entities: Entity[]): Promise<void>;
1886
1886
  packEntityToSection(addEntities: Entity[]): Promise<void>;
@@ -1890,38 +1890,38 @@ declare class SectionPackManager {
1890
1890
  }
1891
1891
 
1892
1892
  declare class SectionRenderer {
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;
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;
1900
1900
  }
1901
1901
 
1902
1902
  declare class SelectChangeEngine {
1903
1903
  lastSelectNodeByKeyboardUUID;
1904
- constructor(project: Project | { _: "Project" | string });
1904
+ constructor(project: Project | { _: "Project" | (string & {}) });
1905
1905
  selectUp(addSelect = false): Promise<void>;
1906
1906
  selectDown(addSelect = false): Promise<void>;
1907
1907
  selectLeft(addSelect = false): Promise<void>;
1908
1908
  selectRight(addSelect = false): Promise<void>;
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>[];
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>[];
1912
1912
  expandSelect(isKeepExpand = false, reversed: boolean = false): Promise<void>;
1913
- afterSelect(selectedNodeRect: ConnectableEntity | { _: "ConnectableEntity" | string }, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true): Promise<void>;
1913
+ afterSelect(selectedNodeRect: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true): Promise<void>;
1914
1914
  getCurrentSelectedNode(): Promise<ConnectableEntity | null>;
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>[];
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>[];
1925
1925
  }
1926
1926
 
1927
1927
  declare namespace Serialized {
@@ -1943,7 +1943,7 @@ declare type TextNode = Entity & {
1943
1943
  color: Color;
1944
1944
  sizeAdjust: TextNodeSizeAdjust;
1945
1945
  };
1946
- function isTextNode(obj: StageObject | { _: "StageObject" | string }): obj is TextNode;
1946
+ function isTextNode(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is TextNode;
1947
1947
  declare type Section = Entity & {
1948
1948
  type: "core:section";
1949
1949
  size: Vector;
@@ -1954,18 +1954,18 @@ declare type Section = Entity & {
1954
1954
  isHidden: boolean;
1955
1955
  isCollapsed: boolean;
1956
1956
  };
1957
- function isSection(obj: StageObject | { _: "StageObject" | string }): obj is Section;
1957
+ function isSection(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is Section;
1958
1958
  declare type ConnectPoint = Entity & {
1959
1959
  type: "core:connect_point";
1960
1960
  };
1961
- function isConnectPoint(obj: StageObject | { _: "StageObject" | string }): obj is ConnectPoint;
1961
+ function isConnectPoint(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is ConnectPoint;
1962
1962
  declare type ImageNode = Entity & {
1963
1963
  path: string;
1964
1964
  size: Vector;
1965
1965
  scale: number;
1966
1966
  type: "core:image_node";
1967
1967
  };
1968
- function isImageNode(obj: StageObject | { _: "StageObject" | string }): obj is ImageNode;
1968
+ function isImageNode(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is ImageNode;
1969
1969
  declare type UrlNode = Entity & {
1970
1970
  url: string;
1971
1971
  title: string;
@@ -1973,7 +1973,7 @@ declare type UrlNode = Entity & {
1973
1973
  color: Color;
1974
1974
  type: "core:url_node";
1975
1975
  };
1976
- function isUrlNode(obj: StageObject | { _: "StageObject" | string }): obj is UrlNode;
1976
+ function isUrlNode(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is UrlNode;
1977
1977
  declare type PortalNode = Entity & {
1978
1978
  // 连接的文件
1979
1979
  portalFilePath: string;
@@ -1987,13 +1987,13 @@ declare type PortalNode = Entity & {
1987
1987
  color: Color;
1988
1988
  type: "core:portal_node";
1989
1989
  };
1990
- function isPortalNode(obj: StageObject | { _: "StageObject" | string }): obj is PortalNode;
1990
+ function isPortalNode(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is PortalNode;
1991
1991
  declare type PenStroke = Entity & {
1992
1992
  type: "core:pen_stroke";
1993
1993
  content: string;
1994
1994
  color: Color;
1995
1995
  };
1996
- function isPenStroke(obj: StageObject | { _: "StageObject" | string }): obj is PenStroke;
1996
+ function isPenStroke(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is PenStroke;
1997
1997
  declare type SvgNode = Entity & {
1998
1998
  type: "core:svg_node";
1999
1999
  content: string;
@@ -2001,7 +2001,7 @@ declare type SvgNode = Entity & {
2001
2001
  color: Color;
2002
2002
  scale: number;
2003
2003
  };
2004
- function isSvgNode(obj: StageObject | { _: "StageObject" | string }): obj is SvgNode;
2004
+ function isSvgNode(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is SvgNode;
2005
2005
  declare type Association = StageObject & {
2006
2006
  text: string;
2007
2007
  color: Color;
@@ -2017,21 +2017,21 @@ declare type MultiTargetUndirectedEdge = Association & {
2017
2017
  padding: number;
2018
2018
  renderType: MultiTargetUndirectedEdgeRenderType;
2019
2019
  };
2020
- function isMultiTargetUndirectedEdge(obj: StageObject | { _: "StageObject" | string }): obj is MultiTargetUndirectedEdge;
2020
+ function isMultiTargetUndirectedEdge(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is MultiTargetUndirectedEdge;
2021
2021
  declare type Edge = Association & {
2022
2022
  source: string;
2023
2023
  target: string;
2024
2024
  sourceRectRate: [number, number]; // 默认中心 0.5, 0.5
2025
2025
  targetRectRate: [number, number]; // 默认中心 0.5, 0.5
2026
2026
  };
2027
- function isEdge(obj: StageObject | { _: "StageObject" | string }): obj is Edge;
2027
+ function isEdge(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is Edge;
2028
2028
  declare type LineEdge = Edge & {
2029
2029
  type: "core:line_edge";
2030
2030
  color: Color;
2031
2031
  text: string;
2032
2032
  };
2033
- function isLineEdge(obj: StageObject | { _: "StageObject" | string }): obj is LineEdge;
2034
- function isCubicCatmullRomSplineEdge(obj: StageObject | { _: "StageObject" | string }): obj is CubicCatmullRomSplineEdge;
2033
+ function isLineEdge(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is LineEdge;
2034
+ function isCubicCatmullRomSplineEdge(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is CubicCatmullRomSplineEdge;
2035
2035
  declare type CubicCatmullRomSplineEdge = Edge & {
2036
2036
  type: "core:cublic_catmull_rom_spline_edge";
2037
2037
  text: string;
@@ -2040,7 +2040,7 @@ declare type CubicCatmullRomSplineEdge = Edge & {
2040
2040
  tension: number;
2041
2041
  };
2042
2042
  declare type CoreEntity = TextNode | Section | ConnectPoint | ImageNode | UrlNode | PenStroke | PortalNode | SvgNode;
2043
- function isCoreEntity(obj: StageObject | { _: "StageObject" | string }): obj is CoreEntity;
2043
+ function isCoreEntity(obj: StageObject | { _: "StageObject" | (string & {}) }): obj is CoreEntity;
2044
2044
  declare type CoreAssociation = LineEdge | CubicCatmullRomSplineEdge | MultiTargetUndirectedEdge;
2045
2045
  declare type File = {
2046
2046
  version: typeof Project.latestVersion;
@@ -2058,19 +2058,19 @@ declare interface Service {
2058
2058
  declare type Settings = z.infer<typeof settingsSchema>;
2059
2059
 
2060
2060
  declare class ShapeRenderer {
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>;
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>;
2074
2074
  }
2075
2075
 
2076
2076
  declare class StageExport {
@@ -2078,36 +2078,36 @@ declare class StageExport {
2078
2078
  markdownExporter: Promise<MarkdownExporter>;
2079
2079
  tabExporter: Promise<TabExporter>;
2080
2080
  mermaidExporter: Promise<MermaidExporter>;
2081
- constructor(project: Project | { _: "Project" | string });
2081
+ constructor(project: Project | { _: "Project" | (string & {}) });
2082
2082
  getPlainTextByEntities(nodes: Entity[]): Promise<void>;
2083
- getMarkdownStringByTextNode(textNode: TextNode | { _: "TextNode" | string }): Promise<void>;
2084
- getTabStringByTextNode(textNode: TextNode | { _: "TextNode" | string }): Promise<void>;
2083
+ getMarkdownStringByTextNode(textNode: TextNode | { _: "TextNode" | (string & {}) }): Promise<void>;
2084
+ getTabStringByTextNode(textNode: TextNode | { _: "TextNode" | (string & {}) }): Promise<void>;
2085
2085
  getMermaidTextByEntities(entities: Entity[]): Promise<string>;
2086
2086
  }
2087
2087
 
2088
2088
  declare class StageExportPng {
2089
- constructor(project: Project | { _: "Project" | string });
2089
+ constructor(project: Project | { _: "Project" | (string & {}) });
2090
2090
  exportStage_(emitter: EventEmitter<EventMap>, signal: AbortSignal, sleepTime: number): Promise<void>;
2091
2091
  exportStage(signal: AbortSignal, sleepTime: number = 2): Promise<void>;
2092
2092
  generateCanvasNode(): Promise<HTMLCanvasElement>;
2093
2093
  }
2094
2094
 
2095
2095
  declare class StageExportSvg {
2096
- constructor(project: Project | { _: "Project" | string });
2096
+ constructor(project: Project | { _: "Project" | (string & {}) });
2097
2097
  svgConfig: Promise<SvgExportConfig>;
2098
2098
  exportContext: Promise<{
2099
2099
  outputDir: string;
2100
2100
  imageMap: Map<string, string>; // attachmentId -> relative file path
2101
2101
  } | null>;
2102
2102
  setConfig(config: 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>;
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>;
2111
2111
  getEntitiesOuterRectangle(entities: Entity[], padding: number): Promise<Rectangle>;
2112
2112
  dumpSelected(): Promise<React.ReactNode>;
2113
2113
  dumpStage(): Promise<React.ReactNode>;
@@ -2122,16 +2122,16 @@ declare class StageImport {
2122
2122
  treeImporter: Promise<TreeImporter>;
2123
2123
  mermaidImporter: Promise<MermaidImporter>;
2124
2124
  markdownImporter: Promise<MarkdownImporter>;
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>;
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>;
2128
2128
  addNodeTreeByTextFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
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>;
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>;
2131
2131
  }
2132
2132
 
2133
2133
  declare class StageManager {
2134
- constructor(project: Project | { _: "Project" | string });
2134
+ constructor(project: Project | { _: "Project" | (string & {}) });
2135
2135
  get(uuid: string): Promise<void>;
2136
2136
  isEmpty(): Promise<boolean>;
2137
2137
  getTextNodes(): Promise<TextNode>[];
@@ -2148,12 +2148,12 @@ declare class StageManager {
2148
2148
  getEntities(): Promise<Entity>[];
2149
2149
  getEntitiesByUUIDs(uuids: string[]): Promise<Entity>[];
2150
2150
  isNoEntity(): Promise<boolean>;
2151
- delete(stageObject: StageObject | { _: "StageObject" | string }): Promise<void>;
2151
+ delete(stageObject: StageObject | { _: "StageObject" | (string & {}) }): Promise<void>;
2152
2152
  getAssociations(): Promise<Association>[];
2153
2153
  getEdges(): Promise<Edge>[];
2154
2154
  getLineEdges(): Promise<LineEdge>[];
2155
2155
  getCrEdges(): Promise<CubicCatmullRomSplineEdge>[];
2156
- add(stageObject: StageObject | { _: "StageObject" | string }): Promise<void>;
2156
+ add(stageObject: StageObject | { _: "StageObject" | (string & {}) }): Promise<void>;
2157
2157
  updateReferences(): Promise<void>;
2158
2158
  getTextNodeByUUID(uuid: string): Promise<TextNode | null>;
2159
2159
  getConnectableEntityByUUID(uuid: string): Promise<ConnectableEntity | null>;
@@ -2162,29 +2162,29 @@ declare class StageManager {
2162
2162
  getCenter(): Promise<Vector>;
2163
2163
  getSize(): Promise<Vector>;
2164
2164
  getBoundingRectangle(): Promise<Rectangle>;
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>;
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>;
2173
2173
  isHaveEntitySelected(): Promise<boolean>;
2174
2174
  getSelectedEntities(): Promise<Entity>[];
2175
2175
  getSelectedAssociations(): Promise<Association>[];
2176
2176
  getSelectedStageObjects(): Promise<StageObject>[];
2177
2177
  getBoundingBoxOfSelected(): Promise<Rectangle>;
2178
- isEntityOnLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
2179
- isAssociationOnLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
2178
+ isEntityOnLocation(location: Vector | { _: "Vector" | (string & {}) }): Promise<boolean>;
2179
+ isAssociationOnLocation(location: Vector | { _: "Vector" | (string & {}) }): Promise<boolean>;
2180
2180
  deleteEntities(deleteNodes: Entity[]): Promise<void>;
2181
2181
  deleteSelectedStageObjects(): Promise<void>;
2182
2182
  deleteAssociation(deleteAssociation: Association): Promise<boolean>;
2183
2183
  deleteEdge(deleteEdge: Edge): Promise<boolean>;
2184
2184
  w;
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>;
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>;
2188
2188
  reverseSelectedNodeEdge(): Promise<void>;
2189
2189
  reverseSelectedEdges(): Promise<void>;
2190
2190
  generateNodeTreeByText(text: string, indention: number = 4, location = this.project.camera.location): Promise<void>;
@@ -2193,12 +2193,12 @@ declare class StageManager {
2193
2193
  generateNodeByMarkdown(text: string, location = this.project.camera.location, autoLayout = true): Promise<void>;
2194
2194
  packEntityToSection(addEntities: Entity[]): Promise<void>;
2195
2195
  packEntityToSectionBySelected(): Promise<void>;
2196
- goInSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
2197
- goOutSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
2196
+ goInSection(entities: Entity[], section: Section | { _: "Section" | (string & {}) }): Promise<void>;
2197
+ goOutSection(entities: Entity[], section: Section | { _: "Section" | (string & {}) }): Promise<void>;
2198
2198
  packSelectedSection(): Promise<void>;
2199
2199
  unpackSelectedSection(): Promise<void>;
2200
2200
  sectionSwitchCollapse(): Promise<void>;
2201
- connectEntityByCrEdge(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
2201
+ connectEntityByCrEdge(fromNode: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }, toNode: ConnectableEntity | { _: "ConnectableEntity" | (string & {}) }): Promise<void>;
2202
2202
  refreshAllStageObjects(): Promise<void>;
2203
2203
  refreshSelected(): Promise<void>;
2204
2204
  changeSelectedEdgeConnectLocation(direction: Direction | null, isSource: boolean = false): Promise<void>;
@@ -2215,9 +2215,9 @@ declare class StageManager {
2215
2215
  }
2216
2216
 
2217
2217
  declare class StageNodeRotate {
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;
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;
2221
2221
  }
2222
2222
 
2223
2223
  declare class StageObject {
@@ -2232,14 +2232,14 @@ declare class StageObject {
2232
2232
  }
2233
2233
 
2234
2234
  declare class StageObjectColorManager {
2235
- constructor(project: Project | { _: "Project" | string });
2236
- setSelectedStageObjectColor(color: Color | { _: "Color" | string }): Promise<void>;
2235
+ constructor(project: Project | { _: "Project" | (string & {}) });
2236
+ setSelectedStageObjectColor(color: Color | { _: "Color" | (string & {}) }): Promise<void>;
2237
2237
  darkenNodeColor(): Promise<void>;
2238
2238
  lightenNodeColor(): Promise<void>;
2239
2239
  }
2240
2240
 
2241
2241
  declare class StageObjectSelectCounter {
2242
- constructor(project: Project | { _: "Project" | string });
2242
+ constructor(project: Project | { _: "Project" | (string & {}) });
2243
2243
  selectedStageObjectCount;
2244
2244
  selectedEntityCount;
2245
2245
  selectedAssociationCount;
@@ -2259,39 +2259,39 @@ declare class StageStyleManager {
2259
2259
  }
2260
2260
 
2261
2261
  declare class StageSyncAssociationManager {
2262
- constructor(project: Project | { _: "Project" | string });
2262
+ constructor(project: Project | { _: "Project" | (string & {}) });
2263
2263
  createTwinsFromSelectedEntities(): void;
2264
2264
  getSyncAssociations(): Promise<SyncAssociation>[];
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;
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;
2270
2270
  }
2271
2271
 
2272
2272
  declare class StageUtils {
2273
- constructor(project: Project | { _: "Project" | string });
2273
+ constructor(project: Project | { _: "Project" | (string & {}) });
2274
2274
  replaceAutoNameWithoutStage(template: string): Promise<string>;
2275
- replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject | { _: "StageObject" | string }): Promise<string>;
2275
+ replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject | { _: "StageObject" | (string & {}) }): Promise<string>;
2276
2276
  isNameConflictWithTextNodes(name: string): Promise<boolean>;
2277
2277
  isNameConflictWithSections(name: string): Promise<boolean>;
2278
2278
  }
2279
2279
 
2280
2280
  declare class StraightEdgeRenderer extends EdgeRendererClass {
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>;
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>;
2287
2287
  getCycleStageSvg(): Promise<React.ReactNode>;
2288
2288
  getShiftingStageSvg(): Promise<React.ReactNode>;
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;
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;
2295
2295
  }
2296
2296
 
2297
2297
  declare class SvgNode extends ConnectableEntity implements ResizeAble {
@@ -2303,7 +2303,7 @@ declare class SvgNode extends ConnectableEntity implements ResizeAble {
2303
2303
  isHiddenBySectionCollapse: Promise<boolean>;
2304
2304
  originalSize: Promise<Vector>;
2305
2305
  image: Promise<HTMLImageElement>;
2306
- constructor(project: Project | { _: "Project" | string }, {
2306
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
2307
2307
  uuid = crypto.randomUUID(),
2308
2308
  details = [],
2309
2309
  attachmentId = "",
@@ -2313,42 +2313,42 @@ declare class SvgNode extends ConnectableEntity implements ResizeAble {
2313
2313
  });
2314
2314
  get geometryCenter(): Promise<Vector>;
2315
2315
  scaleUpdate(scaleDiff: number): 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>;
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>;
2320
2320
  getResizeHandleRect(): Promise<Rectangle>;
2321
2321
  }
2322
2322
 
2323
2323
  declare class SvgNodeRenderer {
2324
- constructor(project: Project | { _: "Project" | string });
2325
- render(svgNode: SvgNode | { _: "SvgNode" | string }): Promise<void>;
2324
+ constructor(project: Project | { _: "Project" | (string & {}) });
2325
+ render(svgNode: SvgNode | { _: "SvgNode" | (string & {}) }): Promise<void>;
2326
2326
  }
2327
2327
 
2328
2328
  declare class SvgRenderer {
2329
2329
  svgCache: Promise<{ [key: string]: HTMLImageElement }>;
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;
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;
2335
2335
  }
2336
2336
 
2337
2337
  declare class SymmetryCurveEdgeRenderer extends EdgeRendererClass {
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>;
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>;
2346
2346
  getCycleStageSvg(): Promise<React.ReactNode>;
2347
2347
  getShiftingStageSvg(): Promise<React.ReactNode>;
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;
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;
2352
2352
  }
2353
2353
 
2354
2354
  declare type SyncableKey = "text" | "color" | "details";
@@ -2362,7 +2362,7 @@ declare class SyncAssociation extends Association {
2362
2362
  _isSelected: Promise<boolean>;
2363
2363
  get isSelected(): Promise<boolean>;
2364
2364
  set isSelected(value: boolean);
2365
- constructor(project: Project | { _: "Project" | string }, {
2365
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
2366
2366
  uuid = crypto.randomUUID() as string,
2367
2367
  keys = ["text", "color", "details"] as SyncableKey[],
2368
2368
  associationList = [] as StageObject[],
@@ -2373,7 +2373,7 @@ declare class SyncAssociation extends Association {
2373
2373
  associationList?: StageObject[];
2374
2374
  color?: Color;
2375
2375
  }, unknown = false);
2376
- applyFrom(source: StageObject | { _: "StageObject" | string }): void;
2376
+ applyFrom(source: StageObject | { _: "StageObject" | (string & {}) }): void;
2377
2377
  }
2378
2378
 
2379
2379
  declare class Tab extends React.Component<Record<string, never>, Record<string, never>> {
@@ -2404,12 +2404,12 @@ declare class Tab extends React.Component<Record<string, never>, Record<string,
2404
2404
  }
2405
2405
 
2406
2406
  declare class TabExporter extends BaseExporter {
2407
- export(textNode: TextNode | { _: "TextNode" | string }): Promise<string>;
2408
- getTabText(node: TextNode | { _: "TextNode" | string }, level: number): Promise<string>;
2407
+ export(textNode: TextNode | { _: "TextNode" | (string & {}) }): Promise<string>;
2408
+ getTabText(node: TextNode | { _: "TextNode" | (string & {}) }, level: number): Promise<string>;
2409
2409
  }
2410
2410
 
2411
2411
  declare class TagManager {
2412
- constructor(project: Project | { _: "Project" | string });
2412
+ constructor(project: Project | { _: "Project" | (string & {}) });
2413
2413
  tagSet: Promise<Set<string>>;
2414
2414
  reset(uuids: string[]): Promise<void>;
2415
2415
  addTag(uuid: string): Promise<void>;
@@ -2441,7 +2441,7 @@ declare class TextNode extends ConnectableEntity implements ResizeAble {
2441
2441
  get isEditing(): Promise<any>;
2442
2442
  set isEditing(value: boolean);
2443
2443
  isHiddenBySectionCollapse;
2444
- constructor(project: Project | { _: "Project" | string }, {
2444
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
2445
2445
  uuid = crypto.randomUUID() as string,
2446
2446
  text = "",
2447
2447
  details = [],
@@ -2465,47 +2465,47 @@ declare class TextNode extends ConnectableEntity implements ResizeAble {
2465
2465
  getBorderRadius(): Promise<number>;
2466
2466
  updateFontSizeCache(): void;
2467
2467
  setFontScaleLevel(level: number): Promise<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;
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;
2471
2471
  adjustSizeByText(): Promise<void>;
2472
2472
  adjustHeightByText(): Promise<void>;
2473
2473
  forceAdjustSizeByText(): Promise<void>;
2474
2474
  rename(text: string): Promise<void>;
2475
- resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
2475
+ resizeHandle(delta: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
2476
2476
  resizeWidthTo(width: number): Promise<void>;
2477
2477
  getResizeHandleRect(): Promise<Rectangle>;
2478
- move(delta: Vector | { _: "Vector" | string }): Promise<void>;
2478
+ move(delta: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
2479
2479
  collideWithOtherEntity(other: Entity): void;
2480
- moveTo(location: Vector | { _: "Vector" | string }): Promise<void>;
2480
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): Promise<void>;
2481
2481
  }
2482
2482
 
2483
2483
  declare class TextNodeRenderer {
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>;
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>;
2489
2489
  }
2490
2490
 
2491
2491
  declare class TextRenderer {
2492
2492
  cache;
2493
- constructor(project: Project | { _: "Project" | string });
2493
+ constructor(project: Project | { _: "Project" | (string & {}) });
2494
2494
  hash(text: string, size: number): Promise<string>;
2495
2495
  getCache(text: string, size: number): Promise<void>;
2496
2496
  getCacheNearestSize(text: string, size: number): Promise<ImageBitmap | undefined>;
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;
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;
2509
2509
  textArrayCache: Promise<LruCache<string, string[]>>;
2510
2510
  textToTextArrayWrapCache(text: string, fontSize: number, limitWidth: number): Promise<string>[];
2511
2511
  textToTextArray(text: string, fontSize: number, limitWidth: number): Promise<string>[];
@@ -2515,8 +2515,8 @@ declare class TextRenderer {
2515
2515
  declare const transformedKeys;
2516
2516
 
2517
2517
  declare class TreeImporter extends BaseImporter {
2518
- constructor(project: Project | { _: "Project" | string });
2519
- import(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
2518
+ constructor(project: Project | { _: "Project" | (string & {}) });
2519
+ import(text: string, indention: number, diffLocation: Vector | { _: "Vector" | (string & {}) } = Vector.getZero()): void;
2520
2520
  importFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
2521
2521
  getIndentLevel(line: string, indention: number): Promise<number>;
2522
2522
  }
@@ -2550,10 +2550,10 @@ declare class UrlNode extends ConnectableEntity {
2550
2550
  get titleRectangle(): Promise<Rectangle>;
2551
2551
  get urlRectangle(): Promise<Rectangle>;
2552
2552
  get rectangle(): Promise<Rectangle>;
2553
- move(delta: Vector | { _: "Vector" | string }): void;
2554
- moveTo(location: Vector | { _: "Vector" | string }): void;
2553
+ move(delta: Vector | { _: "Vector" | (string & {}) }): void;
2554
+ moveTo(location: Vector | { _: "Vector" | (string & {}) }): void;
2555
2555
  isHiddenBySectionCollapse: Promise<boolean>;
2556
- constructor(project: Project | { _: "Project" | string }, {
2556
+ constructor(project: Project | { _: "Project" | (string & {}) }, {
2557
2557
  uuid = crypto.randomUUID() as string,
2558
2558
  title = "",
2559
2559
  details = [],
@@ -2566,47 +2566,47 @@ declare class UrlNode extends ConnectableEntity {
2566
2566
  }
2567
2567
 
2568
2568
  declare class UrlNodeRenderer {
2569
- constructor(project: Project | { _: "Project" | string });
2570
- render(urlNode: UrlNode | { _: "UrlNode" | string }): void;
2571
- renderHoverState(urlNode: UrlNode | { _: "UrlNode" | string }): void;
2569
+ constructor(project: Project | { _: "Project" | (string & {}) });
2570
+ render(urlNode: UrlNode | { _: "UrlNode" | (string & {}) }): void;
2571
+ renderHoverState(urlNode: UrlNode | { _: "UrlNode" | (string & {}) }): void;
2572
2572
  }
2573
2573
 
2574
2574
  declare class VerticalPolyEdgeRenderer extends EdgeRendererClass {
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>;
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>;
2579
2579
  fixedLength: Promise<number>;
2580
- renderTest(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
2580
+ renderTest(edge: LineEdge | { _: "LineEdge" | (string & {}) }): Promise<void>;
2581
2581
  gaussianFunction(x: number): Promise<void>;
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>;
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>;
2588
2588
  getCycleStageSvg(): Promise<React.ReactNode>;
2589
2589
  getShiftingStageSvg(): Promise<React.ReactNode>;
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;
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;
2592
2592
  }
2593
2593
 
2594
2594
  declare class WorldRenderUtils {
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;
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;
2605
2605
  }
2606
2606
 
2607
2607
  // ── 扩展宿主 API ──
2608
2608
 
2609
- export declare function extensionHostApiFactory(extension: Extension | { _: "Extension" | string }): {
2609
+ export declare function extensionHostApiFactory(extension: Extension | { _: "Extension" | (string & {}) }): {
2610
2610
  toast(message: string): Promise<void>;
2611
2611
  toast_success(message: string): Promise<void>;
2612
2612
  toast_error(message: string): Promise<void>;
@@ -2630,7 +2630,7 @@ export declare function extensionHostApiFactory(extension: Extension | { _: "Ext
2630
2630
  tabs_getAllProjects(): Promise<Promise<Project>[]>;
2631
2631
  tabs_getCurrent(): Promise<Promise<Tab | null>>;
2632
2632
  tabs_getCurrentProject(): Promise<Promise<Project | null>>;
2633
- entity_registerType(typeName: string, initialData: any, collisionBox: CollisionBox | { _: "CollisionBox" | string }, 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>;
2634
2634
  entity_onClick(typeName: string, handler: (payload: ClickEventPayload) => void): Promise<void>;
2635
2635
  entity_create(typeName: string, data: any, location: { x: number; y: number }): Promise<Promise<ExtensionEntity>>;
2636
2636
  };