@relation-graph/vue3 3.0.4

package/types/packages/relation-graph-models/models/RelationGraphWith6Effect.d.ts

@@ -0,0 +1,72 @@
+import { RGNode, RGRectTarget } from '../../types';
+import { RelationGraphWith5Zoom } from './RelationGraphWith5Zoom';
+/**
+* Methods related to effects in the relation-graph component
+*/
+export declare class RelationGraphWith6Effect extends RelationGraphWith5Zoom {
+    constructor();
+    /**
+     * <RelationGraph/> Automatically adjust the height of the canvas to fit the content, while maintaining the width of the canvas unchanged.
+     * - By default, the height of the <RelationGraph/> component is the height of the parent element. Sometimes we want to automatically adjust the height according to the amount of content to fit the content. This method can achieve this function.
+     * - Note: This method will modify the height attribute of the canvas. Please ensure that the parent element allows the height of the child element to change, otherwise it may not achieve the expected effect.
+     * - Note: This method is suitable for scenarios where there is less content and you want the canvas height to adapt to the content. If there is more content, it is recommended to use the zoomToFit method to ensure that the content is fully displayed.
+     * @param padding Padding around the content, default is 20px
+     *
+     */
+    fitContentHeight(padding?: number): void;
+    /**
+     * Move the specified nodes to the center of the visible area
+     * @param nodes Optional, defaults to all nodes in the graph
+     * @inner
+     * @protected
+     */
+    protected _moveToCenter(nodes?: (RGNode | RGRectTarget)[]): void;
+    /**
+     * Move the specified coordinates on the canvas to the center of the visible area
+     * @param x X coordinate on the canvas
+     * @param y Y coordinate on the canvas
+     */
+    setCanvasCenter(x: number, y: number): void;
+    /**
+     * Zoom to fit the appropriate size, which means making the specified nodes visible in the view and occupying the view as much as possible.
+     * @param nodes Optional, defaults to all nodes in the graph
+     */
+    zoomToFit(nodes?: (RGNode | RGRectTarget)[]): void;
+    zoomToFitWithAnimation(nodes?: (RGNode | RGRectTarget)[]): Promise<void>;
+    moveToCenterWithAnimation(nodes?: (RGNode | RGRectTarget)[]): Promise<void>;
+    /**
+     * Enable node position animation
+     * - After enabling, when the node position changes, there will be a smooth transition animation effect.
+     */
+    enableNodeXYAnimation(): void;
+    /**
+     * Disable node position animation
+     * - After disabling, when the node position changes, it will directly jump to the new position without animation.
+     */
+    disableNodeXYAnimation(): void;
+    /**
+     * Enable canvas transformation animation
+     * - After enabling, when the canvas is panned or zoomed, there will be a smooth transition animation effect.
+     */
+    enableCanvasAnimation(): void;
+    /**
+     * Disable canvas transformation animation
+     * - After disabling, when the canvas is panned or zoomed, it will directly jump to the new position or scale without animation.
+     */
+    disableCanvasAnimation(): void;
+    /**
+     * Focus on the specified node by its ID
+     * @param nodeId The ID of the node to focus on
+     */
+    focusNodeById(nodeId: string): void;
+    /**
+     * @deprecated
+     */
+    focusRootNode(): void;
+    /**
+     * @inner
+     * @param thisNode
+     * @private
+     */
+    private focusNode;
+}

package/types/packages/relation-graph-models/models/RelationGraphWith6Layout.d.ts

