@knotx/core 0.2.14 → 0.3.1

package/dist/index.d.ts

@@ -1,169 +1,12 @@
-import { R as RenderType, I as IRecord, a as IEngineRuntime, N as Node, E as Edge, C as Container, L as LayerComponent, b as IPlugin, P as Plugin, c as Layer, d as NodeRenderType, e as EdgeRenderType, f as PluginData, g as PluginTools, h as EngineTools, i as IPluginInfo, j as IPluginToolInfo } from './shared/core.B-u2ysAC.js';
-export { B as BasePlugin, t as EdgeOperation, r as EdgeOperationPipe, v as EdgeOperatorFunction, n as EdgeProps, H as HorizontalAlignment, l as NodeMeasured, s as NodeOperation, q as NodeOperationPipe, u as NodeOperatorFunction, k as NodePosition, m as NodeProps, p as PluginConfigs, o as Position, V as VerticalAlignment } from './shared/core.B-u2ysAC.js';
-import { Schema } from 'jsonschema';
+import { E as Engine } from './shared/core.CpyG0nWq.js';
+export { D as BasePlugin, y as CallToolMethod, C as Container, d as Edge, t as EdgeOperation, r as EdgeOperationPipe, v as EdgeOperatorFunction, e as EdgeProps, g as EdgeRenderType, x as EngineOptions, n as EngineTools, H as HorizontalAlignment, w as IEngineRuntime, i as IPlugin, o as IPluginInfo, I as IRecord, p as IToolInfo, A as Interaction, B as InteractionManager, z as InteractionPriority, L as Layer, h as LayerComponent, b as Node, a as NodeMeasured, s as NodeOperation, q as NodeOperationPipe, u as NodeOperatorFunction, N as NodePosition, c as NodeProps, f as NodeRenderType, j as Plugin, k as PluginConfigs, l as PluginData, m as PluginTools, P as Position, R as RenderType, V as VerticalAlignment } from './shared/core.CpyG0nWq.js';
+import { RenderType, IPlugin, LayerComponent } from '@knotx/core';
 import { BehaviorSubject } from 'rxjs';
-import { DataManager, DataOperationPipe, DataOperation } from '@knotx/data';
 export * from '@knotx/data';
-import { RenderType as RenderType$1, IPlugin as IPlugin$1, LayerComponent as LayerComponent$1 } from '@knotx/core';
 export * from '@knotx/utils';
+import 'jsonschema';
 
