@dineug/erd-editor 3.6.0 → 3.8.0

package/dist/constants/zoom.d.ts

@@ -0,0 +1,7 @@
+/** The zoom a scene opens at, and the one the reset chord puts it back to. */
+export declare const ZOOM_RESET = 1;
+/** How far one zoom chord steps the zoom, in or out. */
+export declare const ZOOM_STEP = 0.04;
+/** How far one wheel notch carrying the modifier zooms, on the ERD tab and in a view alike. */
+export declare const WHEEL_ZOOM_STEP = 0.03;
+//# sourceMappingURL=zoom.d.ts.map

package/dist/engine/actions.d.ts

@@ -28,6 +28,12 @@ export type ActionType = keyof RootActionMap;
 export declare const actions: Actions;
 export declare const ChangeActionTypes: ReadonlyArray<ActionType>;
 export declare const ReadonlyIgnoreActionTypes: ReadonlyArray<ActionType>;
+/**
+ * What a view keeps from the document while it is active: every edit a
+ * readonly host refuses, less the host replacing the document outright, which
+ * a view cannot stand in the way of and answers by closing.
+ */
+export declare const ViewIgnoreActionTypes: ReadonlyArray<ActionType>;
 export declare const SharedStreamActionTypes: ReadonlyArray<ActionType>;
 export declare const SharedActionTypes: ReadonlyArray<ActionType>;
 export declare const SharedFollowingActionTypes: ReadonlyArray<ActionType>;

package/dist/engine/index.js