@@ -0,0 +1,85 @@
+import { RGLayout, RGLayoutOptions, RGNode } from '../../types';
+import { RelationGraphWith6Effect } from './RelationGraphWith6Effect';
+/**
+ * Methods related to layout in the relation-graph component
+ */
+export declare class RelationGraphWith6Layout extends RelationGraphWith6Effect {
+    constructor();
+    /**
+     * Assign positions to the nodes in the current graph based on the layout configuration set in the options
+     * - By default, the first node in the graph is used as the root node for layout. You can also specify a custom root node by passing a node object or node id as a parameter.
+     * - If nodes were added to the graph shortly before calling this method, it will wait for a short time to ensure that the addition of nodes is completed before performing the layout.
+     * @param customRootNode Optional, specify a custom root node for layout, can be a node object or node id
+     * @return Promise<void>
+     */
+    doLayout(customRootNode?: RGNode | string): Promise<void>;
+    private _layoutTimer;
+    private _layoutPromise;
+    private _layoutResolve;
+    /**
+     * @inner
+     * @private
+     */
+    private _doLayout;
+    /**
+     * @inner
+     * @protected
+     * @param doLayout
+     */
+    refresh(doLayout?: boolean): Promise<void>;
+    /**
+     * @inner
+     * @private
+     */
+    private placeOtherNodes;
+    /**
+     * @inner
+     * @private
+     */
+    private placeSingleNodes;
+    /**
+     * @inner
+     * @private
+     */
+    private sortGroups;
+    /**
+     * @inner
+     * @private
+     */
+    private placeNextNetwork;
+    /**
+     * If the current layout is force-directed, you can call this method to start or stop the real-time force-directed calculation
+     * - Note: The center layout inherits the force layout and also supports auto layout functionality.
+     */
+    toggleAutoLayout(): void;
+    layoutor: RGLayout | undefined;
+    /**
+     * If the current layout is force, you can call this method to start the force-directed calculation
+     * - Note: The center layout inherits the force layout and also supports auto layout functionality.
+     */
+    startAutoLayout(): void;
+    /**
+     * If the current layout is force, you can call this method to stop the force-directed calculation
+     */
+    stopAutoLayout(): void;
+    /**
+     * Create a layout instance. After creating the layout instance, you can use the placeNodes method of the layout instance to layout nodes.
+     * - Through this method, you can create multiple layout instances with different configurations to layout different nodes of the same graph in different ways, forming a composite layout effect.
+     * - Example:
+     * ```ts
+     * const layoutor = graphInstance.createLayout({
+     *    layoutName: 'tree',
+     *    from: 'left', // left, right, top, bottom
+     *    treeNodeGapH: 200, // Horizontal spacing between nodes
+     *    treeNodeGapV: 50, // Vertical spacing between nodes
+     * });
+     * layoutor.placeNodes(nodes, rootNode);
+     * ```
+     * @param layoutOptions Layout configuration items, type: RGLayoutOptions. When isMainLayout is true, the configuration items here will override the layout configuration items in the overall configuration items of the graph.
+     * @param isMainLayout Whether it is the main layout instance. The main layout instance will affect the layout-related configuration items of the graph, and can control the auto layout function through the startAutoLayout and stopAutoLayout methods of the graph. Default value: false
+     * @return Layout instance A layout instance with a placeNodes method
+     *
+     */
+    createLayout<Layout extends RGLayout>(layoutOptions: RGLayoutOptions, isMainLayout?: boolean): Layout;
+    setLayoutor(layoutor: RGLayout, isMainLayout: boolean, supportAutoLayout?: boolean): void;
+}

package/types/packages/relation-graph-models/models/RelationGraphWith7Event.d.ts

