@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/tabdocs/document-opening-event-args.d.ts

@@ -0,0 +1,13 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A document is about to open; `group` and `index` may be changed, `cancel = true` keeps it closed. */
+export interface DocumentOpeningEventArgs extends EventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    index: number;
+    active: boolean;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-showing-event-args.d.ts

@@ -0,0 +1,19 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDockSide } from './tab-dock-side';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/**
+ * A hidden document is about to be shown again; `cancel = true` keeps it hidden. `group` and
+ * `index` may be changed.
+ */
+export interface DocumentShowingEventArgs extends EventArgs {
+    document: TabDocument;
+    /** The group it goes into; `null` when a dock area (`side`) or a floating window is made for it. */
+    group: TabGroup | null;
+    /** The dock area it goes into, `null` elsewhere. */
+    side: TabDockSide | null;
+    index: number;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-shown-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A hidden document is in a group again. */
+export interface DocumentShownEventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    index: number;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/group-locked-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A group was locked or unlocked. */
+export interface GroupLockedEventArgs {
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/group-locking-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A group is about to be locked or unlocked; `cancel = true` leaves it as it is. */
+export interface GroupLockingEventArgs extends EventArgs {
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/group-split-event-args.d.ts

@@ -0,0 +1,15 @@
+import type { SplitDirection } from './split-direction';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+export interface GroupSplitEventArgs {
+    /** The group split; `null` when the new group went along an edge of the whole layout. */
+    group: TabGroup | null;
+    newGroup: TabGroup;
+    direction: SplitDirection;
+    document: TabDocument | null;
+    /** The copy of `document` opened in the new group, when it was copied. */
+    copy: TabDocument | null;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/group-splitting-event-args.d.ts

@@ -0,0 +1,17 @@
+import type { EventArgs } from '@motifx/core';
+import type { SplitDirection } from './split-direction';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A group is about to be split (or the whole layout, along an edge); `cancel = true` keeps the layout. */
+export interface GroupSplittingEventArgs extends EventArgs {
+    /** The group split; `null` when the new group goes along an edge of the whole layout. */
+    group: TabGroup | null;
+    direction: SplitDirection;
+    /** The document that goes into the new group, if any. */
+    document: TabDocument | null;
+    /** The document is copied into the new group (`splitCopies`), not moved. */
+    copy: boolean;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/index.d.ts

@@ -0,0 +1,102 @@
+export { TabDocumentManager } from './TabDocumentManager';
+export { TabDocument } from './TabDocument';
+export { TabGroup } from './TabGroup';
+export { TabWindow } from './TabWindow';
+export { TabDockArea } from './TabDockArea';
+export { TabBarSettings } from './TabBarSettings';
+export { TabBrowserWindow } from './TabBrowserWindow';
+export type { TabDocumentManagerProps } from './tab-document-manager-props';
+export type { TabDocumentOptions } from './tab-document-options';
+export type { TabDocumentContent } from './tab-document-content';
+export type { TabContentFactory } from './tab-content-factory';
+export type { TabDocumentKeys } from './tab-document-keys';
+export type { TabOpenOptions } from './tab-open-options';
+export type { TabShowOptions } from './tab-show-options';
+export type { TabOpenPosition } from './tab-open-position';
+export type { TabAfterClose } from './tab-after-close';
+export type { TabCloseButton } from './tab-close-button';
+export type { ContentLifetime } from './content-lifetime';
+export type { SplitDirection } from './split-direction';
+export type { TabLayout } from './tab-layout';
+export type { TabLayoutNode } from './tab-layout-node';
+export type { TabLayoutSplit } from './tab-layout-split';
+export type { TabLayoutGroup } from './tab-layout-group';
+export type { TabLayoutDocument } from './tab-layout-document';
+export type { TabLayoutFactory } from './tab-layout-factory';
+export type { TabLayoutChange } from './tab-layout-change';
+export type { DocumentOpeningEventArgs } from './document-opening-event-args';
+export type { DocumentOpenedEventArgs } from './document-opened-event-args';
+export type { DocumentClosingEventArgs } from './document-closing-event-args';
+export type { DocumentClosedEventArgs } from './document-closed-event-args';
+export type { DocumentActivatingEventArgs } from './document-activating-event-args';
+export type { DocumentActivatedEventArgs } from './document-activated-event-args';
+export type { DocumentMovingEventArgs } from './document-moving-event-args';
+export type { DocumentMovedEventArgs } from './document-moved-event-args';
+export type { GroupSplittingEventArgs } from './group-splitting-event-args';
+export type { GroupSplitEventArgs } from './group-split-event-args';
+export type { LayoutChangingEventArgs } from './layout-changing-event-args';
+export type { LayoutChangedEventArgs } from './layout-changed-event-args';
+export type { TabTone } from './tab-tone';
+export type { TabSize } from './tab-size';
+export type { TabBarButton } from './tab-bar-button';
+export type { TabBarButtonSize } from './tab-bar-button-size';
+export type { TabLayoutBar } from './tab-layout-bar';
+export type { PinnedTabSize } from './pinned-tab-size';
+export type { TabShowDescription } from './tab-show-description';
+export type { TabListScope } from './tab-list-scope';
+export type { TabKeyPreset } from './tab-key-preset';
+export type { TabMenuCommand } from './tab-menu-command';
+export type { TabNewDocument } from './tab-new-document';
+export type { TabToolbarItems } from './tab-toolbar-items';
+export type { TabContentClone } from './tab-content-clone';
+export type { DocumentChangingEventArgs } from './document-changing-event-args';
+export type { DocumentChangedEventArgs } from './document-changed-event-args';
+export type { DocumentShowingEventArgs } from './document-showing-event-args';
+export type { DocumentShownEventArgs } from './document-shown-event-args';
+export type { GroupLockingEventArgs } from './group-locking-event-args';
+export type { GroupLockedEventArgs } from './group-locked-event-args';
+export type { TabContextMenuEventArgs } from './tab-context-menu-event-args';
+export type { TabDropSide } from './tab-drop-side';
+export type { TabDropTargetKind } from './tab-drop-target-kind';
+export type { TabDropPlace } from './tab-drop-place';
+export type { TabDropTarget } from './tab-drop-target';
+export type { TabDropMarks } from './tab-drop-marks';
+export type { TabDragSubject } from './tab-drag-subject';
+export type { TabCopyModifier } from './tab-copy-modifier';
+export type { TabDragStartingEventArgs } from './tab-drag-starting-event-args';
+export type { TabDropEventArgs } from './tab-drop-event-args';
+export type { TabDroppedEventArgs } from './tab-dropped-event-args';
+export type { TabDragEndedEventArgs } from './tab-drag-ended-event-args';
+export type { TabDockSide } from './tab-dock-side';
+export type { TabDockGuideKind } from './tab-dock-guide-kind';
+export type { TabRect } from './tab-rect';
+export type { TabLayoutArea } from './tab-layout-area';
+export type { TabLayoutWindow } from './tab-layout-window';
+export type { TabFloatingEventArgs } from './tab-floating-event-args';
+export type { TabFloatedEventArgs } from './tab-floated-event-args';
+export type { TabDockingEventArgs } from './tab-docking-event-args';
+export type { TabDockedEventArgs } from './tab-docked-event-args';
+export type { TabAutoHidingEventArgs } from './tab-auto-hiding-event-args';
+export type { TabAutoHiddenEventArgs } from './tab-auto-hidden-event-args';
+export type { TabSlideEventArgs } from './tab-slide-event-args';
+export type { TabWindowClosingEventArgs } from './tab-window-closing-event-args';
+export type { TabWindowClosedEventArgs } from './tab-window-closed-event-args';
+export type { TabWindowOpeningEventArgs } from './tab-window-opening-event-args';
+export type { TabWindowOpenedEventArgs } from './tab-window-opened-event-args';
+export type { TabErrorEventArgs } from './tab-error-event-args';
+export type { TabNewWindowOptions } from './tab-new-window-options';
+export type { TabNewWindowFallback } from './tab-new-window-fallback';
+export type { TabNewWindowCloseAction } from './tab-new-window-close-action';
+export type { TabNewWindowTitle } from './tab-new-window-title';
+export type { TabOpenWindow } from './tab-open-window';
+export type { TabWindowRequest } from './tab-window-request';
+export type { TabRestoreWindows } from './tab-restore-windows';
+export type { TabLayoutBrowserWindow } from './tab-layout-browser-window';
+export type { TabLayoutHidden } from './tab-layout-hidden';
+export type { TabPresentation } from './tab-presentation';
+export type { TabPresentationKind } from './tab-presentation-kind';
+export type { TabDockPresentation } from './tab-dock-presentation';
+export type { PresentationChangingEventArgs } from './presentation-changing-event-args';
+export type { PresentationChangedEventArgs } from './presentation-changed-event-args';
+export type { TabTabletWhen } from './tab-tablet-when';
+export type { TabNarrowBars } from './tab-narrow-bars';

package/dist/components/tabdocs/keep-scroll.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs `move`, which takes `root` out of the page and puts it in again, and gives every scrolled
+ * element under it its scroll back: a browser forgets the scroll of a node moved that way. Core's
+ * `Transporter` moves with `appendChild` (CORE-REPORTS R29); browsers without `moveBefore` too.
+ */
+export declare function keepScroll<T>(root: Element, move: () => T): T;

package/dist/components/tabdocs/layout-changed-event-args.d.ts

@@ -0,0 +1,17 @@
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabDockArea } from './TabDockArea';
+import type { TabGroup } from './TabGroup';
+import type { TabLayoutChange } from './tab-layout-change';
+import type { TabWindow } from './TabWindow';
+/** The layout changed: groups were added, closed, resized, maximized or restored. */
+export interface LayoutChangedEventArgs {
+    change: TabLayoutChange;
+    group: TabGroup | null;
+    /** The floating window or the new browser window it is about, if one. */
+    window?: TabWindow | TabBrowserWindow | null;
+    /** The dock area it is about, if one. */
+    area?: TabDockArea | null;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/layout-changing-event-args.d.ts

@@ -0,0 +1,19 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabDockArea } from './TabDockArea';
+import type { TabGroup } from './TabGroup';
+import type { TabLayoutChange } from './tab-layout-change';
+import type { TabWindow } from './TabWindow';
+/** The layout is about to change (a group closed, resized, maximized…); `cancel = true` keeps it. */
+export interface LayoutChangingEventArgs extends EventArgs {
+    change: TabLayoutChange;
+    /** The group it is about, if one. */
+    group: TabGroup | null;
+    /** The floating window or the new browser window it is about, if one. */
+    window?: TabWindow | TabBrowserWindow | null;
+    /** The dock area it is about, if one. */
+    area?: TabDockArea | null;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/layout-item.d.ts

@@ -0,0 +1,4 @@
+import type { TabGroup } from './TabGroup';
+import type { TabSplit } from './TabSplit';
+/** A node of the layout tree: a split, or a group (the leaves). */
+export type LayoutItem = TabSplit | TabGroup;

package/dist/components/tabdocs/pinned-tab-size.d.ts

@@ -0,0 +1,2 @@
+/** How wide pinned tabs are: like the others, only the icon (or the first letter), or shrunk to a short width. */
+export type PinnedTabSize = 'normal' | 'compact' | 'shrink';

package/dist/components/tabdocs/place-node.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Puts `node` into `parent` before `before`. A node already on the page is moved with
+ * `moveBefore` where the browser has it, so what is inside keeps its state (scroll, focus, frames);
+ * elsewhere what scrolled inside it scrolls back.
+ */
+export declare function placeNode(parent: Element, node: Element, before: Node | null): void;

package/dist/components/tabdocs/presentation-changed-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabPresentationKind } from './tab-presentation-kind';
+export interface PresentationChangedEventArgs {
+    from: TabPresentationKind;
+    to: TabPresentationKind;
+    width: number;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/presentation-changing-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabPresentationKind } from './tab-presentation-kind';
+/** The manager is about to show its layout another way; `cancel = true` keeps the way it is (until the width or the setting changes again). */
+export interface PresentationChangingEventArgs extends EventArgs {
+    from: TabPresentationKind;
+    to: TabPresentationKind;
+    /** The manager's width, in pixels. */
+    width: number;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/sash-owner.d.ts

@@ -0,0 +1,15 @@
+import type { LayoutOrientation } from '../layout/layout-orientation';
+import type { SplitSash } from './SplitSash';
+/** What a splitter resizes: a split's neighbours, or a dock area against the documents. */
+export interface SashOwner {
+    /** `horizontal`: side by side, the splitter moves along the line. */
+    readonly orientation: LayoutOrientation;
+    readonly rtl: boolean;
+    /** The shares (a split) or the pixels (a dock area) a drag starts from. */
+    sizes: number[];
+    sashIndex(sash: SplitSash): number;
+    /** Moves the splitter after child `index` by `delta` pixels, in the reading direction. */
+    resizeBy(index: number, delta: number): boolean;
+    /** A double click on the splitter. */
+    resetSizes(): void;
+}

package/dist/components/tabdocs/screen-offsets.d.ts

@@ -0,0 +1,9 @@
+/** Notes where `view`'s viewport is, from one of its pointer events. */
+export declare function noteOffset(view: Window, e: MouseEvent): void;
+/** Where `view`'s viewport starts on the screen: as last noted, else guessed from the window's frame. */
+export declare function offsetOf(view: Window): {
+    x: number;
+    y: number;
+};
+/** Whether a point of `view`'s viewport is inside it. */
+export declare function inViewport(view: Window, x: number, y: number): boolean;

package/dist/components/tabdocs/split-direction.d.ts

@@ -0,0 +1,2 @@
+/** The side of a group a new group opens on. */
+export type SplitDirection = 'left' | 'right' | 'up' | 'down';

package/dist/components/tabdocs/tab-after-close.d.ts

@@ -0,0 +1,2 @@
+/** Which tab becomes active when the active one closes: the one used last, or its neighbour on the left or right. */
+export type TabAfterClose = 'recent' | 'left' | 'right';

package/dist/components/tabdocs/tab-auto-hidden-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { TabDockArea } from './TabDockArea';
+import type { TabDocumentManager } from './TabDocumentManager';
+/** A dock area folded to its edge (`on`), or came back. */
+export interface TabAutoHiddenEventArgs {
+    area: TabDockArea;
+    on: boolean;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-auto-hiding-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDockArea } from './TabDockArea';
+import type { TabDocumentManager } from './TabDocumentManager';
+/** A dock area is about to fold to its edge (`on`) or come back; `cancel = true` leaves it. */
+export interface TabAutoHidingEventArgs extends EventArgs {
+    area: TabDockArea;
+    on: boolean;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-bar-button-size.d.ts

@@ -0,0 +1,2 @@
+/** How large the buttons of a group's toolbar are: as other toolbars (`'normal'`), or small squares about the size of a pointer target (`'small'`). */
+export type TabBarButtonSize = 'normal' | 'small';

package/dist/components/tabdocs/tab-bar-button.d.ts

@@ -0,0 +1,2 @@
+/** A built-in button of a group's toolbar: split, maximize the group, the lock mark, auto hide, the close button of a dock area's (or a window's) active document, and a floating window's maximize and close. */
+export type TabBarButton = 'split' | 'maximize' | 'lock' | 'autoHide' | 'close' | 'maximizeWindow' | 'closeWindow';

package/dist/components/tabdocs/tab-close-button.d.ts

@@ -0,0 +1,2 @@
+/** Where tabs show their close button: on every tab, on the active one and under the pointer, or nowhere. */
+export type TabCloseButton = 'always' | 'active' | 'never';

package/dist/components/tabdocs/tab-content-clone.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentBase } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+/** Makes the content of a document's second copy, open in another group. */
+export type TabContentClone = (copy: TabDocument) => ComponentBase | null;

package/dist/components/tabdocs/tab-content-factory.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentBase } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+/** Makes the content of a document that brings none of its own, usually by its `type`. */
+export type TabContentFactory = (document: TabDocument) => ComponentBase | null | undefined;

package/dist/components/tabdocs/tab-context-menu-event-args.d.ts

@@ -0,0 +1,16 @@
+import type { EventArgs } from '@motifx/core';
+import type { MenuItem } from '../../parts/menu/menu-item';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/**
+ * A context menu is about to open on a tab (`document`) or on the empty strip (`document` is
+ * `null`). `items` may be changed or replaced; `cancel = true` opens none.
+ */
+export interface TabContextMenuEventArgs extends EventArgs {
+    document: TabDocument | null;
+    group: TabGroup;
+    items: MenuItem[];
+    byKeyboard: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-copy-modifier.d.ts

@@ -0,0 +1,2 @@
+/** The key held while dropping that opens a copy. `auto`: Ctrl, Option on Apple platforms. */
+export type TabCopyModifier = 'auto' | 'ctrl' | 'alt' | 'shift' | 'meta' | 'none';

package/dist/components/tabdocs/tab-dock-guide-kind.d.ts

@@ -0,0 +1,2 @@
+/** The dock guides a drag shows: the cross over the group under the pointer, and the four at the manager's edges. */
+export type TabDockGuideKind = 'group' | 'edges';

package/dist/components/tabdocs/tab-dock-presentation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * How a dock area shows on a tablet or a phone: in a bottom sheet, in a drawer from its edge, or not
+ * at all; `'auto'`: a drawer for the sides and the top on a tablet, a sheet for the bottom and on a phone.
+ */
+export type TabDockPresentation = 'auto' | 'sheet' | 'drawer' | 'hidden';

package/dist/components/tabdocs/tab-dock-side.d.ts

@@ -0,0 +1,2 @@
+/** A side of the manager a dock area sits on, around the documents: `left` is the start side (the right one right to left). */
+export type TabDockSide = 'left' | 'right' | 'top' | 'bottom';

package/dist/components/tabdocs/tab-docked-event-args.d.ts

@@ -0,0 +1,16 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabDockArea } from './TabDockArea';
+import type { TabDockSide } from './tab-dock-side';
+import type { TabGroup } from './TabGroup';
+/** A document, a group or a window was docked. */
+export interface TabDockedEventArgs {
+    document: TabDocument | null;
+    /** The group it ended up in. */
+    group: TabGroup | null;
+    /** The dock area it went to; `null` when it went back among the documents. */
+    area: TabDockArea | null;
+    side: TabDockSide | null;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-docking-event-args.d.ts

@@ -0,0 +1,21 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabDockSide } from './tab-dock-side';
+import type { TabGroup } from './TabGroup';
+import type { TabWindow } from './TabWindow';
+/** A document, a group or a whole floating window is about to be docked; `side` and `size` may be changed, `cancel = true` leaves it. */
+export interface TabDockingEventArgs extends EventArgs {
+    /** The document; `null` for a group or a window. */
+    document: TabDocument | null;
+    /** The document's group, or the group docked; `null` for a whole window. */
+    group: TabGroup | null;
+    /** The window docked, or the window the document or the group is in. */
+    window: TabWindow | null;
+    /** The dock area it goes to; `null` puts it back where it was docked last. */
+    side: TabDockSide | null;
+    /** The size of a new dock area (pixels, or a share such as `'25%'`); `null` for the manager's `dockAreaSize`. */
+    size: number | string | null;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-document-content.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentBase } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+/** A document's content: a component, or a function that makes it (called again after `dispose`). */
+export type TabDocumentContent = ComponentBase | ((document: TabDocument) => ComponentBase | null);

package/dist/components/tabdocs/tab-document-keys.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The keys of `TabDocumentManager`, each a list of chords (`'Ctrl+W'`, or two in a row: `'Ctrl+K W'`;
+ * see `addShortcut`). They work while focus is inside the manager; the strip and splitter keys only
+ * on a tab or a splitter.
+ */
+export interface TabDocumentKeys {
+    nextTab: string[];
+    previousTab: string[];
+    closeTab: string[];
+    /** Hides the active document; `show`, or "Show hidden" in the menus, brings it back. */
+    hide: string[];
+    /** Closes the active group's documents (pinned ones stay while `keepPinned` is on). */
+    closeAllTabs: string[];
+    /** Closes the active group's documents that have no unsaved changes. */
+    closeSavedTabs: string[];
+    /** `{n}` stands for 1 to 9: the n-th group. */
+    focusGroup: string[];
+    splitRight: string[];
+    /** Opens the list of recently used documents; again while it is open, the next (the previous) one. */
+    recentNext: string[];
+    recentPrevious: string[];
+    /** Back and forward over the documents activated last, across groups. */
+    goBack: string[];
+    goForward: string[];
+    /** Opens the document closed last again. */
+    reopenClosed: string[];
+    /** Keeps the active preview tab open. */
+    keepOpen: string[];
+    /** Pins or unpins the active document. */
+    togglePin: string[];
+    /** Opens the group's list of open documents (the "…" button). */
+    showOpenList: string[];
+    /** On a tab: the next and previous tab in the strip (the other way round right to left), the first and the last. */
+    stripNext: string[];
+    stripPrevious: string[];
+    stripFirst: string[];
+    stripLast: string[];
+    /** On a tab: closes it. */
+    closeFocusedTab: string[];
+    /** Moves the active tab a place to the start or the end of its strip (not past the pinned or the other tabs). */
+    moveTabLeft: string[];
+    moveTabRight: string[];
+    /** Moves the active document to the next or previous group (a new one when there is none). */
+    moveToNextGroup: string[];
+    moveToPreviousGroup: string[];
+    /** Moves the active document to the group on that side, or into a new group there. */
+    moveToGroupLeft: string[];
+    moveToGroupRight: string[];
+    moveToGroupUp: string[];
+    moveToGroupDown: string[];
+    /** Starts "Move to…" for the active document. */
+    moveTo: string[];
+    /** In "Move to…": a side of the group, or the next group that way; the next and previous group; move there; leave it. */
+    targetLeft: string[];
+    targetRight: string[];
+    targetUp: string[];
+    targetDown: string[];
+    targetNextGroup: string[];
+    targetPreviousGroup: string[];
+    targetDrop: string[];
+    targetCancel: string[];
+    /** On a splitter: makes the group before it smaller or larger, as small or as large as it can be. */
+    resizeSmaller: string[];
+    resizeLarger: string[];
+    resizeMin: string[];
+    resizeMax: string[];
+    /** Moves the active document into a floating window of its own. */
+    float: string[];
+    /** Puts the active document back where it was docked (from a floating window). */
+    dock: string[];
+    /** Moves the active document into the dock area on that side. */
+    dockLeft: string[];
+    dockRight: string[];
+    dockTop: string[];
+    dockBottom: string[];
+    /** Folds the active document's dock area to its edge, or brings it back. */
+    toggleAutoHide: string[];
+    /** Focus to the next or previous part: the documents, each dock area, each floating window. */
+    nextPart: string[];
+    previousPart: string[];
+    /** In a folded dock area's strip of titles: the next and the previous title (Home and End are `stripFirst`, `stripLast`). */
+    autoHideNext: string[];
+    autoHidePrevious: string[];
+    /** In a floating window: moves and resizes it with the keys below until Enter or Escape. */
+    moveWindow: string[];
+    /** In a floating window: maximizes it within the page, or restores it. */
+    maximizeWindow: string[];
+    /** In a floating window: closes it with its documents. */
+    closeWindow: string[];
+    /** Moves the active document into a new browser window of its own. */
+    moveToNewWindow: string[];
+    /** In a new browser window: moves the active document back to the main window. */
+    moveToMainWindow: string[];
+    /** While moving a window by keys: moves it, makes it narrower, wider, shorter, taller; keeps it there; puts it back. */
+    windowLeft: string[];
+    windowRight: string[];
+    windowUp: string[];
+    windowDown: string[];
+    windowNarrower: string[];
+    windowWider: string[];
+    windowShorter: string[];
+    windowTaller: string[];
+    windowDone: string[];
+    windowCancel: string[];
+}