@likec4/diagram 1.44.0 → 1.46.0

package/dist/editor/LikeC4EditorProvider.d.ts

@@ -0,0 +1,22 @@
+import { PropsWithChildren, Context } from 'react';
+import type * as t from '@likec4/core/types';
+export type LikeC4EditorPort = {
+    /**
+     * Fetch a view by its ID and layout type.
+     *
+     * @param viewId - The ID of the view to fetch.
+     * @param layout - The layout type to use when fetching the view.
+     */
+    fetchView(viewId: t.ViewId, layout?: t.LayoutType): t.LayoutedView | Promise<t.LayoutedView>;
+    /**
+     * Callback invoked when the view changes.
+     */
+    handleChange(viewId: t.ViewId, change: t.ViewChange): void | Promise<void>;
+};
+export type LikeC4EditorProviderProps = PropsWithChildren<{
+    editor: LikeC4EditorPort;
+}>;
+export declare const LikeC4EditorReactContext: Context<LikeC4EditorPort | null>;
+export declare function LikeC4EditorProvider({ children, editor }: LikeC4EditorProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function EnsureEditorContext({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element | null;
+export declare function useOptionalLikeC4EditorPort(): LikeC4EditorPort | null;

package/dist/editor/LikeC4EditorProvider.js

@@ -0,0 +1,12 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext } from 'react';
+
+const LikeC4EditorReactContext = createContext(null);
+function LikeC4EditorProvider({ children, editor }) {
+  return /* @__PURE__ */ jsx(LikeC4EditorReactContext.Provider, { value: editor, children });
+}
+function useOptionalLikeC4EditorPort() {
+  return useContext(LikeC4EditorReactContext);
+}
+
+export { LikeC4EditorProvider, LikeC4EditorReactContext, useOptionalLikeC4EditorPort };

package/dist/editor/__tests__/fixture.d.ts

@@ -0,0 +1,205 @@
+import { Types, Builder } from '@likec4/core/builder';
+import { DiagramEdge, DiagramNode, LayoutedElementView } from '@likec4/core/types';
+import { WritableDraft } from 'immer';
+import { LiteralUnion } from 'type-fest';
+/**
+  Snapshot {@link indexSnapshot} is built from the model below.
+=======
+specification {
+  element el
+  element app
+  tag tag-1
+  tag tag-2
+  tag tag-3
+}
+
+model {
+  el customer 'Customer' {
+    #tag-1 #tag-2
+    description 'Uses services online'
+  }
+
+  el saas {
+    #tag-1
+    title 'SaaS Application'
+    description 'Provides online services to customers'
+
+    el frontend {
+      #tag-2
+      title 'Frontend'
+
+      app spa {
+        #tag-2
+        title 'SPA'
+        description 'Single Page Application'
+        icon tech:react
+
+        -> api
+      }
+      app pwa {
+        #tag-2
+        title 'PWA'
+        description 'Progressive Web Application'
+        icon tech:react
+
+        -> api
+      }
+    }
+    el backend {
+      title 'Backend'
+
+      el auth {
+        title 'Auth'
+        description 'Authentication'
+      }
+
+      el api {
+        #tag-3
+        title 'API'
+        description 'REST API'
+        icon tech:nodejs
+      }
+
+      el worker {
+        title 'Worker'
+        description 'Background processing'
+      }
+
+      api -> auth
+      api -> worker
+      api -> external.database
+      worker -> external.email
+    }
+
+    frontend -> api {
+      title 'requests'
+      technology 'REST'
+      description '''
+  requests **data**
+'''
+    }
+  }
+
+  el external {
+    title 'External'
+    description 'External system'
+
+    el email {
+      title 'Email'
+      description 'Email service'
+    }
+
+    el database {
+      title 'Database'
+      description 'External database'
+    }
+  }
+
+  customer -> saas.frontend 'uses'
+
+}
+
+views {
+  view index {
+    title 'Landscape'
+    description '''
+      System _Landscape_
+
+    '''
+
+    include
+      *,
+      saas.**,
+      external.**
+  }
+}
+
+*/
+/**
+ * Builder that produces the model used to create {@link indexSnapshot}
+ * Here for type safety and easy maintenance of the snapshot.
+ */
+declare function simplebuilder(): Builder<Types<"el" | "app", "external" | "saas" | "customer" | "saas.frontend" | "saas.frontend.spa" | "saas.frontend.pwa" | "saas.backend" | "saas.backend.auth" | "saas.backend.api" | "saas.backend.worker" | "external.email" | "external.database", "index", never, "tag-1" | "tag-2" | "tag-3", never, never, never>>;
+type A = Types.ToAux<ReturnType<typeof simplebuilder>['Types']>;
+type ExistingNodes = A['ElementId'];
+type WithoutNodesEdges<V = LayoutedElementView> = Omit<V, 'nodes' | 'edges'>;
+export type NodeIds = LiteralUnion<ExistingNodes, string>;
+type NodeUpdater = ((draft: WritableDraft<Omit<DiagramNode, 'id'>>) => void) | Partial<Omit<DiagramNode, 'id'>> | undefined | null;
+type NodeIdFrom<N> = N extends infer L extends string ? L | ExistingNodes : ExistingNodes;
+type ExistingEdges = 'edge1' | 'edge2' | 'edge3' | 'edge4' | 'edge5' | 'edge6' | 'edge7';
+type UpdatableEdge<Node> = Omit<DiagramEdge, 'id' | 'source' | 'target'> & {
+    id: LiteralUnion<ExistingEdges, string>;
+    source: Node;
+    target: Node;
+};
+type EdgeUpdater<Node> = ((draft: WritableDraft<UpdatableEdge<Node>>) => void) | Partial<UpdatableEdge<Node>> | undefined | null;
+export type Patches<N, E> = {
+    view?: Partial<WithoutNodesEdges> | ((draft: WritableDraft<WithoutNodesEdges>) => void);
+    nodes?: {
+        [Id in ExistingNodes]?: NodeUpdater;
+    } & {
+        [Id in N & string]?: NodeUpdater | undefined | null;
+    };
+    edges?: {
+        [Id in ExistingEdges]?: EdgeUpdater<NodeIdFrom<N>>;
+    } & {
+        [Id in E & string]?: EdgeUpdater<NodeIdFrom<N>>;
+    };
+};
+/**
+ * Helper to get a fixture with manual layout snapshot, and auto layouted view.
+ * It takes {@link indexSnapshot} as base, applies provided patches
+ * to return as auto-layouted.
+ *
+ * Patcher can modify view properties, nodes and edges by their ids.
+ *
+ * Nodes/Edges can be modified, removed (by setting to null/undefined), or added (by using new key).
+ *
+ * @example
+ * const { snapshot, layouted } = prepareFixtures({
+ *   nodes: {
+ *     // Merge changes to the node
+ *     'customer': {
+ *       x: 100,
+ *     },
+ *     // Apply changes to existing node via immer
+ *     'saas.api': d => {
+ *       d.color = 'secondary'
+ *     },
+ *     // Remove node from snapshot
+ *    'saas.frontend': null,
+ *    // Add new node to layouted View
+ *    'another': d => {
+ *      d.title = 'Another Node'
+ *   },
+ *   edges: {
+ *     // Merge changes to existing edge
+ *     'edge1: customer to frontend': d => {
+ *        d.source = 'another'
+ *     },
+ *     // Delete existing edge
+ *    'edge2: frontend to api': null,
+ *     // Add new edge (TS will check source/target ids)
+ *     'customer -> another': {
+ *       label: 'New Edge',
+ *       source: 'customer',
+ *       target: 'another',
+ *     }
+ *   }
+ * }
+
+ * })
+ */
+export declare function prepareFixtures<const N, E>(patcher?: Patches<N, E>): {
+    snapshot: LayoutedElementView;
+    snapshotNodes: Record<ExistingNodes, DiagramNode>;
+    snapshotEdges: Record<ExistingEdges, DiagramEdge>;
+    layouted: LayoutedElementView;
+    layoutedNodes: {
+        [Id in ExistingNodes | N & string]: DiagramNode;
+    };
+    layoutedEdges: {
+        [Id in ExistingEdges | E & string]: DiagramEdge;
+    };
+};
+export {};

package/dist/editor/applyChangesToManualLayout.d.ts

@@ -0,0 +1,8 @@
+import * as t from '@likec4/core/types';
+/**
+ * Applies changes to a manual layout.
+ *
+ * @param manual - The manual layout.
+ * @param latest - The latest layout.
+ */
+export declare function applyChangesToManualLayout(manualView: t.LayoutedView, latestView: t.LayoutedView): t.LayoutedView;

package/dist/editor/applyChangesToManualLayout.js

@@ -0,0 +1,182 @@
+import { invariant, nonNullable } from '@likec4/core';
+import { BBox, vector } from '@likec4/core/geometry';
+import { setAutoFreeze, produce, castDraft } from 'immer';
+import { isNullish } from 'remeda';
+
+function applyChangesToManualLayout(manualView, latestView) {
+  try {
+    setAutoFreeze(false);
+    return _applyChangesToManualLayout(manualView, latestView);
+  } finally {
+    setAutoFreeze(true);
+  }
+}
+const isRootNode = (node) => isNullish(node.parent);
+function _applyChangesToManualLayout(manualView, latestView) {
+  invariant(manualView.id === latestView.id, "View IDs do not match");
+  invariant(manualView._type === latestView._type, "View types do not match");
+  invariant(manualView._layout === "manual" && latestView._layout === "auto", "Views must be manual and auto");
+  const compounds = /* @__PURE__ */ new Set();
+  const newnodes = /* @__PURE__ */ new Set();
+  const isNotCompound = (node) => !compounds.has(typeof node === "string" ? node : node.id);
+  const isBetweenNewLeafNodes = (edge) => newnodes.has(edge.source) && newnodes.has(edge.target) && isNotCompound(edge.source) && isNotCompound(edge.target);
+  const nodesMap = new Map(
+    latestView.nodes.map((latest) => {
+      if (latest.children && latest.children.length > 0) {
+        compounds.add(latest.id);
+      }
+      const manual = manualView.nodes.find((n) => n.id === latest.id);
+      if (manual) {
+        return [latest.id, applyFromManualNode({ latest, manual })];
+      }
+      newnodes.add(latest.id);
+      return [latest.id, removeDrift(latest)];
+    })
+  );
+  const newNodesOnly = newnodes.size === nodesMap.size;
+  if (newNodesOnly) {
+    return produce(latestView, (draft) => {
+      draft._layout = "manual";
+      draft.nodes = castDraft([...nodesMap.values()]);
+      draft.edges = castDraft(latestView.edges.map(removeDrift));
+      delete draft.drifts;
+    });
+  }
+  if (compounds.size > 0) {
+    expandCompoundNodes(nodesMap);
+  }
+  const nodes = [...nodesMap.values()];
+  const edges = latestView.edges.map((latest) => {
+    const dir = latest.dir ?? "forward";
+    const hasSameEndpoints = (candidate) => candidate.source === latest.source && candidate.target === latest.target && (candidate.dir === dir || !candidate.dir && !latest.dir);
+    let manual = manualView.edges.find((e) => e.id === latest.id && hasSameEndpoints(e));
+    if (!manual) {
+      manual = manualView.edges.find((e) => hasSameEndpoints(e));
+    }
+    if (manual) {
+      return applyFromManualEdge({
+        latest,
+        manual
+      });
+    }
+    if (isBetweenNewLeafNodes(latest)) {
+      return removeDrift(latest);
+    }
+    const sourceNode = nodesMap.get(latest.source);
+    const targetNode = nodesMap.get(latest.target);
+    return makeAsStraightLine(latest, sourceNode, targetNode);
+  });
+  const bounds = BBox.merge(...nodes.filter(isRootNode));
+  return produce(latestView, (draft) => {
+    draft._layout = "manual";
+    draft.nodes = castDraft(nodes);
+    draft.edges = castDraft(edges);
+    draft.bounds = bounds;
+    delete draft.drifts;
+  });
+}
+const COMPOUND_PADDING = {
+  Left: 42,
+  Right: 42,
+  Top: 60,
+  Bottom: 42
+};
+function expandCompoundNodes(nodes) {
+  function expand(nodeId) {
+    const node = nonNullable(nodes.get(nodeId), `Node ${nodeId} not found`);
+    if (node.children.length === 0) {
+      return node;
+    }
+    const childBBoxes = [];
+    for (const childId of node.children) {
+      childBBoxes.push(
+        expand(childId)
+      );
+    }
+    const childrenBBox = BBox.merge(...childBBoxes);
+    node.x = childrenBBox.x - COMPOUND_PADDING.Left;
+    node.y = childrenBBox.y - COMPOUND_PADDING.Top;
+    node.width = childrenBBox.width + COMPOUND_PADDING.Left + COMPOUND_PADDING.Right;
+    node.height = childrenBBox.height + COMPOUND_PADDING.Top + COMPOUND_PADDING.Bottom;
+    return node;
+  }
+  for (const node of nodes.values()) {
+    if (!isRootNode(node) || node.children.length === 0) {
+      continue;
+    }
+    expand(node.id);
+  }
+}
+function applyFromManualNode({ latest, manual }) {
+  invariant(manual.id === latest.id, "Node IDs do not match");
+  return produce(latest, (next) => {
+    next.x = manual.x;
+    next.y = manual.y;
+    next.drifts = null;
+  });
+}
+function applyFromManualEdge(edges) {
+  const { manual, latest } = edges;
+  return produce(latest, (draft) => {
+    if (manual.controlPoints) {
+      draft.controlPoints = manual.controlPoints;
+    } else {
+      delete draft.controlPoints;
+    }
+    draft.points = castDraft(manual.points);
+    if (manual.labelBBox) {
+      draft.labelBBox = latest.labelBBox ?? manual.labelBBox;
+      draft.labelBBox.x = manual.labelBBox.x;
+      draft.labelBBox.y = manual.labelBBox.y;
+    }
+    draft.drifts = null;
+  });
+}
+function removeDrift(object) {
+  if ("drifts" in object && object.drifts !== null) {
+    const result = { ...object };
+    result.drifts = null;
+    return result;
+  }
+  return object;
+}
+function makeAsStraightLine(edge, sourceNode, targetNode) {
+  const controlPoints = edgeControlPoints(sourceNode, targetNode);
+  const labelPos = controlPoints[0];
+  return produce(edge, (draft) => {
+    draft.controlPoints = controlPoints;
+    if (edge.labelBBox) {
+      draft.labelBBox.x = labelPos.x;
+      draft.labelBBox.y = labelPos.y;
+    }
+    delete draft.drifts;
+  });
+}
+function getBorderPointOnVector(node, nodeCenter, v) {
+  const xScale = node.width / 2 / v.x;
+  const yScale = node.height / 2 / v.y;
+  const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
+  return vector(v).multiply(scale).add(nodeCenter);
+}
+function edgeControlPoints(source, target) {
+  const sourceCenter = vector(BBox.center(source));
+  const targetCenter = vector(BBox.center(target));
+  if (source === target) {
+    const loopSize = 80;
+    const centerOfTopBoundary = vector(0, source.height || 0).multiply(-0.5).add(sourceCenter);
+    return [
+      centerOfTopBoundary.add(vector(-loopSize / 2.5, -loopSize)).round().toObject(),
+      centerOfTopBoundary.add(vector(loopSize / 2.5, -loopSize)).round().toObject()
+    ];
+  }
+  const sourceToTargetVector = targetCenter.subtract(sourceCenter);
+  const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
+  const targetBorderPoint = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1));
+  const sourceToTarget = targetBorderPoint.subtract(sourceBorderPoint);
+  return [
+    sourceBorderPoint.add(sourceToTarget.multiply(0.4)).round().toObject(),
+    sourceBorderPoint.add(sourceToTarget.multiply(0.6)).round().toObject()
+  ];
+}
+
+export { applyChangesToManualLayout };