@@ -0,0 +1,270 @@
+import { CreatingLinePlotOptions, CreatingNodePlotOptions, RGLine, RGLineConnectEventHandler, RGLineTarget, RGNode, RGPosition, RGUserEvent, RGCoordinate, JsonLine } from '../../types';
+import { RelationGraphWith6Layout } from './RelationGraphWith6Layout';
+/**
+ *  The relation-graph component UI and graphInstance event bus handle user interaction events.
+ *  - Most of the events handled here are user interaction events, while some other events are handled by the following classes:
+ *    - Editor-related events are handled in RelationGraphWith91Editing
+ *    - MiniView-related events are handled in RelationGraphWith92MiniView
+ *
+ */
+export declare class RelationGraphWith7Event extends RelationGraphWith6Layout {
+    constructor();
+    private _prevClickNodeTime;
+    /**
+     * Triggered when the user clicks on a node
+     * @param node The clicked node object
+     * @param e MouseDown or TouchStart event
+     *
+     */
+    onNodeClick(node: RGNode, e: RGUserEvent): void;
+    protected _nodeXYMappingBeforeDrag: {
+        [nodeId: string]: {
+            x: number;
+            y: number;
+        };
+    };
+    /**
+     * Triggered when the user starts dragging a node
+     * - When the user starts dragging but does not move the node, it is considered as clicking the node, and the onNodeClick event will be triggered instead.
+     * @param willMoveNode The node object that will be moved
+     * @param e MouseDown or TouchStart event
+     */
+    onNodeDragStart(willMoveNode: RGNode, e: RGUserEvent): void;
+    /**
+     * @inner
+     * @protected
+     */
+    protected canvasAutoMoving: (draggingEventXy: RGCoordinate) => boolean;
+    private _canvasMovingTimer;
+    /**
+     * @inner
+     * @protected
+     */
+    private _onNodeDragEnd;
+    /**
+     * Triggered when the user clicks on a line
+     * - Triggered when the user clicks on a line path or line text
+     * @param line The clicked line object
+     * @param e MouseDown or TouchStart event
+     */
+    onLineClick(line: RGLine, e: RGUserEvent): void;
+    /**
+     * Triggered when the node's expand/collapse button is clicked.
+     * - This method will expand or collapse all descendant nodes of the node.
+     * - If the node is collapsed, it will be expanded; if it is expanded, it will be collapsed.
+     * @param node The node object to be expanded or collapsed
+     * @param e
+     */
+    expandOrCollapseNode(node: RGNode, e: RGUserEvent): void;
+    /**
+     * Expand the specified node
+     * - This method will expand the specified node and make its child nodes visible.
+     * @param node The node object to be expanded
+     * @param e
+     */
+    expandNode(node: RGNode, e?: RGUserEvent): void;
+    /**
+     * Collapse the specified node
+     * - This method will collapse the specified node and hide its child nodes.
+     * @param node The node object to be collapsed
+     * @param e
+     */
+    collapseNode(node: RGNode, e?: RGUserEvent): void;
+    private _relayoutTaskTimer;
+    /**
+     * After the node is expanded or collapsed, the visibility of the related nodes needs to be recalculated, and re-layout may be required.
+     * @inner
+     * @private
+     */
+    private _effectWhenExpandedOrCollapsed;
+    /**
+     * @inner
+     * @private
+     */
+    private onCanvasDragEnd;
+    /**
+     * User clicks on the canvas
+     * @param e
+     */
+    onCanvasClick(e: RGUserEvent): void;
+    /**
+     * @inner
+     * @private
+     */
+    private getNodeAtEvent;
+    /**
+     * @inner
+     * @private
+     */
+    private onCanvasSelectionEnd;
+    /**
+     * Start the "creating node" interaction state
+     * - You can set the callback function onCreateNode in the setting, and add the node to the graph data through graphInstance.addNodes([newNodeJson]); in the callback function.
+     * - You can also set templateMove in the setting to get the move event of the node during placement, so as to achieve complex logic (such as highlighting an existing node when moving to it, and recording the id of this highlighted node, so that in the onCreateNode callback function, you can directly create a new node associated with the highlighted node)
+     * @param e
+     * @param setting Settings used to set the template information of the node being created, the callback function when the creation is completed, etc.
+     */
+    startCreatingNodePlot(e: RGUserEvent, setting: CreatingNodePlotOptions): void;
+    /**
+     * Start the "creating line" interaction state
+     * - When the line creation is completed, you need to call graphInstance.addLines([newLineJson]); in the onCreateLine callback function (or through the onLineBeCreated event of the <RelationGraph> component) to add the new line to the graph data.
+     * - You can also set fromNode in the setting to specify the starting node of the line.
+     * @param e
+     * @param setting Settings used to set the template information of the line being created, the callback function when the creation is completed, etc.
+     *
+     */
+    startCreatingLinePlot(e: RGUserEvent, setting: CreatingLinePlotOptions): void;
+    private _onMovingWhenCreatingLine;
+    /**
+     * Stop the "creating line" interaction state
+     * - This method is generally called by relation-graph itself, and users do not need to call this method manually. Unless the user needs to complete complex special interaction logic.
+     *
+     */
+    stopCreatingLinePlot(): void;
+    /**
+     * @inner
+     * @private
+     */
+    private onMovingWhenCreatingLinePlot;
+    /**
+     * @inner
+     * @private
+     */
+    private onCanvasClickWhenCreatingLinePlot;
+    _step1EventTime: number;
+    /**
+     * @inner
+     * @private
+     */
+    private onNodeClickWhenCreatingLinePlot;
+    _onCreateLineCallback: RGLineConnectEventHandler | undefined;
+    /**
+     * Triggered when the creation of a line is ready. You can modify the line data in this event, or return true to prevent the line from being created (for example, if the user selects a node that is not allowed to be connected and requires the user to select another node).
+     * - This method will ultimately trigger the `onLineBeCreated` event of the <RelationGraph /> component. In this event, users can obtain the line data and use the graphInstance.addLines([newLineJson]) method to complete the data change and add the line to the graph.
+     * @param from Current line start node, may be null
+     * @param to Current line end node, may be null or RGPosition, Position type means the user did not select a node to connect to, but clicked on the canvas to create a line to that position.
+     * @returns Return true to prevent the line from being created.
+     * @protected
+     */
+    protected onReadyToCreateLine(from: RGNode, to: RGNode | RGPosition): false | RGCoordinate | undefined;
+    /**
+     * User right-click context menu event
+     * - Finally, you can get this event through the onContextmenu event, and you can get the position where the user right-clicked and the type of object clicked (canvas | line | node) and the object through this event.
+     * @param e
+     */
+    onContextmenu(e: RGUserEvent): void;
+    /**
+     * Toggle fullscreen mode
+     - If newValue is true, enter fullscreen mode
+     - If newValue is false, exit fullscreen mode
+     - If newValue is not provided, toggle fullscreen mode
+     * @param newValue
+     */
+    fullscreen(newValue?: boolean): Promise<void>;
+    /**
+     * User scroll mouse wheel event
+     * - Supports touchpad and mouse wheel
+     * - This event will determine whether to zoom the canvas or scroll the canvas based on whether the user presses the Ctrl/Cmd key and options.wheelEventAction
+     * - When options.disableWheelEvent is true, there will be no response
+     * @param e
+     */
+    onMouseWheel(e: WheelEvent): true | undefined;
+    /**
+     * @inner
+     * @private
+     */
+    private _applyWheelEvent;
+    private _mouseWheelTimer;
+    private _mouseWheelEventPrevApplyTime;
+    private _mouseWheelForce;
+    /**
+     * @inner
+     * @private
+     */
+    private _onMouseWheel;
+    /**
+     * Scroll the canvas
+     * @param buffX - The amount to scroll
+     * @param buffY - The amount to scroll
+     */
+    scrollView(buffX: number, buffY: number): void;
+    /**
+     * @inner
+     * @private
+     */
+    private onLineDragStart;
+    onLineDragEnd(x_buff: number, y_buff: number, e: RGUserEvent): void;
+    /**
+     * User Start Drag Canvas
+     * - This method will determine whether to create a selection area or move the canvas based on whether the user is holding down the Shift key or the configuration item options.dragEventAction.
+     * - When options.dragEventAction is set to 'none', clicking and dragging on the canvas will only trigger a click event and will not create a selection area or move the canvas.
+     * @param e
+     */
+    onCanvasDragStart(e: RGUserEvent): void;
+    /**
+     * User Start Move Canvas
+     *
+     * @param e
+     * @param forceStartMove
+     */
+    startMoveCanvas(e: RGUserEvent, forceStartMove?: boolean): void;
+    /**
+     * @inner
+     * @private
+     */
+    protected onCanvasDragging(newX: number, newY: number, buffX: number, buffY: number): void;
+    /**
+     * @inner
+     * @param e
+     */
+    private onCanvasDragStop;
+    /**
+     * @inner
+     * @param e
+     */
+    private startCreateSelection;
+    private _fullscreenchangeHandler;
+    /**
+     * Monitor fullscreen changes
+     * @inner
+     * @private
+     */
+    protected addFullscreenListener(): void;
+    /**
+     * Remove fullscreen change monitoring
+     * @inner
+     * @private
+     */
+    protected removeFullscreenListener(): void;
+    /**
+     * Default line connect end handler for <RGConnectTarget /> component
+     * - This method does not make any data changes. Users need to obtain the line information through the onLineConnectEnd event of the <RGConnectTarget /> component, and use the graphInstance.addLines([newLineJson]) method to complete the data change.
+     *
+     * @inner
+     * @private
+     */
+    defaultLineConnectEndHandler(from: RGNode | RGLineTarget | RGPosition, to: RGNode | RGLineTarget | RGPosition, newLine?: JsonLine): void;
+    /**
+     * Default line vertex change handler
+     * - This method does not make any data changes. Users need to obtain the line information through the onLineBeCreated event when the line is created or the line vertex is changed, and use the graphInstance.addLines([newLineJson]) method to complete the data change.
+     * - Why does the line vertex change also need to be added through addLines to add data?
+     *      - Because the implementation of line vertex change is to delete the original line data first, and then add a new line data to achieve it. However, the line data obtained through the onLineBeCreated event will be a line data with an id and all information identical to the original line.
+     *
+     * @inner
+     * @param from
+     * @param to
+     * @param newLine
+     */
+    defaultLineVertexBeChangedHandler(from: RGNode | RGLineTarget | RGPosition, to: RGNode | RGLineTarget | RGPosition, newLine?: JsonLine): void;
+    /**
+     * Sleep for a specified amount of time
+     * @param time - The time to sleep in milliseconds
+     */
+    sleep(time: number): Promise<void>;
+    /**
+     * This method is called by the force layout engine to update the view after each iteration of the force layout calculation is completed.
+     * @inner
+     * @private
+     */
+    forceLayoutTickCallback(): void;
+}

