@dineug/erd-editor 3.10.0 → 4.0.0

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

@@ -1,4 +1,5 @@
-import { ReducerType } from './actions';
+import { Relationship } from '../../../internal-types';
+import { ActionMap, ActionType, ReducerType } from './actions';
 export declare const addRelationshipAction: {
     (payload: {
         id: string;
@@ -72,12 +73,41 @@ export declare const changeRelationshipOnUpdateAction: {
     toString(): string;
     type: string;
 };
+export declare const changeRelationshipColumnsAction: {
+    (payload: {
+        id: string;
+        start: {
+            tableId: string;
+            columnIds: string[];
+        };
+        end: {
+            tableId: string;
+            columnIds: string[];
+        };
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        start: {
+            tableId: string;
+            columnIds: string[];
+        };
+        end: {
+            tableId: string;
+            columnIds: string[];
+        };
+    }>;
+    toString(): string;
+    type: string;
+};
+type ColumnsPayload = ActionMap[typeof ActionType.changeRelationshipColumns];
+/** Whether the payload names other tables than the relationship's, which the reducer ignores. */
+export declare const namesOtherTables: (relationship: Relationship, { start, end }: Pick<ColumnsPayload, "start" | "end">) => boolean;
 export declare const relationshipReducers: {
     "relationship.add": ReducerType<"relationship.add">;
     "relationship.remove": ReducerType<"relationship.remove">;
     "relationship.changeType": ReducerType<"relationship.changeType">;
     "relationship.changeOnDelete": ReducerType<"relationship.changeOnDelete">;
     "relationship.changeOnUpdate": ReducerType<"relationship.changeOnUpdate">;
+    "relationship.changeColumns": ReducerType<"relationship.changeColumns">;
 };
 export declare const actions: {
     addRelationshipAction: {
@@ -153,5 +183,31 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeRelationshipColumnsAction: {
+        (payload: {
+            id: string;
+            start: {
+                tableId: string;
+                columnIds: string[];
+            };
+            end: {
+                tableId: string;
+                columnIds: string[];
+            };
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            start: {
+                tableId: string;
+                columnIds: string[];
+            };
+            end: {
+                tableId: string;
+                columnIds: string[];
+            };
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
+export {};
 //# sourceMappingURL=atom.actions.d.ts.map

package/dist/engine/modules/relationship/endFlags.d.ts

@@ -0,0 +1,14 @@
+import { RootState } from '../../state';
+/**
+ * Marks each relationship identifying when every column it ends on is a primary
+ * key, and not identifying, as a new one starts, once none of them is left or
+ * it is removed, so the value follows the document whatever order actions arrive in.
+ */
+export declare function recalculateIdentification(state: RootState): void;
+/**
+ * Starts each relationship dashed when every column it ends on is not null and
+ * ringed otherwise, read off the columns as the identification is; one with no
+ * end column left is dashed, as a new one starts.
+ */
+export declare function recalculateStartRelationshipType(state: RootState): void;
+//# sourceMappingURL=endFlags.d.ts.map

package/dist/engine/modules/relationship/fkColumns.d.ts

@@ -1,16 +1,35 @@
 import { AnyAction } from '@dineug/r-html';
-import { Column } from '../../../internal-types';
-/** The start table's name and the names the end table's columns hold. */
-export type ForeignKeyNaming = {
+import { RootState } from '../../state';
+import { Column, Table } from '../../../internal-types';
+/**
+ * The start table's name and the names the end table's columns hold, which
+ * name the copies, and the document's database, which types a serial key's copy.
+ */
+export type ForeignKeyContext = {
     startTableName: string;
     endColumnNames: string[];
+    database: number;
 };
+/**
+ * The columns a relationship drawn from a table copies into the table it ends
+ * on, the start table's primary key in column order, which a press on a table
+ * and the + button beside it both read.
+ */
+export declare const getStartKeyColumns: (collections: RootState["collections"], startTable: Table) => Column[];
+/** A name as two names compare: trimmed, without case. */
+export declare const toNameKey: (name: string) => string;
 /**
  * Tells a name of one word, id, ID, Id, UUID, id2 or 회원번호, from one of
  * several, user_id, userId, UserID, IDCard or 회원ID: one word is letters and
  * digits with none of the breaks CASE_BOUNDARY finds, read past marks and digits.
  */
 export declare const isSingleWord: (name: string) => boolean;
+/**
+ * Joins the table name and the key name with an underscore when the key name
+ * is a single word other than the table name, compared without case; a blank
+ * table name, or a key name of several words, leaves the key name alone.
+ */
+export declare function prefixKeyName(tableName: string, keyName: string): string;
 /**
  * Names the foreign key column of each single word key after the start table,
  * user_id for the key id of user, keeps other key names, and numbers a name
@@ -19,8 +38,8 @@ export declare const isSingleWord: (name: string) => boolean;
 export declare function toForeignKeyNames(startTableName: string, keyNames: string[], endColumnNames: string[]): string[];
 /**
  * Adds a NOT NULL copy of each start column to the end table under the id at
- * the same index of endColumnIds, named by toForeignKeyNames, carrying its data
- * type, default and comment. The caller owns the ids the relationship needs.
+ * the same index of endColumnIds, named by toForeignKeyNames, typed by
+ * toReferenceDataType, with its default and comment. The caller owns the ids.
  */
-export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[], { startTableName, endColumnNames }: ForeignKeyNaming) => AnyAction[];
+export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[], { startTableName, endColumnNames, database }: ForeignKeyContext) => AnyAction[];
 //# sourceMappingURL=fkColumns.d.ts.map

package/dist/engine/modules/relationship/history.d.ts

@@ -5,5 +5,6 @@ export declare const relationshipPushUndoHistoryMap: {
     "relationship.changeType": PushUndoHistory;
     "relationship.changeOnDelete": PushUndoHistory;
     "relationship.changeOnUpdate": PushUndoHistory;
+    "relationship.changeColumns": PushUndoHistory;
 };
 //# sourceMappingURL=history.d.ts.map

package/dist/engine/modules/relationship/hooks.d.ts

@@ -1,14 +1,3 @@
 import { Hook } from '../../hooks';
-import { RootState } from '../../state';
-/**
- * Marks each relationship identifying when every column it ends on is a primary
- * key. A load reads it off the columns again, as a key edit or a removal does.
- */
-export declare function recalculateIdentification({ doc, collections }: RootState): void;
-/**
- * Starts each relationship dashed when every column it ends on is not null and
- * ringed otherwise, read off the columns as the identification is.
- */
-export declare function recalculateStartRelationshipType({ doc, collections, }: RootState): void;
 export declare const hooks: Hook[];
 //# sourceMappingURL=hooks.d.ts.map

package/dist/engine/modules/relationship/referenceType.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tells a serial type, serial or one of PostgreSQL's own, by its whole name
+ * without case once trimmed, whatever the database; serial(4) is none.
+ */
+export declare function isSerialType(dataType: string): boolean;
+/**
+ * The data type a foreign key takes from its key: the integer a serial key
+ * stores, in capitals when the key's type is written in capitals, and any other
+ * type as it is, a bare serial kept where the database has none.
+ */
+export declare function toReferenceDataType(dataType: string, database: number): string;
+//# sourceMappingURL=referenceType.d.ts.map

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

@@ -1,4 +1,5 @@
 import { Reducer } from '@dineug/r-html';
+import { DDLScriptPosition } from '../../../constants/schema';
 import { EngineContext } from '../../context';
 import { RootState } from '../../state';
 import { ValuesType } from '../../../internal-types';
@@ -16,10 +17,11 @@ export declare const ActionType: {
     readonly changeColumnNameCase: "settings.changeColumnNameCase";
     readonly changeBracketType: "settings.changeBracketType";
     readonly changeRelationshipDataTypeSync: "settings.changeRelationshipDataTypeSync";
-    readonly changeRelationshipOptimization: "settings.changeRelationshipOptimization";
     readonly changeColumnOrder: "settings.changeColumnOrder";
     readonly changeMaxWidthComment: "settings.changeMaxWidthComment";
+    readonly changeLockSettings: "settings.changeLockSettings";
     readonly changeIgnoreSaveSettings: "settings.changeIgnoreSaveSettings";
+    readonly changeDDLScript: "settings.changeDDLScript";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -65,9 +67,6 @@ export type ActionMap = {
     [ActionType.changeRelationshipDataTypeSync]: {
         value: boolean;
     };
-    [ActionType.changeRelationshipOptimization]: {
-        value: boolean;
-    };
     [ActionType.changeColumnOrder]: {
         value: number;
         target: number;
@@ -75,10 +74,24 @@ export type ActionMap = {
     [ActionType.changeMaxWidthComment]: {
         value: number;
     };
+    [ActionType.changeLockSettings]: {
+        lockSettingType: number;
+        value: boolean;
+        /**
+         * The settings named as the sending store shows them: a lock holds them,
+         * and an unlock shows the code settings among them on every peer, so each
+         * saves one value. The viewport and the tab carry none to unlock.
+         */
+        values: Partial<RootState['settings']['lockedValues']>;
+    };
     [ActionType.changeIgnoreSaveSettings]: {
         saveSettingType: number;
         value: boolean;
     };
+    [ActionType.changeDDLScript]: {
+        position: ValuesType<typeof DDLScriptPosition>;
+        value: string;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 //# sourceMappingURL=actions.d.ts.map

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

@@ -118,6 +118,8 @@ export declare const changeDatabaseAction: {
     toString(): string;
     type: string;
 };
+/** The tab the reader stands on, which a canvas type lock taken on Settings holds. */
+export declare function rememberCanvasType({ settings, editor }: RootState): void;
 export declare const changeCanvasTypeAction: {
     (payload: {
         value: string;
@@ -172,15 +174,6 @@ export declare const changeRelationshipDataTypeSyncAction: {
     toString(): string;
     type: string;
 };
-export declare const changeRelationshipOptimizationAction: {
-    (payload: {
-        value: boolean;
-    }): import('@dineug/r-html').AnyAction<{
-        value: boolean;
-    }>;
-    toString(): string;
-    type: string;
-};
 export declare const changeColumnOrderAction: {
     (payload: {
         value: number;
@@ -201,6 +194,24 @@ export declare const changeMaxWidthCommentAction: {
     toString(): string;
     type: string;
 };
+export declare const changeLockSettingsAction: {
+    (payload: {
+        lockSettingType: number;
+        value: boolean;
+        values: Partial<RootState["settings"]["lockedValues"]>;
+    }): import('@dineug/r-html').AnyAction<{
+        lockSettingType: number;
+        value: boolean;
+        values: Partial<RootState["settings"]["lockedValues"]>;
+    }>;
+    toString(): string;
+    type: string;
+};
+/**
+ * The locks of the settings every peer shows one screen of, their setters
+ * never following-tagged, so an unlock of one carries the unlocker's value.
+ */
+export declare const CodeLockSettings: number;
 export declare const changeIgnoreSaveSettingsAction: {
     (payload: {
         saveSettingType: number;
@@ -212,6 +223,23 @@ export declare const changeIgnoreSaveSettingsAction: {
     toString(): string;
     type: string;
 };
+export declare const changeDDLScriptAction: {
+    (payload: {
+        position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+        value: string;
+    }): import('@dineug/r-html').AnyAction<{
+        position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+        value: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+/**
+ * Lands the settings of a load that replaces the document: each lock through
+ * its register, a bit no lock owns taken from the load as show is, and each
+ * setting locked once it lands but the view keeping the screen.
+ */
+export declare function landLoadedSettings({ settings, lww }: RootState, loaded: RootState['settings'], version: number): void;
 export declare const settingsReducers: {
     "settings.changeDatabaseName": ReducerType<"settings.changeDatabaseName">;
     "settings.changeZoomLevel": ReducerType<"settings.changeZoomLevel">;
@@ -226,10 +254,11 @@ export declare const settingsReducers: {
     "settings.changeColumnNameCase": ReducerType<"settings.changeColumnNameCase">;
     "settings.changeBracketType": ReducerType<"settings.changeBracketType">;
     "settings.changeRelationshipDataTypeSync": ReducerType<"settings.changeRelationshipDataTypeSync">;
-    "settings.changeRelationshipOptimization": ReducerType<"settings.changeRelationshipOptimization">;
     "settings.changeColumnOrder": ReducerType<"settings.changeColumnOrder">;
     "settings.changeMaxWidthComment": ReducerType<"settings.changeMaxWidthComment">;
+    "settings.changeLockSettings": ReducerType<"settings.changeLockSettings">;
     "settings.changeIgnoreSaveSettings": ReducerType<"settings.changeIgnoreSaveSettings">;
+    "settings.changeDDLScript": ReducerType<"settings.changeDDLScript">;
 };
 export declare const actions: {
     changeDatabaseNameAction: {
@@ -355,15 +384,6 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
-    changeRelationshipOptimizationAction: {
-        (payload: {
-            value: boolean;
-        }): import('@dineug/r-html').AnyAction<{
-            value: boolean;
-        }>;
-        toString(): string;
-        type: string;
-    };
     changeColumnOrderAction: {
         (payload: {
             value: number;
@@ -384,6 +404,19 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeLockSettingsAction: {
+        (payload: {
+            lockSettingType: number;
+            value: boolean;
+            values: Partial<RootState["settings"]["lockedValues"]>;
+        }): import('@dineug/r-html').AnyAction<{
+            lockSettingType: number;
+            value: boolean;
+            values: Partial<RootState["settings"]["lockedValues"]>;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeIgnoreSaveSettingsAction: {
         (payload: {
             saveSettingType: number;
@@ -395,5 +428,16 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeDDLScriptAction: {
+        (payload: {
+            position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+            value: string;
+        }): import('@dineug/r-html').AnyAction<{
+            position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+            value: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
 //# sourceMappingURL=atom.actions.d.ts.map

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

@@ -18,8 +18,15 @@ export type PinchZoom = {
  * pan as it travels. Streamed, so a whole pinch is one undo entry as a wheel is.
  */
 export declare const pinchZoomAction$: ({ zoomLevel, screen, scene }: PinchZoom, source?: GeometrySource) => GeneratorAction;
+/**
+ * Locks the settings named at what they hold now, or unlocks them carrying the
+ * code settings among them as they show here. A canvas type locked on the
+ * Settings tab holds the tab the reader came from.
+ */
+export declare const changeLockSettingsAction$: (lockSettingType: number, value: boolean) => GeneratorAction;
 export declare const actions$: {
     changeZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
     streamZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
+    changeLockSettingsAction$: (lockSettingType: number, value: boolean) => GeneratorAction;
 };
 //# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/modules/settings/history.d.ts

@@ -3,6 +3,7 @@ export declare const settingsPushUndoHistoryMap: {
     "settings.scrollTo": PushUndoHistory;
     "settings.changeShow": PushUndoHistory;
     "settings.changeZoomLevel": PushUndoHistory;
+    "settings.changeDDLScript": PushUndoHistory;
 };
 export declare const settingsPushStreamHistoryMap: {
     "settings.streamScrollTo": PushStreamHistory;

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

@@ -10,6 +10,7 @@ export declare const ActionType: {
     readonly changeTableName: "table.changeName";
     readonly changeTableComment: "table.changeComment";
     readonly changeTableColor: "table.changeColor";
+    readonly changeTableGroup: "table.changeGroup";
     readonly changeZIndex: "table.changeZIndex";
     readonly sortTable: "table.sort";
 };
@@ -44,6 +45,13 @@ export type ActionMap = {
         color: string;
         prevColor: string;
     };
+    [ActionType.changeTableGroup]: ChangeTableValuePayload & {
+        /**
+         * The groupId the table held, sent by a drop alone: its undo is written as
+         * the drag it ends closes, after the reducer has run, so it cannot read it.
+         */
+        prevValue?: string;
+    };
     [ActionType.changeZIndex]: {
         id: string;
         zIndex: number;

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

@@ -90,6 +90,21 @@ export declare const changeTableColorAction: {
     toString(): string;
     type: string;
 };
+export declare const changeTableGroupAction: {
+    (payload: {
+        id: string;
+        value: string;
+    } & {
+        prevValue?: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        value: string;
+    } & {
+        prevValue?: string;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const changeZIndexAction: {
     (payload: {
         id: string;
@@ -114,6 +129,7 @@ export declare const tableReducers: {
     "table.changeName": ReducerType<"table.changeName">;
     "table.changeComment": ReducerType<"table.changeComment">;
     "table.changeColor": ReducerType<"table.changeColor">;
+    "table.changeGroup": ReducerType<"table.changeGroup">;
     "table.changeZIndex": ReducerType<"table.changeZIndex">;
     "table.sort": ReducerType<"table.sort">;
 };
@@ -209,6 +225,21 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeTableGroupAction: {
+        (payload: {
+            id: string;
+            value: string;
+        } & {
+            prevValue?: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            value: string;
+        } & {
+            prevValue?: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeZIndexAction: {
         (payload: {
             id: string;

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

@@ -5,9 +5,9 @@ export declare const removeTableAction$: (id?: string) => GeneratorAction;
 export declare const selectTableAction$: (id: string, $mod: boolean) => GeneratorAction;
 export declare const pasteTableAction$: (columns: Column[]) => GeneratorAction;
 /**
- * Runs the engine's sort once, on copies of the live tables, and places each
- * table at the point it found. A replayed table.sort measures each replica's
- * own text, so only the placed points come out the same everywhere.
+ * Runs the engine's sort on copies of the live tables and groups, then places
+ * each table and each group with members where it found them. A replayed
+ * table.sort measures each replica's own text; placed points agree everywhere.
  */
 export declare const sortTablesToMoveAction$: () => GeneratorAction;
 export declare const actions$: {

package/dist/engine/modules/table/history.d.ts

@@ -4,6 +4,7 @@ export declare const tablePushUndoHistoryMap: {
     "table.remove": PushUndoHistory;
     "table.changeName": PushUndoHistory;
     "table.changeComment": PushUndoHistory;
+    "table.changeGroup": PushUndoHistory;
     "table.moveTo": PushUndoHistory;
     "table.sort": PushUndoHistory;
 };

package/dist/engine/modules/table-column/generator.actions.d.ts

@@ -8,6 +8,13 @@ export declare const removeColumnAction$: (tableId: string, columnIds: string[])
 export declare const toggleColumnValueAction$: (focusType: FocusType, tableId: string, columnId: string) => GeneratorAction;
 export declare const changeColumnDataTypeAction$: (payload: ChangeColumnValuePayload) => GeneratorAction;
 export declare const changeColumnValueAction$: (focusType: FocusType, tableId: string, columnId: string, value: string) => GeneratorAction;
+/**
+ * Makes every named column still in the table a primary key, or none once all
+ * are, and no other; it sends no relationship action, and none for a column
+ * already there, as its undo records the negation.
+ */
+export declare const changeColumnsPrimaryKeyAction$: (tableId: string, columnIds: string[]) => GeneratorAction;
+/** Toggles one column's primary key, the rule above over a single column. */
 export declare const changeColumnPrimaryKeyAction$: (tableId: string, columnId: string) => GeneratorAction;
 export declare const actions$: {
     addColumnAction$: (tableId?: string) => GeneratorAction;
@@ -16,5 +23,6 @@ export declare const actions$: {
     changeColumnDataTypeAction$: (payload: ChangeColumnValuePayload) => GeneratorAction;
     changeColumnValueAction$: (focusType: FocusType, tableId: string, columnId: string, value: string) => GeneratorAction;
     changeColumnPrimaryKeyAction$: (tableId: string, columnId: string) => GeneratorAction;
+    changeColumnsPrimaryKeyAction$: (tableId: string, columnIds: string[]) => GeneratorAction;
 };
 //# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/modules/table-column/hooks.d.ts

@@ -1,9 +1,3 @@
 import { Hook } from '../../hooks';
-import { RootState } from '../../state';
-/**
- * Marks as a foreign key every column a relationship ends on, and only those,
- * as a load leaves the marks to be read off the relationships again.
- */
-export declare function validateForeignKeys({ doc, collections }: RootState): void;
 export declare const hooks: Hook[];
 //# sourceMappingURL=hooks.d.ts.map

package/dist/engine/modules/table-column/keys.d.ts

@@ -0,0 +1,14 @@
+import { RootState } from '../../state';
+/**
+ * Sets every column's primary key mark from its primary key option, the one
+ * place the editor changes both, so a file that saves no mark shows the key.
+ * The foreign key mark is left to validateForeignKeys.
+ */
+export declare function syncPrimaryKeys({ collections }: RootState): void;
+/**
+ * Marks as a foreign key every column of a table in the document that a
+ * relationship in the document ends on in that table, and clears every other
+ * one, a removed column's too, so a file's bits never hang on arrival order.
+ */
+export declare function validateForeignKeys({ doc, collections }: RootState): void;
+//# sourceMappingURL=keys.d.ts.map

package/dist/engine/modules/table-column/utils/dataType.d.ts

@@ -1,4 +1,22 @@
 import { ChangeColumnValuePayload } from '../actions';
 import { RootState } from '../../../state';
-export declare function getDataTypeSyncColumns(stack: ChangeColumnValuePayload[], state: RootState, payload: ChangeColumnValuePayload, payloads?: ChangeColumnValuePayload[]): ChangeColumnValuePayload[];
+type DataTypeSyncEnd = {
+    tableId: string;
+    columnIds: string[];
+};
+/** The two ends of a relationship, all the data type sync reads of one. */
+export type DataTypeSyncRelationship = {
+    start: DataTypeSyncEnd;
+    end: DataTypeSyncEnd;
+};
+/**
+ * Drains the stack, listing each column its relationships reach once: a key
+ * sends its foreign keys toReferenceDataType of its value, a foreign key sends
+ * its key its value, unless the key is serial, which keeps it and stops there.
+ *
+ * @param relationships The relationships to follow, the document's by default;
+ * a caller about to change one hands the list as it will stand.
+ */
+export declare function getDataTypeSyncColumns(stack: ChangeColumnValuePayload[], state: RootState, payloads?: ChangeColumnValuePayload[], relationships?: DataTypeSyncRelationship[]): ChangeColumnValuePayload[];
+export {};
 //# sourceMappingURL=dataType.d.ts.map

package/dist/engine/modules/table-group/actions.d.ts

@@ -0,0 +1,63 @@
+import { Reducer } from '@dineug/r-html';
+import { EngineContext } from '../../context';
+import { RootState } from '../../state';
+import { ValuesType } from '../../../internal-types';
+export declare const ActionType: {
+    readonly addTableGroup: "tableGroup.add";
+    readonly moveTableGroup: "tableGroup.move";
+    readonly moveToTableGroup: "tableGroup.moveTo";
+    readonly removeTableGroup: "tableGroup.remove";
+    readonly resizeTableGroup: "tableGroup.resize";
+    readonly changeTableGroupName: "tableGroup.changeName";
+    readonly changeTableGroupColor: "tableGroup.changeColor";
+    readonly changeTableGroupZIndex: "tableGroup.changeZIndex";
+};
+export type ActionType = ValuesType<typeof ActionType>;
+export type ActionMap = {
+    [ActionType.addTableGroup]: {
+        id: string;
+        color?: string;
+        ui: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            zIndex: number;
+        };
+    };
+    [ActionType.moveTableGroup]: {
+        movementX: number;
+        movementY: number;
+        ids: string[];
+    };
+    [ActionType.moveToTableGroup]: {
+        id: string;
+        x: number;
+        y: number;
+    };
+    [ActionType.removeTableGroup]: {
+        id: string;
+    };
+    [ActionType.resizeTableGroup]: {
+        id: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    [ActionType.changeTableGroupName]: {
+        id: string;
+        value: string;
+    };
+    [ActionType.changeTableGroupColor]: {
+        id: string;
+        color: string;
+        prevColor: string;
+    };
+    [ActionType.changeTableGroupZIndex]: {
+        id: string;
+        zIndex: number;
+    };
+};
+export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
+//# sourceMappingURL=actions.d.ts.map