@flowscape-ui/core-sdk 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,39 +1,121 @@
 import Konva from 'konva';
+export { default as Konva } from 'konva';
 import * as konva_lib_types from 'konva/lib/types';
 
-interface BaseNodeOptions {
-    id?: string;
-    x?: number;
-    y?: number;
-    width?: number;
-    height?: number;
+type Listener<TArgs extends unknown[]> = (...args: TArgs) => void;
+declare class EventBus<TEvents extends {
+    [K in keyof TEvents]: unknown[];
+} = Record<string, unknown[]>> {
+    private _listeners;
+    constructor();
+    get listeners(): Map<string, Listener<TEvents[keyof TEvents & string]>[]>;
+    on<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
+    off<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
+    once<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
+    emit<K extends keyof TEvents & string>(event: K, ...args: TEvents[K]): void;
 }
-declare abstract class BaseNode<T extends Konva.Node = Konva.Node> {
-    protected konvaNode: T;
+
+/**
+ * Base class for a node addon.
+ *
+ * Usage:
+ *   class MyAddon extends NodeAddon<TextNode> {
+ *     protected onAttach(node: TextNode) { ... }
+ *     protected onDetach(node: TextNode) { ... }
+ *   }
+ */
+declare abstract class NodeAddon<TNode extends BaseNode = BaseNode> {
+    protected abstract onAttach(node: TNode): void;
+    protected abstract onDetach(node: TNode): void;
+    /** Internal helper: called by the node's addon manager */
+    attach(node: TNode): void;
+    /** Internal helper: called by the node's addon manager */
+    detach(node: TNode): void;
+}
+
+/**
+ * Addon manager for a specific node.
+ * Allows adding/removing addons with a convenient API:
+ *   node.addons.add(addon)
+ *   node.addons.add([a, b])
+ *   node.addons.remove(addon)
+ *   node.addons.list()
+ */
+declare class NodeAddons<TNode extends BaseNode = BaseNode> {
+    private readonly _node;
+    private readonly _addons;
+    constructor(node: TNode);
+    /** Attach one or more addons to the node */
+    add(addons: NodeAddon<TNode> | NodeAddon<TNode>[]): TNode;
+    /** Detach one or more addons from the node */
+    remove(addons: NodeAddon<TNode> | NodeAddon<TNode>[]): TNode;
+    /** All attached addons (array copy) */
+    list(): NodeAddon<TNode>[];
+    /** Check if a specific addon is attached */
+    has(addon: NodeAddon<TNode>): boolean;
+    /** Detach and clear all addons (used when removing the node) */
+    clear(): void;
+}
+
+type KonvaNode = Konva.Node;
+type KonvaShape = Konva.Shape;
+type KonvaGroup = Konva.Group;
+type KonvaLayer = Konva.Layer;
+type KonvaStage = Konva.Stage;
+type KonvaText = Konva.Text;
+type KonvaImage = Konva.Image;
+type KonvaCircle = Konva.Circle;
+type KonvaEllipse = Konva.Ellipse;
+type KonvaArc = Konva.Arc;
+type KonvaArrow = Konva.Arrow;
+type KonvaStar = Konva.Star;
+type KonvaRing = Konva.Ring;
+type KonvaRegularPolygon = Konva.RegularPolygon;
+type KonvaNodeConfig = Konva.NodeConfig;
+type KonvaGroupConfig = Konva.GroupConfig;
+
+/**
+ * Public interface for working with node addons.
+ * Hides the internal implementation of NodeAddons<BaseNode>.
+ */
+interface NodeAddonsHandle {
+    add(addons: NodeAddon | NodeAddon[]): unknown;
+    remove(addons: NodeAddon | NodeAddon[]): unknown;
+    list(): NodeAddon[];
+    has(addon: NodeAddon): boolean;
+    clear(): void;
+}
+/**
+ * Base interface for public Node Handles.
+ * Concrete implementations will proxy BaseNode methods.
+ */
+interface NodeHandle<TKonva extends KonvaNode = KonvaNode> {
     readonly id: string;
-    constructor(node: T, options?: BaseNodeOptions);
-    getNode(): T;
-    setPosition({ x, y }: {
+    readonly addons: NodeAddonsHandle;
+    getPosition(): {
         x: number;
         y: number;
-    }): void;
-    getPosition(): konva_lib_types.Vector2d;
+    };
+    setPosition(position: {
+        x: number;
+        y: number;
+    }): this;
     remove(): void;
+    /**
+     * Safe access to the low-level Konva object.
+     * Returns the object itself without the need to import Konva from an external dependency.
+     */
+    getKonvaNode(): TKonva;
 }
-
-interface ShapeNodeOptions extends BaseNodeOptions {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    cornerRadius?: number | number[];
-}
-declare class ShapeNode extends BaseNode<Konva.Rect> {
-    constructor(options: ShapeNodeOptions);
+/**
+ * Handle for ShapeNode (rectangle with rounded corners)
+ */
+interface ShapeNodeHandle extends NodeHandle {
     setFill(color: string): this;
     setStroke(color: string): this;
     setStrokeWidth(width: number): this;
     setCornerRadius(radius: number | number[]): this;
-    setSize({ width, height }: {
+    setSize(size: {
         width: number;
         height: number;
     }): this;
@@ -42,34 +124,183 @@ declare class ShapeNode extends BaseNode<Konva.Rect> {
     getStrokeWidth(): number;
     getCornerRadius(): number;
 }
+/**
+ * Handle for TextNode
+ */
+interface TextNodeHandle extends NodeHandle {
+    getText(): string;
+    setText(text: string): this;
+    setFontSize(size: number): this;
+    setFontFamily(family: string): this;
+    setFill(color: string): this;
+    setEditable(editable: boolean): this;
+    isEditable(): boolean;
+    onTextChange(callback: (event: {
+        oldText: string;
+        newText: string;
+        cancelled: boolean;
+    }) => void): this;
+    onEditStart(callback: () => void): this;
+    onEditEnd(callback: () => void): this;
+}
+/**
+ * Handle for ImageNode
+ */
+interface ImageNodeHandle extends NodeHandle {
+    setSrc(url: string, crossOrigin?: '' | 'anonymous' | 'use-credentials'): Promise<this>;
+    setImage(image: HTMLImageElement): this;
+    setSize(size: {
+        width: number;
+        height: number;
+    }): this;
+    setCornerRadius(radius: number | number[]): this;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCornerRadius(): number;
+}
+/**
+ * Handle for CircleNode
+ */
+interface CircleNodeHandle extends NodeHandle {
+    setRadius(radius: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+    getRadius(): number;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+}
+/**
+ * Handle for EllipseNode
+ */
+interface EllipseNodeHandle extends NodeHandle {
+    setRadiusX(radiusX: number): this;
+    setRadiusY(radiusY: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+    getRadiusX(): number;
+    getRadiusY(): number;
+}
+/**
+ * Handle for ArcNode
+ */
+interface ArcNodeHandle extends NodeHandle {
+    setInnerRadius(radius: number): this;
+    setOuterRadius(radius: number): this;
+    setAngle(angle: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+/**
+ * Handle for ArrowNode
+ */
+interface ArrowNodeHandle extends NodeHandle {
+    setPoints(points: number[]): this;
+    setPointerLength(length: number): this;
+    setPointerWidth(width: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+    getPoints(): number[];
+}
+/**
+ * Handle for StarNode
+ */
+interface StarNodeHandle extends NodeHandle {
+    setNumPoints(points: number): this;
+    setInnerRadius(radius: number): this;
+    setOuterRadius(radius: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+/**
+ * Handle for RingNode
+ */
+interface RingNodeHandle extends NodeHandle {
+    setInnerRadius(radius: number): this;
+    setOuterRadius(radius: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+/**
+ * Handle for RegularPolygonNode
+ */
+interface RegularPolygonNodeHandle extends NodeHandle {
+    setSides(sides: number): this;
+    setRadius(radius: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+    getRadius(): number;
+    getSides(): number;
+}
+/**
+ * Handle for GroupNode
+ */
+interface GroupNodeHandle extends NodeHandle {
+    addChild(child: KonvaNode | NodeHandle): this;
+    removeChild(child: KonvaNode | NodeHandle): this;
+    removeAllChildren(): this;
+    getChildren(): KonvaNode[];
+    findByName(name: string): KonvaNode[];
+    setDraggable(draggable: boolean): this;
+    isDraggable(): boolean;
+    setListening(listening: boolean): this;
+    isListening(): boolean;
+    setClip(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): this;
+}
 
-type Listener<TArgs extends unknown[]> = (...args: TArgs) => void;
-declare class EventBus<TEvents extends {
-    [K in keyof TEvents]: unknown[];
-} = Record<string, unknown[]>> {
-    private _listeners;
-    constructor();
-    get listeners(): Map<string, Listener<TEvents[keyof TEvents & string]>[]>;
-    on<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
-    off<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
-    once<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
-    emit<K extends keyof TEvents & string>(event: K, ...args: TEvents[K]): void;
+interface BaseNodeOptions {
+    id?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+declare abstract class BaseNode<T extends Konva.Node = Konva.Node> implements NodeHandle<T> {
+    protected konvaNode: T;
+    readonly id: string;
+    /** Local addons attached to this node */
+    readonly addons: NodeAddons<this>;
+    constructor(node: T, options?: BaseNodeOptions);
+    /**
+     * Public access to the low-level Konva object.
+     * Use this method instead of importing `konva` directly.
+     */
+    getKonvaNode(): T;
+    setPosition({ x, y }: {
+        x: number;
+        y: number;
+    }): this;
+    getPosition(): konva_lib_types.Vector2d;
+    remove(): void;
 }
 
 /**
- * Типизированные события CoreEngine
- * Все события строго типизированы для лучшего DX
+ * Typed CoreEngine events
+ * All events are strictly typed for better DX
  */
 interface CoreEvents {
-    /** Нода была создана и добавлена в мир */
+    /** Node was created and added to the world */
     'node:created': [node: BaseNode];
-    /** Нода была удалена из мира */
+    /** Node was removed from the world */
     'node:removed': [node: BaseNode];
-    /** Нода была выделена */
+    /** Node was selected */
     'node:selected': [node: BaseNode];
-    /** Выделение ноды было снято */
+    /** Node was deselected */
     'node:deselected': [node: BaseNode];
-    /** Нода была изменена (position, size, rotation, etc.) */
+    /** Node was transformed (position, size, rotation, etc.) */
     'node:transformed': [
         node: BaseNode,
         changes: {
@@ -82,29 +313,29 @@ interface CoreEvents {
             scaleY?: number;
         }
     ];
-    /** Z-index ноды был изменён */
+    /** Node z-index was changed */
     'node:zIndexChanged': [node: BaseNode, oldIndex: number, newIndex: number];
-    /** Группа была создана */
+    /** Group was created */
     'group:created': [group: BaseNode, nodes: BaseNode[]];
-    /** Группа была разгруппирована */
+    /** Group was ungrouped */
     'group:ungrouped': [group: BaseNode, nodes: BaseNode[]];
-    /** Множественное выделение создано */
+    /** Multi-selection was created */
     'selection:multi:created': [nodes: BaseNode[]];
-    /** Множественное выделение уничтожено */
+    /** Multi-selection was destroyed */
     'selection:multi:destroyed': [];
-    /** Выделение полностью снято */
+    /** Selection was completely cleared */
     'selection:cleared': [];
-    /** Ноды были скопированы в буфер обмена */
+    /** Nodes were copied to clipboard */
     'clipboard:copy': [nodes: BaseNode[]];
-    /** Ноды были вырезаны в буфер обмена */
+    /** Nodes were cut to clipboard */
     'clipboard:cut': [nodes: BaseNode[]];
-    /** Ноды были вставлены из буфера обмена */
+    /** Nodes were pasted from clipboard */
     'clipboard:paste': [nodes: BaseNode[]];
-    /** Зум был изменён программно */
+    /** Zoom was changed programmatically */
     'camera:setZoom': [{
         scale: number;
     }];
-    /** Зум был изменён пользователем (колесо мыши) */
+    /** Zoom was changed by user (mouse wheel) */
     'camera:zoom': [{
         scale: number;
         position: {
@@ -112,17 +343,17 @@ interface CoreEvents {
             y: number;
         };
     }];
-    /** Камера была сброшена */
+    /** Camera was reset */
     'camera:reset': [];
-    /** Шаг зума был изменён */
+    /** Zoom step was changed */
     'camera:zoomStep': [{
         zoomStep: number;
     }];
-    /** Шаг панорамирования был изменён */
+    /** Pan step was changed */
     'camera:panStep': [{
         panStep: number;
     }];
-    /** Камера была перемещена (панорамирование) */
+    /** Camera was moved (panning) */
     'camera:pan': [{
         dx: number;
         dy: number;
@@ -131,79 +362,74 @@ interface CoreEvents {
             y: number;
         };
     }];
-    /** Плагин был добавлен */
+    /** Plugin was added */
     'plugin:added': [pluginName: string];
-    /** Плагин был удалён */
+    /** Plugin was removed */
     'plugin:removed': [pluginName: string];
-    /** Stage был изменён (resize) */
+    /** Stage was resized */
     'stage:resized': [{
         width: number;
         height: number;
     }];
 }
 
-interface TextNodeOptions extends BaseNodeOptions {
-    text?: string;
-    fontSize?: number;
-    fontFamily?: string;
-    fontStyle?: string;
-    fill?: string;
-    align?: 'left' | 'center' | 'right';
-    padding?: number;
+interface CameraManagerOptions {
+    stage: Konva.Stage;
+    eventBus: EventBus<CoreEvents>;
+    target?: Konva.Node;
+    initialScale?: number;
+    minScale?: number;
+    maxScale?: number;
+    draggable?: boolean;
+    zoomStep?: number;
+    panStep?: number;
 }
-declare class TextNode extends BaseNode<Konva.Text> {
-    constructor(options?: TextNodeOptions);
-    getText(): string;
-    getFontSize(): number;
-    getFontFamily(): string;
-    getFontStyle(): string;
-    getFill(): string | undefined;
-    getAlign(): 'left' | 'center' | 'right';
-    getPadding(): number;
-    getSize(): {
-        width: number;
-        height: number;
-    };
-    setText(text: string): this;
-    setFontSize(size: number): this;
-    setFontFamily(family: string): this;
-    setFontStyle(style: string): this;
-    setFill(color: string): this;
-    setAlign(align: 'left' | 'center' | 'right'): this;
-    setPadding(padding: number): this;
-    setSize({ width, height }: {
-        width: number;
-        height: number;
-    }): this;
+declare class CameraManager {
+    private _stage;
+    private _eventBus;
+    private _target;
+    private _scale;
+    private _minScale;
+    private _maxScale;
+    private _zoomStep;
+    private _panStep;
+    private _wheelScheduled;
+    private _pendingWheelEvent;
+    constructor(options: CameraManagerOptions);
+    private _initWheelZoom;
+    private _handleWheel;
+    get zoomStep(): number;
+    get panStep(): number;
+    setZoom(zoom: number): void;
+    zoomIn(step?: number): void;
+    zoomOut(step?: number): void;
+    reset(): void;
+    setDraggable(enabled: boolean): void;
+    setZoomStep(step: number): void;
+    setPanStep(step: number): void;
 }
 
-type ImageSource = HTMLImageElement;
-interface ImageNodeOptions extends BaseNodeOptions {
-    image?: ImageSource;
-    src?: string;
-    width?: number;
-    height?: number;
+interface ArcNodeOptions extends BaseNodeOptions {
+    innerRadius?: number;
+    outerRadius?: number;
+    angle?: number;
+    rotation?: number;
+    clockwise?: boolean;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
 }
-declare class ImageNode extends BaseNode<Konva.Image> {
-    constructor(options?: ImageNodeOptions);
-    getSize(): {
-        width: number;
-        height: number;
-    };
-    /**
-     * Async loads image from URL and sets it to Konva.Image.
-     * Returns this for chaining.
-     */
-    setSrc(url: string, crossOrigin?: '' | 'anonymous' | 'use-credentials' | undefined): Promise<this>;
-    /**
-     * Set already loaded image source (HTMLImageElement)
-     */
-    setImage(image: ImageSource): this;
-    setSize({ width, height }: {
-        width: number;
-        height: number;
-    }): this;
-    private _loadHTMLImage;
+
+interface ArrowNodeOptions extends BaseNodeOptions {
+    points?: number[];
+    tension?: number;
+    pointerLength?: number;
+    pointerWidth?: number;
+    pointerAtBeginning?: boolean;
+    pointerAtEnding?: boolean;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
 }
 
 interface CircleNodeOptions extends BaseNodeOptions {
@@ -212,17 +438,6 @@ interface CircleNodeOptions extends BaseNodeOptions {
     stroke?: string;
     strokeWidth?: number;
 }
-declare class CircleNode extends BaseNode<Konva.Circle> {
-    constructor(options?: CircleNodeOptions);
-    getRadius(): number;
-    getFill(): string | undefined;
-    getStroke(): string | undefined;
-    getStrokeWidth(): number;
-    setRadius(radius: number): this;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
-}
 
 interface EllipseNodeOptions extends BaseNodeOptions {
     radiusX?: number;
@@ -231,74 +446,47 @@ interface EllipseNodeOptions extends BaseNodeOptions {
     stroke?: string;
     strokeWidth?: number;
 }
-declare class EllipseNode extends BaseNode<Konva.Ellipse> {
-    constructor(options?: EllipseNodeOptions);
-    getRadiusX(): number;
-    getRadiusY(): number;
-    getFill(): string | undefined;
-    getStroke(): string | undefined;
-    getStrokeWidth(): number;
-    setRadiusX(value: number): this;
-    setRadiusY(value: number): this;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
-}
 
-interface ArcNodeOptions extends BaseNodeOptions {
-    innerRadius?: number;
-    outerRadius?: number;
-    angle?: number;
-    rotation?: number;
-    clockwise?: boolean;
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-}
-declare class ArcNode extends BaseNode<Konva.Arc> {
-    constructor(options?: ArcNodeOptions);
-    getInnerRadius(): number;
-    getOuterRadius(): number;
-    getAngle(): number;
-    isClockwise(): boolean;
-    setInnerRadius(v: number): this;
-    setOuterRadius(v: number): this;
-    setAngle(v: number): this;
-    setRotationDeg(v: number): this;
-    setClockwise(v: boolean): this;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
+interface GroupNodeOptions extends BaseNodeOptions {
+    draggable?: boolean;
+    listening?: boolean;
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 
-interface ArrowNodeOptions extends BaseNodeOptions {
-    points?: number[];
-    tension?: number;
-    pointerLength?: number;
-    pointerWidth?: number;
-    pointerAtBeginning?: boolean;
-    pointerAtEnding?: boolean;
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
+type ImageSource = HTMLImageElement;
+interface ImageNodeOptions extends BaseNodeOptions {
+    image?: ImageSource;
+    src?: string;
+    width?: number;
+    height?: number;
 }
-declare class ArrowNode extends BaseNode<Konva.Arrow> {
-    constructor(options?: ArrowNodeOptions);
-    getPoints(): number[];
-    getTension(): number;
-    getPointerLength(): number;
-    getPointerWidth(): number;
-    getPointerAtBeginning(): boolean;
-    getPointerAtEnding(): boolean;
-    setPoints(v: number[]): this;
-    setTension(v: number): this;
-    setPointerLength(v: number): this;
-    setPointerWidth(v: number): this;
-    setPointerAtBeginning(v: boolean): this;
-    setPointerAtEnding(v: boolean): this;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
+declare class ImageNode extends BaseNode<Konva.Image> {
+    constructor(options?: ImageNodeOptions);
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Async loads image from URL and sets it to Konva.Image.
+     * Returns this for chaining.
+     */
+    setSrc(url: string, crossOrigin?: '' | 'anonymous' | 'use-credentials' | undefined): Promise<this>;
+    /**
+     * Set already loaded image source (HTMLImageElement)
+     */
+    setImage(image: ImageSource): this;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
+    setCornerRadius(radius: number | number[]): this;
+    getCornerRadius(): number;
+    private _loadHTMLImage;
 }
 
 interface RegularPolygonNodeOptions extends BaseNodeOptions {
@@ -308,92 +496,125 @@ interface RegularPolygonNodeOptions extends BaseNodeOptions {
     stroke?: string;
     strokeWidth?: number;
 }
-declare class RegularPolygonNode extends BaseNode<Konva.RegularPolygon> {
-    constructor(options?: RegularPolygonNodeOptions);
-    getSides(): number;
-    getRadius(): number;
-    getFill(): string | undefined;
-    getStroke(): string | undefined;
-    getStrokeWidth(): number;
-    setSides(v: number): this;
-    setRadius(v: number): this;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
-}
 
-interface StarNodeOptions extends BaseNodeOptions {
-    numPoints?: number;
+interface RingNodeOptions extends BaseNodeOptions {
     innerRadius?: number;
     outerRadius?: number;
     fill?: string;
     stroke?: string;
     strokeWidth?: number;
 }
-declare class StarNode extends BaseNode<Konva.Star> {
-    constructor(options?: StarNodeOptions);
-    getNumPoints(): number;
-    getInnerRadius(): number;
-    getOuterRadius(): number;
-    getFill(): string | undefined;
-    getStroke(): string | undefined;
-    getStrokeWidth(): number;
-    setNumPoints(v: number): this;
-    setInnerRadius(v: number): this;
-    setOuterRadius(v: number): this;
+
+interface ShapeNodeOptions extends BaseNodeOptions {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    cornerRadius?: number | number[];
+}
+declare class ShapeNode extends BaseNode<Konva.Rect> {
+    constructor(options: ShapeNodeOptions);
     setFill(color: string): this;
     setStroke(color: string): this;
     setStrokeWidth(width: number): this;
+    setCornerRadius(radius: number | number[]): this;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    getCornerRadius(): number;
 }
 
-interface RingNodeOptions extends BaseNodeOptions {
+interface StarNodeOptions extends BaseNodeOptions {
+    numPoints?: number;
     innerRadius?: number;
     outerRadius?: number;
     fill?: string;
     stroke?: string;
     strokeWidth?: number;
 }
-declare class RingNode extends BaseNode<Konva.Ring> {
-    constructor(options?: RingNodeOptions);
-    getInnerRadius(): number;
-    getOuterRadius(): number;
-    getFill(): string | undefined;
-    getStroke(): string | undefined;
-    getStrokeWidth(): number;
-    setInnerRadius(v: number): this;
-    setOuterRadius(v: number): this;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
-}
 
-interface GroupNodeOptions extends BaseNodeOptions {
-    draggable?: boolean;
-    listening?: boolean;
-    clip?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
+interface TextNodeOptions extends BaseNodeOptions {
+    text?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontStyle?: string;
+    fill?: string;
+    align?: 'left' | 'center' | 'right';
+    verticalAlign?: 'top' | 'middle' | 'bottom';
+    padding?: number;
+    lineHeight?: number;
+    /** Включить редактирование по двойному клику (по умолчанию true) */
+    editable?: boolean;
 }
-declare class GroupNode extends BaseNode<Konva.Group> {
-    constructor(options?: GroupNodeOptions);
-    addChild(child: Konva.Node | BaseNode): this;
-    removeChild(child: Konva.Node | BaseNode): this;
-    removeAllChildren(): this;
-    getChildren(): Konva.Node[];
-    findByName(name: string): Konva.Node[];
-    setDraggable(v: boolean): this;
-    isDraggable(): boolean;
-    setListening(v: boolean): this;
-    isListening(): boolean;
-    setClip(rect: {
-        x: number;
-        y: number;
+/** Событие изменения текста */
+interface TextChangeEvent {
+    /** Предыдущий текст */
+    oldText: string;
+    /** Новый текст */
+    newText: string;
+    /** Было ли изменение отменено (Escape) */
+    cancelled: boolean;
+}
+declare class TextNode extends BaseNode<Konva.Text> {
+    /** Включено ли редактирование по двойному клику */
+    private _editable;
+    /** Находится ли нода в режиме редактирования */
+    private _isEditing;
+    /** Текущий textarea элемент */
+    private _textarea;
+    /** Колбэки для событий редактирования */
+    private _onTextChangeCallbacks;
+    private _onEditStartCallbacks;
+    private _onEditEndCallbacks;
+    /** Флаг: ожидание повторного двойного клика для входа в редактирование внутри группы */
+    private _pendingGroupEditDblClick;
+    private _groupEditClickResetAttached;
+    constructor(options?: TextNodeOptions);
+    getText(): string;
+    setText(text: string): this;
+    setFontSize(size: number): this;
+    setFontFamily(family: string): this;
+    setFill(color: string): this;
+    setAlign(align: 'left' | 'center' | 'right'): this;
+    setPadding(padding: number): this;
+    setSize({ width, height }: {
         width: number;
         height: number;
     }): this;
+    setLineHeight(lineHeight: number): this;
+    setVerticalAlign(align: 'top' | 'middle' | 'bottom'): this;
+    isEditable(): boolean;
+    setEditable(editable: boolean): this;
+    isEditing(): boolean;
+    startEdit(): void;
+    finishEdit(): void;
+    cancelEdit(): void;
+    onTextChange(cb: (event: TextChangeEvent) => void): this;
+    offTextChange(cb: (event: TextChangeEvent) => void): this;
+    onEditStart(cb: () => void): this;
+    offEditStart(cb: () => void): this;
+    onEditEnd(cb: () => void): this;
+    offEditEnd(cb: () => void): this;
+    private _setupEditHandler;
+    /**
+     * При трансформации (resize) «запекаем» scaleX/scaleY в width/height,
+     * а затем сбрасываем scale обратно в 1.
+     *
+     * В итоге:
+     * - рамка может свободно менять ширину/высоту и по диагонали;
+     * - сам текст не растягивается, т.к. fontSize не меняется, а scale всегда 1.
+     */
+    private _setupTransformHandler;
+    private _oldText;
+    private _keyHandler;
+    private _clickHandler;
+    private _syncTextareaRafId;
+    private _syncTextareaPosition;
+    private _openTextarea;
+    private _saveAndClose;
 }
 
 declare class NodeManager {
@@ -410,17 +631,17 @@ declare class NodeManager {
     get world(): Konva.Group;
     get stage(): Konva.Stage;
     get eventBus(): EventBus<CoreEvents>;
-    addShape(options: ShapeNodeOptions): ShapeNode;
-    addText(options: TextNodeOptions): TextNode;
-    addImage(options: ImageNodeOptions): ImageNode;
-    addCircle(options: CircleNodeOptions): CircleNode;
-    addEllipse(options: EllipseNodeOptions): EllipseNode;
-    addArc(options: ArcNodeOptions): ArcNode;
-    addStar(options: StarNodeOptions): StarNode;
-    addArrow(options: ArrowNodeOptions): ArrowNode;
-    addRing(options: RingNodeOptions): RingNode;
-    addRegularPolygon(options: RegularPolygonNodeOptions): RegularPolygonNode;
-    addGroup(options: GroupNodeOptions): GroupNode;
+    addShape(options: ShapeNodeOptions): ShapeNodeHandle;
+    addText(options: TextNodeOptions): TextNodeHandle;
+    addImage(options: ImageNodeOptions): ImageNodeHandle;
+    addCircle(options: CircleNodeOptions): CircleNodeHandle;
+    addEllipse(options: EllipseNodeOptions): EllipseNodeHandle;
+    addArc(options: ArcNodeOptions): ArcNodeHandle;
+    addStar(options: StarNodeOptions): StarNodeHandle;
+    addArrow(options: ArrowNodeOptions): ArrowNodeHandle;
+    addRing(options: RingNodeOptions): RingNodeHandle;
+    addRegularPolygon(options: RegularPolygonNodeOptions): RegularPolygonNodeHandle;
+    addGroup(options: GroupNodeOptions): GroupNodeHandle;
     remove(node: BaseNode): void;
     findById(id: string): BaseNode | undefined;
     list(): BaseNode[];
@@ -431,42 +652,6 @@ declare class NodeManager {
     private _scheduleBatchDraw;
 }
 
-interface CameraManagerOptions {
-    stage: Konva.Stage;
-    eventBus: EventBus<CoreEvents>;
-    target?: Konva.Node;
-    initialScale?: number;
-    minScale?: number;
-    maxScale?: number;
-    draggable?: boolean;
-    zoomStep?: number;
-    panStep?: number;
-}
-declare class CameraManager {
-    private _stage;
-    private _eventBus;
-    private _target;
-    private _scale;
-    private _minScale;
-    private _maxScale;
-    private _zoomStep;
-    private _panStep;
-    private _wheelScheduled;
-    private _pendingWheelEvent;
-    constructor(options: CameraManagerOptions);
-    private _initWheelZoom;
-    private _handleWheel;
-    get zoomStep(): number;
-    get panStep(): number;
-    setZoom(zoom: number): void;
-    zoomIn(step?: number): void;
-    zoomOut(step?: number): void;
-    reset(): void;
-    setDraggable(enabled: boolean): void;
-    setZoomStep(step: number): void;
-    setPanStep(step: number): void;
-}
-
 interface LODLevel {
     minScale: number;
     maxScale: number;
@@ -670,7 +855,57 @@ declare class VirtualizationManager {
     destroy(): void;
 }
 
+/**
+ * Base class for a plugin addon.
+ *
+ * Usage:
+ *   class MyPluginAddon extends PluginAddon<MyPlugin> {
+ *     protected onAttach(plugin: MyPlugin, core: CoreEngine) { ... }
+ *     protected onDetach(plugin: MyPlugin, core: CoreEngine) { ... }
+ *   }
+ */
+declare abstract class PluginAddon<TPlugin extends Plugin = Plugin> {
+    protected abstract onAttach(plugin: TPlugin, core: CoreEngine): void;
+    protected abstract onDetach(plugin: TPlugin, core: CoreEngine): void;
+    /** Internal helper: called by the plugin's addon manager */
+    attach(plugin: TPlugin, core: CoreEngine): void;
+    /** Internal helper: called by the plugin's addon manager */
+    detach(plugin: TPlugin, core: CoreEngine): void;
+}
+
+/**
+ * Addon manager for a specific plugin.
+ * Allows adding/removing addons with a convenient API:
+ *   plugin.addons.add(addon)
+ *   plugin.addons.add([a, b])
+ *   plugin.addons.remove(addon)
+ *   plugin.addons.list()
+ */
+declare class PluginAddons<TPlugin extends Plugin = Plugin> {
+    private readonly _plugin;
+    private readonly _addons;
+    private _core;
+    constructor(plugin: TPlugin);
+    /** Internal helper: called from Plugin.attach */
+    _attachAll(core: CoreEngine): void;
+    /** Internal helper: called from Plugin.detach */
+    _detachAll(core: CoreEngine): void;
+    /** Attach one or more addons to the plugin */
+    add(addons: PluginAddon<TPlugin> | PluginAddon<TPlugin>[]): TPlugin;
+    /** Detach one or more addons from the plugin */
+    remove(addons: PluginAddon<TPlugin> | PluginAddon<TPlugin>[]): TPlugin;
+    /** All attached addons (array copy) */
+    list(): PluginAddon<TPlugin>[];
+    /** Check if a specific addon is attached */
+    has(addon: PluginAddon<TPlugin>): boolean;
+    /** Detach and clear all addons (used when removing the plugin) */
+    clear(): void;
+}
+
 declare abstract class Plugin {
+    /** Local addons attached to this plugin */
+    readonly addons: PluginAddons<this>;
+    constructor();
     protected abstract onAttach(core: CoreEngine): void;
     protected abstract onDetach(core: CoreEngine): void;
     attach(core: CoreEngine): void;
@@ -715,12 +950,25 @@ declare class CoreEngine {
     private _minScale;
     private _maxScale;
     private _gridLayer;
+    private _resizeObserver;
     readonly container: HTMLDivElement;
     readonly nodes: NodeManager;
     readonly camera: CameraManager;
     readonly virtualization: VirtualizationManager;
     readonly plugins: Plugins;
     constructor(options: CoreEngineOptions);
+    /**
+     * Setup automatic canvas resize when container size changes
+     */
+    private _setupAutoResize;
+    /**
+     * Handle container resize
+     */
+    private _handleResize;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
     get eventBus(): EventBus<CoreEvents>;
     get stage(): Konva.Stage;
     get gridLayer(): Konva.Layer;
@@ -737,34 +985,146 @@ declare class CoreEngine {
     }): void;
     setBackgroundColor(color: string): void;
     setDraggable(draggable: boolean): void;
+    /**
+     * Enable or disable auto-resize
+     */
+    setAutoResize(enabled: boolean): void;
 }
 
-interface LogoOptions {
-    src: string;
-    width: number;
-    height: number;
-    opacity?: number;
+/**
+ * HistoryAction — description of a single action in history
+ *
+ * Action types:
+ * - 'create' — node creation (before: null, after: SerializedNodeState)
+ * - 'remove' — node removal (before: SerializedNodeState, after: null)
+ * - 'transform' — transformation (before/after: TransformState)
+ * - 'zIndex' — z-index change (before/after: { zIndex: number })
+ * - 'group' — grouping (before: { childIds, childStates }, after: SerializedNodeState)
+ * - 'ungroup' — ungrouping (before: SerializedNodeState, after: { childStates })
+ * - 'batch' — composite action (children: HistoryAction[])
+ */
+interface HistoryAction {
+    /** Action type: 'create', 'remove', 'transform', 'zIndex', 'group', 'ungroup', 'batch' */
+    type: string;
+    /** ID of the node this action relates to (empty string for batch) */
+    nodeId: string;
+    /** State BEFORE the action (null for create, not used for batch) */
+    before: unknown;
+    /** State AFTER the action (null for remove, not used for batch) */
+    after: unknown;
+    /** Action timestamp */
+    timestamp: number;
+    /** Child actions for batch */
+    children?: HistoryAction[];
 }
-declare class LogoPlugin extends Plugin {
-    private _core?;
-    private _layer?;
-    private _image?;
-    private _src;
-    private _width;
-    private _height;
-    private _opacity;
-    constructor(options: LogoOptions);
-    protected onAttach(core: CoreEngine): void;
-    protected onDetach(core: CoreEngine): void;
-    setOpacity(opacity: number): void;
-    setSize({ width, height }: {
-        width: number;
-        height: number;
-    }): void;
-    setSource(src: string): void;
-    private _setImage;
-    private _loadImageFromString;
-    private _layout;
+/**
+ * HistoryManager — action history manager for Undo/Redo
+ *
+ * Logic:
+ * - push(action) adds an action to history
+ * - If currentIndex < length-1, actions after currentIndex are removed first
+ * - select(index) switches current index without removing history
+ * - undo() returns current action and moves index backward
+ * - redo() moves index forward and returns the action
+ */
+declare class HistoryManager {
+    private _actions;
+    private _currentIndex;
+    /**
+     * Add an action to history.
+     * If currentIndex < length-1, removes actions after currentIndex first.
+     */
+    push(action: HistoryAction): void;
+    /**
+     * Remove actions from fromIndex to the end of the array.
+     */
+    pop(fromIndex: number): void;
+    /**
+     * Switch current index (for history navigation).
+     * Does not remove actions from history.
+     */
+    select(index: number): void;
+    /**
+     * Get current index in history.
+     * -1 means we are "before" the first action (empty state).
+     */
+    getCurrentIndex(): number;
+    /**
+     * Number of actions in history.
+     */
+    get length(): number;
+    /**
+     * Get a copy of all actions array.
+     */
+    getActions(): HistoryAction[];
+    /**
+     * Can undo be performed (are there actions to roll back).
+     */
+    canUndo(): boolean;
+    /**
+     * Can redo be performed (are there actions to repeat).
+     */
+    canRedo(): boolean;
+    /**
+     * Perform undo: return current action and move index backward.
+     * Returns the action to roll back (apply before).
+     */
+    undo(): HistoryAction | null;
+    /**
+     * Perform redo: move index forward and return the action.
+     * Returns the action to repeat (apply after).
+     */
+    redo(): HistoryAction | null;
+    /**
+     * Clear all history.
+     */
+    clear(): void;
+    /**
+     * Get action by index (without changing currentIndex).
+     */
+    getAction(index: number): HistoryAction | null;
+    /**
+     * Debug output of history state.
+     */
+    private _debug;
+}
+
+interface AreaSelectionPluginOptions {
+    rectStroke?: string;
+    rectFill?: string;
+    rectStrokeWidth?: number;
+    rectOpacity?: number;
+    enableKeyboardShortcuts?: boolean;
+}
+/**
+ * AreaSelectionPlugin
+ * - Drag LKM over empty space draws selection rectangle (marquee) in screen coordinates
+ * - All nodes whose client rectangles intersect the rectangle are temporarily grouped
+ * - Click outside — temporary group is removed, nodes return to their original positions
+ * - Ctrl+G — lock in permanent group (GroupNode through NodeManager)
+ * - Ctrl+Shift+G — unlock selected permanent group
+ */
+declare class AreaSelectionPlugin extends Plugin {
+    private _core?;
+    private _layer;
+    private _rect;
+    private _start;
+    private _transformer;
+    private _selecting;
+    private _skipNextClick;
+    private _lastPickedBaseNodes;
+    private _options;
+    constructor(options?: AreaSelectionPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    private _finalizeArea;
+    private _clearSelection;
+    private _getSelectionPlugin;
+    private _rectsIntersect;
+    private _findOwningGroupBaseNode;
+    private _isAncestor;
+    private _isPermanentGroupSelected;
+    private _currentGroupNode;
 }
 
 interface CameraHotkeysOptions {
@@ -802,155 +1162,6 @@ declare class CameraHotkeysPlugin extends Plugin {
     private _pan;
 }
 
-interface MultiGroupControllerDeps {
-    ensureTempMulti: (nodes: BaseNode[]) => void;
-    destroyTempMulti: () => void;
-    commitTempMultiToGroup: () => void;
-    isActive: () => boolean;
-    forceUpdate: () => void;
-    onWorldChanged?: () => void;
-    isInsideTempByTarget?: (target: Konva.Node) => boolean;
-}
-/**
- * MultiGroupController — thin controller encapsulating work with temporary multi-group.
- * Actual logic lives in passed dependencies (SelectionPlugin),
- * thanks to which we don't duplicate code for frames/overlays and behavior.
- */
-declare class MultiGroupController {
-    private deps;
-    constructor(deps: MultiGroupControllerDeps);
-    ensure(nodes: BaseNode[]): void;
-    destroy(): void;
-    commitToPermanentGroup(): void;
-    isActive(): boolean;
-    forceUpdateOverlays(): void;
-    onWorldChanged(): void;
-    isInsideTempByTarget(target: Konva.Node): boolean;
-}
-
-interface SelectionPluginOptions {
-    dragEnabled?: boolean;
-    enableTransformer?: boolean;
-    deselectOnEmptyClick?: boolean;
-    selectablePredicate?: (node: Konva.Node) => boolean;
-    autoPanEnabled?: boolean;
-    autoPanEdgePx?: number;
-    autoPanMaxSpeedPx?: number;
-}
-/**
- * Universal selection and dragging plugin for nodes compatible with BaseNode.
- *
- * Default behavior:
- * - Click on node in NodeManager layer selects the node
- * - Selected node becomes draggable (dragEnabled)
- * - Click on empty area deselects (deselectOnEmptyClick)
- * - Optionally enable Konva.Transformer (enableTransformer)
- */
-declare class SelectionPlugin extends Plugin {
-    private _core?;
-    private _options;
-    private _selected;
-    private _prevDraggable;
-    private _transformer;
-    private _transformerWasVisibleBeforeDrag;
-    private _cornerHandlesWereVisibleBeforeDrag;
-    private _sizeLabelWasVisibleBeforeDrag;
-    private _rotateHandlesWereVisibleBeforeDrag;
-    private _cornerHandlesGroup;
-    private _cornerHandles;
-    private _cornerHandlesSuppressed;
-    private _transformOppositeCorner;
-    private _sizeLabel;
-    private _radiusLabel;
-    private _rotateHandlesGroup;
-    private _rotateHandles;
-    private _rotateDragState;
-    private _rotateCenterAbsStart;
-    private _prevStageDraggableBeforeRotate;
-    private _worldSyncRafId;
-    private _onCameraZoomEvent;
-    private _hoverTr;
-    private _isPointerDown;
-    private _autoPanRafId;
-    private _autoPanActive;
-    private _autoPanEdgePx;
-    private _autoPanMaxSpeedPx;
-    private _draggingNode;
-    private _ratioKeyPressed;
-    private _onGlobalKeyDown;
-    private _onGlobalKeyUp;
-    private _tempMultiSet;
-    private _tempMultiGroup;
-    private _tempMultiTr;
-    private _tempOverlay;
-    private _tempRotateHandlesGroup;
-    private _tempRotateHandles;
-    private _tempPlacement;
-    getMultiGroupController(): MultiGroupController;
-    private _tempMultiSizeLabel;
-    private _tempMultiHitRect;
-    private _multiCtrl;
-    private _startAutoPanLoop;
-    private _stopAutoPanLoop;
-    /**
-     * Deferred redraw (throttling)
-     * Groups multiple batchDraw calls into one
-     */
-    private _scheduleBatchDraw;
-    private _parentGroupDuringChildEdit;
-    private _parentGroupPrevDraggable;
-    private _dragMoveScheduled;
-    private _batchDrawScheduled;
-    private _hoverThrottle;
-    private _uiUpdateDebounce;
-    constructor(options?: SelectionPluginOptions);
-    setOptions(patch: Partial<SelectionPluginOptions>): void;
-    protected onAttach(core: CoreEngine): void;
-    protected onDetach(core: CoreEngine): void;
-    private _onMouseDown;
-    private _select;
-    private _clearSelection;
-    private _ensureTempMulti;
-    private _destroyTempMulti;
-    private _updateTempRotateHandlesPosition;
-    private _updateTempMultiSizeLabel;
-    private _updateTempMultiHitRect;
-    private _commitTempMultiToGroup;
-    private _tryUngroupSelectedGroup;
-    private _ensureHoverTr;
-    private _destroyHoverTr;
-    private _onHoverMoveThrottled;
-    private _onHoverMove;
-    private _onHoverDown;
-    private _onHoverUp;
-    private _onHoverLeave;
-    private _refreshTransformer;
-    private _restyleSideAnchors;
-    private _setupRotateHandles;
-    private _destroyRotateHandles;
-    private _getNodeCenterAbs;
-    private _updateRotateHandlesPosition;
-    private _setupSizeLabel;
-    private _scheduleUIUpdate;
-    private _updateSizeLabel;
-    private _destroySizeLabel;
-    private _isCornerRadiusSupported;
-    private _getCornerRadiusArray;
-    private _setCornerRadiusArray;
-    private _setupCornerRadiusHandles;
-    private _destroyCornerRadiusHandles;
-    private _bakeRectScale;
-    private _updateCornerRadiusHandlesPosition;
-    private _updateCornerRadiusHandlesVisibility;
-    private _ensureRadiusLabel;
-    private _updateRadiusLabelAt;
-    private _showRadiusLabelForCorner;
-    private _hideRadiusLabel;
-    private _destroyRadiusLabel;
-    private _findBaseNodeByTarget;
-    private _onNodeRemoved;
-}
-
 interface GridPluginOptions {
     stepX?: number;
     stepY?: number;
@@ -1001,96 +1212,209 @@ declare class GridPlugin extends Plugin {
     setSnap(enabled: boolean): void;
 }
 
-interface RulerPluginOptions {
-    thicknessPx?: number;
-    fontFamily?: string;
-    fontSizePx?: number;
-    color?: string;
-    bgColor?: string;
-    borderColor?: string;
-    enabled?: boolean;
+interface HistoryPluginOptions {
+    /** DOM target для прослушивания клавиш (по умолчанию globalThis) */
+    target?: Window | Document | HTMLElement | EventTarget;
+    /** Игнорировать хоткеи, если фокус на редактируемом элементе */
+    ignoreEditableTargets?: boolean;
+    /** Максимальное количество действий в истории (0 = без лимита) */
+    maxHistoryLength?: number;
 }
-declare class RulerPlugin extends Plugin {
+/**
+ * HistoryPlugin — плагин для Undo/Redo функциональности
+ *
+ * Хоткеи:
+ * - Ctrl+Z / Cmd+Z — Undo
+ * - Ctrl+Shift+Z / Cmd+Shift+Z — Redo
+ *
+ * Автоматически записывает в историю:
+ * - Создание нод (node:created)
+ * - Удаление нод (node:removed)
+ * - Трансформации (node:transformed)
+ * - Изменение z-index (node:zIndexChanged)
+ * - Создание групп (group:created)
+ * - Разгруппировка (group:ungrouped)
+ */
+declare class HistoryPlugin extends Plugin {
     private _core?;
+    private _history;
     private _options;
-    private _layer;
-    private _hGroup?;
-    private _vGroup?;
-    private _hBg?;
-    private _vBg?;
-    private _hTicksShape?;
-    private _vTicksShape?;
-    private _hBorder?;
-    private _vBorder?;
-    private _redrawScheduled;
-    private _lastRedrawTime;
-    private _redrawThrottleMs;
-    private _panThrottleMs;
-    private _cachedActiveGuide;
-    private _cacheInvalidated;
-    private _stepsCache;
-    constructor(options?: RulerPluginOptions);
+    /** Флаг для предотвращения записи в историю при undo/redo */
+    private _isUndoRedoInProgress;
+    /** Кэш состояний нод ДО начала drag/transform */
+    private _dragStartStateCache;
+    /** Флаг batch-режима для временной группы */
+    private _isBatchMode;
+    /** Буфер действий для batch */
+    private _batchBuffer;
+    /** Таймер для автоматического завершения batch */
+    private _batchCommitTimer;
+    constructor(options?: HistoryPluginOptions);
     /**
-     * Calculate optimal step for ruler ticks
-     * Uses nice numbers: 1, 2, 5, 10, 20, 50, 100 and so on
+     * Получить менеджер истории для внешнего доступа
      */
-    private _calculateNiceStep;
+    getHistoryManager(): HistoryManager;
     /**
-     * Format number for display on ruler
-     * Always returns an integer without decimal places
+     * Начать batch-режим для группировки нескольких действий
      */
-    private _formatNumber;
+    startBatch(): void;
     /**
-     * Calculate and cache parameters for ticks for current scale
+     * Завершить batch-режим (вызывается извне после эмита всех событий)
      */
-    private _getStepsConfig;
+    commitBatch(): void;
+    /**
+     * Проверить, активен ли batch-режим
+     */
+    isBatchMode(): boolean;
     protected onAttach(core: CoreEngine): void;
     protected onDetach(core: CoreEngine): void;
+    private _onKeyDown;
+    private _isEditableTarget;
+    private _onDragStart;
+    private _onDragEnd;
     /**
-     * Get active guide from RulerGuidesPlugin (with caching)
+     * Завершить batch-режим и записать составное действие
      */
-    private _getActiveGuideInfo;
+    private _finishBatch;
+    private _onTransformStart;
+    private _onTransformEnd;
+    private _performUndo;
+    private _performRedo;
     /**
-     * Invalidate active guide cache
+     * Применить состояние из action (before или after)
      */
-    private _invalidateGuideCache;
+    private _applyActionState;
     /**
-     * Universal ruler drawing (horizontal or vertical)
-     * @param ctx - canvas context
-     * @param axis - ruler axis ('h' for horizontal, 'v' for vertical)
-     * @param activeGuide - cached active guide info
+     * Применить состояние трансформации к ноде
      */
-    private _drawRuler;
+    private _applyTransformState;
     /**
-     * Draw horizontal ruler
-     * @param activeGuide - cached active guide info
+     * Применить действие группировки
      */
-    private _drawHorizontalRuler;
+    private _applyGroupAction;
     /**
-     * Draw vertical ruler
-     * @param activeGuide - cached active guide info
+     * Применить действие разгруппировки
      */
-    private _drawVerticalRuler;
+    private _applyUngroupAction;
     /**
-     * Full ruler redraw
+     * Воссоздать ноду по сериализованному состоянию
      */
-    private _redraw;
+    private _recreateNode;
+    private _onNodeCreated;
+    private _onNodeRemoved;
+    private _onNodeTransformed;
     /**
-     * Deferred redraw with improved throttling
-     * Groups fast zoom/pan events for optimization
-     * @param isPanning - true for panning (more aggressive throttling)
+     * Запланировать завершение batch с debounce
      */
-    private _scheduleRedraw;
-    show(): void;
-    hide(): void;
+    private _scheduleBatchCommit;
+    private _onZIndexChanged;
+    private _onGroupCreated;
+    private _onGroupUngrouped;
     /**
-     * Toggle ruler visibility
+     * Полная сериализация ноды для истории
      */
-    toggle(): void;
+    private _serializeNode;
     /**
-     * Check if ruler is visible
+     * Захватить состояние трансформации (для drag/transform)
+     * Использует абсолютные координаты для корректной работы с временными группами
      */
-    isVisible(): boolean;
+    private _captureTransformState;
+    /**
+     * Построить after-состояние из changes события node:transformed
+     * Использует координаты из changes (world-local для temp-multi-group)
+     */
+    private _buildAfterState;
+    /**
+     * Получить тип ноды из Konva className
+     */
+    private _getNodeType;
+    /**
+     * Найти BaseNode по Konva.Node (ищет также по родителям)
+     */
+    private _findBaseNodeByKonva;
+    /**
+     * Сравнить два состояния на равенство
+     * Использует абсолютные координаты для сравнения (absX, absY, absRotation, etc.)
+     */
+    private _statesEqual;
+    /**
+     * Обрезать историю если превышен лимит
+     */
+    private _trimHistoryIfNeeded;
+    private _debug;
+}
+
+interface LogoOptions {
+    src: string;
+    width: number;
+    height: number;
+    opacity?: number;
+}
+declare class LogoPlugin extends Plugin {
+    private _core?;
+    private _layer?;
+    private _image?;
+    private _src;
+    private _width;
+    private _height;
+    private _opacity;
+    constructor(options: LogoOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    setOpacity(opacity: number): void;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    setSource(src: string): void;
+    private _setImage;
+    private _loadImageFromString;
+    private _layout;
+}
+
+interface NodeHotkeysOptions {
+    target?: Window | Document | HTMLElement | EventTarget;
+    ignoreEditableTargets?: boolean;
+}
+declare class NodeHotkeysPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _clipboard;
+    private _selectionPlugin?;
+    constructor(options?: NodeHotkeysOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(_core: CoreEngine): void;
+    private _onKeyDown;
+    private _isEditableTarget;
+    private _handleCopy;
+    private _handleCut;
+    private _handlePaste;
+    private _handleDelete;
+    private _getSelectedNodes;
+    private _deleteNodes;
+    private _serializeNode;
+    private _serializeKonvaNode;
+    private _getNodeTypeFromKonva;
+    private _deserializeNode;
+    private _getPastePosition;
+    private _isPointerOnScreen;
+    private _getScreenCenter;
+    private _getClipboardCenter;
+    private _computeSelectionWorldCenter;
+    private _handleMoveUp;
+    private _handleMoveDown;
+    private _handleMoveToTop;
+    private _handleMoveToBottom;
+    /**
+     * Checks if the node is inside a real group (not the group itself)
+     */
+    private _isNodeInsidePermanentGroup;
+    /**
+     * Checks if the node is inside a real group
+     * - For group itself — do nothing (moveUp/moveDown already applied to the group)
+     * - For node inside group — FORBIDDEN to change z-index
+     */
+    private _syncGroupZIndex;
 }
 
 interface RulerGuidesPluginOptions {
@@ -1266,126 +1590,379 @@ declare class RulerManagerPlugin extends Plugin {
     deleteActiveGuide(): boolean;
 }
 
-interface AreaSelectionPluginOptions {
-    rectStroke?: string;
-    rectFill?: string;
-    rectStrokeWidth?: number;
-    rectOpacity?: number;
-    enableKeyboardShortcuts?: boolean;
+interface RulerPluginOptions {
+    thicknessPx?: number;
+    fontFamily?: string;
+    fontSizePx?: number;
+    color?: string;
+    bgColor?: string;
+    borderColor?: string;
+    enabled?: boolean;
 }
-/**
- * AreaSelectionPlugin
- * - Drag LKM over empty space draws selection rectangle (marquee) in screen coordinates
- * - All nodes whose client rectangles intersect the rectangle are temporarily grouped
- * - Click outside — temporary group is removed, nodes return to their original positions
- * - Ctrl+G — lock in permanent group (GroupNode through NodeManager)
- * - Ctrl+Shift+G — unlock selected permanent group
- */
-declare class AreaSelectionPlugin extends Plugin {
+declare class RulerPlugin extends Plugin {
     private _core?;
-    private _layer;
-    private _rect;
-    private _start;
-    private _transformer;
-    private _selecting;
     private _options;
-    constructor(options?: AreaSelectionPluginOptions);
+    private _layer;
+    private _hGroup?;
+    private _vGroup?;
+    private _hBg?;
+    private _vBg?;
+    private _hTicksShape?;
+    private _vTicksShape?;
+    private _hBorder?;
+    private _vBorder?;
+    private _redrawScheduled;
+    private _lastRedrawTime;
+    private _redrawThrottleMs;
+    private _panThrottleMs;
+    private _cachedActiveGuide;
+    private _cacheInvalidated;
+    private _stepsCache;
+    constructor(options?: RulerPluginOptions);
+    /**
+     * Calculate optimal step for ruler ticks
+     * Uses nice numbers: 1, 2, 5, 10, 20, 50, 100 and so on
+     */
+    private _calculateNiceStep;
+    /**
+     * Format number for display on ruler
+     * Always returns an integer without decimal places
+     */
+    private _formatNumber;
+    /**
+     * Calculate and cache parameters for ticks for current scale
+     */
+    private _getStepsConfig;
     protected onAttach(core: CoreEngine): void;
     protected onDetach(core: CoreEngine): void;
-    private _finalizeArea;
-    private _clearSelection;
-    private _getSelectionPlugin;
-    private _rectsIntersect;
-    private _findOwningGroupBaseNode;
-    private _isAncestor;
-    private _isPermanentGroupSelected;
-    private _currentGroupNode;
-    private _pointerInsidePermanentGroupBBox;
-}
-
-interface NodeHotkeysOptions {
-    target?: Window | Document | HTMLElement | EventTarget;
-    ignoreEditableTargets?: boolean;
-}
-declare class NodeHotkeysPlugin extends Plugin {
-    private _core?;
-    private _options;
-    private _clipboard;
-    private _selectionPlugin?;
-    constructor(options?: NodeHotkeysOptions);
-    protected onAttach(core: CoreEngine): void;
-    protected onDetach(_core: CoreEngine): void;
-    private _onKeyDown;
-    private _isEditableTarget;
-    private _handleCopy;
-    private _handleCut;
-    private _handlePaste;
-    private _handleDelete;
-    private _getSelectedNodes;
-    private _deleteNodes;
-    private _serializeNode;
-    private _serializeKonvaNode;
-    private _getNodeTypeFromKonva;
-    private _deserializeNode;
-    private _getPastePosition;
-    private _isPointerOnScreen;
-    private _getScreenCenter;
-    private _getClipboardCenter;
-    private _computeSelectionWorldCenter;
-    private _handleMoveUp;
-    private _handleMoveDown;
     /**
-     * Checks if the node is inside a real group (not the group itself)
+     * Get active guide from RulerGuidesPlugin (with caching)
      */
-    private _isNodeInsidePermanentGroup;
+    private _getActiveGuideInfo;
     /**
-     * Checks if the node is inside a real group
-     * - For group itself — do nothing (moveUp/moveDown already applied to the group)
-     * - For node inside group — FORBIDDEN to change z-index
+     * Invalidate active guide cache
      */
-    private _syncGroupZIndex;
+    private _invalidateGuideCache;
+    /**
+     * Universal ruler drawing (horizontal or vertical)
+     * @param ctx - canvas context
+     * @param axis - ruler axis ('h' for horizontal, 'v' for vertical)
+     * @param activeGuide - cached active guide info
+     */
+    private _drawRuler;
+    /**
+     * Draw horizontal ruler
+     * @param activeGuide - cached active guide info
+     */
+    private _drawHorizontalRuler;
+    /**
+     * Draw vertical ruler
+     * @param activeGuide - cached active guide info
+     */
+    private _drawVerticalRuler;
+    /**
+     * Full ruler redraw
+     */
+    private _redraw;
+    /**
+     * Deferred redraw with improved throttling
+     * Groups fast zoom/pan events for optimization
+     * @param isPanning - true for panning (more aggressive throttling)
+     */
+    private _scheduleRedraw;
+    show(): void;
+    hide(): void;
+    /**
+     * Toggle ruler visibility
+     */
+    toggle(): void;
+    /**
+     * Check if ruler is visible
+     */
+    isVisible(): boolean;
 }
 
+interface MultiGroupControllerDeps {
+    ensureTempMulti: (nodes: BaseNode[]) => void;
+    destroyTempMulti: () => void;
+    commitTempMultiToGroup: () => void;
+    isActive: () => boolean;
+    forceUpdate: () => void;
+    onWorldChanged?: () => void;
+    isInsideTempByTarget?: (target: Konva.Node) => boolean;
+}
 /**
- * ThrottleHelper - utility for throttling (limiting the frequency of calls)
- *
- * Used to limit the frequency of operation execution to a certain number of times per second.
- * For example, to limit UI updates to 60 FPS (16ms) or 30 FPS (32ms).
- *
- * @example
- * ```typescript
- * private _throttle = new ThrottleHelper(16); // 60 FPS
+ * MultiGroupController — thin controller encapsulating work with temporary multi-group.
+ * Actual logic lives in passed dependencies (SelectionPlugin),
+ * thanks to which we don't duplicate code for frames/overlays and behavior.
+ */
+declare class MultiGroupController {
+    private deps;
+    constructor(deps: MultiGroupControllerDeps);
+    ensure(nodes: BaseNode[]): void;
+    destroy(): void;
+    commitToPermanentGroup(): void;
+    isActive(): boolean;
+    forceUpdateOverlays(): void;
+    onWorldChanged(): void;
+    isInsideTempByTarget(target: Konva.Node): boolean;
+}
+
+interface SelectionPluginOptions {
+    dragEnabled?: boolean;
+    enableTransformer?: boolean;
+    deselectOnEmptyClick?: boolean;
+    selectablePredicate?: (node: Konva.Node) => boolean;
+    autoPanEnabled?: boolean;
+    autoPanEdgePx?: number;
+    autoPanMaxSpeedPx?: number;
+}
+/**
+ * Universal selection and dragging plugin for nodes compatible with BaseNode.
  *
- * onMouseMove() {
- *   if (!this._throttle.shouldExecute()) return;
- *   // Execute expensive operation
- * }
- * ```
+ * Default behavior:
+ * - Click on node in NodeManager layer selects the node
+ * - Selected node becomes draggable (dragEnabled)
+ * - Click on empty area deselects (deselectOnEmptyClick)
+ * - Optionally enable Konva.Transformer (enableTransformer)
  */
-declare class ThrottleHelper {
-    private _lastTime;
-    private _throttle;
-    /**
-     * @param throttleMs - minimum interval between calls in milliseconds
-     */
-    constructor(throttleMs?: number);
+declare class SelectionPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _selected;
+    private _prevDraggable;
+    private _transformer;
+    private _transformerWasVisibleBeforeDrag;
+    private _cornerHandlesWereVisibleBeforeDrag;
+    private _sizeLabelWasVisibleBeforeDrag;
+    private _rotateHandlesWereVisibleBeforeDrag;
+    private _cornerHandlesGroup;
+    private _cornerHandles;
+    private _cornerHandlesSuppressed;
+    private _transformOppositeCorner;
+    private _sizeLabel;
+    private _radiusLabel;
+    private _rotateHandlesGroup;
+    private _rotateHandles;
+    private _rotateDragState;
+    private _rotateCenterAbsStart;
+    private _prevStageDraggableBeforeRotate;
+    private _worldSyncRafId;
+    private _onCameraZoomEvent;
+    private _hoverTr;
+    private _isPointerDown;
+    private _autoPanRafId;
+    private _autoPanActive;
+    private _autoPanEdgePx;
+    private _autoPanMaxSpeedPx;
+    private _draggingNode;
+    private _ratioKeyPressed;
+    private _onGlobalKeyDown;
+    private _onGlobalKeyUp;
+    private _tempMultiSet;
+    private _tempMultiNodes;
+    private _tempMultiInitialTransforms;
+    private _tempMultiGroup;
+    private _tempOverlay;
+    getMultiGroupController(): MultiGroupController;
+    private _multiCtrl;
+    private _startAutoPanLoop;
+    private _stopAutoPanLoop;
     /**
-     * Checks if the operation can be executed
-     * @returns true if enough time has passed since the last call
+     * Deferred redraw (throttling)
+     * Groups multiple batchDraw calls into one
      */
-    shouldExecute(): boolean;
+    private _scheduleBatchDraw;
+    private _parentGroupDuringChildEdit;
+    private _parentGroupPrevDraggable;
+    private _dragMoveScheduled;
+    private _batchDrawScheduled;
+    private _hoverThrottle;
+    private _uiUpdateDebounce;
+    constructor(options?: SelectionPluginOptions);
+    setOptions(patch: Partial<SelectionPluginOptions>): void;
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    private _onMouseDown;
+    private _select;
+    private _clearSelection;
     /**
-     * Resets the timer (the next call will be executed immediately)
+     * Apply transformation from overlay group to actual nodes using matrix math.
+     * Each node's transform is updated to match the overlay group's transformation,
+     * while staying in its original parent.
      */
-    reset(): void;
+    private _applyOverlayTransformToNodes;
     /**
-     * Changes the throttling interval
+     * Update overlay group bbox to match current positions of selected nodes.
+     * Must be called after drag/transform when nodes change position.
      */
-    setThrottle(throttleMs: number): void;
+    private _updateTempMultiOverlayBBox;
     /**
-     * Returns the current throttling interval
+     * Compute union bounding box for multiple nodes in world-local coordinates.
+     * Used for overlay-only temporary multi-group.
+     * Returns bbox that doesn't change when world transform (zoom/pan) changes.
      */
-    getThrottle(): number;
+    private _computeUnionBBox;
+    private _ensureTempMulti;
+    private _destroyTempMulti;
+    private _commitTempMultiToGroup;
+    private _tryUngroupSelectedGroup;
+    private _ensureHoverTr;
+    private _destroyHoverTr;
+    private _onHoverMoveThrottled;
+    private _onHoverMove;
+    private _onHoverDown;
+    private _onHoverUp;
+    private _onHoverLeave;
+    private _refreshTransformer;
+    private _restyleSideAnchors;
+    private _setupRotateHandles;
+    private _destroyRotateHandles;
+    private _getNodeCenterAbs;
+    private _updateRotateHandlesPosition;
+    private _setupSizeLabel;
+    private _scheduleUIUpdate;
+    private _updateSizeLabel;
+    private _destroySizeLabel;
+    private _isCornerRadiusSupported;
+    private _getCornerRadiusArray;
+    private _setCornerRadiusArray;
+    private _setupCornerRadiusHandles;
+    private _destroyCornerRadiusHandles;
+    private _bakeRectScale;
+    private _updateCornerRadiusHandlesPosition;
+    private _updateCornerRadiusHandlesVisibility;
+    private _ensureRadiusLabel;
+    private _updateRadiusLabelAt;
+    private _showRadiusLabelForCorner;
+    private _hideRadiusLabel;
+    private _destroyRadiusLabel;
+    private _findBaseNodeByTarget;
+    private _onNodeRemoved;
+    private _disableGroupChildrenDragging;
+}
+
+interface VisualGuidesPluginOptions {
+    guidelineColor?: string;
+    guidelineWidth?: number;
+    guidelineDash?: number[];
+    thresholdPx?: number;
+}
+/**
+ * VisualGuidesPlugin — snapping of nodes and groups relative to other nodes/groups + stage borders.
+ *
+ * Implemented directly on top of Konva, based on the official guidelines example:
+ * https://konvajs.org/docs/sandbox/Guides.html
+ */
+declare class VisualGuidesPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _layer;
+    private _dragMoveHandler;
+    private _dragEndHandler;
+    private _nodesAddHandler;
+    private _nodesRemoveHandler;
+    constructor(options?: VisualGuidesPluginOptions);
+    private _applyGapSnappingForDrag;
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    private _onDragMove;
+    private _clearGuides;
+    private _drawDragGuides;
+    private _pointOnRay;
+    private _drawRayMarkerWithLabel;
+    private _buildDragRays;
+    private _collectOtherNodeBoxes;
+    private _intersectRayWithBox;
+    private _getLineGuideStops;
+    private _getObjectSnappingEdges;
+    private _getGuides;
+    private _attachExistingTransformers;
+    private _walkAttachTransformers;
+    private _attachTransformer;
+    private _walkDetachTransformers;
+    private _handleTransformerTransform;
+    private _drawResizeGuides;
+    private _buildResizeRays;
+    private _isVisualLinesShouldCleared;
+}
+
+type ImageHoverFilterMode = 'sepia' | 'warm' | 'cool';
+interface ImageHoverFilterAddonOptions {
+    mode?: ImageHoverFilterMode;
+    /** 0..1 — effect strength for warm/cool */
+    intensity?: number;
+    /** pixelRatio for cache during hover. Default = devicePixelRatio or 1 */
+    pixelRatio?: number;
+}
+declare class ImageHoverFilterAddon extends NodeAddon<ImageNode> {
+    private readonly mode;
+    private readonly intensity;
+    private readonly pixelRatio;
+    private readonly nodes;
+    constructor(options?: ImageHoverFilterAddonOptions);
+    protected onAttach(node: ImageNode): void;
+    protected onDetach(node: ImageNode): void;
+}
+
+/**
+ * Addon for RulerPlugin, set up by RulerGuidesPlugin.
+ */
+declare class RulerGuidesAddon extends PluginAddon<RulerPlugin> {
+    private readonly _options;
+    private _instance;
+    private _owned;
+    constructor(options?: RulerGuidesPluginOptions);
+    protected onAttach(_plugin: RulerPlugin, core: CoreEngine): void;
+    protected onDetach(_plugin: RulerPlugin, core: CoreEngine): void;
+}
+
+/**
+ * Addon for RulerPlugin, set up by RulerHighlightPlugin.
+ */
+declare class RulerHighlightAddon extends PluginAddon<RulerPlugin> {
+    private readonly _options;
+    private _instance;
+    private _owned;
+    constructor(options?: RulerHighlightPluginOptions);
+    protected onAttach(_plugin: RulerPlugin, core: CoreEngine): void;
+    protected onDetach(_plugin: RulerPlugin, core: CoreEngine): void;
+}
+
+/**
+ * Addon for RulerPlugin, set up by RulerManagerPlugin.
+ */
+declare class RulerManagerAddon extends PluginAddon<RulerPlugin> {
+    private readonly _options;
+    private _instance;
+    private _owned;
+    constructor(options?: RulerManagerPluginOptions);
+    protected onAttach(_plugin: RulerPlugin, core: CoreEngine): void;
+    protected onDetach(_plugin: RulerPlugin, core: CoreEngine): void;
+}
+
+interface ShapeHoverHighlightAddonOptions {
+    stroke?: string;
+    strokeWidth?: number;
+    fill?: string;
+    mode?: 'stroke' | 'fill' | 'both';
+}
+declare class ShapeHoverHighlightAddon extends NodeAddon<ShapeNode> {
+    private readonly stroke;
+    private readonly strokeWidth;
+    private readonly fill;
+    private readonly mode;
+    private readonly nodes;
+    constructor(options?: ShapeHoverHighlightAddonOptions);
+    protected onAttach(node: ShapeNode): void;
+    protected onDetach(node: ShapeNode): void;
+}
+
+declare class TextAutoTrimAddon extends NodeAddon<TextNode> {
+    private readonly nodes;
+    protected onAttach(node: TextNode): void;
+    protected onDetach(node: TextNode): void;
+    private normalize;
 }
 
 /**
@@ -1427,4 +2004,46 @@ declare class DebounceHelper {
     cancel(): void;
 }
 
-export { ArcNode, AreaSelectionPlugin, ArrowNode, CameraHotkeysPlugin, CameraManager, CircleNode, CoreEngine, DebounceHelper, EllipseNode, EventBus, GridPlugin, GroupNode, ImageNode, LogoPlugin, NodeHotkeysPlugin, NodeManager, Plugins, RegularPolygonNode, RingNode, RulerGuidesPlugin, RulerHighlightPlugin, RulerManagerPlugin, RulerPlugin, SelectionPlugin, ShapeNode, StarNode, TextNode, ThrottleHelper };
+/**
+ * ThrottleHelper - utility for throttling (limiting the frequency of calls)
+ *
+ * Used to limit the frequency of operation execution to a certain number of times per second.
+ * For example, to limit UI updates to 60 FPS (16ms) or 30 FPS (32ms).
+ *
+ * @example
+ * ```typescript
+ * private _throttle = new ThrottleHelper(16); // 60 FPS
+ *
+ * onMouseMove() {
+ *   if (!this._throttle.shouldExecute()) return;
+ *   // Execute expensive operation
+ * }
+ * ```
+ */
+declare class ThrottleHelper {
+    private _lastTime;
+    private _throttle;
+    /**
+     * @param throttleMs - minimum interval between calls in milliseconds
+     */
+    constructor(throttleMs?: number);
+    /**
+     * Checks if the operation can be executed
+     * @returns true if enough time has passed since the last call
+     */
+    shouldExecute(): boolean;
+    /**
+     * Resets the timer (the next call will be executed immediately)
+     */
+    reset(): void;
+    /**
+     * Changes the throttling interval
+     */
+    setThrottle(throttleMs: number): void;
+    /**
+     * Returns the current throttling interval
+     */
+    getThrottle(): number;
+}
+
+export { type ArcNodeHandle, type ArcNodeOptions, AreaSelectionPlugin, type AreaSelectionPluginOptions, type ArrowNodeHandle, type ArrowNodeOptions, type BaseNodeOptions, type CameraHotkeysOptions, CameraHotkeysPlugin, CameraManager, type CircleNodeHandle, type CircleNodeOptions, CoreEngine, type CoreEngineOptions, type CoreEvents, DebounceHelper, type EllipseNodeHandle, type EllipseNodeOptions, EventBus, GridPlugin, type GridPluginOptions, type GroupNodeHandle, type GroupNodeOptions, type HistoryAction, HistoryManager, HistoryPlugin, type HistoryPluginOptions, ImageHoverFilterAddon, type ImageNodeHandle, type ImageNodeOptions, type ImageSource, type KonvaArc, type KonvaArrow, type KonvaCircle, type KonvaEllipse, type KonvaGroup, type KonvaGroupConfig, type KonvaImage, type KonvaLayer, type KonvaNode, type KonvaNodeConfig, type KonvaRegularPolygon, type KonvaRing, type KonvaShape, type KonvaStage, type KonvaStar, type KonvaText, type LogoOptions, LogoPlugin, NodeAddon, NodeAddons, type NodeAddonsHandle, type NodeHandle, type NodeHotkeysOptions, NodeHotkeysPlugin, NodeManager, PluginAddon, Plugins, type RegularPolygonNodeHandle, type RegularPolygonNodeOptions, type RingNodeHandle, type RingNodeOptions, RulerGuidesAddon, RulerGuidesPlugin, type RulerGuidesPluginOptions, RulerHighlightAddon, RulerHighlightPlugin, type RulerHighlightPluginOptions, RulerManagerAddon, RulerManagerPlugin, type RulerManagerPluginOptions, RulerPlugin, type RulerPluginOptions, SelectionPlugin, type SelectionPluginOptions, ShapeHoverHighlightAddon, type ShapeNodeHandle, type ShapeNodeOptions, type StarNodeHandle, type StarNodeOptions, TextAutoTrimAddon, type TextNodeHandle, type TextNodeOptions, ThrottleHelper, VisualGuidesPlugin, type VisualGuidesPluginOptions };