-/**
- * 用户交互优先级定义
- * 数值越大优先级越高
- */
-declare enum InteractionPriority {
-    /** 文本输入框激活状态（输入中需独占） */
-    InputActive = 2000,
-    /** 实体连接拖拽 */
-    EntityConnectDrag = 1930,
-    /** 实体测量拖拽 */
-    EntityMeasureDrag = 1920,
-    /** 实体位置拖拽 */
-    EntityPositionDrag = 1910,
-    /** 连续操作：画布拖拽、缩放等进行中的动作 */
-    ContinuousDrag = 1900,
-    /** 右键菜单/上下文操作 */
-    ContextMenu = 1800,
-    /** 键盘快捷键（如 Delete/Ctrl+C） */
-    KeyboardShortcut = 1700,
-    /** 单击选中元素 */
-    ClickSelection = 1600,
-    /** 双击编辑元素 */
-    DoubleClickEdit = 1500,
-    /** 框选（多选）操作 */
-    MarqueeSelection = 1300,
-    /** 套索选择（Lasso Select） */
-    LassoSelection = 1250,
-    /** 长按操作（长按菜单/工具） */
-    LongPress = 1100,
-    /** 悬停提示（Hover Tooltip） */
-    HoverTooltip = 1000,
-    /** 画布平移（空格拖拽或手势） */
-    CanvasPan = 900,
-    /** 画布缩放（滚轮或双指） */
-    CanvasZoom = 800,
-    /** 多指手势（如三指滑动） */
-    MultiTouchGesture = 700
-}
-interface Interaction {
-    pluginId: string;
-    type: string;
-    priority: InteractionPriority;
-    active?: boolean;
-}
-/**
- * 交互管理器
- */
-declare class InteractionManager {
-    private interactions;
-    /**
-     * 获取当前活动的交互
-     */
-    get activeInteraction(): Interaction | undefined;
-    /**
-     * 检查是否可以交互
-     * @param pluginId 插件ID
-     * @param type 交互类型
-     * @param autoStartPriority 自动启动优先级
-     * @returns 是否可以交互
-     */
-    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
-    /**
-     * 启动交互
-     * @param pluginId 插件ID
-     * @param type 交互类型
-     * @param priority 优先级
-     * @returns 取消交互的函数
-     */
-    startInteraction(pluginId: string, type: string, priority: InteractionPriority): () => void;
-    /**
-     * 结束交互
-     * @param pluginId 插件ID
-     * @param type 交互类型
-     */
-    endInteraction(pluginId: string, type: string): void;
-    private updateActive;
-}
-
-interface EngineOptions<TNode extends IRecord = IRecord, TEdge extends IRecord = IRecord> {
-    container: Container;
-    plugins?: Plugin[];
-    pluginConfig?: IRecord;
-    nodes?: Node<TNode>[];
-    edges?: Edge<TEdge>[];
-    runtime?: IEngineRuntime;
-}
-declare module '@knotx/core' {
-    interface EngineTools {
-        listPlugins: Engine['listPlugins'];
-        listPluginTools: Engine['listPluginTools'];
-        getNodes: Engine['getNodes'];
-        getEdges: Engine['getEdges'];
-    }
-}
-declare class Engine<TRenderType extends RenderType = RenderType, TNode extends IRecord = IRecord, TEdge extends IRecord = IRecord> {
-    readonly runtime: IEngineRuntime;
-    readonly interactionManager: InteractionManager;
-    readonly nodesManager: DataManager<Node<TNode>>;
-    readonly edgesManager: DataManager<Edge<TEdge>>;
-    private container$;
-    private nodes$;
-    private edges$;
-    private layers$;
-    private plugins$;
-    private nodeRenderers$;
-    private edgeRenderers$;
-    private _pluginDataContainer;
-    private _pluginToolsContainer;
-    private engineTools;
-    private toolParametersValidator;
-    get container(): Container;
-    set container(value: Container);
-    get nodes(): Node<TNode>[];
-    get edges(): Edge<TEdge>[];
-    get layers(): Map<number, LayerComponent<TRenderType>[]>;
-    get plugins(): IPlugin<string, any, RenderType>[];
-    constructor(options: EngineOptions<TNode, TEdge>);
-    private init;
-    getLayerComponents(layer: Layer): LayerComponent<TRenderType>[];
-    addNodePipe(pipe: DataOperationPipe<Node<TNode>>): () => void;
-    addEdgePipe(pipe: DataOperationPipe<Edge<TEdge>>): () => void;
-    changePluginConfig(pluginName: string, config: IRecord): void;
-    dispatchNodeOperation(operation: DataOperation<Node<TNode>>): void;
-    dispatchEdgeOperation(operation: DataOperation<Edge<TEdge>>): void;
-    getPlugin<TPlugin extends IPlugin>(pluginName: TPlugin['name']): TPlugin | undefined;
-    getNode(id: string): Node<TNode> | undefined;
-    getNodeDraft(id: string): Node<TNode> | undefined;
-    getNodes(): Node<TNode>[];
-    getNodeRenderer(type: string): NodeRenderType | undefined;
-    getEdge(id: string): Edge<TEdge> | undefined;
-    getEdgeDraft(id: string): Edge<TEdge> | undefined;
-    getEdges(): Edge<TEdge>[];
-    getEdgeRenderer(type: string): EdgeRenderType | undefined;
-    registerPluginData<T extends keyof PluginData, TP extends keyof PluginData[T]>(pluginName: T, property: TP, data: BehaviorSubject<PluginData[T][TP]>): void;
-    resetPluginData<T extends keyof PluginData>(pluginName: T): void;
-    registerPluginTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, property: TP, data: {
-        description: string;
-        parameters: Schema;
-        func: PluginTools[T][TP];
-    }): void;
-    resetPluginTool<T extends keyof PluginTools>(pluginName: T): void;
-    registerNodeRenderer(type: string, renderer: NodeRenderType): () => void;
-    registerEdgeRenderer(type: string, renderer: EdgeRenderType): (() => void);
-    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
-    startInteraction(pluginId: string, type: string, priority: InteractionPriority): void;
-    endInteraction(pluginId: string, type: string): void;
-    callTool<T extends keyof EngineTools>(engineToolName: T, ...args: Parameters<EngineTools[T]>): ReturnType<EngineTools[T]>;
-    callTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, toolName: TP, ...args: Parameters<PluginTools[T][TP]>): ReturnType<PluginTools[T][TP]>;
-    listPlugins(): IPluginInfo[];
-    listPluginTools({ pluginName }: {
-        pluginName: string;
-    }): IPluginToolInfo[];
-    listEngineTools(): IPluginToolInfo[];
-    destroy(): void;
-}
-
-declare function getLayerRenders<TRenderType extends RenderType$1 = RenderType$1>(plugin: IPlugin$1): LayerComponent$1<TRenderType>[];
+declare function getLayerRenders<TRenderType extends RenderType = RenderType>(plugin: IPlugin): LayerComponent<TRenderType>[];
 
 /**
  * Runtime 类
@@ -226,4 +69,4 @@ declare function use<T, TContext>(hook: () => {
     __contextValue__: TContext;
 }, context: TContext): T;
 
-export { Container, Edge, EdgeRenderType, Engine, type EngineOptions, type EngineTools, IEngineRuntime, IPlugin, IPluginInfo, IPluginToolInfo, IRecord, type Interaction, InteractionManager, InteractionPriority, Layer, LayerComponent, Node, NodeRenderType, Plugin, PluginData, PluginTools, RenderType, Runtime, getLayerRenders, use };
+export { Engine, Runtime, getLayerRenders, use };

package/dist/index.js

@@ -193,17 +193,62 @@ class Engine {
       {
         type: "function",
         name: "getNodes",
-        description: "Get all nodes",
+        description: "Get all nodes data",
         parameters: {}
       },
       {
         type: "function",
         name: "getEdges",
-        description: "Get all edges",
+        description: "Get all edges data",
         parameters: {}
+      },
+      {
+        type: "function",
+        name: "getNode",
+        description: "Get node data",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        type: "function",
+        name: "getEdge",
+        description: "Get edge data",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string" }
+          },
+          required: ["id"]
+        }
       }
     ].map((tool) => [tool.name, tool])));
     __publicField$2(this, "toolParametersValidator", new Validator());
+    __publicField$2(this, "callTool", (pluginNameOrEngineToolName, ...args) => {
+      let toolDefinition;
+      let toolDisplayName;
+      if (this.engineTools.has(pluginNameOrEngineToolName)) {
+        toolDefinition = __spreadProps$1(__spreadValues$1({}, this.engineTools.get(pluginNameOrEngineToolName)), { func: this[pluginNameOrEngineToolName].bind(this) });
+        toolDisplayName = toolDefinition.name;
+      } else {
+        toolDefinition = get(this, ["_pluginToolsContainer", pluginNameOrEngineToolName, args == null ? void 0 : args[0]]);
+        toolDisplayName = `${pluginNameOrEngineToolName}.${args == null ? void 0 : args[0]}`;
+      }
+      const tool = toolDefinition == null ? void 0 : toolDefinition.func;
+      if (!tool || typeof tool !== "function") {
+        throw new Error(`Tool ${String(toolDisplayName)} not found`);
+      }
+      const parameters = args[args.length - 1];
+      const validator = this.toolParametersValidator.validate(parameters, toolDefinition.parameters);
+      if (validator.errors.length > 0) {
+        throw new Error(`Invalid tool parameters: ${validator.errors.map((e) => e.stack).join(", ")}`);
+      }
+      return tool(parameters);
+    });
     var _a;
     this.runtime = (_a = options.runtime) != null ? _a : {};
     this.container$.next(options.container);
@@ -274,7 +319,7 @@ class Engine {
   addEdgePipe(pipe) {
     return this.edgesManager.addDataOperationPipe(pipe);
   }
-  changePluginConfig(pluginName, config) {
+  changePluginConfig({ pluginName, config }) {
     var _a, _b;
     (_b = (_a = this.plugins$.value.get(pluginName)) == null ? void 0 : _a.onConfigChange) == null ? void 0 : _b.call(_a, config);
   }
@@ -284,13 +329,13 @@ class Engine {
   dispatchEdgeOperation(operation) {
     this.edgesManager.dispatch(operation);
   }
-  getPlugin(pluginName) {
+  getPlugin({ pluginName }) {
     return this.plugins$.value.get(pluginName);
   }
-  getNode(id) {
+  getNode({ id }) {
     return this.nodesManager.getData(id);
   }
-  getNodeDraft(id) {
+  getNodeDraft({ id }) {
     return this.nodesManager.getCurrentDraftData(id);
   }
   getNodes() {
@@ -299,10 +344,10 @@ class Engine {
   getNodeRenderer(type) {
     return this.nodeRenderers$.value.get(type);
   }
-  getEdge(id) {
+  getEdge({ id }) {
     return this.edgesManager.getData(id);
   }
-  getEdgeDraft(id) {
+  getEdgeDraft({ id }) {
     return this.edgesManager.getCurrentDraftData(id);
   }
   getEdges() {
@@ -352,27 +397,6 @@ class Engine {
   endInteraction(pluginId, type) {
     this.interactionManager.endInteraction(pluginId, type);
   }
-  callTool(pluginNameOrEngineToolName, ...args) {
-    let toolDefinition;
-    let toolDisplayName;
-    if (this.engineTools.has(pluginNameOrEngineToolName)) {
-      toolDefinition = __spreadProps$1(__spreadValues$1({}, this.engineTools.get(pluginNameOrEngineToolName)), { func: this[pluginNameOrEngineToolName].bind(this) });
-      toolDisplayName = toolDefinition.name;
-    } else {
-      toolDefinition = get(this, ["_pluginToolsContainer", pluginNameOrEngineToolName, args == null ? void 0 : args[0]]);
-      toolDisplayName = `${pluginNameOrEngineToolName}.${args == null ? void 0 : args[0]}`;
-    }
-    const tool = toolDefinition == null ? void 0 : toolDefinition.func;
-    if (!tool || typeof tool !== "function") {
-      throw new Error(`Tool ${String(toolDisplayName)} not found`);
-    }
-    const parameters = args[args.length - 1];
-    const validator = this.toolParametersValidator.validate(parameters, toolDefinition.parameters);
-    if (validator.errors.length > 0) {
-      throw new Error(`Invalid tool parameters: ${validator.errors.map((e) => e.stack).join(", ")}`);
-    }
-    return tool(parameters);
-  }
   listPlugins() {
     return Array.from(this.plugins$.value.values()).map((plugin) => ({
       name: plugin.name,
@@ -418,6 +442,10 @@ const _BasePlugin = class _BasePlugin {
      * 可随时存入，销毁时会自动执行
      */
     __publicField$1(this, "subscriptions", []);
