@flowscape-ui/core-sdk 1.0.2 → 1.0.4

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,262 @@ 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;
+}
+/**
+ * Handle for SvgNode
+ */
+interface SvgNodeHandle extends NodeHandle {
+    setSrc(url: string, onLoad?: (node: unknown) => void, onError?: (error: Error) => void): Promise<unknown>;
+    setSize(size: {
+        width: number;
+        height: number;
+    }): this;
+    setCornerRadius(radius: number | number[]): this;
+    setOpacity(opacity: number): this;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCornerRadius(): number;
+    getOpacity(): number;
+    isLoading(): boolean;
+    isLoaded(): boolean;
+}
+/**
+ * Handle for VideoNode
+ */
+interface VideoNodeHandle extends NodeHandle {
+    setSrc(url: string, options?: Record<string, unknown>): Promise<unknown>;
+    play(): Promise<unknown>;
+    pause(): this;
+    stop(): this;
+    setCurrentTime(time: number): this;
+    getCurrentTime(): number;
+    getDuration(): number;
+    setVolume(volume: number): this;
+    getVolume(): number;
+    setMuted(muted: boolean): this;
+    isMuted(): boolean;
+    setLoop(loop: boolean): this;
+    isLoop(): boolean;
+    setPlaybackRate(rate: number): this;
+    getPlaybackRate(): number;
+    isPlaying(): boolean;
+    isLoaded(): boolean;
+    getVideoElement(): HTMLVideoElement | null;
+    setSize(size: {
+        width: number;
+        height: number;
+    }): this;
+    setCornerRadius(radius: number | number[]): this;
+    setOpacity(opacity: number): this;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCornerRadius(): number;
+    getOpacity(): number;
+}
+/**
+ * Handle for GifNode
+ */
+interface GifNodeHandle extends NodeHandle {
+    setSrc(url: string, options?: Record<string, unknown>): Promise<unknown>;
+    play(): this;
+    pause(): this;
+    isPlaying(): boolean;
+    isLoaded(): boolean;
+    getFrameIndex(): number;
+    getCanvas(): HTMLCanvasElement | null;
+    setSize(size: {
+        width: number;
+        height: number;
+    }): this;
+    setCornerRadius(radius: number | number[]): this;
+    setOpacity(opacity: number): this;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCornerRadius(): number;
+    getOpacity(): 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;
+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 +392,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 +422,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,50 +441,191 @@ 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;
+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 ArcNodeOptions extends BaseNodeOptions {
+    innerRadius?: number;
+    outerRadius?: number;
+    angle?: number;
+    rotation?: number;
+    clockwise?: boolean;
     fill?: string;
-    align?: 'left' | 'center' | 'right';
-    padding?: number;
+    stroke?: string;
+    strokeWidth?: 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;
+
+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 {
+    radius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+
+interface EllipseNodeOptions extends BaseNodeOptions {
+    radiusX?: number;
+    radiusY?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+
+interface MediaPlaceholderOptions {
+    text: string;
+    textColor: string;
+    font: string;
+    backgroundColor: string;
+    borderColor: string;
+    baseSpinnerColor: string;
+    accentSpinnerColor: string;
+    lineWidth: number;
+    fallbackWidth: number;
+    fallbackHeight: number;
+}
+declare class MediaPlaceholder {
+    private readonly _node;
+    private _options;
+    private _rafId;
+    private _startTime;
+    private _lastDrawTime;
+    private _canvas;
+    private _ctx;
+    private _logicalWidth;
+    private _logicalHeight;
+    private _pixelRatio;
+    private readonly _maxPixelRatio;
+    private readonly _maxCanvasPixels;
+    private readonly _targetFps;
+    constructor(node: Konva.Image, options?: Partial<MediaPlaceholderOptions>);
+    setOptions(options: Partial<MediaPlaceholderOptions>): void;
+    start(): void;
+    stop(): void;
+    private _tick;
+    private _getPixelRatio;
+    private _draw;
+}
+
+declare global {
+    interface Window {
+        gifler?: (url: string) => GiflerInstance;
+    }
+    interface GiflerInstance {
+        frames: (canvas: HTMLCanvasElement, onDrawFrame: (ctx: CanvasRenderingContext2D, frame: GiflerFrame) => void) => void;
+    }
+    interface GiflerFrame {
+        width: number;
+        height: number;
+        buffer: HTMLCanvasElement;
+    }
+}
+interface GifNodeOptions extends BaseNodeOptions {
+    src?: string;
+    width?: number;
+    height?: number;
+    cornerRadius?: number | number[];
+    autoplay?: boolean;
+    placeholder?: Partial<MediaPlaceholderOptions>;
+    onLoad?: (node: GifNode) => void;
+    onError?: (error: Error) => void;
+    onFrame?: (node: GifNode, frameIndex: number) => void;
+}
+declare class GifNode extends BaseNode<Konva.Image> {
+    private _canvas;
+    private _placeholder;
+    private _isLoaded;
+    private _isPlaying;
+    private _giflerLoaded;
+    private _frameIndex;
+    constructor(options?: GifNodeOptions);
+    setSrc(url: string, options?: Omit<GifNodeOptions, 'src' | 'x' | 'y' | 'width' | 'height'>): Promise<this>;
+    play(): this;
+    pause(): this;
+    isPlaying(): boolean;
+    isLoaded(): boolean;
+    getFrameIndex(): number;
+    getCanvas(): HTMLCanvasElement | null;
     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;
+    setCornerRadius(radius: number | number[]): this;
+    getCornerRadius(): number;
+    setOpacity(opacity: number): this;
+    getOpacity(): number;
+    private _ensureGiflerLibrary;
+    private _cleanup;
+    remove(): void;
+}
+
+interface GroupNodeOptions extends BaseNodeOptions {
+    draggable?: boolean;
+    listening?: boolean;
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 
 type ImageSource = HTMLImageElement;
@@ -183,8 +634,11 @@ interface ImageNodeOptions extends BaseNodeOptions {
     src?: string;
     width?: number;
     height?: number;
+    cornerRadius?: number | number[];
+    placeholder?: Partial<MediaPlaceholderOptions>;
 }
 declare class ImageNode extends BaseNode<Konva.Image> {
+    private _placeholder;
     constructor(options?: ImageNodeOptions);
     getSize(): {
         width: number;
@@ -203,123 +657,48 @@ declare class ImageNode extends BaseNode<Konva.Image> {
         width: number;
         height: number;
     }): this;
+    setCornerRadius(radius: number | number[]): this;
+    getCornerRadius(): number;
     private _loadHTMLImage;
+    remove(): void;
 }
 
-interface CircleNodeOptions extends BaseNodeOptions {
+interface RegularPolygonNodeOptions extends BaseNodeOptions {
+    sides?: number;
     radius?: number;
     fill?: string;
     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;
-    radiusY?: number;
-    fill?: string;
-    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 {
+interface RingNodeOptions 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 ArrowNodeOptions extends BaseNodeOptions {
-    points?: number[];
-    tension?: number;
-    pointerLength?: number;
-    pointerWidth?: number;
-    pointerAtBeginning?: boolean;
-    pointerAtEnding?: boolean;
+interface ShapeNodeOptions extends BaseNodeOptions {
     fill?: string;
     stroke?: string;
     strokeWidth?: number;
+    cornerRadius?: number | 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;
+declare class ShapeNode extends BaseNode<Konva.Rect> {
+    constructor(options: ShapeNodeOptions);
     setFill(color: string): this;
     setStroke(color: string): this;
     setStrokeWidth(width: number): this;
-}
-
-interface RegularPolygonNodeOptions extends BaseNodeOptions {
-    sides?: number;
-    radius?: number;
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-}
-declare class RegularPolygonNode extends BaseNode<Konva.RegularPolygon> {
-    constructor(options?: RegularPolygonNodeOptions);
-    getSides(): number;
-    getRadius(): number;
+    setCornerRadius(radius: number | number[]): this;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
     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;
+    getCornerRadius(): number;
 }
 
 interface StarNodeOptions extends BaseNodeOptions {
@@ -330,70 +709,184 @@ interface StarNodeOptions extends BaseNodeOptions {
     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;
-    setFill(color: string): this;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): this;
+
+interface SvgNodeOptions extends BaseNodeOptions {
+    src?: string;
+    width?: number;
+    height?: number;
+    cornerRadius?: number | number[];
+    placeholder?: Partial<MediaPlaceholderOptions>;
+    onLoad?: (node: SvgNode) => void;
+    onError?: (error: Error) => void;
+}
+declare class SvgNode extends BaseNode<Konva.Image> {
+    private _isLoading;
+    private _isLoaded;
+    private _placeholder;
+    constructor(options?: SvgNodeOptions);
+    isLoading(): boolean;
+    isLoaded(): boolean;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    setSrc(url: string, onLoad?: (node: SvgNode) => void, onError?: (error: Error) => void): Promise<this>;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
+    setCornerRadius(radius: number | number[]): this;
+    getCornerRadius(): number;
+    setOpacity(opacity: number): this;
+    getOpacity(): number;
+    remove(): void;
 }
 
-interface RingNodeOptions extends BaseNodeOptions {
-    innerRadius?: number;
-    outerRadius?: number;
+interface TextNodeOptions extends BaseNodeOptions {
+    text?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontStyle?: string;
     fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
+    align?: 'left' | 'center' | 'right';
+    verticalAlign?: 'top' | 'middle' | 'bottom';
+    padding?: number;
+    lineHeight?: number;
+    /** Включить редактирование по двойному клику (по умолчанию true) */
+    editable?: boolean;
 }
-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;
+/** Событие изменения текста */
+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;
-    setStroke(color: string): this;
-    setStrokeWidth(width: number): 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 _inputHandler;
+    private _prevWrap;
+    private _getWrappedLineCount;
+    private _ensureHeightFitsWrappedText;
+    private _ensureWidthFitsText;
+    private _syncNodeSizeFromTextarea;
+    private _syncTextareaPosition;
+    private _openTextarea;
+    private _saveAndClose;
 }
 
-interface GroupNodeOptions extends BaseNodeOptions {
-    draggable?: boolean;
-    listening?: boolean;
-    clip?: {
-        x: number;
-        y: number;
+interface VideoNodeOptions extends BaseNodeOptions {
+    src?: string;
+    width?: number;
+    height?: number;
+    cornerRadius?: number | number[];
+    autoplay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    currentTime?: number;
+    volume?: number;
+    playbackRate?: number;
+    placeholder?: Partial<MediaPlaceholderOptions>;
+    onLoadedMetadata?: (node: VideoNode, video: HTMLVideoElement) => void;
+    onError?: (error: Error) => void;
+    onPlay?: (node: VideoNode) => void;
+    onPause?: (node: VideoNode) => void;
+    onEnded?: (node: VideoNode) => void;
+}
+declare class VideoNode extends BaseNode<Konva.Image> {
+    private _videoElement;
+    private _animation;
+    private _placeholder;
+    private _isPlaying;
+    private _isLoaded;
+    constructor(options?: VideoNodeOptions);
+    setSrc(url: string, options?: Omit<VideoNodeOptions, 'src' | 'x' | 'y' | 'width' | 'height'>): Promise<this>;
+    play(): Promise<this>;
+    pause(): this;
+    stop(): this;
+    setCurrentTime(time: number): this;
+    getCurrentTime(): number;
+    getDuration(): number;
+    setVolume(volume: number): this;
+    getVolume(): number;
+    setMuted(muted: boolean): this;
+    isMuted(): boolean;
+    setLoop(loop: boolean): this;
+    isLoop(): boolean;
+    setPlaybackRate(rate: number): this;
+    getPlaybackRate(): number;
+    isPlaying(): boolean;
+    isLoaded(): boolean;
+    getVideoElement(): HTMLVideoElement | null;
+    getSize(): {
         width: number;
         height: number;
     };
-}
-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;
+    setSize({ width, height }: {
         width: number;
         height: number;
     }): this;
+    setCornerRadius(radius: number | number[]): this;
+    getCornerRadius(): number;
+    setOpacity(opacity: number): this;
+    getOpacity(): number;
+    private _ensureAnimation;
+    private _cleanup;
+    remove(): void;
 }
 
 declare class NodeManager {
@@ -410,17 +903,20 @@ 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;
+    addSvg(options: SvgNodeOptions): SvgNodeHandle;
+    addVideo(options: VideoNodeOptions): VideoNodeHandle;
+    addGif(options: GifNodeOptions): GifNodeHandle;
     remove(node: BaseNode): void;
     findById(id: string): BaseNode | undefined;
     list(): BaseNode[];
@@ -431,42 +927,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,11 +1130,61 @@ declare class VirtualizationManager {
     destroy(): void;
 }
 
-declare abstract class Plugin {
-    protected abstract onAttach(core: CoreEngine): void;
-    protected abstract onDetach(core: CoreEngine): void;
-    attach(core: CoreEngine): void;
-    detach(core: CoreEngine): 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;
+    detach(core: CoreEngine): void;
 }
 
 declare class Plugins {
@@ -715,12 +1225,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 +1260,152 @@ 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 {
+/**
+ * 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 _image?;
-    private _src;
-    private _width;
-    private _height;
-    private _opacity;
-    constructor(options: LogoOptions);
+    private _layer;
+    private _rect;
+    private _start;
+    private _transformer;
+    private _selecting;
+    private _skipNextClick;
+    private _lastPickedBaseNodes;
+    private _autoPanRafId;
+    private _autoPanActive;
+    private _autoPanEdgePx;
+    private _autoPanMaxSpeedPx;
+    private _options;
+    constructor(options?: AreaSelectionPluginOptions);
     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;
+    private _startAutoPanLoop;
+    private _stopAutoPanLoop;
+    private _finalizeArea;
+    private _clearSelection;
+    private _getSelectionPlugin;
+    private _rectsIntersect;
+    private _findOwningGroupBaseNode;
+    private _isAncestor;
+    private _isPermanentGroupSelected;
+    private _currentGroupNode;
 }
 
 interface CameraHotkeysOptions {
@@ -802,295 +1443,297 @@ 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;
+interface ContentFromClipboardPluginOptions {
+    target?: Window | Document | HTMLElement | EventTarget;
+    ignoreEditableTargets?: boolean;
+    maxImageSize?: number;
+    enableDragDrop?: boolean;
+}
+declare class ContentFromClipboardPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _dragDropAddon;
+    constructor(options?: ContentFromClipboardPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(_core: CoreEngine): void;
+    private _onPaste;
+    private _handlePaste;
+    handleDrop(e: DragEvent): Promise<void>;
+    private _handleDataTransfer;
+    private _pasteSvgText;
+    private _pasteSvgFile;
+    private _pasteImageFile;
+    private _pasteVideoFile;
+    private _fitIntoMaxSize;
+    private _isEditableTarget;
+    private _getPastePosition;
+    private _isPointerOnScreen;
+    private _getScreenCenter;
+    private _getAsString;
+    private _looksLikeVideoFile;
+    private _htmlToText;
+    private _readFileAsText;
+    private _extractSvgMarkup;
+    private _svgTextToSrc;
+    private _parseSvgNumber;
+    private _extractSvgSize;
+    private _loadImageSize;
+}
+
+interface GridPluginOptions {
+    stepX?: number;
+    stepY?: number;
+    color?: string;
+    lineWidth?: number;
+    visible?: boolean;
+    minScaleToShow?: number | null;
+    enableSnap?: 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.
+ * GridPlugin — draws a grid and implements snap to grid on drag/resize.
+ * Architecture is identical to other plugins: onAttach/onDetach, own layer with Konva.Shape.
+ *
+ * Important points of the current architecture:
+ * - Panning/scale is performed by Stage transformations.
+ * - Nodes are placed on the NodeManager layer (core.nodes.layer), also Transformers are added to it.
  */
-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;
+declare class GridPlugin extends Plugin {
+    private _core?;
+    private _layer;
+    private _shape;
+    private _stepX;
+    private _stepY;
+    private _color;
+    private _lineWidth;
+    private _visible;
+    private _minScaleToShow;
+    private _enableSnap;
+    private _dragMoveHandler;
+    private _nodesAddHandler;
+    private _nodesRemoveHandler;
+    private _redrawScheduled;
+    private _transformersCache;
+    private _cacheInvalidated;
+    constructor(options?: GridPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    /**
+     * Deferred redraw (throttling)
+     */
+    private _scheduleRedraw;
+    protected onDetach(core: CoreEngine): void;
+    setVisible(visible: boolean): void;
+    get stepX(): number;
+    get stepY(): number;
+    get minScaleToShow(): number | null;
+    setStep(stepX: number, stepY: number): void;
+    setMinScaleToShow(value: number | null): void;
+    setSnap(enabled: boolean): void;
 }
 
-interface SelectionPluginOptions {
-    dragEnabled?: boolean;
-    enableTransformer?: boolean;
-    deselectOnEmptyClick?: boolean;
-    selectablePredicate?: (node: Konva.Node) => boolean;
-    autoPanEnabled?: boolean;
-    autoPanEdgePx?: number;
-    autoPanMaxSpeedPx?: number;
+interface HistoryPluginOptions {
+    /** DOM target для прослушивания клавиш (по умолчанию globalThis) */
+    target?: Window | Document | HTMLElement | EventTarget;
+    /** Игнорировать хоткеи, если фокус на редактируемом элементе */
+    ignoreEditableTargets?: boolean;
+    /** Максимальное количество действий в истории (0 = без лимита) */
+    maxHistoryLength?: number;
 }
 /**
- * Universal selection and dragging plugin for nodes compatible with BaseNode.
+ * HistoryPlugin — плагин для Undo/Redo функциональности
  *
- * 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)
+ * Хоткеи:
+ * - 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 SelectionPlugin extends Plugin {
+declare class HistoryPlugin extends Plugin {
     private _core?;
+    private _history;
     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;
+    /** Флаг для предотвращения записи в историю при undo/redo */
+    private _isUndoRedoInProgress;
+    /** Кэш состояний нод ДО начала drag/transform */
+    private _dragStartStateCache;
+    /** Флаг batch-режима для временной группы */
+    private _isBatchMode;
+    /** Буфер действий для batch */
+    private _batchBuffer;
+    /** Таймер для автоматического завершения batch */
+    private _batchCommitTimer;
+    constructor(options?: HistoryPluginOptions);
     /**
-     * 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;
+    getHistoryManager(): HistoryManager;
+    /**
+     * Начать batch-режим для группировки нескольких действий
+     */
+    startBatch(): void;
+    /**
+     * Завершить batch-режим (вызывается извне после эмита всех событий)
+     */
+    commitBatch(): void;
+    /**
+     * Проверить, активен ли batch-режим
+     */
+    isBatchMode(): boolean;
     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;
-    color?: string;
-    lineWidth?: number;
-    visible?: boolean;
-    minScaleToShow?: number | null;
-    enableSnap?: boolean;
-}
-/**
- * GridPlugin — draws a grid and implements snap to grid on drag/resize.
- * Architecture is identical to other plugins: onAttach/onDetach, own layer with Konva.Shape.
- *
- * Important points of the current architecture:
- * - Panning/scale is performed by Stage transformations.
- * - Nodes are placed on the NodeManager layer (core.nodes.layer), also Transformers are added to it.
- */
-declare class GridPlugin extends Plugin {
-    private _core?;
-    private _layer;
-    private _shape;
-    private _stepX;
-    private _stepY;
-    private _color;
-    private _lineWidth;
-    private _visible;
-    private _minScaleToShow;
-    private _enableSnap;
-    private _dragMoveHandler;
-    private _nodesAddHandler;
-    private _nodesRemoveHandler;
-    private _redrawScheduled;
-    private _transformersCache;
-    private _cacheInvalidated;
-    constructor(options?: GridPluginOptions);
-    protected onAttach(core: CoreEngine): void;
+    private _onKeyDown;
+    private _isEditableTarget;
+    private _onDragStart;
+    private _onDragEnd;
     /**
-     * Deferred redraw (throttling)
+     * Завершить batch-режим и записать составное действие
      */
-    private _scheduleRedraw;
-    protected onDetach(core: CoreEngine): void;
-    setVisible(visible: boolean): void;
-    get stepX(): number;
-    get stepY(): number;
-    get minScaleToShow(): number | null;
-    setStep(stepX: number, stepY: number): void;
-    setMinScaleToShow(value: number | null): void;
-    setSnap(enabled: boolean): void;
-}
-
-interface RulerPluginOptions {
-    thicknessPx?: number;
-    fontFamily?: string;
-    fontSizePx?: number;
-    color?: string;
-    bgColor?: string;
-    borderColor?: string;
-    enabled?: boolean;
-}
-declare class RulerPlugin extends Plugin {
-    private _core?;
-    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);
+    private _finishBatch;
+    private _onTransformStart;
+    private _onTransformEnd;
+    private _performUndo;
+    private _performRedo;
     /**
-     * Calculate optimal step for ruler ticks
-     * Uses nice numbers: 1, 2, 5, 10, 20, 50, 100 and so on
+     * Применить состояние из action (before или after)
      */
-    private _calculateNiceStep;
+    private _applyActionState;
     /**
-     * Format number for display on ruler
-     * Always returns an integer without decimal places
+     * Применить состояние трансформации к ноде
      */
-    private _formatNumber;
+    private _applyTransformState;
     /**
-     * Calculate and cache parameters for ticks for current scale
+     * Применить действие группировки
      */
-    private _getStepsConfig;
-    protected onAttach(core: CoreEngine): void;
-    protected onDetach(core: CoreEngine): void;
+    private _applyGroupAction;
     /**
-     * Get active guide from RulerGuidesPlugin (with caching)
+     * Применить действие разгруппировки
      */
-    private _getActiveGuideInfo;
+    private _applyUngroupAction;
     /**
-     * Invalidate active guide cache
+     * Воссоздать ноду по сериализованному состоянию
      */
-    private _invalidateGuideCache;
+    private _recreateNode;
+    private _onNodeCreated;
+    private _onNodeRemoved;
+    private _onNodeTransformed;
     /**
-     * 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
+     * Запланировать завершение batch с debounce
      */
-    private _drawRuler;
+    private _scheduleBatchCommit;
+    private _onZIndexChanged;
+    private _onGroupCreated;
+    private _onGroupUngrouped;
     /**
-     * Draw horizontal ruler
-     * @param activeGuide - cached active guide info
+     * Полная сериализация ноды для истории
      */
-    private _drawHorizontalRuler;
+    private _serializeNode;
     /**
-     * Draw vertical ruler
-     * @param activeGuide - cached active guide info
+     * Захватить состояние трансформации (для drag/transform)
+     * Использует абсолютные координаты для корректной работы с временными группами
      */
-    private _drawVerticalRuler;
+    private _captureTransformState;
     /**
-     * Full ruler redraw
+     * Построить after-состояние из changes события node:transformed
+     * Использует координаты из changes (world-local для temp-multi-group)
      */
-    private _redraw;
+    private _buildAfterState;
     /**
-     * Deferred redraw with improved throttling
-     * Groups fast zoom/pan events for optimization
-     * @param isPanning - true for panning (more aggressive throttling)
+     * Получить тип ноды из Konva className
      */
-    private _scheduleRedraw;
-    show(): void;
-    hide(): void;
+    private _getNodeType;
     /**
-     * Toggle ruler visibility
+     * Найти BaseNode по Konva.Node (ищет также по родителям)
      */
-    toggle(): void;
+    private _findBaseNodeByKonva;
     /**
-     * Check if ruler is visible
+     * Сравнить два состояния на равенство
+     * Использует абсолютные координаты для сравнения (absX, absY, absRotation, etc.)
      */
-    isVisible(): boolean;
+    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 _onPaste;
+    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 +1909,473 @@ declare class RulerManagerPlugin extends Plugin {
     deleteActiveGuide(): boolean;
 }
 
-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 _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;
-    private _pointerInsidePermanentGroupBBox;
-}
-
-interface NodeHotkeysOptions {
-    target?: Window | Document | HTMLElement | EventTarget;
-    ignoreEditableTargets?: boolean;
+interface RulerPluginOptions {
+    thicknessPx?: number;
+    fontFamily?: string;
+    fontSizePx?: number;
+    color?: string;
+    bgColor?: string;
+    borderColor?: string;
+    enabled?: boolean;
 }
-declare class NodeHotkeysPlugin extends Plugin {
+declare class RulerPlugin extends Plugin {
     private _core?;
     private _options;
-    private _clipboard;
-    private _selectionPlugin?;
-    constructor(options?: NodeHotkeysOptions);
+    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 _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;
+    protected onDetach(core: CoreEngine): void;
     /**
-     * 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 VideoOverlayAddonOptions {
+    zIndex?: number;
+    marginPx?: number;
+    controlsHeightPx?: number;
+    speeds?: number[];
+    minWidthPx?: number;
+    minHeightPx?: number;
+    maxWorldScaleToShow?: number | null;
+    hideDuringCameraZoomMs?: number;
+    uiBackgroundColor?: string;
+    uiBorderColor?: string;
+    uiTextColor?: string;
+    uiMutedTextColor?: string;
+    uiAccentColor?: string;
+    uiTrackColor?: string;
+    uiTrackFilledColor?: string;
+}
+declare class VideoOverlayAddon extends PluginAddon<SelectionPlugin> {
+    private _core;
+    private _rootEl;
+    private _controlsEl;
+    private _playBtn;
+    private _muteBtn;
+    private _speedBtn;
+    private _timeLabel;
+    private _seekInput;
+    private _volInput;
+    private _selectedVideoNode;
+    private _selectedVideoEl;
+    private _hiddenForDrag;
+    private _hiddenForSize;
+    private _hiddenForTransform;
+    private _hiddenForZoom;
+    private _hiddenForWorldScale;
+    private _hiddenForNotReady;
+    private _uiMode;
+    private _zoomUnhideTimeoutId;
+    private _onKonvaDragStart;
+    private _onKonvaDragEnd;
+    private _onKonvaTransformStart;
+    private _onKonvaTransformEnd;
+    private _onLayerTransformStart;
+    private _onLayerTransformEnd;
+    private _onLayerDragStart;
+    private _onLayerDragEnd;
+    private _rafId;
+    private _options;
+    private _onNodeSelected;
+    private _onNodeDeselected;
+    private _onSelectionCleared;
+    private _onNodeTransformed;
+    private _onStageResized;
+    private _onCameraChanged;
+    private _onWorldChanged;
+    private _onTimeUpdate;
+    private _onLoadedMetadata;
+    private _onCanPlay;
+    private _onPlayPauseSync;
+    constructor(options?: VideoOverlayAddonOptions);
+    protected onAttach(_plugin: SelectionPlugin, core: CoreEngine): void;
+    protected onDetach(_plugin: SelectionPlugin, core: CoreEngine): void;
+    private _ensureDom;
+    private _updateRangeFill;
+    private _tryShowForNode;
+    private _show;
+    private _hide;
+    private _bindLayerInteractionEvents;
+    private _unbindLayerInteractionEvents;
+    private _bindKonvaDragEvents;
+    private _unbindKonvaDragEvents;
+    private _bindKonvaTransformEvents;
+    private _unbindKonvaTransformEvents;
+    private _hideTemporarilyForZoom;
+    private _bindVideoEvents;
+    private _unbindVideoEvents;
+    private _isVideoReady;
+    private _maybeShowWhenReady;
+    private _scheduleSync;
+    private _syncPosition;
+    private _syncControls;
+    private _formatTime;
+    private _applyUiMode;
+}
+
+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;
+    enableVideoOverlay?: boolean | VideoOverlayAddonOptions;
+}
+/**
+ * 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;
+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;
     /**
-     * @param throttleMs - minimum interval between calls in milliseconds
+     * Deferred redraw (throttling)
+     * Groups multiple batchDraw calls into one
      */
-    constructor(throttleMs?: number);
+    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;
     /**
-     * Checks if the operation can be executed
-     * @returns true if enough time has passed since the last call
+     * 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.
      */
-    shouldExecute(): boolean;
+    private _applyOverlayTransformToNodes;
     /**
-     * Resets the timer (the next call will be executed immediately)
+     * Update overlay group bbox to match current positions of selected nodes.
+     * Must be called after drag/transform when nodes change position.
      */
-    reset(): void;
+    private _updateTempMultiOverlayBBox;
     /**
-     * Changes the 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.
      */
-    setThrottle(throttleMs: number): void;
+    private _computeUnionBBox;
+    private _ensureTempMulti;
+    private _destroyTempMultiOverlayOnly;
+    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;
     /**
-     * Returns the current throttling interval
+     * Set custom rotation cursor with dynamic angle based on handle position
      */
-    getThrottle(): number;
+    private _setRotateCursor;
+    /**
+     * Apply rotated cursor by creating a rotated SVG data URL
+     */
+    private _applyRotatedCursor;
+    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 +2417,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, ContentFromClipboardPlugin, type ContentFromClipboardPluginOptions, CoreEngine, type CoreEngineOptions, type CoreEvents, DebounceHelper, type EllipseNodeHandle, type EllipseNodeOptions, EventBus, type GifNodeHandle, type GifNodeOptions, 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, MediaPlaceholder, type MediaPlaceholderOptions, 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, type SvgNodeHandle, type SvgNodeOptions, TextAutoTrimAddon, type TextNodeHandle, type TextNodeOptions, ThrottleHelper, type VideoNodeHandle, type VideoNodeOptions, VideoOverlayAddon, type VideoOverlayAddonOptions, VisualGuidesPlugin, type VisualGuidesPluginOptions };