package/types/packages/relation-graph-models/models/RelationGraphWith91Editing.d.ts

@@ -0,0 +1,210 @@
+import { RelationGraphWith9EasyView } from './RelationGraphWith9EasyView';
+import { JsonLineLike, RGCtrlPointForLine44, RGJunctionPoint, RGLine, RGLineConnectEventHandler, RGLineVertexBeDroppedEventHandler, RGNode, RGResizeHandlePosition, RGUserEvent } from '../../types';
+/**
+ * Capability extension class related to the editor of the relation-graph component
+ */
+export declare class RelationGraphWith91Editing extends RelationGraphWith9EasyView {
+    constructor();
+    /**
+     * Set the nodes being edited
+     * - Set to null or an empty array to cancel all nodes being edited
+     * - After setting, the position and size of the editing controller (<RGEditingNodeController>) will be automatically updated. If there are no editing nodes, the controller will be hidden.
+     * @param nodes
+     *
+     */
+    setEditingNodes(nodes: RGNode[] | null): void;
+    /**
+     * Add a node to the editing nodes
+     * @param node
+     */
+    addEditingNode(node: RGNode): void;
+    /**
+     * Remove a node from the editing nodes
+     * @param node
+     */
+    removeEditingNode(node: RGNode): void;
+    /**
+     * Toggle the editing state of a node
+     * @param node
+     */
+    toggleEditingNode(node: RGNode): void;
+    /**
+     * Update the view of the editing controller
+     * - This method is automatically called when the editing nodes are set or changed.
+     */
+    updateEditingControllerView(): void;
+    /**
+     * @inner
+     * @protected
+     */
+    protected _updateEditingControllerView(): void;
+    protected _onResizing: any;
+    protected _onResizeEnd: any;
+    protected _startPoint: {
+        x: number;
+        y: number;
+    };
+    protected _startEventCanvasXy: {
+        x: number;
+        y: number;
+    };
+    protected _startSizeCanvasXy: {
+        x: number;
+        y: number;
+    };
+    protected _startSize: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        widthOnCanvas: number;
+        heightOnCanvas: number;
+    };
+    protected _resizeType: RGResizeHandlePosition;
+    protected _nodeStartSizeMap: WeakMap<RGNode, any>;
+    protected resizeMinLimit: {
+        width: number;
+        height: number;
+    };
+    /**
+     * User starts resizing the editing controller
+     * @param type User handles the resize handle position: "t" | "r" | "b" | "l" | "tl" | "tr" | "bl" | "br"
+     * @param e
+     */
+    onResizeStart(type: RGResizeHandlePosition, e: RGUserEvent): void;
+    private _resizeDraggingTimer;
+    private _resizeDraggingEvent;
+    private _resizeDraggingStoped;
+    /**
+     * @inner
+     * @private
+     */
+    private onResizing;
+    /**
+     * @inner
+     * @private
+     */
+    private onResizingRequest;
+    /**
+     * @inner
+     * @private
+     */
+    private _applyResizeScale;
+    /**
+     * @inner
+     * @private
+     */
+    private onResizeEnd;
+    /**
+     * When dragging a node, update the position of the dragged node and other nodes being edited
+     * - This method is called internally by relation-graph and does not need to be called by the user
+     * @inner
+     * @private
+     */
+    protected draggingSelectedNodes(draggedNode: RGNode, newX: number, newY: number, buff_x: number, buff_y: number): void;
+    /**
+     * @inner
+     * @private
+     */
+    protected _updateEditingConnectControllerView(): void;
+    /**
+     * Set the line being edited
+     * - When set to null, the line being edited is canceled
+     * - When the line being edited is not null, the <RGEditingLineController> controller will automatically display and update its position
+     * @param line The line being edited
+     */
+    setEditingLine(line: RGLine | null): void;
+    /**
+     * @inner
+     * @private
+     */
+    private updateReferenceLineView;
+    /**
+     * Hide the editing line view
+     * - Generally used in this scenario: when editing a line, the line editing controller may block the display of the line. When modifying the appearance of the line (such as arrows, etc.), this method can be called to hide the line editing controller view, allowing users to preview the final effect of the line in time.
+     */
+    hideEditingLineView(): void;
+    /**
+     * Update the view of the editing line controller
+     * - This method is automatically called when the editing line is set or changed.
+     */
+    updateEditingLineView(): void;
+    /**
+     * @inner
+     * @private
+     */
+    protected _updateEditingLineView(): void;
+    /**
+     * Start dragging the start or end point of the line to reselect the start or end point of the line
+     * - During the process of changing the start or end point of the line, the line will be removed. When reconnecting, you can get the new line information (the new line information id and other attributes will be retained) through onLineConnectEventHandler(or through the onLineBeCreated event of the <RelationGraph> component). You need to complete the data change through graphInstance.addLines([newJsonLine]) to finally complete the modification of the line endpoint.
+     * @param type Choose to drag the start point or end point of the line, 'start' means dragging the start point, 'end' means dragging the end point
+     * @param $event
+     * @param onLineConnectEventHandler Callback function after line connection is completed, you can get the new line information through the parameters, you need to complete the data change through graphInstance.addLines([newJsonLine])
+     *
+     */
+    startMoveLineVertex(type: 'start' | 'end', $event: RGUserEvent, onLineConnectEventHandler: RGLineConnectEventHandler): void;
+    private _startCreateLineFromNodeTime;
+    /**
+     * Start creating a line from a specified starting point
+     * - The <RGConnectSource> and <RGConnectTarget> components will use this method, and you can call this method yourself to create a line from a specified node
+     * - It is worth noting that: fromNode can be empty. If it is empty, it will try to automatically find the starting point. The logic is:
+     *     - 1. Determine whether lineTemplate.from is empty. If it is not empty, use the node corresponding to lineTemplate.from as the starting point
+     *     - 2. Find the only node from the currently edited nodes as the starting node.
+     *     - 3. If the starting node still cannot be found, an exception is thrown
+     * - When the user completes the connection of the line, the onLineConnectEventHandler callback will be triggered (or through the onLineBeCreated event of the <RelationGraph> component), and you need to add the line data in the callback, through
+     *
+     * @param fromNode
+     * @param useLineTemplate
+     * @param $event
+     * @param onLineConnectEventHandler
+     */
+    startCreateLineFromNode(fromNode: RGNode | null | undefined, useLineTemplate: JsonLineLike, $event: RGUserEvent, onLineConnectEventHandler: RGLineConnectEventHandler): void;
+    /**
+     * When the start or end point of the line is connected to the junction point of a node, this method is called
+     * - This method is called internally by relation-graph and does not need to be called by the user
+     * @param type
+     * @param $event
+     * @param junctionPointOffset
+     * @param onLineVertexBeDropped
+     * @inner
+     */
+    onLineVertexBeDropped(type: RGJunctionPoint, $event: RGUserEvent, junctionPointOffset?: {
+        x: number;
+        y: number;
+    }, onLineVertexBeDropped?: RGLineVertexBeDroppedEventHandler): void;
+    /**
+     * Start dragging the line text position
+     * - This method is called internally by relation-graph and does not need to be called by the user
+     * @param $event
+     * @param moveEndCallback
+     * @inner
+     */
+    startMoveLineText($event: RGUserEvent, moveEndCallback: () => void): void;
+    /**
+     * Start dragging the line control point (applicable to lines with curved line types)
+     * - This method is called internally by relation-graph and does not need to be called by the user
+     * @param ctrlPointIndex
+     * @param $event
+     * @param onLinePathChanged
+     * @inner
+     */
+    startMoveLine6CtrlPoint(ctrlPointIndex: number, $event: RGUserEvent, onLinePathChanged: (line: RGLine) => void): void;
+    /**
+     * Start dragging the line control point (applicable to lines with line type RGLineShape.StandardOrthogonal)
+     * - This method is called internally by relation-graph and does not need to be called by the user
+     * @param split
+     * @param $event
+     * @param onLinePathChanged
+     */
+    startMoveLine44CtrlPoint(split: RGCtrlPointForLine44, $event: RGUserEvent, onLinePathChanged: (line: RGLine) => void): void;
+    /**
+     * When the start or end point of the line is dropped onto the connection point on the node connection controller (<RGEditingConnectController />), this method is called
+     * - This method is called internally by relation-graph and does not need to be called by the user
+     * @param junctionPoint
+     * @param $event
+     * @param connectBoxDom
+     * @param lineVertexBeDroppedEventHandler
+     * @inner
+     */
+    onLineVertexBeDroppedOnConnectController(junctionPoint: RGJunctionPoint, $event: RGUserEvent, connectBoxDom?: HTMLElement, lineVertexBeDroppedEventHandler?: RGLineVertexBeDroppedEventHandler): void;
+}