@inditextech/weave-sdk 0.1.0

package/dist/sdk.d.ts

@@ -0,0 +1,2255 @@
+import { ClipFuncOutput } from 'konva/lib/Container';
+import { Context } from 'konva/lib/Context';
+import { default as default_2 } from 'emittery';
+import { default as default_3 } from 'konva';
+import { default as default_4 } from 'pino';
+import { Doc } from 'yjs';
+import { Filter } from 'konva/lib/Node';
+import { Group } from 'konva/lib/Group';
+import { Layer } from 'konva/lib/Layer';
+import { Line } from 'konva/lib/shapes/Line';
+import { LineCap } from 'konva/lib/Shape';
+import { LineJoin } from 'konva/lib/Shape';
+import { Logger } from 'pino';
+import { MappedTypeDescription } from '../../../../node_modules/@syncedstore/core/types/doc';
+import { Node as Node_2 } from 'konva/lib/Node';
+import { NodeSerializable } from '@inditextech/weave-types';
+import { Rect } from 'konva/lib/shapes/Rect';
+import { SceneContext } from 'konva/lib/Context';
+import { Shape } from 'konva/lib/Shape';
+import { ShapeConfig } from 'konva/lib/Shape';
+import { Stage } from 'konva/lib/Stage';
+import { StageConfig } from 'konva/lib/Stage';
+import { Text as Text_2 } from 'konva/lib/shapes/Text';
+import { Transformer as Transformer_2 } from 'konva/lib/shapes/Transformer';
+import { Vector2d } from 'konva/lib/types';
+import { WeaveAwarenessChange } from '@inditextech/weave-types';
+import { WeaveConfig } from '@inditextech/weave-types';
+import { WeaveElementAttributes } from '@inditextech/weave-types';
+import { WeaveElementInstance } from '@inditextech/weave-types';
+import { WeaveExportNodeOptions } from '@inditextech/weave-types';
+import { WeaveFont } from '@inditextech/weave-types';
+import { WeaveLoggerConfig } from '@inditextech/weave-types';
+import { WeaveNodeBase } from '@inditextech/weave-types';
+import { WeavePluginBase } from '@inditextech/weave-types';
+import { WeavePosition } from '@inditextech/weave-types';
+import { WeaveSelection } from '@inditextech/weave-types';
+import { WeaveState } from '@inditextech/weave-types';
+import { WeaveStateElement } from '@inditextech/weave-types';
+import { WeaveStatus } from '@inditextech/weave-types';
+import { WeaveStoreBase } from '@inditextech/weave-types';
+import { WeaveStoreOptions } from '@inditextech/weave-types';
+import { WeaveUser } from '@inditextech/weave-types';
+
+export declare const BRUSH_TOOL_STATE: {
+    readonly INACTIVE: "inactive";
+    readonly IDLE: "idle";
+    readonly DEFINE_STROKE: "defineStroke";
+};
+
+export declare const COPY_PASTE_NODES_PLUGIN_STATE: {
+    readonly IDLE: "idle";
+    readonly PASTING: "pasting";
+};
+
+export declare const FRAME_TOOL_ACTION_NAME = "frameTool";
+
+export declare const FRAME_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly ADDING: "adding";
+    readonly ADDED: "added";
+};
+
+export declare type Guide = {
+    lineGuide: number;
+    offset: number;
+    orientation: GuideOrientation;
+    snap: NodeSnap;
+};
+
+export declare const GUIDE_LINE_NAME = "guide-line";
+
+export declare const GUIDE_ORIENTATION: {
+    readonly HORIZONTAL: "H";
+    readonly VERTICAL: "V";
+};
+
+export declare type GuideOrientation = (typeof GUIDE_ORIENTATION)[GuideOrientationKeys];
+
+export declare type GuideOrientationKeys = keyof typeof GUIDE_ORIENTATION;
+
+export declare const IMAGE_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly UPLOADING: "uploading";
+    readonly ADDING: "adding";
+    readonly FINISHED: "finished";
+};
+
+export declare type ImageProps = WeaveElementAttributes & {
+    id: string;
+    width?: number;
+    height?: number;
+    imageURL?: string;
+    imageInfo?: {
+        width: number;
+        height: number;
+    };
+};
+
+export declare type LineGuide = {
+    lineGuide: number;
+    diff: number;
+    snap: NodeSnap;
+    offset: number;
+};
+
+export declare type LineGuideStop = {
+    vertical: number[];
+    horizontal: number[];
+};
+
+export declare const MOVE_TOOL_ACTION_NAME = "moveTool";
+
+export declare const MOVE_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly MOVING: "moving";
+};
+
+export declare const NODE_SNAP: {
+    readonly START: "start";
+    readonly CENTER: "center";
+    readonly END: "end";
+};
+
+export declare type NodeSnap = (typeof NODE_SNAP)[NodeSnapKeys];
+
+export declare type NodeSnapKeys = keyof typeof NODE_SNAP;
+
+export declare type NodeSnappingEdge = {
+    guide: number;
+    offset: number;
+    snap: NodeSnap;
+};
+
+export declare type NodeSnappingEdges = {
+    vertical: NodeSnappingEdge[];
+    horizontal: NodeSnappingEdge[];
+};
+
+export declare const PEN_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly ADDING: "adding";
+    readonly DEFINING_SIZE: "definingSize";
+    readonly ADDED: "added";
+};
+
+export declare const RECTANGLE_TOOL_ACTION_NAME = "rectangleTool";
+
+export declare const RECTANGLE_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly ADDING: "adding";
+    readonly DEFINING_SIZE: "definingSize";
+    readonly ADDED: "added";
+};
+
+export declare function resetScale(node: default_3.Node): void;
+
+export declare const SELECTION_TOOL_ACTION_NAME = "selectionTool";
+
+export declare const SELECTION_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly SELECTING: "selection";
+};
+
+export declare function sendEvent<T>(eventName: string, payload: T): void;
+
+export declare const TEXT_TOOL_STATE: {
+    readonly IDLE: "idle";
+    readonly ADDING: "adding";
+    readonly FINISHED: "finished";
+};
+
+export declare type TextSerializable = default_3.TextConfig & NodeSerializable & {
+    type: 'text';
+    id: string;
+};
+
+export declare class Weave extends default_2 {
+    private id;
+    private config;
+    private logger;
+    private moduleLogger;
+    private reconciler;
+    private stateSerializer;
+    private renderer;
+    private status;
+    private setupManager;
+    private registerManager;
+    private stateManager;
+    private storeManager;
+    private stageManager;
+    private groupsManager;
+    private targetingManager;
+    private cloningManager;
+    private fontsManager;
+    private zIndexManager;
+    private pluginsManager;
+    private actionsManager;
+    private exportManager;
+    constructor(weaveConfig: WeaveConfig, stageConfig: default_3.StageConfig);
+    setupRenderer(): void;
+    setStatus(status: WeaveStatus): void;
+    getStatus(): WeaveStatus;
+    setStore(store: WeaveStore): void;
+    start(): Promise<void>;
+    getId(): string;
+    getConfiguration(): WeaveConfig;
+    emitEvent<T>(event: string, payload: T): void;
+    addEventListener<T>(event: string, callback: (payload: T) => void): void;
+    removeEventListener<T>(event: string, callback: (payload: T) => void): void;
+    getLogger(): WeaveLogger;
+    getMainLogger(): Logger;
+    getChildLogger(name: string): default_4.Logger<never, boolean>;
+    getStageManager(): WeaveStageManager;
+    getStage(): Stage;
+    getMainLayer(): Layer | undefined;
+    setStage(stage: default_3.Stage): void;
+    getStageConfiguration(): StageConfig;
+    getInstanceRecursive(instance: default_3.Node, filterInstanceType?: string[]): default_3.Node;
+    getRegisterManager(): WeaveRegisterManager;
+    getPlugins(): Record<string, WeavePlugin>;
+    getPlugin<T extends WeavePlugin>(pluginName: string): T;
+    getNodesHandlers(): Record<string, WeaveNode>;
+    getNodeHandler<T extends WeaveNode>(nodeType: string): T;
+    getActionsHandlers(): Record<string, WeaveAction>;
+    getActionHandler<T extends WeaveAction>(actionName: string): T;
+    getStore<T extends WeaveStore>(): T;
+    registerPlugin(plugin: WeavePlugin): void;
+    registerNodeHandler(node: WeaveNode): void;
+    registerActionHandler(action: WeaveAction): void;
+    registerStore(store: WeaveStore): void;
+    isPluginEnabled(pluginName: string): boolean;
+    enablePlugin(pluginName: string): void;
+    disablePlugin(pluginName: string): void;
+    getActiveAction(): string | undefined;
+    triggerAction<T>(actionName: string, params?: T): unknown;
+    getPropsAction(actionName: string): WeaveElementAttributes;
+    updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
+    cancelAction(actionName: string): void;
+    update(newState: WeaveState): void;
+    render(): void;
+    findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): {
+        node: WeaveStateElement | null;
+        parent: WeaveStateElement | null;
+        index: number;
+    };
+    findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
+    getNode(nodeKey: string): {
+        node: WeaveStateElement | null;
+        parent: WeaveStateElement | null;
+        index: number;
+    };
+    addNode(node: WeaveStateElement, parentId?: string, index?: number | undefined, doRender?: boolean): void;
+    updateNode(node: WeaveStateElement, doRender?: boolean): void;
+    removeNode(node: WeaveStateElement, doRender?: boolean): void;
+    removeNodes(nodes: WeaveStateElement[], doRender?: boolean): void;
+    moveNode(node: WeaveStateElement, position: WeavePosition, doRender?: boolean): void;
+    moveUp(node: WeaveElementInstance): void;
+    moveDown(node: WeaveElementInstance): void;
+    sendToBack(node: WeaveElementInstance): void;
+    bringToFront(node: WeaveElementInstance): void;
+    group(nodes: WeaveStateElement[]): void;
+    unGroup(group: WeaveStateElement): void;
+    getMousePointer(point?: Vector2d): {
+        mousePoint: Vector2d;
+        container: Group | Layer | undefined;
+        measureContainer: Group | Layer | undefined;
+    };
+    getMousePointerRelativeToContainer(container: default_3.Group | default_3.Layer): {
+        mousePoint: {
+            x: number;
+            y: number;
+        };
+        container: Group | Layer;
+    };
+    nodesToGroupSerialized(instancesToClone: default_3.Node[]): {
+        serializedNodes: WeaveStateElement[];
+        minPoint: Vector2d;
+    } | undefined;
+    cloneNodes(instancesToClone: default_3.Node[], targetContainer: default_3.Layer | default_3.Group | undefined, onPoint: Vector2d): void;
+    getFonts(): WeaveFont[];
+    exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+    exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+}
+
+declare const WEAVE_CONNECTED_USER_INFO_KEY = "userInfo";
+
+export declare const WEAVE_FRAME_NODE_TYPE = "frame";
+
+export declare const WEAVE_GRID_DEFAULT_SIZE = 50;
+
+export declare const WEAVE_GRID_LAYER_ID = "gridLayer";
+
+export declare const WEAVE_GRID_TYPES: {
+    readonly LINES: "lines";
+    readonly DOTS: "dots";
+};
+
+export declare const WEAVE_NODES_SELECTION_LAYER_ID = "selectionLayer";
+
+declare const WEAVE_USER_POINTER_KEY = "userPointer";
+
+export declare abstract class WeaveAction {
+    protected instance: Weave;
+    protected name: string;
+    props: WeaveElementAttributes;
+    protected callbacks: WeaveActionCallbacks | undefined;
+    private logger;
+    constructor(callbacks?: WeaveActionCallbacks);
+    getName(): string;
+    getLogger(): Logger;
+    register(instance: Weave): this;
+    updateProps(props: WeaveElementAttributes): void;
+    getProps(): WeaveElementAttributes;
+    abstract init?(): void;
+    abstract trigger(cancelAction: () => void, params?: unknown): unknown;
+    abstract internalUpdate?(): void;
+    abstract cleanup?(): void;
+}
+
+export declare type WeaveActionCallbacks = {
+    onPropsChange?: WeaveActionPropsChangeCallback;
+};
+
+export declare type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes) => void;
+
+export declare class WeaveBrushToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected state: WeaveBrushToolActionState;
+    protected clickPoint: Vector2d | null;
+    protected strokeId: string | null;
+    protected container: default_3.Layer | default_3.Group | undefined;
+    protected measureContainer: default_3.Layer | default_3.Group | undefined;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor(callbacks: WeaveBrushToolCallbacks);
+    getName(): string;
+    initProps(): {
+        stroke: string;
+        strokeWidth: number;
+        opacity: number;
+    };
+    private setupEvents;
+    private setState;
+    private handleStartStroke;
+    private handleEndStroke;
+    private handleMovement;
+    trigger(cancel: () => void): void;
+    cleanup(): void;
+}
+
+export declare type WeaveBrushToolActionState = (typeof BRUSH_TOOL_STATE)[WeaveBrushToolActionStateKeys];
+
+export declare type WeaveBrushToolActionStateKeys = keyof typeof BRUSH_TOOL_STATE;
+
+export declare type WeaveBrushToolCallbacks = WeaveActionCallbacks;
+
+export declare type WeaveConnectedUserInfoKey = typeof WEAVE_CONNECTED_USER_INFO_KEY;
+
+export declare type WeaveConnectedUsersChangeCallback = (users: WeaveConnectedUsersChanged) => void;
+
+export declare type WeaveConnectedUsersChanged = {
+    [userName: string]: WeaveUser;
+};
+
+export declare class WeaveConnectedUsersPlugin extends WeavePlugin {
+    private connectedUsers;
+    private getUser;
+    private onConnectedUsersChanged;
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    constructor(params: WeaveConnectedUsersPluginParams);
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveConnectedUsersPluginParams = {
+    onConnectedUsersChanged?: WeaveConnectedUsersChangeCallback;
+    getUser?: () => WeaveUser;
+};
+
+export declare class WeaveContextMenuPlugin extends WeavePlugin {
+    private config;
+    private callbacks;
+    private touchTimer;
+    private tapHold;
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    constructor(options: WeaveStageContextMenuPluginOptions, callbacks: WeaveStageContextMenuPluginCallbacks);
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    triggerContextMenu(target: any): void;
+    private initEvents;
+    isTapHold(): boolean;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveCopyPasteNodesCanCopyChangeCallback = (canCopy: boolean) => void;
+
+export declare type WeaveCopyPasteNodesCanPasteChangeCallback = (canPaste: boolean, nodes: WeaveToPasteNode[]) => void;
+
+export declare type WeaveCopyPasteNodesOnCopyCallback = (error?: Error) => void;
+
+export declare type WeaveCopyPasteNodesOnPasteCallback = (error?: Error) => void;
+
+export declare type WeaveCopyPasteNodesOnPasteExternalCallback = (item: ClipboardItem) => void;
+
+export declare class WeaveCopyPasteNodesPlugin extends WeavePlugin {
+    protected state: WeaveCopyPasteNodesPluginState;
+    private callbacks;
+    private toPaste;
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    constructor(callbacks?: WeaveCopyPasteNodesPluginCallbacks);
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    private readClipboardData;
+    private writeClipboardData;
+    private initEvents;
+    private mapToPasteNodes;
+    private setState;
+    private handlePaste;
+    private performCopy;
+    private performPaste;
+    copy(): Promise<void>;
+    paste(): Promise<void>;
+    getSelectedNodes(): {
+        konvaNode: Group | Shape<ShapeConfig>;
+        node: NodeSerializable;
+    }[];
+    isPasting(): boolean;
+    private cancel;
+    private getNodesSelectionPlugin;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveCopyPasteNodesPluginCallbacks = {
+    onCopy?: WeaveCopyPasteNodesOnCopyCallback;
+    onPaste?: WeaveCopyPasteNodesOnPasteCallback;
+    onPasteExternal?: WeaveCopyPasteNodesOnPasteExternalCallback;
+};
+
+export declare type WeaveCopyPasteNodesPluginState = (typeof COPY_PASTE_NODES_PLUGIN_STATE)[WeaveCopyPasteNodesPluginStateKeys];
+
+export declare type WeaveCopyPasteNodesPluginStateKeys = keyof typeof COPY_PASTE_NODES_PLUGIN_STATE;
+
+export declare type WeaveExportNodeActionParams = {
+    node: WeaveElementInstance;
+    options?: WeaveExportNodeOptions;
+};
+
+export declare class WeaveExportNodeToolAction extends WeaveAction {
+    protected cancelAction: () => void;
+    private defaultFormatOptions;
+    private options;
+    internalUpdate: undefined;
+    init: undefined;
+    getName(): string;
+    private exportNode;
+    trigger(cancelAction: () => void, { node, options }: WeaveExportNodeActionParams): Promise<void>;
+    cleanup(): void;
+}
+
+export declare type WeaveExportStageActionParams = {
+    options?: WeaveExportNodeOptions;
+};
+
+export declare class WeaveExportStageToolAction extends WeaveAction {
+    protected cancelAction: () => void;
+    private defaultFormatOptions;
+    private options;
+    internalUpdate: undefined;
+    init: undefined;
+    getName(): string;
+    private exportStage;
+    trigger(cancelAction: () => void, { options }: WeaveExportStageActionParams): Promise<void>;
+    cleanup(): void;
+}
+
+export declare class WeaveFitToScreenToolAction extends WeaveAction {
+    protected previousAction: string;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    getName(): string;
+    private getStageZoomPlugin;
+    init(): void;
+    trigger(cancelAction: () => void, params: WeaveFitToScreenToolActionParams): void;
+    cleanup(): void;
+}
+
+export declare type WeaveFitToScreenToolActionParams = {
+    previousAction: string;
+};
+
+export declare class WeaveFitToSelectionToolAction extends WeaveAction {
+    protected previousAction: string;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    getName(): string;
+    private getNodesSelectionPlugin;
+    private getStageZoomPlugin;
+    init(): void;
+    trigger(cancelAction: () => void, params: WeaveFitToSelectionToolActionParams): void;
+    cleanup(): void;
+}
+
+export declare type WeaveFitToSelectionToolActionParams = {
+    previousAction: string;
+};
+
+export declare class WeaveFrameNode extends WeaveNode {
+    protected nodeType: string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Group;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: WeaveStateElement[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: WeaveStateElement[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+}
+
+export declare class WeaveFrameToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected state: WeaveFrameToolActionState;
+    protected frameId: string | null;
+    protected container: default_3.Layer | default_3.Group | undefined;
+    protected clickPoint: Vector2d | null;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor(callbacks: WeaveFrameToolCallbacks);
+    getName(): string;
+    initProps(params?: WeaveFrameToolActionTriggerParams): {
+        title: string;
+        fontFamily: string;
+        editing: boolean;
+        opacity: number;
+    };
+    private setupEvents;
+    private setState;
+    private addFrame;
+    private handleAdding;
+    trigger(cancelAction: () => void, params?: WeaveFrameToolActionTriggerParams): void;
+    cleanup(): void;
+}
+
+export declare type WeaveFrameToolActionState = (typeof FRAME_TOOL_STATE)[WeaveFrameToolActionStateKeys];
+
+export declare type WeaveFrameToolActionStateKeys = keyof typeof FRAME_TOOL_STATE;
+
+export declare type WeaveFrameToolActionTriggerParams = {
+    fontFamily?: string;
+};
+
+export declare type WeaveFrameToolCallbacks = WeaveActionCallbacks;
+
+export declare class WeaveGroupNode extends WeaveNode {
+    protected nodeType: string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Group;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: WeaveStateElement[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: WeaveStateElement[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+}
+
+export declare class WeaveImageNode extends WeaveNode {
+    protected nodeType: string;
+    private imageLoaded;
+    cropping: boolean;
+    constructor();
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Group;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: never[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: never[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+    private loadImage;
+    private getImageToolAction;
+}
+
+export declare class WeaveImageToolAction extends WeaveAction {
+    private imageCallbacks;
+    protected initialized: boolean;
+    protected initialCursor: string | null;
+    protected state: WeaveImageToolActionState;
+    protected imageId: string | null;
+    protected tempImageId: string | null;
+    protected container: default_3.Layer | default_3.Group | undefined;
+    protected imageURL: string | null;
+    protected preloadImgs: Record<string, HTMLImageElement>;
+    protected clickPoint: Vector2d | null;
+    protected cancelAction: () => void;
+    update: undefined;
+    constructor(imageCallbacks: WeaveImageToolActionCallbacks);
+    getName(): string;
+    getPreloadedImage(imageId: string): HTMLImageElement | undefined;
+    initProps(): {
+        width: number;
+        height: number;
+        scaleX: number;
+        scaleY: number;
+    };
+    init(): void;
+    private setupEvents;
+    private setState;
+    private loadImage;
+    private addImageNode;
+    private addImage;
+    private handleAdding;
+    trigger(cancelAction: () => void, params?: WeaveImageToolActionTriggerParams): {
+        finishUploadCallback: (imageURL: string) => void;
+    } | undefined;
+    internalUpdate(): void;
+    cleanup(): void;
+}
+
+export declare type WeaveImageToolActionCallbacks = WeaveActionCallbacks & {
+    onUploadImage: WeaveImageToolActionOnAddImageCallback;
+    onImageLoadStart?: WeaveImageToolActionOnStartLoadImageCallback;
+    onImageLoadEnd?: WeaveImageToolActionOnEndLoadImageCallback;
+};
+
+export declare type WeaveImageToolActionOnAddImageCallback = (finished: (imageURL: string) => void) => Promise<void>;
+
+export declare type WeaveImageToolActionOnEndLoadImageCallback = (error?: Error) => void;
+
+export declare type WeaveImageToolActionOnStartLoadImageCallback = () => void;
+
+export declare type WeaveImageToolActionState = (typeof IMAGE_TOOL_STATE)[WeaveImageToolActionStateKeys];
+
+export declare type WeaveImageToolActionStateKeys = keyof typeof IMAGE_TOOL_STATE;
+
+export declare type WeaveImageToolActionTriggerParams = {
+    imageURL?: string;
+};
+
+export declare class WeaveLayerNode extends WeaveNode {
+    protected nodeType: string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Layer;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: WeaveStateElement[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: WeaveStateElement[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+}
+
+export declare class WeaveLineNode extends WeaveNode {
+    protected nodeType: string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Line<    {
+    name: string;
+    id?: string;
+    nodeType?: string;
+    children?: WeaveStateElement[];
+    }>;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: never[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: never[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+}
+
+declare class WeaveLogger {
+    private config;
+    private disabled;
+    private logger;
+    constructor(config: WeaveLoggerConfig);
+    private log;
+    getDisabled(): boolean;
+    getLevel(): default_4.LevelWithSilentOrString;
+    getLogger(): Logger;
+    getChildLogger(name: string): default_4.Logger<never, boolean>;
+}
+
+export declare class WeaveMoveToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected state: WeaveMoveToolActionState;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor();
+    getName(): string;
+    private setupEvents;
+    private setState;
+    private setMoving;
+    trigger(cancelAction: () => void): void;
+    cleanup(): void;
+}
+
+export declare type WeaveMoveToolActionState = (typeof MOVE_TOOL_STATE)[WeaveMoveToolActionStateKeys];
+
+export declare type WeaveMoveToolActionStateKeys = keyof typeof MOVE_TOOL_STATE;
+
+export declare abstract class WeaveNode implements WeaveNodeBase {
+    protected instance: Weave;
+    protected nodeType: string;
+    private logger;
+    protected previousPointer: string | null;
+    register(instance: Weave): this;
+    getNodeType(): string;
+    getLogger(): Logger;
+    getSelectionPlugin(): WeaveNodesSelectionPlugin;
+    isSelecting(): boolean;
+    isPasting(): boolean;
+    isNodeSelected(ele: default_3.Node): boolean;
+    setupDefaultNodeEvents(node: default_3.Node): void;
+    abstract createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
+    abstract createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+    abstract updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    abstract removeInstance(instance: WeaveElementInstance): void;
+    abstract toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+export declare type WeaveNodesSelectionChangeCallback = (nodes: WeaveSelection[]) => void;
+
+export declare class WeaveNodesSelectionPlugin extends WeavePlugin {
+    private tr;
+    private selectionRectangle;
+    private active;
+    private cameFromSelectingMultiple;
+    private selecting;
+    private initialized;
+    private callbacks;
+    render: undefined;
+    constructor(callbacks: WeaveNodesSelectionPluginCallbacks);
+    registersLayers(): boolean;
+    getName(): string;
+    getLayerName(): string;
+    initLayer(): void;
+    init(): void;
+    private getLayer;
+    private triggerSelectedNodesEvent;
+    private initEvents;
+    getTransformer(): Transformer_2;
+    setSelectedNodes(nodes: default_3.Node[]): void;
+    getSelectedNodes(): (default_3.Group | default_3.Shape)[];
+    removeSelectedNodes(): void;
+    selectAll(): void;
+    selectNone(): void;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveNodesSelectionPluginCallbacks = {
+    onNodesChange: WeaveNodesSelectionChangeCallback;
+    onStageSelection?: WeaveNodesSelectionStageSelectionCallback;
+};
+
+export declare type WeaveNodesSelectionStageSelectionCallback = () => void;
+
+export declare class WeaveNodesSnappingPlugin extends WeavePlugin {
+    private guideLineOffset;
+    render: undefined;
+    constructor();
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    setEnabled(enabled: boolean): void;
+    private initEvents;
+    getLineGuideStops(skipShape: default_3.Node): LineGuideStop;
+    getObjectSnappingEdges(node: default_3.Node): NodeSnappingEdges;
+    getGuides(lineGuideStops: LineGuideStop, itemBounds: NodeSnappingEdges): Guide[];
+    drawGuides(guides: Guide[]): void;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveOnNodeMenuCallback = (instance: Weave, selection: WeaveSelection[], point: Vector2d, visible: boolean) => void;
+
+export declare type WeavePasteModel = {
+    weaveInstanceId: string;
+    weave: Record<string, WeaveStateElement>;
+    weaveMinPoint: Vector2d;
+};
+
+export declare class WeavePenToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected initialCursor: string | null;
+    protected state: WeavePenToolActionState;
+    protected lineId: string | null;
+    protected tempLineId: string | null;
+    protected container: default_3.Layer | default_3.Group | undefined;
+    protected measureContainer: default_3.Layer | default_3.Group | undefined;
+    protected clickPoint: Vector2d | null;
+    protected tempPoint: default_3.Circle | undefined;
+    protected tempNextPoint: default_3.Circle | undefined;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor(callbacks: WeavePenToolCallbacks);
+    getName(): string;
+    initProps(): {
+        stroke: string;
+        strokeWidth: number;
+        opacity: number;
+    };
+    private setupEvents;
+    private setState;
+    private addLine;
+    private handleAdding;
+    private handleSettingSize;
+    private handleMovement;
+    trigger(cancelAction: () => void): void;
+    cleanup(): void;
+}
+
+export declare type WeavePenToolActionState = (typeof PEN_TOOL_STATE)[WeavePenToolActionStateKeys];
+
+export declare type WeavePenToolActionStateKeys = keyof typeof PEN_TOOL_STATE;
+
+export declare type WeavePenToolCallbacks = WeaveActionCallbacks;
+
+export declare abstract class WeavePlugin implements WeavePluginBase {
+    protected instance: Weave;
+    protected name: string;
+    protected enabled: boolean;
+    private logger;
+    register(instance: Weave): this;
+    getName(): string;
+    getLogger(): Logger;
+    isEnabled(): boolean;
+    abstract init?(): void;
+    abstract render?(): void;
+    abstract enable(): void;
+    abstract disable(): void;
+}
+
+export declare class WeaveRectangleNode extends WeaveNode {
+    protected nodeType: string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Rect;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: never[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: never[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+}
+
+export declare class WeaveRectangleToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected state: WeaveRectangleToolActionState;
+    protected rectId: string | null;
+    protected creating: boolean;
+    protected moved: boolean;
+    protected clickPoint: Vector2d | null;
+    protected container: default_3.Group | default_3.Layer | undefined;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor(callbacks: WeaveRectangleToolCallbacks);
+    getName(): string;
+    initProps(): {
+        opacity: number;
+        fill: string;
+        stroke: string;
+        strokeWidth: number;
+        width: number;
+        height: number;
+    };
+    private setupEvents;
+    private setState;
+    private addRectangle;
+    private handleAdding;
+    private handleSettingSize;
+    private handleMovement;
+    trigger(cancelAction: () => void): void;
+    cleanup(): void;
+}
+
+export declare type WeaveRectangleToolActionState = (typeof RECTANGLE_TOOL_STATE)[WeaveRectangleToolActionStateKeys];
+
+export declare type WeaveRectangleToolActionStateKeys = keyof typeof RECTANGLE_TOOL_STATE;
+
+export declare type WeaveRectangleToolCallbacks = WeaveActionCallbacks;
+
+declare class WeaveRegisterManager {
+    private instance;
+    private nodesHandlers;
+    private actionsHandlers;
+    private plugins;
+    private logger;
+    constructor(instance: Weave);
+    getPlugins(): Record<string, WeavePlugin>;
+    getNodesHandlers(): Record<string, WeaveNode>;
+    getActionsHandlers(): Record<string, WeaveAction>;
+    getPlugin<T extends WeavePlugin>(pluginName: string): T;
+    getActionHandler<T extends WeaveAction>(actionName: string): T;
+    getNodeHandler(nodeType: string): WeaveNode;
+    registerPlugins(): void;
+    registerPlugin(plugin: WeavePlugin): void;
+    registerNodesHandlers(): void;
+    registerNodeHandler(node: WeaveNode): void;
+    registerActionsHandlers(): void;
+    registerActionHandler(action: WeaveAction): void;
+}
+
+export declare class WeaveSelectionToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected state: WeaveSelectionToolActionState;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor();
+    getName(): string;
+    private setupEvents;
+    private setState;
+    private setSelection;
+    trigger(cancelAction: () => void): void;
+    cleanup(): void;
+}
+
+export declare type WeaveSelectionToolActionState = (typeof SELECTION_TOOL_STATE)[WeaveSelectionToolActionStateKeys];
+
+export declare type WeaveSelectionToolActionStateKeys = keyof typeof SELECTION_TOOL_STATE;
+
+export declare type WeaveStageContextMenuPluginCallbacks = {
+    onNodeMenu: WeaveOnNodeMenuCallback;
+};
+
+export declare type WeaveStageContextMenuPluginOptions = {
+    xOffset?: number;
+    yOffset?: number;
+};
+
+export declare class WeaveStageDropAreaPlugin extends WeavePlugin {
+    private callbacks?;
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    constructor(callbacks?: WeaveStageDropAreaPluginCallbacks);
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    private initEvents;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveStageDropAreaPluginCallbacks = {
+    onStageDrop?: WeaveStageDropCallback;
+    doUploadFile?: WeaveStageDropUploadFileCallback;
+};
+
+export declare type WeaveStageDropCallback = (event: DragEvent) => void;
+
+export declare type WeaveStageDropUploadFileCallback = (event: File) => Promise<void>;
+
+export declare class WeaveStageGridPlugin extends WeavePlugin {
+    private moveToolActive;
+    private isMouseMiddleButtonPressed;
+    private isSpaceKeyPressed;
+    private type;
+    private gridColor;
+    private originColor;
+    private gridSize;
+    constructor(params: WeaveStageGridPluginParams);
+    registersLayers(): boolean;
+    getName(): string;
+    getLayerName(): string;
+    initLayer(): void;
+    init(): void;
+    private initEvents;
+    getLayer(): Layer | undefined;
+    private renderGrid;
+    private round;
+    private renderGridLines;
+    private renderGridDots;
+    render(): void;
+    enable(): void;
+    disable(): void;
+    getType(): WeaveStageGridType;
+    setType(type: WeaveStageGridType): void;
+}
+
+export declare type WeaveStageGridPluginParams = {
+    gridSize?: number;
+};
+
+export declare type WeaveStageGridType = (typeof WEAVE_GRID_TYPES)[WeaveStageGridTypeKeys];
+
+export declare type WeaveStageGridTypeKeys = keyof typeof WEAVE_GRID_TYPES;
+
+declare class WeaveStageManager {
+    private instance;
+    private logger;
+    private stage;
+    private config;
+    constructor(instance: Weave, config: default_3.StageConfig);
+    getConfiguration(): StageConfig;
+    setStage(stage: default_3.Stage): void;
+    getStage(): Stage;
+    getMainLayer(): default_3.Layer | undefined;
+    getInstanceRecursive(instance: default_3.Node, filterInstanceType?: string[]): default_3.Node;
+    initStage(): void;
+}
+
+export declare class WeaveStageNode extends WeaveNode {
+    protected nodeType: string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    createInstance(props: WeaveElementAttributes): Stage;
+    updateInstance(): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: never[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: never[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+}
+
+export declare class WeaveStagePanningPlugin extends WeavePlugin {
+    private moveToolActive;
+    private isMouseMiddleButtonPressed;
+    private isSpaceKeyPressed;
+    protected previousPointer: string | null;
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    constructor();
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    private enableMove;
+    private disableMove;
+    private initEvents;
+    enable(): void;
+    disable(): void;
+}
+
+export declare class WeaveStageResizePlugin extends WeavePlugin {
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveStageZoomChanged = {
+    scale: number;
+    zoomSteps: number[];
+    actualStep: number;
+    onDefaultStep: boolean;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+};
+
+export declare type WeaveStageZoomOnZoomChangeCallback = (zoomInfo: WeaveStageZoomChanged) => void;
+
+export declare class WeaveStageZoomPlugin extends WeavePlugin {
+    getLayerName: undefined;
+    initLayer: undefined;
+    render: undefined;
+    private zoomSteps;
+    private actualScale;
+    private actualStep;
+    private padding;
+    defaultStep: number;
+    private onZoomChangeCb;
+    constructor(params: WeaveStageZoomPluginParams);
+    registersLayers(): boolean;
+    getName(): string;
+    init(): void;
+    private setZoom;
+    canZoomOut(): boolean;
+    canZoomIn(): boolean;
+    zoomToStep(step: number): void;
+    private findClosestStepIndex;
+    zoomIn(): void;
+    zoomOut(): void;
+    fitToScreen(): void;
+    fitToSelection(): void;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveStageZoomPluginParams = {
+    zoomSteps?: number[];
+    defaultZoom?: number;
+    onZoomChange?: WeaveStageZoomOnZoomChangeCallback;
+};
+
+export declare abstract class WeaveStore implements WeaveStoreBase {
+    protected instance: Weave;
+    protected name: string;
+    protected supportsUndoManager: boolean;
+    protected config: WeaveStoreOptions;
+    private state;
+    private latestState;
+    private document;
+    private logger;
+    private undoManager;
+    private isRoomLoaded;
+    constructor(config: WeaveStoreOptions);
+    getName(): string;
+    getLogger(): Logger;
+    register(instance: Weave): this;
+    getUser(): WeaveUser;
+    setState(state: WeaveState): void;
+    setLatestState(newState: WeaveState): void;
+    getLatestState(): WeaveState;
+    getDocument(): Doc;
+    getState(): MappedTypeDescription<WeaveState>;
+    getStateJson(): WeaveState;
+    setup(): void;
+    canUndoStateStep(): boolean;
+    canRedoStateStep(): boolean;
+    undoStateStep(): void;
+    redoStateStep(): void;
+    abstract connect(): void;
+    abstract disconnect(): void;
+    abstract onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
+    abstract setAwarenessInfo(field: string, value: unknown): void;
+}
+
+export declare class WeaveTextNode extends WeaveNode {
+    protected nodeType: string;
+    private editing;
+    constructor();
+    getType(): string;
+    createNode(key: string, props: WeaveElementAttributes): {
+        key: string;
+        type: string;
+        props: {
+            id: string;
+            nodeType: string;
+            children: never[];
+        };
+    };
+    private updateNode;
+    createInstance(props: WeaveElementAttributes): Text_2;
+    updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+    removeInstance(nodeInstance: WeaveElementInstance): void;
+    toNode(instance: WeaveElementInstance): {
+        key: string;
+        type: any;
+        props: {
+            id: string;
+            nodeType: any;
+            children: never[];
+            clearBeforeDraw?: boolean;
+            clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
+            clipX?: number;
+            clipY?: number;
+            clipWidth?: number;
+            clipHeight?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        } | {
+            id: string;
+            nodeType: any;
+            children: never[];
+            fill?: string | CanvasGradient;
+            fillPatternImage?: HTMLImageElement;
+            fillPatternX?: number;
+            fillPatternY?: number;
+            fillPatternOffset?: Vector2d;
+            fillPatternOffsetX?: number;
+            fillPatternOffsetY?: number;
+            fillPatternScale?: Vector2d;
+            fillPatternScaleX?: number;
+            fillPatternScaleY?: number;
+            fillPatternRotation?: number;
+            fillPatternRepeat?: string;
+            fillLinearGradientStartPoint?: Vector2d;
+            fillLinearGradientStartPointX?: number;
+            fillLinearGradientStartPointY?: number;
+            fillLinearGradientEndPoint?: Vector2d;
+            fillLinearGradientEndPointX?: number;
+            fillLinearGradientEndPointY?: number;
+            fillLinearGradientColorStops?: Array<number | string>;
+            fillRadialGradientStartPoint?: Vector2d;
+            fillRadialGradientStartPointX?: number;
+            fillRadialGradientStartPointY?: number;
+            fillRadialGradientEndPoint?: Vector2d;
+            fillRadialGradientEndPointX?: number;
+            fillRadialGradientEndPointY?: number;
+            fillRadialGradientStartRadius?: number;
+            fillRadialGradientEndRadius?: number;
+            fillRadialGradientColorStops?: Array<number | string>;
+            fillEnabled?: boolean;
+            fillPriority?: string;
+            fillRule?: CanvasFillRule;
+            stroke?: string | CanvasGradient;
+            strokeWidth?: number;
+            fillAfterStrokeEnabled?: boolean;
+            hitStrokeWidth?: number | string;
+            strokeScaleEnabled?: boolean;
+            strokeHitEnabled?: boolean;
+            strokeEnabled?: boolean;
+            lineJoin?: LineJoin;
+            lineCap?: LineCap;
+            sceneFunc?: (con: Context, shape: Shape) => void;
+            hitFunc?: (con: Context, shape: Shape) => void;
+            shadowColor?: string;
+            shadowBlur?: number;
+            shadowOffset?: Vector2d;
+            shadowOffsetX?: number;
+            shadowOffsetY?: number;
+            shadowOpacity?: number;
+            shadowEnabled?: boolean;
+            shadowForStrokeEnabled?: boolean;
+            dash?: number[];
+            dashOffset?: number;
+            dashEnabled?: boolean;
+            perfectDrawEnabled?: boolean;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            visible?: boolean;
+            listening?: boolean;
+            name?: string;
+            opacity?: number;
+            scale?: Vector2d;
+            scaleX?: number;
+            skewX?: number;
+            skewY?: number;
+            scaleY?: number;
+            rotation?: number;
+            rotationDeg?: number;
+            offset?: Vector2d;
+            offsetX?: number;
+            offsetY?: number;
+            draggable?: boolean;
+            dragDistance?: number;
+            dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
+            preventDefault?: boolean;
+            globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
+            filters?: Array<Filter>;
+        };
+    };
+    private createTextAreaDOM;
+    private removeTextAreaDOM;
+    private triggerEditMode;
+}
+
+export declare class WeaveTextToolAction extends WeaveAction {
+    protected initialized: boolean;
+    protected initialCursor: string | null;
+    protected state: WeaveTextToolActionState;
+    protected textId: string | null;
+    protected container: default_3.Layer | default_3.Group | undefined;
+    protected clickPoint: Vector2d | null;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    init: undefined;
+    constructor();
+    getName(): string;
+    private setupEvents;
+    private setState;
+    private addText;
+    private handleAdding;
+    trigger(cancelAction: () => void): void;
+    cleanup(): void;
+}
+
+export declare type WeaveTextToolActionState = (typeof TEXT_TOOL_STATE)[WeaveTextToolActionStateKeys];
+
+export declare type WeaveTextToolActionStateKeys = keyof typeof TEXT_TOOL_STATE;
+
+export declare type WeaveToPasteNode = {
+    konvaNode: default_3.Node;
+    node: NodeSerializable;
+};
+
+export declare type WeaveUserPointer = {
+    user: string;
+    x: number;
+    y: number;
+};
+
+export declare type WeaveUserPointerKey = typeof WEAVE_USER_POINTER_KEY;
+
+export declare class WeaveUsersPointersPlugin extends WeavePlugin {
+    private usersPointers;
+    private usersPointersTimers;
+    private getUser;
+    private renderCursors;
+    private userPointerCircleRadius;
+    private userPointerSeparation;
+    private userPointerCircleStrokeWidth;
+    private userPointerNameFontSize;
+    private userPointerBackgroundCornerRadius;
+    private userPointerBackgroundPaddingX;
+    private userPointerBackgroundPaddingY;
+    render: undefined;
+    constructor(params: WeaveUsersPointersPluginParams);
+    registersLayers(): boolean;
+    getName(): string;
+    getLayerName(): string;
+    initLayer(): void;
+    getLayer(): default_3.Layer | undefined;
+    init(): void;
+    private stringToColour;
+    private setUserMovementTimer;
+    private renderPointers;
+    toggleRenderCursors(): void;
+    setRenderCursors(render: boolean): void;
+    enable(): void;
+    disable(): void;
+}
+
+export declare type WeaveUsersPointersPluginParams = {
+    getUser?: () => WeaveUser;
+};
+
+export declare class WeaveZoomInToolAction extends WeaveAction {
+    protected previousAction: string;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    getName(): string;
+    private getStageZoomPlugin;
+    init(): void;
+    trigger(cancelAction: () => void, params: WeaveZoomInToolActionParams): void;
+    cleanup(): void;
+}
+
+export declare type WeaveZoomInToolActionParams = {
+    previousAction: string;
+};
+
+export declare class WeaveZoomOutToolAction extends WeaveAction {
+    protected previousAction: string;
+    protected cancelAction: () => void;
+    internalUpdate: undefined;
+    getName(): string;
+    private getStageZoomPlugin;
+    init(): void;
+    trigger(cancelAction: () => void, params: WeaveZoomOutToolActionParams): void;
+    cleanup(): void;
+}
+
+export declare type WeaveZoomOutToolActionParams = {
+    previousAction: string;
+};
+
+export { }