@inditextech/weave-sdk 0.1.1 → 0.2.0

package/dist/sdk.d.cts

@@ -0,0 +1,1433 @@
+import Emittery from "emittery";
+import Konva from "konva";
+import { Vector2d } from "konva/lib/types";
+import pino, { Logger } from "pino";
+import { MappedTypeDescription } from "@syncedstore/core/types/doc";
+import { Doc } from "yjs";
+import { StageConfig } from "konva/lib/Stage";
+
+//#region ../types/dist/types.d.ts
+declare const WEAVE_INSTANCE_STATUS: {
+  readonly "IDLE": "idle";
+  readonly "STARTING": "starting";
+  readonly "LOADING_FONTS": "loadingFonts";
+  readonly "RUNNING": "running";
+};
+declare const WEAVE_NODE_POSITION: {
+  readonly "UP": "up";
+  readonly "DOWN": "down";
+  readonly "FRONT": "front";
+  readonly "BACK": "back";
+};
+declare const WEAVE_EXPORT_FORMATS: {
+  readonly "PNG": "image/png";
+  readonly "JPEG": "image/jpeg";
+};
+//#endregion
+//#region src/base/action.d.ts
+interface WeaveActionBase {
+  init?(): void;
+  trigger(cancelAction: () => void, params?: unknown): unknown;
+  internalUpdate?(): void;
+  cleanup?(): void;
+}
+
+//#endregion
+//#region src/base/plugin.d.ts
+interface WeavePluginBase {
+  init?(): void;
+  render?(): void;
+  enable(): void;
+  disable(): void;
+  isEnabled(): boolean;
+}
+
+//#endregion
+//#region src/base/store.d.ts
+type WeaveStoreOptions = {
+  getUser: () => WeaveUser;
+  undoManagerOptions?: WeaveUndoManagerOptions;
+};
+interface WeaveStoreBase {
+  connect(): void;
+  disconnect(): void;
+  onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
+  setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/types.d.ts
+type WeaveConfig = {
+  store: WeaveStoreBase;
+  nodes?: WeaveNodeBase[];
+  actions?: WeaveActionBase[];
+  plugins?: WeavePluginBase[];
+  fonts?: WeaveFont[];
+  callbacks?: WeaveCallbacks;
+  logger?: WeaveLoggerConfig;
+};
+type WeaveStatusKeys = keyof typeof WEAVE_INSTANCE_STATUS;
+type WeaveStatus = (typeof WEAVE_INSTANCE_STATUS)[WeaveStatusKeys];
+type NodeSerializable = Konva.NodeConfig & {
+  id: string;
+  type: string;
+};
+type WeaveElementAttributes = {
+  [key: string]: any;
+  id?: string;
+  nodeType?: string;
+  children?: WeaveStateElement[];
+};
+type WeaveStateElement = {
+  key: string;
+  type: string;
+  props: WeaveElementAttributes;
+};
+type WeaveState = {
+  weave: {
+    key: "stage";
+    type: "stage";
+    props: {
+      [key: string]: unknown;
+      id: "stage";
+      children: WeaveStateElement[];
+    };
+  } | Record<string, WeaveStateElement>;
+};
+type WeaveSelection = {
+  instance: Konva.Shape | Konva.Group;
+  node: WeaveStateElement;
+};
+type WeaveMousePointInfoSimple = {
+  mousePoint: Vector2d;
+  container: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
+  measureContainer: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveSerializedGroup = {
+  serializedNodes: WeaveStateElement[];
+  minPoint: Vector2d;
+} | undefined;
+type WeaveNodeFound = {
+  node: WeaveStateElement | null;
+  parent: WeaveStateElement | null;
+  index: number;
+};
+type WeaveAwarenessChange<K extends string, T> = { [key in K]: T };
+type WeaveElementInstance = Konva.Layer | Konva.Group | Konva.Shape;
+type WeaveLoggerConfig = {
+  disabled?: boolean;
+  level?: "debug" | "info" | "warn" | "error";
+};
+type WeavePositionKeys = keyof typeof WEAVE_NODE_POSITION;
+type WeavePosition = (typeof WEAVE_NODE_POSITION)[WeavePositionKeys];
+type WeaveExportNodeOptions = {
+  format?: typeof WEAVE_EXPORT_FORMATS.PNG;
+  padding?: number;
+  pixelRatio?: number;
+  backgroundColor?: string;
+  quality?: number;
+};
+type WeaveUser = {
+  name: string;
+  email: string;
+};
+type WeaveFont = {
+  id: string;
+  name: string;
+};
+type WeaveUndoManagerOptions = {
+  captureTimeout?: number;
+  trackedOrigins?: Set<any>;
+};
+type WeaveUndoRedoChange = {
+  canRedo: boolean;
+  canUndo: boolean;
+  redoStackLength: number;
+  undoStackLength: number;
+};
+type WeaveCallbacks = {
+  onRender?: () => void;
+  onRoomLoaded?: (loaded: boolean) => void;
+  onInstanceStatus?: (status: WeaveStatus) => void;
+  onActiveActionChange?: (actionName: string | undefined) => void;
+  onStateChange?: (state: WeaveState) => void;
+  onUndoManagerStatusChange?: (undoManagerStatus: WeaveUndoRedoChange) => void;
+};
+
+//#endregion
+//#region src/base/node.d.ts
+interface WeaveNodeBase {
+  createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(instance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+} //#endregion
+//#region src/stores/store.d.ts
+
+//#endregion
+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): WeaveStore;
+  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;
+}
+
+//#endregion
+//#region src/plugins/plugin.d.ts
+declare abstract class WeavePlugin implements WeavePluginBase {
+  protected instance: Weave;
+  protected name: string;
+  protected enabled: boolean;
+  private logger;
+  register(instance: Weave): WeavePlugin;
+  getName(): string;
+  getLogger(): Logger;
+  isEnabled(): boolean;
+  abstract init?(): void;
+  abstract render?(): void;
+  abstract enable(): void;
+  abstract disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/types.d.ts
+type WeaveNodesSelectionChangeCallback = (nodes: WeaveSelection[]) => void;
+type WeaveNodesSelectionStageSelectionCallback = () => void;
+type WeaveNodesSelectionPluginCallbacks = {
+  onNodesChange: WeaveNodesSelectionChangeCallback;
+  onStageSelection?: WeaveNodesSelectionStageSelectionCallback;
+};
+
+//#endregion
+//#region src/plugins/nodes-selection/nodes-selection.d.ts
+declare class WeaveNodesSelectionPlugin extends WeavePlugin {
+  private tr;
+  private selectionRectangle;
+  private active;
+  private cameFromSelectingMultiple;
+  private selecting;
+  private initialized;
+  private callbacks;
+  render: undefined;
+  constructor(callbacks: WeaveNodesSelectionPluginCallbacks);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  init(): void;
+  private getLayer;
+  private triggerSelectedNodesEvent;
+  private initEvents;
+  getTransformer(): Konva.Transformer;
+  setSelectedNodes(nodes: Konva.Node[]): void;
+  getSelectedNodes(): (Konva.Group | Konva.Shape)[];
+  removeSelectedNodes(): void;
+  selectAll(): void;
+  selectNone(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/nodes/node.d.ts
+declare abstract class WeaveNode implements WeaveNodeBase {
+  protected instance: Weave;
+  protected nodeType: string;
+  private logger;
+  protected previousPointer: string | null;
+  register(instance: Weave): WeaveNode;
+  getNodeType(): string;
+  getLogger(): Logger;
+  getSelectionPlugin(): WeaveNodesSelectionPlugin;
+  isSelecting(): boolean;
+  isPasting(): boolean;
+  isNodeSelected(ele: Konva.Node): boolean;
+  setupDefaultNodeEvents(node: Konva.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;
+}
+
+//#endregion
+//#region src/actions/types.d.ts
+type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes) => void;
+type WeaveActionCallbacks = {
+  onPropsChange?: WeaveActionPropsChangeCallback;
+};
+
+//#endregion
+//#region src/actions/action.d.ts
+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): WeaveAction;
+  updateProps(props: WeaveElementAttributes): void;
+  getProps(): WeaveElementAttributes;
+  abstract init?(): void;
+  abstract trigger(cancelAction: () => void, params?: unknown): unknown;
+  abstract internalUpdate?(): void;
+  abstract cleanup?(): void;
+}
+
+//#endregion
+//#region src/logger/logger.d.ts
+declare class WeaveLogger {
+  private config;
+  private disabled;
+  private logger;
+  constructor(config: WeaveLoggerConfig);
+  private log;
+  getDisabled(): boolean;
+  getLevel(): pino.LevelWithSilentOrString;
+  getLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+}
+
+//#endregion
+//#region src/managers/register.d.ts
+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;
+}
+
+//#endregion
+//#region src/managers/stage.d.ts
+declare class WeaveStageManager {
+  private instance;
+  private logger;
+  private stage;
+  private config;
+  constructor(instance: Weave, config: Konva.StageConfig);
+  getConfiguration(): StageConfig;
+  setStage(stage: Konva.Stage): void;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  initStage(): void;
+}
+
+//#endregion
+//#region src/weave.d.ts
+declare class Weave extends Emittery {
+  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: Konva.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): pino.Logger<never, boolean>;
+  getStageManager(): WeaveStageManager;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  setStage(stage: Konva.Stage): void;
+  getStageConfiguration(): StageConfig;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.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): WeaveNodeFound;
+  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): WeaveMousePointInfo;
+  getMousePointerRelativeToContainer(container: Konva.Group | Konva.Layer): WeaveMousePointInfoSimple;
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
+  cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Layer | Konva.Group | undefined, onPoint: Vector2d): void;
+  getFonts(): WeaveFont[];
+  exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+  exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+}
+
+//#endregion
+//#region src/utils.d.ts
+declare function resetScale(node: Konva.Node): void;
+
+//#endregion
+//#region src/nodes/stage/stage.d.ts
+declare class WeaveStageNode extends WeaveNode {
+  protected nodeType: string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/layer/layer.d.ts
+declare class WeaveLayerNode extends WeaveNode {
+  protected nodeType: string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/group/group.d.ts
+declare class WeaveGroupNode extends WeaveNode {
+  protected nodeType: string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/rectangle/rectangle.d.ts
+declare class WeaveRectangleNode extends WeaveNode {
+  protected nodeType: string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/line/line.d.ts
+declare class WeaveLineNode extends WeaveNode {
+  protected nodeType: string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/text/text.d.ts
+declare class WeaveTextNode extends WeaveNode {
+  protected nodeType: string;
+  private editing;
+  constructor();
+  getType(): string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  private updateNode;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+  private createTextAreaDOM;
+  private removeTextAreaDOM;
+  private triggerEditMode;
+}
+
+//#endregion
+//#region src/nodes/text/types.d.ts
+type TextSerializable = Konva.TextConfig & NodeSerializable & {
+  type: "text";
+  id: string;
+};
+
+//#endregion
+//#region src/nodes/image/image.d.ts
+declare class WeaveImageNode extends WeaveNode {
+  protected nodeType: string;
+  private imageLoaded;
+  cropping: boolean;
+  constructor();
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+  private loadImage;
+  private getImageToolAction;
+}
+
+//#endregion
+//#region src/nodes/image/types.d.ts
+type ImageProps = WeaveElementAttributes & {
+  id: string;
+  width?: number;
+  height?: number;
+  imageURL?: string;
+  imageInfo?: {
+    width: number;
+    height: number;
+  };
+};
+
+//#endregion
+//#region src/nodes/frame/frame.d.ts
+declare class WeaveFrameNode extends WeaveNode {
+  protected nodeType: string;
+  createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(nodeInstance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/frame/constants.d.ts
+declare const WEAVE_FRAME_NODE_TYPE = "frame";
+
+//#endregion
+//#region src/actions/zoom-out-tool/types.d.ts
+type WeaveZoomOutToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/zoom-out-tool/zoom-out-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/zoom-in-tool/types.d.ts
+type WeaveZoomInToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/zoom-in-tool/zoom-in-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/fit-to-screen-tool/types.d.ts
+type WeaveFitToScreenToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/fit-to-screen-tool/fit-to-screen-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/fit-to-selection-tool/types.d.ts
+type WeaveFitToSelectionToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/fit-to-selection-tool/fit-to-selection-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/move-tool/constants.d.ts
+declare const MOVE_TOOL_ACTION_NAME = "moveTool";
+declare const MOVE_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "MOVING": "moving";
+};
+
+//#endregion
+//#region src/actions/move-tool/types.d.ts
+type WeaveMoveToolActionStateKeys = keyof typeof MOVE_TOOL_STATE;
+type WeaveMoveToolActionState = (typeof MOVE_TOOL_STATE)[WeaveMoveToolActionStateKeys];
+
+//#endregion
+//#region src/actions/move-tool/move-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/selection-tool/constants.d.ts
+declare const SELECTION_TOOL_ACTION_NAME = "selectionTool";
+declare const SELECTION_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "SELECTING": "selection";
+};
+
+//#endregion
+//#region src/actions/selection-tool/types.d.ts
+type WeaveSelectionToolActionStateKeys = keyof typeof SELECTION_TOOL_STATE;
+type WeaveSelectionToolActionState = (typeof SELECTION_TOOL_STATE)[WeaveSelectionToolActionStateKeys];
+
+//#endregion
+//#region src/actions/selection-tool/selection-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/rectangle-tool/constants.d.ts
+declare const RECTANGLE_TOOL_ACTION_NAME = "rectangleTool";
+declare const RECTANGLE_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "ADDING": "adding";
+  readonly "DEFINING_SIZE": "definingSize";
+  readonly "ADDED": "added";
+};
+
+//#endregion
+//#region src/actions/rectangle-tool/types.d.ts
+type WeaveRectangleToolActionStateKeys = keyof typeof RECTANGLE_TOOL_STATE;
+type WeaveRectangleToolActionState = (typeof RECTANGLE_TOOL_STATE)[WeaveRectangleToolActionStateKeys];
+type WeaveRectangleToolCallbacks = WeaveActionCallbacks;
+
+//#endregion
+//#region src/actions/rectangle-tool/rectangle-tool.d.ts
+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: Konva.Group | Konva.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;
+}
+
+//#endregion
+//#region src/actions/pen-tool/constants.d.ts
+declare const PEN_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "ADDING": "adding";
+  readonly "DEFINING_SIZE": "definingSize";
+  readonly "ADDED": "added";
+};
+
+//#endregion
+//#region src/actions/pen-tool/types.d.ts
+type WeavePenToolActionStateKeys = keyof typeof PEN_TOOL_STATE;
+type WeavePenToolActionState = (typeof PEN_TOOL_STATE)[WeavePenToolActionStateKeys];
+type WeavePenToolCallbacks = WeaveActionCallbacks;
+
+//#endregion
+//#region src/actions/pen-tool/pen-tool.d.ts
+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: Konva.Layer | Konva.Group | undefined;
+  protected measureContainer: Konva.Layer | Konva.Group | undefined;
+  protected clickPoint: Vector2d | null;
+  protected tempPoint: Konva.Circle | undefined;
+  protected tempNextPoint: Konva.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;
+}
+
+//#endregion
+//#region src/actions/brush-tool/constants.d.ts
+declare const BRUSH_TOOL_STATE: {
+  readonly "INACTIVE": "inactive";
+  readonly "IDLE": "idle";
+  readonly "DEFINE_STROKE": "defineStroke";
+};
+
+//#endregion
+//#region src/actions/brush-tool/types.d.ts
+type WeaveBrushToolActionStateKeys = keyof typeof BRUSH_TOOL_STATE;
+type WeaveBrushToolActionState = (typeof BRUSH_TOOL_STATE)[WeaveBrushToolActionStateKeys];
+type WeaveBrushToolCallbacks = WeaveActionCallbacks;
+
+//#endregion
+//#region src/actions/brush-tool/brush-tool.d.ts
+declare class WeaveBrushToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveBrushToolActionState;
+  protected clickPoint: Vector2d | null;
+  protected strokeId: string | null;
+  protected container: Konva.Layer | Konva.Group | undefined;
+  protected measureContainer: Konva.Layer | Konva.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;
+}
+
+//#endregion
+//#region src/actions/text-tool/constants.d.ts
+declare const TEXT_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "ADDING": "adding";
+  readonly "FINISHED": "finished";
+};
+
+//#endregion
+//#region src/actions/text-tool/types.d.ts
+type WeaveTextToolActionStateKeys = keyof typeof TEXT_TOOL_STATE;
+type WeaveTextToolActionState = (typeof TEXT_TOOL_STATE)[WeaveTextToolActionStateKeys];
+
+//#endregion
+//#region src/actions/text-tool/text-tool.d.ts
+declare class WeaveTextToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected initialCursor: string | null;
+  protected state: WeaveTextToolActionState;
+  protected textId: string | null;
+  protected container: Konva.Layer | Konva.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;
+}
+
+//#endregion
+//#region src/actions/image-tool/constants.d.ts
+declare const IMAGE_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "UPLOADING": "uploading";
+  readonly "ADDING": "adding";
+  readonly "FINISHED": "finished";
+};
+
+//#endregion
+//#region src/actions/image-tool/types.d.ts
+type WeaveImageToolActionStateKeys = keyof typeof IMAGE_TOOL_STATE;
+type WeaveImageToolActionState = (typeof IMAGE_TOOL_STATE)[WeaveImageToolActionStateKeys];
+type WeaveImageToolActionOnAddImageCallback = (finished: (imageURL: string) => void) => Promise<void>;
+type WeaveImageToolActionOnStartLoadImageCallback = () => void;
+type WeaveImageToolActionOnEndLoadImageCallback = (error?: Error) => void;
+type WeaveImageToolActionCallbacks = WeaveActionCallbacks & {
+  onUploadImage: WeaveImageToolActionOnAddImageCallback;
+  onImageLoadStart?: WeaveImageToolActionOnStartLoadImageCallback;
+  onImageLoadEnd?: WeaveImageToolActionOnEndLoadImageCallback;
+};
+type WeaveImageToolActionTriggerParams = {
+  imageURL?: string;
+};
+type WeaveImageToolActionTriggerReturn = {
+  finishUploadCallback: (imageURL: string) => void;
+} | undefined;
+
+//#endregion
+//#region src/actions/image-tool/image-tool.d.ts
+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: Konva.Layer | Konva.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): WeaveImageToolActionTriggerReturn;
+  internalUpdate(): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/frame-tool/constants.d.ts
+declare const FRAME_TOOL_ACTION_NAME = "frameTool";
+declare const FRAME_TOOL_STATE: {
+  readonly "IDLE": "idle";
+  readonly "ADDING": "adding";
+  readonly "ADDED": "added";
+};
+
+//#endregion
+//#region src/actions/frame-tool/types.d.ts
+type WeaveFrameToolActionStateKeys = keyof typeof FRAME_TOOL_STATE;
+type WeaveFrameToolActionState = (typeof FRAME_TOOL_STATE)[WeaveFrameToolActionStateKeys];
+type WeaveFrameToolCallbacks = WeaveActionCallbacks;
+type WeaveFrameToolActionTriggerParams = {
+  fontFamily?: string;
+};
+type WeaveFrameToolProps = {
+  title: string;
+  fontFamily: string;
+  editing: boolean;
+  opacity: number;
+};
+
+//#endregion
+//#region src/actions/frame-tool/frame-tool.d.ts
+declare class WeaveFrameToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveFrameToolActionState;
+  protected frameId: string | null;
+  protected container: Konva.Layer | Konva.Group | undefined;
+  protected clickPoint: Vector2d | null;
+  protected cancelAction: () => void;
+  internalUpdate: undefined;
+  init: undefined;
+  constructor(callbacks: WeaveFrameToolCallbacks);
+  getName(): string;
+  initProps(params?: WeaveFrameToolActionTriggerParams): WeaveFrameToolProps;
+  private setupEvents;
+  private setState;
+  private addFrame;
+  private handleAdding;
+  trigger(cancelAction: () => void, params?: WeaveFrameToolActionTriggerParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/export-stage-tool/types.d.ts
+type WeaveExportStageActionParams = {
+  options?: WeaveExportNodeOptions;
+};
+
+//#endregion
+//#region src/actions/export-stage-tool/export-stage-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/actions/export-node-tool/types.d.ts
+type WeaveExportNodeActionParams = {
+  node: WeaveElementInstance;
+  options?: WeaveExportNodeOptions;
+};
+
+//#endregion
+//#region src/actions/export-node-tool/export-node-tool.d.ts
+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;
+}
+
+//#endregion
+//#region src/plugins/stage-grid/constants.d.ts
+declare const WEAVE_GRID_DEFAULT_SIZE = 50;
+declare const WEAVE_GRID_LAYER_ID = "gridLayer";
+declare const WEAVE_GRID_TYPES: {
+  readonly "LINES": "lines";
+  readonly "DOTS": "dots";
+};
+
+//#endregion
+//#region src/plugins/stage-grid/types.d.ts
+type WeaveStageGridPluginParams = {
+  gridSize?: number;
+};
+type WeaveStageGridTypeKeys = keyof typeof WEAVE_GRID_TYPES;
+type WeaveStageGridType = (typeof WEAVE_GRID_TYPES)[WeaveStageGridTypeKeys];
+
+//#endregion
+//#region src/plugins/stage-grid/stage-grid.d.ts
+declare class WeaveStageGridPlugin extends WeavePlugin {
+  private moveToolActive;
+  private isMouseMiddleButtonPressed;
+  private isSpaceKeyPressed;
+  private type;
+  private gridColor;
+  private originColor;
+  private gridSize;
+  constructor(params: WeaveStageGridPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  init(): void;
+  private initEvents;
+  getLayer(): Konva.Layer | undefined;
+  private renderGrid;
+  private round;
+  private renderGridLines;
+  private renderGridDots;
+  render(): void;
+  enable(): void;
+  disable(): void;
+  getType(): WeaveStageGridType;
+  setType(type: WeaveStageGridType): void;
+}
+
+//#endregion
+//#region src/plugins/stage-panning/stage-panning.d.ts
+declare class WeaveStagePanningPlugin extends WeavePlugin {
+  private moveToolActive;
+  private isMouseMiddleButtonPressed;
+  private isSpaceKeyPressed;
+  protected previousPointer: string | null;
+  getLayerName: undefined;
+  initLayer: undefined;
+  render: undefined;
+  constructor();
+  getName(): string;
+  init(): void;
+  private enableMove;
+  private disableMove;
+  private initEvents;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-resize/stage-resize.d.ts
+declare class WeaveStageResizePlugin extends WeavePlugin {
+  getLayerName: undefined;
+  initLayer: undefined;
+  render: undefined;
+  getName(): string;
+  init(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-zoom/types.d.ts
+type WeaveStageZoomChanged = {
+  scale: number;
+  zoomSteps: number[];
+  actualStep: number;
+  onDefaultStep: boolean;
+  canZoomIn: boolean;
+  canZoomOut: boolean;
+};
+type WeaveStageZoomOnZoomChangeCallback = (zoomInfo: WeaveStageZoomChanged) => void;
+type WeaveStageZoomPluginParams = {
+  zoomSteps?: number[];
+  defaultZoom?: number;
+  onZoomChange?: WeaveStageZoomOnZoomChangeCallback;
+};
+
+//#endregion
+//#region src/plugins/stage-zoom/stage-zoom.d.ts
+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);
+  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;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/constants.d.ts
+declare const WEAVE_NODES_SELECTION_LAYER_ID = "selectionLayer";
+
+//#endregion
+//#region src/plugins/connected-users/constants.d.ts
+declare const WEAVE_CONNECTED_USER_INFO_KEY = "userInfo";
+
+//#endregion
+//#region src/plugins/connected-users/types.d.ts
+type WeaveConnectedUsersPluginParams = {
+  onConnectedUsersChanged?: WeaveConnectedUsersChangeCallback;
+  getUser?: () => WeaveUser;
+};
+type WeaveConnectedUsersChanged = {
+  [userName: string]: WeaveUser;
+};
+type WeaveConnectedUsersChangeCallback = (users: WeaveConnectedUsersChanged) => void;
+type WeaveConnectedUserInfoKey = typeof WEAVE_CONNECTED_USER_INFO_KEY;
+
+//#endregion
+//#region src/plugins/connected-users/connected-users.d.ts
+declare class WeaveConnectedUsersPlugin extends WeavePlugin {
+  private connectedUsers;
+  private getUser;
+  private onConnectedUsersChanged;
+  getLayerName: undefined;
+  initLayer: undefined;
+  render: undefined;
+  constructor(params: WeaveConnectedUsersPluginParams);
+  getName(): string;
+  init(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/users-pointers/constants.d.ts
+declare const WEAVE_USER_POINTER_KEY = "userPointer";
+
+//#endregion
+//#region src/plugins/users-pointers/types.d.ts
+type WeaveUsersPointersPluginParams = {
+  getUser?: () => WeaveUser;
+};
+type WeaveUserPointer = {
+  user: string;
+  x: number;
+  y: number;
+};
+type WeaveUserPointerKey = typeof WEAVE_USER_POINTER_KEY;
+
+//#endregion
+//#region src/plugins/users-pointers/users-pointers.d.ts
+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);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  getLayer(): Konva.Layer | undefined;
+  init(): void;
+  private stringToColour;
+  private setUserMovementTimer;
+  private renderPointers;
+  toggleRenderCursors(): void;
+  setRenderCursors(render: boolean): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/context-menu/types.d.ts
+type WeaveStageContextMenuPluginOptions = {
+  xOffset?: number;
+  yOffset?: number;
+};
+type WeaveOnNodeMenuCallback = (instance: Weave, selection: WeaveSelection[], point: Vector2d, visible: boolean) => void;
+type WeaveStageContextMenuPluginCallbacks = {
+  onNodeMenu: WeaveOnNodeMenuCallback;
+};
+
+//#endregion
+//#region src/plugins/context-menu/context-menu.d.ts
+declare class WeaveContextMenuPlugin extends WeavePlugin {
+  private config;
+  private callbacks;
+  private touchTimer;
+  private tapHold;
+  getLayerName: undefined;
+  initLayer: undefined;
+  render: undefined;
+  constructor(options: WeaveStageContextMenuPluginOptions, callbacks: WeaveStageContextMenuPluginCallbacks);
+  getName(): string;
+  init(): void;
+  triggerContextMenu(target: any): void;
+  private initEvents;
+  isTapHold(): boolean;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-drop-area/types.d.ts
+type WeaveStageDropCallback = (event: DragEvent) => void;
+type WeaveStageDropUploadFileCallback = (event: File) => Promise<void>;
+type WeaveStageDropAreaPluginCallbacks = {
+  onStageDrop?: WeaveStageDropCallback;
+  doUploadFile?: WeaveStageDropUploadFileCallback;
+};
+
+//#endregion
+//#region src/plugins/stage-drop-area/stage-drop-area.d.ts
+declare class WeaveStageDropAreaPlugin extends WeavePlugin {
+  private callbacks?;
+  getLayerName: undefined;
+  initLayer: undefined;
+  render: undefined;
+  constructor(callbacks?: WeaveStageDropAreaPluginCallbacks);
+  getName(): string;
+  init(): void;
+  private initEvents;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/copy-paste-nodes/constants.d.ts
+declare const COPY_PASTE_NODES_PLUGIN_STATE: {
+  readonly "IDLE": "idle";
+  readonly "PASTING": "pasting";
+};
+
+//#endregion
+//#region src/plugins/copy-paste-nodes/types.d.ts
+type WeaveCopyPasteNodesPluginStateKeys = keyof typeof COPY_PASTE_NODES_PLUGIN_STATE;
+type WeaveCopyPasteNodesPluginState = (typeof COPY_PASTE_NODES_PLUGIN_STATE)[WeaveCopyPasteNodesPluginStateKeys];
+type WeaveCopyPasteNodesCanCopyChangeCallback = (canCopy: boolean) => void;
+type WeaveCopyPasteNodesCanPasteChangeCallback = (canPaste: boolean, nodes: WeaveToPasteNode[]) => void;
+type WeaveCopyPasteNodesOnCopyCallback = (error?: Error) => void;
+type WeaveCopyPasteNodesOnPasteCallback = (error?: Error) => void;
+type WeaveCopyPasteNodesOnPasteExternalCallback = (item: ClipboardItem) => void;
+type WeaveCopyPasteNodesPluginCallbacks = {
+  onCopy?: WeaveCopyPasteNodesOnCopyCallback;
+  onPaste?: WeaveCopyPasteNodesOnPasteCallback;
+  onPasteExternal?: WeaveCopyPasteNodesOnPasteExternalCallback;
+};
+type WeavePasteModel = {
+  weaveInstanceId: string;
+  weave: Record<string, WeaveStateElement>;
+  weaveMinPoint: Vector2d;
+};
+type WeaveToPasteNode = {
+  konvaNode: Konva.Node;
+  node: NodeSerializable;
+};
+
+//#endregion
+//#region src/plugins/copy-paste-nodes/copy-paste-nodes.d.ts
+declare class WeaveCopyPasteNodesPlugin extends WeavePlugin {
+  protected state: WeaveCopyPasteNodesPluginState;
+  private callbacks;
+  private toPaste;
+  getLayerName: undefined;
+  initLayer: undefined;
+  render: undefined;
+  constructor(callbacks?: WeaveCopyPasteNodesPluginCallbacks);
+  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(): WeaveToPasteNode[];
+  isPasting(): boolean;
+  private cancel;
+  private getNodesSelectionPlugin;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-snapping/constants.d.ts
+declare const GUIDE_LINE_NAME = "guide-line";
+declare const GUIDE_ORIENTATION: {
+  readonly "HORIZONTAL": "H";
+  readonly "VERTICAL": "V";
+};
+declare const NODE_SNAP: {
+  readonly "START": "start";
+  readonly "CENTER": "center";
+  readonly "END": "end";
+};
+
+//#endregion
+//#region src/plugins/nodes-snapping/types.d.ts
+type NodeSnapKeys = keyof typeof NODE_SNAP;
+type NodeSnap = (typeof NODE_SNAP)[NodeSnapKeys];
+type NodeSnappingEdge = {
+  guide: number;
+  offset: number;
+  snap: NodeSnap;
+};
+type NodeSnappingEdges = {
+  vertical: NodeSnappingEdge[];
+  horizontal: NodeSnappingEdge[];
+};
+type LineGuideStop = {
+  vertical: number[];
+  horizontal: number[];
+};
+type LineGuide = {
+  lineGuide: number;
+  diff: number;
+  snap: NodeSnap;
+  offset: number;
+};
+type GuideOrientationKeys = keyof typeof GUIDE_ORIENTATION;
+type GuideOrientation = (typeof GUIDE_ORIENTATION)[GuideOrientationKeys];
+type Guide = {
+  lineGuide: number;
+  offset: number;
+  orientation: GuideOrientation;
+  snap: NodeSnap;
+};
+
+//#endregion
+//#region src/plugins/nodes-snapping/nodes-snapping.d.ts
+declare class WeaveNodesSnappingPlugin extends WeavePlugin {
+  private guideLineOffset;
+  render: undefined;
+  constructor();
+  getName(): string;
+  init(): void;
+  setEnabled(enabled: boolean): void;
+  private initEvents;
+  getLineGuideStops(skipShape: Konva.Node): LineGuideStop;
+  getObjectSnappingEdges(node: Konva.Node): NodeSnappingEdges;
+  getGuides(lineGuideStops: LineGuideStop, itemBounds: NodeSnappingEdges): Guide[];
+  drawGuides(guides: Guide[]): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+export { BRUSH_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_LINE_NAME, GUIDE_ORIENTATION, Guide, GuideOrientation, GuideOrientationKeys, IMAGE_TOOL_STATE, ImageProps, LineGuide, LineGuideStop, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, NODE_SNAP, NodeSnap, NodeSnapKeys, NodeSnappingEdge, NodeSnappingEdges, PEN_TOOL_STATE, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, TEXT_TOOL_STATE, TextSerializable, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_SIZE, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_NODES_SELECTION_LAYER_ID, Weave, WeaveAction, WeaveActionCallbacks, WeaveActionPropsChangeCallback, WeaveBrushToolAction, WeaveBrushToolActionState, WeaveBrushToolActionStateKeys, WeaveBrushToolCallbacks, WeaveConnectedUserInfoKey, WeaveConnectedUsersChangeCallback, WeaveConnectedUsersChanged, WeaveConnectedUsersPlugin, WeaveConnectedUsersPluginParams, WeaveContextMenuPlugin, WeaveCopyPasteNodesCanCopyChangeCallback, WeaveCopyPasteNodesCanPasteChangeCallback, WeaveCopyPasteNodesOnCopyCallback, WeaveCopyPasteNodesOnPasteCallback, WeaveCopyPasteNodesOnPasteExternalCallback, WeaveCopyPasteNodesPlugin, WeaveCopyPasteNodesPluginCallbacks, WeaveCopyPasteNodesPluginState, WeaveCopyPasteNodesPluginStateKeys, WeaveExportNodeActionParams, WeaveExportNodeToolAction, WeaveExportStageActionParams, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToScreenToolActionParams, WeaveFitToSelectionToolAction, WeaveFitToSelectionToolActionParams, WeaveFrameNode, WeaveFrameToolAction, WeaveFrameToolActionState, WeaveFrameToolActionStateKeys, WeaveFrameToolActionTriggerParams, WeaveFrameToolCallbacks, WeaveFrameToolProps, WeaveGroupNode, WeaveImageNode, WeaveImageToolAction, WeaveImageToolActionCallbacks, WeaveImageToolActionOnAddImageCallback, WeaveImageToolActionOnEndLoadImageCallback, WeaveImageToolActionOnStartLoadImageCallback, WeaveImageToolActionState, WeaveImageToolActionStateKeys, WeaveImageToolActionTriggerParams, WeaveImageToolActionTriggerReturn, WeaveLayerNode, WeaveLineNode, WeaveMoveToolAction, WeaveMoveToolActionState, WeaveMoveToolActionStateKeys, WeaveNode, WeaveNodesSelectionChangeCallback, WeaveNodesSelectionPlugin, WeaveNodesSelectionPluginCallbacks, WeaveNodesSelectionStageSelectionCallback, WeaveNodesSnappingPlugin, WeaveOnNodeMenuCallback, WeavePasteModel, WeavePenToolAction, WeavePenToolActionState, WeavePenToolActionStateKeys, WeavePenToolCallbacks, WeavePlugin, WeaveRectangleNode, WeaveRectangleToolAction, WeaveRectangleToolActionState, WeaveRectangleToolActionStateKeys, WeaveRectangleToolCallbacks, WeaveSelectionToolAction, WeaveSelectionToolActionState, WeaveSelectionToolActionStateKeys, WeaveStageContextMenuPluginCallbacks, WeaveStageContextMenuPluginOptions, WeaveStageDropAreaPlugin, WeaveStageDropAreaPluginCallbacks, WeaveStageDropCallback, WeaveStageDropUploadFileCallback, WeaveStageGridPlugin, WeaveStageGridPluginParams, WeaveStageGridType, WeaveStageGridTypeKeys, WeaveStageNode, WeaveStagePanningPlugin, WeaveStageResizePlugin, WeaveStageZoomChanged, WeaveStageZoomOnZoomChangeCallback, WeaveStageZoomPlugin, WeaveStageZoomPluginParams, WeaveStore, WeaveTextNode, WeaveTextToolAction, WeaveTextToolActionState, WeaveTextToolActionStateKeys, WeaveToPasteNode, WeaveUserPointer, WeaveUserPointerKey, WeaveUsersPointersPlugin, WeaveUsersPointersPluginParams, WeaveZoomInToolAction, WeaveZoomInToolActionParams, WeaveZoomOutToolAction, WeaveZoomOutToolActionParams, resetScale };