package/dist/editor/editorActor.actions.d.ts

@@ -0,0 +1,201 @@
+import { ViewChange } from '@likec4/core/types';
+import { ActionFunction, CancelAction, Values, PromiseActorLogic, EventObject, NonReducibleUnknown, StopAction } from 'xstate';
+import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './editorActor';
+import { HotkeyActorLogic } from './hotkeyActor';
+export declare const raiseSync: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+export declare const cancelSync: () => CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
+export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+type LayoutChanges = ViewChange.ResetManualLayout | ViewChange.SaveViewSnapshot;
+export declare const isLayoutChange: (change: ViewChange) => change is LayoutChanges;
+export declare const withoutSnapshotChanges: (data: ViewChange[]) => (ViewChange.ChangeElementStyle | ViewChange.ChangeAutoLayout)[];
+export declare const saveStateBeforeEdit: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, never, never, never>;
+export declare const startEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, Values<{
+    "has pending": {
+        type: "has pending";
+        params: unknown;
+    };
+    "can undo": {
+        type: "can undo";
+        params: unknown;
+    };
+}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+export declare const stopHotkey: () => StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
+export declare const ensureHotKey: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, Values<{
+    "has pending": {
+        type: "has pending";
+        params: unknown;
+    };
+    "can undo": {
+        type: "can undo";
+        params: unknown;
+    };
+}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+export declare const pushHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, never, never, never>;
+export declare const stopEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, Values<{
+    "has pending": {
+        type: "has pending";
+        params: unknown;
+    };
+    "can undo": {
+        type: "can undo";
+        params: unknown;
+    };
+}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+export declare const markHistoryAsSynched: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, never, never, never>;
+export declare const popHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, never, never, never>;
+export declare const undo: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, Values<{
+    "has pending": {
+        type: "has pending";
+        params: unknown;
+    };
+    "can undo": {
+        type: "can undo";
+        params: unknown;
+    };
+}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+export declare const addSnapshotToPendingChanges: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, never, never, never>;
+export {};