@@ -1,33 +1,33 @@
-import { Rr as e, Wt as t, b as n, g as r, jn as i, l as a, m as o, n as s, on as c, q as l, r as u, t as d, ui as f } from "../schemaGCService--wGet5O7.js";
+import { In as e, X as t, Yt as n, _ as r, _i as i, dn as a, h as o, n as s, qi as c, r as l, t as u, u as d, x as f } from "../schemaGCService-CXVjeF9p.js";
 import { isEmpty as p } from "es-toolkit/compat";
 import { omit as m } from "es-toolkit";
 import { Observable as h, Subject as g, debounceTime as _, map as v } from "rxjs";
 //#region src/engine/replication-store.ts
 var y = { change: "change" };
 function b(b) {
-	let x = /* @__PURE__ */ new Set(), S = r(b), C = a(S, !1);
-	C.dispatchSync(c({
+	let x = /* @__PURE__ */ new Set(), S = r(b), C = d(S, !1);
+	C.dispatchSync(a({
 		width: 0,
 		height: 0
 	}));
-	let w = u(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(n), _(200)), D = /* @__PURE__ */ new Set(), O = new d(), k = (e) => (D.has(e) || D.add(e), () => {
+	let w = l(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(f), _(200)), D = /* @__PURE__ */ new Set(), O = new u(), k = (e) => (D.has(e) || D.add(e), () => {
 		D.delete(e);
-	}), A = (e, n) => {
+	}), A = (e, t) => {
 		D.forEach((r) => {
 			let i = Reflect.get(r, e);
-			t(i, n);
+			n(i, t);
 		});
-	}, j = (t) => {
-		let n = e(t);
-		C.dispatchSync(l(p(n) ? "{}" : n)), O.run(f(C.state)).then((e) => {
-			(e.tableIds.length || e.tableColumnIds.length || e.relationshipIds.length || e.indexIds.length || e.indexColumnIds.length || e.memoIds.length) && (s(C.state, e), C.dispatchSync(i()));
+	}, j = (n) => {
+		let r = i(n);
+		C.dispatchSync(t(p(r) ? "{}" : r)), O.run(c(C.state)).then((t) => {
+			(t.tableIds.length || t.tableColumnIds.length || t.relationshipIds.length || t.indexIds.length || t.indexColumnIds.length || t.memoIds.length) && (s(C.state, t), C.dispatchSync(e()));
 		});
 	}, M = (e) => {
 		T.next([e].flat());
 	};
-	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(n), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
+	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(f), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
 		get value() {
-			return f(C.state);
+			return c(C.state);
 		},
 		on: k,
 		setInitialValue: j,

package/dist/engine/modules/editor/actions.d.ts

@@ -1,9 +1,9 @@
 import { Reducer } from '@dineug/r-html';
 import { EngineContext } from '../../context';
 import { RootState } from '../../state';
-import { LWW, ValuesType } from '../../../internal-types';
+import { LWW, Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
-import { FocusType, MoveKey, SelectType, SharedFocus } from './state';
+import { FocusType, MoveKey, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
 export declare const ActionType: {
     readonly changeHasHistory: "editor.changeHasHistory";
     readonly selectAll: "editor.selectAll";
@@ -43,6 +43,17 @@ export declare const ActionType: {
     readonly validationIds: "editor.validationIds";
     readonly getLWW: "editor.getLWW";
     readonly mergeLWW: "editor.mergeLWW";
+    readonly viewOpen: "editor.viewOpen";
+    readonly viewClose: "editor.viewClose";
+    readonly viewScrollTo: "editor.viewScrollTo";
+    readonly viewStreamScrollTo: "editor.viewStreamScrollTo";
+    readonly viewChangeZoomLevel: "editor.viewChangeZoomLevel";
+    readonly viewStreamZoomLevel: "editor.viewStreamZoomLevel";
+    readonly viewMoveTable: "editor.viewMoveTable";
+    readonly viewSetLayout: "editor.viewSetLayout";
+    readonly viewChangeShowMode: "editor.viewChangeShowMode";
+    readonly viewSetCenters: "editor.viewSetCenters";
+    readonly changeVisualizationMode: "editor.changeVisualizationMode";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -143,6 +154,53 @@ export type ActionMap = {
     [ActionType.mergeLWW]: {
         lww: LWW;
     };
+    [ActionType.viewOpen]: {
+        kind: ViewKind;
+        /** The tables the view opens narrowed to; none and it opens on the whole document. */
+        centerIds?: string[];
+    };
+    [ActionType.viewClose]: {
+        kind: ViewKind;
+    };
+    [ActionType.viewScrollTo]: {
+        originX: number;
+        originY: number;
+        kind?: ViewKind;
+    };
+    [ActionType.viewStreamScrollTo]: {
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    };
+    [ActionType.viewChangeZoomLevel]: {
+        value: number;
+        kind?: ViewKind;
+    };
+    [ActionType.viewStreamZoomLevel]: {
+        value: number;
+        kind?: ViewKind;
+    };
+    [ActionType.viewMoveTable]: {
+        ids: string[];
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    };
+    [ActionType.viewSetLayout]: {
+        kind: ViewKind;
+        positions: Record<string, Point>;
+    };
+    [ActionType.viewChangeShowMode]: {
+        value: ShowMode;
+        kind?: ViewKind;
+    };
+    [ActionType.viewSetCenters]: {
+        tableIds: string[];
+        kind?: ViewKind;
+    };
+    [ActionType.changeVisualizationMode]: {
+        value: VisualizationMode;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 //# sourceMappingURL=actions.d.ts.map

package/dist/engine/modules/editor/atom.actions.d.ts

@@ -309,6 +309,17 @@ export declare const mergeLWWAction: {
     type: string;
 };
 export declare const editorReducers: {
+    "editor.viewOpen": ReducerType<"editor.viewOpen">;
+    "editor.viewClose": ReducerType<"editor.viewClose">;
+    "editor.viewScrollTo": ReducerType<"editor.viewScrollTo">;
+    "editor.viewStreamScrollTo": ReducerType<"editor.viewStreamScrollTo">;
+    "editor.viewChangeZoomLevel": ReducerType<"editor.viewChangeZoomLevel">;
+    "editor.viewStreamZoomLevel": ReducerType<"editor.viewStreamZoomLevel">;
+    "editor.viewMoveTable": ReducerType<"editor.viewMoveTable">;
+    "editor.viewSetLayout": ReducerType<"editor.viewSetLayout">;
+    "editor.viewChangeShowMode": ReducerType<"editor.viewChangeShowMode">;
+    "editor.viewSetCenters": ReducerType<"editor.viewSetCenters">;
+    "editor.changeVisualizationMode": ReducerType<"editor.changeVisualizationMode">;
     "editor.changeHasHistory": ReducerType<"editor.changeHasHistory">;
     "editor.selectAll": ReducerType<"editor.selectAll">;
     "editor.unselectAll": ReducerType<"editor.unselectAll">;
@@ -349,6 +360,131 @@ export declare const editorReducers: {
     "editor.mergeLWW": ReducerType<"editor.mergeLWW">;
 };
 export declare const actions: {
+    viewOpenAction: {
+        (payload: {
+            kind: import('./state').ViewKind;
+            centerIds?: string[];
+        }): import('@dineug/r-html').AnyAction<{
+            kind: import('./state').ViewKind;
+            centerIds?: string[];
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewCloseAction: {
+        (payload: {
+            kind: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewScrollToAction: {
+        (payload: {
+            originX: number;
+            originY: number;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            originX: number;
+            originY: number;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewStreamScrollToAction: {
+        (payload: {
+            movementX: number;
+            movementY: number;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            movementX: number;
+            movementY: number;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewChangeZoomLevelAction: {
+        (payload: {
+            value: number;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: number;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewStreamZoomLevelAction: {
+        (payload: {
+            value: number;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: number;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewMoveTableAction: {
+        (payload: {
+            ids: string[];
+            movementX: number;
+            movementY: number;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            ids: string[];
+            movementX: number;
+            movementY: number;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewSetLayoutAction: {
+        (payload: {
+            kind: import('./state').ViewKind;
+            positions: Record<string, import('../../../internal-types').Point>;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: import('./state').ViewKind;
+            positions: Record<string, import('../../../internal-types').Point>;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewChangeShowModeAction: {
+        (payload: {
+            value: import('./state').ShowMode;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: import('./state').ShowMode;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewSetCentersAction: {
+        (payload: {
+            tableIds: string[];
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            tableIds: string[];
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeVisualizationModeAction: {
+        (payload: {
+            value: import('./state').VisualizationMode;
+        }): import('@dineug/r-html').AnyAction<{
+            value: import('./state').VisualizationMode;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeHasHistoryAction: {
         (payload: {
             hasUndo: boolean;

package/dist/engine/modules/editor/generator.actions.d.ts

@@ -1,11 +1,17 @@
 import { GeneratorAction } from '../../generator.actions';
 import { Point } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
+import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
 import { ClipboardPayload } from '../../../utils/table-clipboard';
 import { MoveKey } from './state';
 export declare const loadJsonAction$: (value: string) => GeneratorAction;
 export declare const initialLoadJsonAction$: (value: string) => GeneratorAction;
-export declare const moveAllAction$: (movementX: number, movementY: number) => GeneratorAction;
+/**
+ * Moves the selection by a pointer step, scaled by the zoom of the scene the
+ * drag runs in. From a view scene the step goes to that view's own placement,
+ * which holds tables alone, and the document's placement is left where it is.
+ */
+export declare const moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource) => GeneratorAction;
 export declare const removeSelectedAction$: () => GeneratorAction;
 export type DuplicateConfig = {
     tableIds?: string[];
@@ -15,7 +21,12 @@ export type DuplicateConfig = {
 };
 export declare const pasteEntitiesAction$: (payload: ClipboardPayload, pasteRound: number) => GeneratorAction;
 export declare const duplicateAction$: ({ tableIds, memoIds, offset, escapeCollision, }: DuplicateConfig) => GeneratorAction;
-export declare const dragSelectAction$: (dragRect: Rect) => GeneratorAction;
+/**
+ * Selects what the rect covers among what the source shows, each entity read
+ * at the point and the size that source draws it: a view places its tables
+ * and shows no memo, so a marquee drawn over it picks by the view, not the document.
+ */
+export declare const dragSelectAction$: (dragRect: Rect, source?: GeometrySource) => GeneratorAction;
 export declare const unselectAllAction$: () => GeneratorAction;
 export declare const focusMoveTableAction$: (moveKey: MoveKey, shiftKey: boolean) => GeneratorAction;
 export declare const drawStartRelationshipAction$: (relationshipType: number) => GeneratorAction;
@@ -30,13 +41,14 @@ export declare const dragoverColumnAction$: (targetId: string, targetTableId: st
 export declare const columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
 export declare const columnKeyHoverEndAction$: () => GeneratorAction;
 export declare const actions$: {
+    focusFlowTableAction$: (tableIds: string[]) => GeneratorAction;
     loadJsonAction$: (value: string) => GeneratorAction;
     initialLoadJsonAction$: (value: string) => GeneratorAction;
-    moveAllAction$: (movementX: number, movementY: number) => GeneratorAction;
+    moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource) => GeneratorAction;
     removeSelectedAction$: () => GeneratorAction;
     pasteEntitiesAction$: (payload: ClipboardPayload, pasteRound: number) => GeneratorAction;
     duplicateAction$: ({ tableIds, memoIds, offset, escapeCollision, }: DuplicateConfig) => GeneratorAction;
-    dragSelectAction$: (dragRect: Rect) => GeneratorAction;
+    dragSelectAction$: (dragRect: Rect, source?: GeometrySource) => GeneratorAction;
     unselectAllAction$: () => GeneratorAction;
     focusMoveTableAction$: (moveKey: MoveKey, shiftKey: boolean) => GeneratorAction;
     drawStartRelationshipAction$: (relationshipType: number) => GeneratorAction;

package/dist/engine/modules/editor/state.d.ts

@@ -36,6 +36,14 @@ export type Editor = {
     sharedSelectionTrackerMap: Record<string, SharedSelectionTracker>;
     sharedDragSelectTrackerMap: Record<string, SharedDragSelectTracker>;
     dragSelect: Rect | null;
+    /**
+     * The scene view a reader can stand in over the document: the Flow mode of
+     * the visualization tab, null while it is not open. Local to this client,
+     * never the file, the history or a peer.
+     */
+    views: EditorViews;
+    /** Which of its two modes the visualization tab shows. Remembered for the session. */
+    visualizationMode: VisualizationMode;
 };
 export type Viewport = {
     width: number;
@@ -90,6 +98,39 @@ export declare const SelectType: {
     readonly memo: "memo";
 };
 export type SelectType = ValuesType<typeof SelectType>;
+export declare const ShowMode: {
+    readonly nameOnly: "nameOnly";
+    readonly keysOnly: "keysOnly";
+    readonly allFields: "allFields";
+};
+export type ShowMode = ValuesType<typeof ShowMode>;
+export declare const ViewKind: {
+    readonly flow: "flow";
+};
+export type ViewKind = ValuesType<typeof ViewKind>;
+export declare const VisualizationMode: {
+    readonly graph: "graph";
+    readonly flow: "flow";
+};
+export type VisualizationMode = ValuesType<typeof VisualizationMode>;
+/**
+ * A scene drawn over the document in its own coordinates: the tables it places
+ * by id, the placement it is looked at through, and what it shows of each
+ * table. Memos are never placed, so a view draws none.
+ */
+export type SceneView = {
+    kind: ViewKind;
+    showMode: ShowMode;
+    positions: Record<string, Point>;
+    originX: number;
+    originY: number;
+    zoomLevel: number;
+    /** The tables the view narrows to, and none while it shows the whole document. */
+    centerIds: string[];
+};
+export type EditorViews = {
+    flow: SceneView | null;
+};
 export declare const FocusType: {
     readonly tableName: "tableName";
     readonly tableComment: "tableComment";

package/dist/engine/modules/editor/view.actions.d.ts

@@ -0,0 +1,270 @@
+import { ReducerType } from './actions';
+import { Editor, ViewKind } from './state';
+/** Drops the view, which is what any replacement of the document owes it. */
+export declare function clearViews(editor: Editor): void;
+export declare const viewOpenAction: {
+    (payload: {
+        kind: ViewKind;
+        centerIds?: string[];
+    }): import('@dineug/r-html').AnyAction<{
+        kind: ViewKind;
+        centerIds?: string[];
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewCloseAction: {
+    (payload: {
+        kind: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        kind: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewScrollToAction: {
+    (payload: {
+        originX: number;
+        originY: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        originX: number;
+        originY: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewStreamScrollToAction: {
+    (payload: {
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewChangeZoomLevelAction: {
+    (payload: {
+        value: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        value: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewStreamZoomLevelAction: {
+    (payload: {
+        value: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        value: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewMoveTableAction: {
+    (payload: {
+        ids: string[];
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        ids: string[];
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewSetLayoutAction: {
+    (payload: {
+        kind: ViewKind;
+        positions: Record<string, import('../../../internal-types').Point>;
+    }): import('@dineug/r-html').AnyAction<{
+        kind: ViewKind;
+        positions: Record<string, import('../../../internal-types').Point>;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewChangeShowModeAction: {
+    (payload: {
+        value: import('./state').ShowMode;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        value: import('./state').ShowMode;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewSetCentersAction: {
+    (payload: {
+        tableIds: string[];
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        tableIds: string[];
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeVisualizationModeAction: {
+    (payload: {
+        value: import('./state').VisualizationMode;
+    }): import('@dineug/r-html').AnyAction<{
+        value: import('./state').VisualizationMode;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewReducers: {
+    "editor.viewOpen": ReducerType<"editor.viewOpen">;
+    "editor.viewClose": ReducerType<"editor.viewClose">;
+    "editor.viewScrollTo": ReducerType<"editor.viewScrollTo">;
+    "editor.viewStreamScrollTo": ReducerType<"editor.viewStreamScrollTo">;
+    "editor.viewChangeZoomLevel": ReducerType<"editor.viewChangeZoomLevel">;
+    "editor.viewStreamZoomLevel": ReducerType<"editor.viewStreamZoomLevel">;
+    "editor.viewMoveTable": ReducerType<"editor.viewMoveTable">;
+    "editor.viewSetLayout": ReducerType<"editor.viewSetLayout">;
+    "editor.viewChangeShowMode": ReducerType<"editor.viewChangeShowMode">;
+    "editor.viewSetCenters": ReducerType<"editor.viewSetCenters">;
+    "editor.changeVisualizationMode": ReducerType<"editor.changeVisualizationMode">;
+};
+export declare const viewActions: {
+    viewOpenAction: {
+        (payload: {
+            kind: ViewKind;
+            centerIds?: string[];
+        }): import('@dineug/r-html').AnyAction<{
+            kind: ViewKind;
+            centerIds?: string[];
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewCloseAction: {
+        (payload: {
+            kind: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewScrollToAction: {
+        (payload: {
+            originX: number;
+            originY: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            originX: number;
+            originY: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewStreamScrollToAction: {
+        (payload: {
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewChangeZoomLevelAction: {
+        (payload: {
+            value: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewStreamZoomLevelAction: {
+        (payload: {
+            value: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewMoveTableAction: {
+        (payload: {
+            ids: string[];
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            ids: string[];
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewSetLayoutAction: {
+        (payload: {
+            kind: ViewKind;
+            positions: Record<string, import('../../../internal-types').Point>;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: ViewKind;
+            positions: Record<string, import('../../../internal-types').Point>;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewChangeShowModeAction: {
+        (payload: {
+            value: import('./state').ShowMode;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: import('./state').ShowMode;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewSetCentersAction: {
+        (payload: {
+            tableIds: string[];
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            tableIds: string[];
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeVisualizationModeAction: {
+        (payload: {
+            value: import('./state').VisualizationMode;
+        }): import('@dineug/r-html').AnyAction<{
+            value: import('./state').VisualizationMode;
+        }>;
+        toString(): string;
+        type: string;
+    };
+};
+//# sourceMappingURL=view.actions.d.ts.map