+    __publicField$1(this, "callTool", (...args) => {
+      var _a;
+      return (_a = Reflect.get(this, getSymbol("engine")).value) == null ? void 0 : _a.callTool(...args);
+    });
     Reflect.set(this, getSymbol("engine"), new BehaviorSubject(null));
   }
   get pluginId() {

package/dist/shared/core.CpyG0nWq.d.cts

@@ -0,0 +1,323 @@
+import { Schema } from 'jsonschema';
+import { BehaviorSubject, SubscriptionLike } from 'rxjs';
+import { DataManager, DataOperationPipe, DataOperation } from '@knotx/data';
+
+/**
+ * 用户交互优先级定义
+ * 数值越大优先级越高
+ */
+declare enum InteractionPriority {
+    /** 文本输入框激活状态（输入中需独占） */
+    InputActive = 2000,
+    /** 实体连接拖拽 */
+    EntityConnectDrag = 1930,
+    /** 实体测量拖拽 */
+    EntityMeasureDrag = 1920,
+    /** 实体位置拖拽 */
+    EntityPositionDrag = 1910,
+    /** 连续操作：画布拖拽、缩放等进行中的动作 */
+    ContinuousDrag = 1900,
+    /** 右键菜单/上下文操作 */
+    ContextMenu = 1800,
+    /** 键盘快捷键（如 Delete/Ctrl+C） */
+    KeyboardShortcut = 1700,
+    /** 单击选中元素 */
+    ClickSelection = 1600,
+    /** 双击编辑元素 */
+    DoubleClickEdit = 1500,
+    /** 框选（多选）操作 */
+    MarqueeSelection = 1300,
+    /** 套索选择（Lasso Select） */
+    LassoSelection = 1250,
+    /** 长按操作（长按菜单/工具） */
+    LongPress = 1100,
+    /** 悬停提示（Hover Tooltip） */
+    HoverTooltip = 1000,
+    /** 画布平移（空格拖拽或手势） */
+    CanvasPan = 900,
+    /** 画布缩放（滚轮或双指） */
+    CanvasZoom = 800,
+    /** 多指手势（如三指滑动） */
+    MultiTouchGesture = 700
+}
+interface Interaction {
+    pluginId: string;
+    type: string;
+    priority: InteractionPriority;
+    active?: boolean;
+}
+/**
+ * 交互管理器
+ */
+declare class InteractionManager {
+    private interactions;
+    /**
+     * 获取当前活动的交互
+     */
+    get activeInteraction(): Interaction | undefined;
+    /**
+     * 检查是否可以交互
+     * @param pluginId 插件ID
+     * @param type 交互类型
+     * @param autoStartPriority 自动启动优先级
+     * @returns 是否可以交互
+     */
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
+    /**
+     * 启动交互
+     * @param pluginId 插件ID
+     * @param type 交互类型
+     * @param priority 优先级
+     * @returns 取消交互的函数
+     */
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority): () => void;
+    /**
+     * 结束交互
+     * @param pluginId 插件ID
+     * @param type 交互类型
+     */
+    endInteraction(pluginId: string, type: string): void;
+    private updateActive;
+}
+
+interface EngineOptions<TNode extends IRecord = IRecord, TEdge extends IRecord = IRecord> {
+    container: Container;
+    plugins?: Plugin[];
+    pluginConfig?: IRecord;
+    nodes?: Node<TNode>[];
+    edges?: Edge<TEdge>[];
+    runtime?: IEngineRuntime;
+}
+declare module '@knotx/core' {
+    interface EngineTools {
+        listPlugins: Engine['listPlugins'];
+        listPluginTools: Engine['listPluginTools'];
+        getNodes: Engine['getNodes'];
+        getEdges: Engine['getEdges'];
+        getNode: Engine['getNode'];
+        getEdge: Engine['getEdge'];
+    }
+}
+interface CallToolMethod {
+    <T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: Extract<T, keyof PluginTools>, toolName: Extract<TP, keyof PluginTools[T]>, ...args: Parameters<PluginTools[T][TP]>): ReturnType<PluginTools[T][TP]>;
+    <T extends keyof EngineTools>(engineToolName: Extract<T, keyof EngineTools>, ...args: Parameters<EngineTools[T]>): ReturnType<EngineTools[T]>;
+}
+declare class Engine<TRenderType extends RenderType = RenderType, TNode extends IRecord = IRecord, TEdge extends IRecord = IRecord> {
+    readonly runtime: IEngineRuntime;
+    readonly interactionManager: InteractionManager;
+    readonly nodesManager: DataManager<Node<TNode>>;
+    readonly edgesManager: DataManager<Edge<TEdge>>;
+    private container$;
+    private nodes$;
+    private edges$;
+    private layers$;
+    private plugins$;
+    private nodeRenderers$;
+    private edgeRenderers$;
+    private _pluginDataContainer;
+    private _pluginToolsContainer;
+    private engineTools;
+    private toolParametersValidator;
+    get container(): Container;
+    set container(value: Container);
+    get nodes(): Node<TNode>[];
+    get edges(): Edge<TEdge>[];
+    get layers(): Map<number, LayerComponent<TRenderType>[]>;
+    get plugins(): IPlugin<string, any, RenderType>[];
+    constructor(options: EngineOptions<TNode, TEdge>);
+    private init;
+    callTool: CallToolMethod;
+    getLayerComponents(layer: Layer): LayerComponent<TRenderType>[];
+    addNodePipe(pipe: DataOperationPipe<Node<TNode>>): () => void;
+    addEdgePipe(pipe: DataOperationPipe<Edge<TEdge>>): () => void;
+    changePluginConfig({ pluginName, config }: {
+        pluginName: string;
+        config: IRecord;
+    }): void;
+    dispatchNodeOperation(operation: DataOperation<Node<TNode>>): void;
+    dispatchEdgeOperation(operation: DataOperation<Edge<TEdge>>): void;
+    getPlugin<TPlugin extends IPlugin>({ pluginName }: {
+        pluginName: TPlugin['name'];
+    }): TPlugin | undefined;
+    getNode({ id }: {
+        id: string;
+    }): Node<TNode> | undefined;
+    getNodeDraft({ id }: {
+        id: string;
+    }): Node<TNode> | undefined;
+    getNodes(): Node<TNode>[];
+    getNodeRenderer(type: string): NodeRenderType | undefined;
+    getEdge({ id }: {
+        id: string;
+    }): Edge<TEdge> | undefined;
+    getEdgeDraft({ id }: {
+        id: string;
+    }): Edge<TEdge> | undefined;
+    getEdges(): Edge<TEdge>[];
+    getEdgeRenderer(type: string): EdgeRenderType | undefined;
+    registerPluginData<T extends keyof PluginData, TP extends keyof PluginData[T]>(pluginName: T, property: TP, data: BehaviorSubject<PluginData[T][TP]>): void;
+    resetPluginData<T extends keyof PluginData>(pluginName: T): void;
+    registerPluginTool<T extends keyof PluginTools, TP extends keyof PluginTools[T]>(pluginName: T, property: TP, data: {
+        description: string;
+        parameters: Schema;
+        func: PluginTools[T][TP];
+    }): void;
+    resetPluginTool<T extends keyof PluginTools>(pluginName: T): void;
+    registerNodeRenderer(type: string, renderer: NodeRenderType): () => void;
+    registerEdgeRenderer(type: string, renderer: EdgeRenderType): (() => void);
+    canInteract(pluginId: string, type: string, autoStartPriority?: InteractionPriority): boolean;
+    startInteraction(pluginId: string, type: string, priority: InteractionPriority): void;
+    endInteraction(pluginId: string, type: string): void;
+    listPlugins(): IPluginInfo[];
+    listPluginTools({ pluginName }: {
+        pluginName: string;
+    }): IToolInfo[];
+    listEngineTools(): IToolInfo[];
+    destroy(): void;
+}
+
+declare abstract class BasePlugin<TPluginName extends string = string, TPluginConfig extends IRecord | undefined = undefined, TRenderType extends RenderType = RenderType> implements IPlugin<TPluginName, TPluginConfig, TRenderType> {
+    abstract name: TPluginName;
+    constructor(__: TPluginConfig);
+    private static _instanceId;
+    private _instanceId;
+    get pluginId(): string;
+    /**
+     * 插件生命周期中的订阅回调
+     * 可随时存入，销毁时会自动执行
+     */
+    protected subscriptions: (SubscriptionLike | (() => void))[];
+    protected callTool: Engine['callTool'];
+    onDestroy(): void;
+}
+
+type HorizontalAlignment = 'left' | 'right';
+type VerticalAlignment = 'top' | 'bottom';
+type IRecord = Record<string, any>;
+interface NodePosition {
+    x: number;
+    y: number;
+}
+interface NodeMeasured {
+    width: number;
+    height: number;
+}
+interface Node<TData extends IRecord = IRecord> {
+    id: string;
+    type?: string;
+    position: NodePosition;
+    measured?: NodeMeasured;
+    data: TData;
+}
+interface NodeProps<TData extends IRecord = IRecord> {
+    node: Node<TData>;
+}
+interface Edge<TData extends IRecord = IRecord> {
+    id: string;
+    source: string;
+    target: string;
+    type?: string;
+    data?: TData;
+}
+interface EdgeProps<TData extends IRecord = IRecord> {
+    edge: Edge<TData>;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+}
+interface Container {
+    width: number;
+    height: number;
+}
+type Position = 'top' | 'right' | 'bottom' | 'left';
+type RenderType = (...args: any[]) => any;
+type NodeRenderType<TD extends IRecord = any, TR = any> = (props: NodeProps<TD>) => TR;
+type EdgeRenderType<TD extends IRecord = any, TR = any> = (props: EdgeProps<TD>) => TR;
+declare enum Layer {
+    Canvas = 0,
+    Background = 4,
+    Edges = 16,
+    Nodes = 64,
+    Foreground = 256
+}
+interface LayerComponent<TRenderType> {
+    plugin: string;
+    name: string;
+    layer: Layer;
+    render: TRenderType;
+    /**
+     * 层级偏移量
+     * @default 0
+     * (layer >> 1, layer << 1]
+     */
+    offset?: number;
+}
+interface IPlugin<TPluginName extends string = string, TPluginConfig extends IRecord | undefined = any, TRenderType extends RenderType = RenderType> {
+    name: TPluginName;
+    pluginId: string;
+    description?: string;
+    onInit?: (config: TPluginConfig) => void;
+    onConfigChange?: (config: TPluginConfig) => void;
+    onDestroy?: () => void;
+    render?: (...args: Parameters<TRenderType>) => ReturnType<TRenderType>;
+}
+type Plugin<TName extends string = string, TConfig extends IRecord | undefined = any, TRenderType extends RenderType = RenderType> = new (__: TConfig) => BasePlugin<TName, TConfig, TRenderType>;
+type PluginConfigs<TPlugins extends Plugin[]> = ((TPlugins[number] extends Plugin<infer T> ? {
+    [TName in T as Extract<TPlugins[number], Plugin<TName>> extends Plugin<TName, undefined> ? never : TName]: Extract<TPlugins[number], Plugin<TName>> extends infer T ? T extends Plugin<TName, infer TConfig> ? TConfig : never : never;
+} : {}));
+/**
+ * plugin data host
+ * @example
+ * `declare module '@knotx/core' {
+ *   interface PluginData {
+ *     pluginName: {
+ *       property: any
+ *     }
+ *   }
+ * }`
+ */
+interface PluginData {
+}
+/**
+ * plugin tools host
+ * @example
+ * `declare module '@knotx/core' {
+ *   interface PluginTools {
+ *     pluginName: {
+ *       toolName: (params: any) => any
+ *     }
+ *   }
+ * }`
+ */
+interface PluginTools {
+}
+interface EngineTools {
+}
+interface IPluginInfo {
+    name: string;
+    description?: string;
+}
+interface IToolInfo {
+    type: 'function';
+    name: string;
+    description: string;
+    parameters: Schema;
+}
+type NodeOperationPipe<T extends IRecord = any> = DataOperationPipe<Node<T>>;
+type EdgeOperationPipe<T extends IRecord = any> = DataOperationPipe<Edge<T>>;
+type NodeOperation<T extends IRecord = any> = DataOperation<Node<T>>;
+type EdgeOperation<T extends IRecord = any> = DataOperation<Edge<T>>;
+type NodeOperatorFunction<T extends IRecord = any, TArgs extends any[] = any[]> = (...args: TArgs) => NodeOperation<T>[];
+type EdgeOperatorFunction<T extends IRecord = any, TArgs extends any[] = any[]> = (...args: TArgs) => EdgeOperation<T>[];
+interface IEngineRuntime {
+    render?: {
+        getValue: <T, R = T>(value: BehaviorSubject<T> | T, options: {
+            paths: string[];
+            selector?: (value: T, context?: any) => R;
+            context?: any;
+        }) => T | R;
+    };
+}
+
+export { type Interaction as A, InteractionManager as B, type Container as C, BasePlugin as D, Engine as E, type HorizontalAlignment as H, type IRecord as I, Layer as L, type NodePosition as N, type Position as P, type RenderType as R, type VerticalAlignment as V, type NodeMeasured as a, type Node as b, type NodeProps as c, type Edge as d, type EdgeProps as e, type NodeRenderType as f, type EdgeRenderType as g, type LayerComponent as h, type IPlugin as i, type Plugin as j, type PluginConfigs as k, type PluginData as l, type PluginTools as m, type EngineTools as n, type IPluginInfo as o, type IToolInfo as p, type NodeOperationPipe as q, type EdgeOperationPipe as r, type NodeOperation as s, type EdgeOperation as t, type NodeOperatorFunction as u, type EdgeOperatorFunction as v, type IEngineRuntime as w, type EngineOptions as x, type CallToolMethod as y, InteractionPriority as z };