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

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

@@ -0,0 +1,1073 @@
+import { ComponentBase, type Bind, type Event as MotifEvent, type IBaseProp } from '@motifx/core';
+import { FocusContainer } from '../../core/container';
+import type { UiStrings } from '../../core/ui-strings';
+import type { MenuItem } from '../../parts/menu/menu-item';
+import type { TabsActivation } from '../tabs/tabs-activation';
+import type { ContentLifetime } from './content-lifetime';
+import type { DocumentActivatedEventArgs } from './document-activated-event-args';
+import type { DocumentActivatingEventArgs } from './document-activating-event-args';
+import type { DocumentChangedEventArgs } from './document-changed-event-args';
+import type { DocumentChangingEventArgs } from './document-changing-event-args';
+import type { DocumentClosedEventArgs } from './document-closed-event-args';
+import type { DocumentClosingEventArgs } from './document-closing-event-args';
+import type { DocumentMovedEventArgs } from './document-moved-event-args';
+import type { DocumentMovingEventArgs } from './document-moving-event-args';
+import type { DocumentOpenedEventArgs } from './document-opened-event-args';
+import type { DocumentOpeningEventArgs } from './document-opening-event-args';
+import type { DocumentShowingEventArgs } from './document-showing-event-args';
+import type { DocumentShownEventArgs } from './document-shown-event-args';
+import { DocumentTab } from './DocumentTab';
+import { DropMarks } from './DropMarks';
+import type { GroupLockedEventArgs } from './group-locked-event-args';
+import type { GroupLockingEventArgs } from './group-locking-event-args';
+import type { GroupSplitEventArgs } from './group-split-event-args';
+import type { GroupSplittingEventArgs } from './group-splitting-event-args';
+import type { LayoutChangedEventArgs } from './layout-changed-event-args';
+import type { LayoutChangingEventArgs } from './layout-changing-event-args';
+import type { LayoutItem } from './layout-item';
+import { LayoutDropTarget } from './LayoutDropTarget';
+import type { PinnedTabSize } from './pinned-tab-size';
+import type { SplitDirection } from './split-direction';
+import type { TabAfterClose } from './tab-after-close';
+import type { TabBarButton } from './tab-bar-button';
+import type { TabBarButtonSize } from './tab-bar-button-size';
+import type { TabCloseButton } from './tab-close-button';
+import type { TabContentFactory } from './tab-content-factory';
+import type { TabContextMenuEventArgs } from './tab-context-menu-event-args';
+import type { TabCopyModifier } from './tab-copy-modifier';
+import { TabDocument } from './TabDocument';
+import type { TabDocumentKeys } from './tab-document-keys';
+import type { TabDocumentManagerProps } from './tab-document-manager-props';
+import type { TabDocumentOptions } from './tab-document-options';
+import type { TabDragEndedEventArgs } from './tab-drag-ended-event-args';
+import type { TabDragStartingEventArgs } from './tab-drag-starting-event-args';
+import type { TabDragSubject } from './tab-drag-subject';
+import type { TabDropEventArgs } from './tab-drop-event-args';
+import type { TabDropPlace } from './tab-drop-place';
+import type { TabDropSide } from './tab-drop-side';
+import type { TabDropTarget } from './tab-drop-target';
+import type { TabDroppedEventArgs } from './tab-dropped-event-args';
+import { TabGroup } from './TabGroup';
+import type { TabKeyPreset } from './tab-key-preset';
+import type { TabLayout } from './tab-layout';
+import type { TabLayoutChange } from './tab-layout-change';
+import type { TabLayoutFactory } from './tab-layout-factory';
+import type { TabListScope } from './tab-list-scope';
+import type { TabMenuCommand } from './tab-menu-command';
+import type { TabNewDocument } from './tab-new-document';
+import type { TabOpenOptions } from './tab-open-options';
+import type { TabOpenPosition } from './tab-open-position';
+import type { TabShowDescription } from './tab-show-description';
+import type { TabShowOptions } from './tab-show-options';
+import type { TabSize } from './tab-size';
+import { TabSplit } from './TabSplit';
+import type { TabToolbarItems } from './tab-toolbar-items';
+import { DockDropTarget } from './DockDropTarget';
+import type { TabAutoHiddenEventArgs } from './tab-auto-hidden-event-args';
+import type { TabAutoHidingEventArgs } from './tab-auto-hiding-event-args';
+import { TabDockArea } from './TabDockArea';
+import type { TabDockGuideKind } from './tab-dock-guide-kind';
+import type { TabDockSide } from './tab-dock-side';
+import type { TabDockedEventArgs } from './tab-docked-event-args';
+import type { TabDockingEventArgs } from './tab-docking-event-args';
+import type { TabFloatedEventArgs } from './tab-floated-event-args';
+import type { TabFloatingEventArgs } from './tab-floating-event-args';
+import type { TabRect } from './tab-rect';
+import type { TabSlideEventArgs } from './tab-slide-event-args';
+import { TabWindow } from './TabWindow';
+import type { TabWindowClosedEventArgs } from './tab-window-closed-event-args';
+import type { TabWindowClosingEventArgs } from './tab-window-closing-event-args';
+import type { SashOwner } from './sash-owner';
+import { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabErrorEventArgs } from './tab-error-event-args';
+import type { TabNewWindowCloseAction } from './tab-new-window-close-action';
+import type { TabNewWindowFallback } from './tab-new-window-fallback';
+import type { TabNewWindowOptions } from './tab-new-window-options';
+import type { TabNewWindowTitle } from './tab-new-window-title';
+import type { TabOpenWindow } from './tab-open-window';
+import type { TabRestoreWindows } from './tab-restore-windows';
+import type { TabWindowOpenedEventArgs } from './tab-window-opened-event-args';
+import type { TabWindowOpeningEventArgs } from './tab-window-opening-event-args';
+import type { ContextMenuPresentation } from '../contextmenu/context-menu-presentation';
+import type { PresentationChangedEventArgs } from './presentation-changed-event-args';
+import type { PresentationChangingEventArgs } from './presentation-changing-event-args';
+import type { TabDockPresentation } from './tab-dock-presentation';
+import type { TabPresentation } from './tab-presentation';
+import type { TabPresentationKind } from './tab-presentation-kind';
+import type { TabNarrowBars } from './tab-narrow-bars';
+import type { TabTabletWhen } from './tab-tablet-when';
+/**
+ * Documents in tabs, in groups that split side by side and one under the other, as code editors
+ * have them. A document's content is any component; it is moved, never made again, when its tab
+ * moves to another group. Tabs can be previews, pinned, coloured and counted; each group has a
+ * list of its documents, every tab and the strip a context menu, and the recently used documents
+ * are a key away. Every user action is also a method, asks first (`on…ing`, cancelable) and
+ * reports after (`on…ed`). The layout saves to JSON and loads back.
+ *
+ * @example
+ * <TabDocumentManager label="Editor" style="block-size: 30rem" ref={(m: TabDocumentManager) => (this.docs = m)} />
+ *
+ * this.docs.open(new TabDocument({ title: 'Orders', content: () => new OrderGrid() }), { preview: true });
+ * this.docs.split(this.docs.activeGroup!, 'right', this.docs.findDocument('report')!);
+ * localStorage.layout = JSON.stringify(this.docs.saveLayout());
+ */
+export declare class TabDocumentManager extends FocusContainer<HTMLDivElement, TabDocumentManagerProps> {
+    /** The keys a manager in a browser tab starts with: keys the browser lets the page have. */
+    static readonly browserKeys: Readonly<TabDocumentKeys>;
+    /** The keys of a desktop editor, for an installed app (`keyPreset: 'desktop'`). */
+    static readonly desktopKeys: Readonly<TabDocumentKeys>;
+    constructor(props?: IBaseProp<TabDocumentManagerProps>);
+    get label(): string;
+    set label(value: Bind<string>);
+    get closeButton(): TabCloseButton;
+    set closeButton(value: Bind<TabCloseButton>);
+    get contentLifetime(): ContentLifetime;
+    set contentLifetime(value: Bind<ContentLifetime>);
+    get closeEmptyGroups(): boolean;
+    set closeEmptyGroups(value: Bind<boolean>);
+    get openPosition(): TabOpenPosition;
+    set openPosition(value: Bind<TabOpenPosition>);
+    get afterClose(): TabAfterClose;
+    set afterClose(value: Bind<TabAfterClose>);
+    get activation(): TabsActivation;
+    set activation(value: Bind<TabsActivation>);
+    get minGroupWidth(): number;
+    set minGroupWidth(value: Bind<number>);
+    get minGroupHeight(): number;
+    set minGroupHeight(value: Bind<number>);
+    get resizeStep(): number;
+    set resizeStep(value: Bind<number>);
+    get groupActions(): boolean;
+    set groupActions(value: Bind<boolean>);
+    get toolbarItems(): TabToolbarItems | null;
+    set toolbarItems(value: TabToolbarItems | null);
+    get maximizeOnDoubleClick(): boolean;
+    set maximizeOnDoubleClick(value: Bind<boolean>);
+    get previewTabs(): boolean;
+    set previewTabs(value: Bind<boolean>);
+    get pinnedTabSize(): PinnedTabSize;
+    set pinnedTabSize(value: Bind<PinnedTabSize>);
+    get pinnedTabsOnSeparateRow(): boolean;
+    set pinnedTabsOnSeparateRow(value: Bind<boolean>);
+    get closeButtonOnPinned(): boolean;
+    set closeButtonOnPinned(value: Bind<boolean>);
+    get keepPinned(): boolean;
+    set keepPinned(value: Bind<boolean>);
+    get tabSize(): TabSize;
+    set tabSize(value: Bind<TabSize>);
+    get tabMinWidth(): number;
+    set tabMinWidth(value: Bind<number>);
+    get tabMaxWidth(): number;
+    set tabMaxWidth(value: Bind<number>);
+    get tabFixedWidth(): number;
+    set tabFixedWidth(value: Bind<number>);
+    get wrapTabs(): boolean;
+    set wrapTabs(value: Bind<boolean>);
+    get scrollButtons(): boolean;
+    set scrollButtons(value: Bind<boolean>);
+    get singleTabTitle(): boolean;
+    set singleTabTitle(value: Bind<boolean>);
+    get barButtons(): readonly TabBarButton[] | 'all';
+    set barButtons(value: Bind<readonly TabBarButton[] | 'all'>);
+    get barButtonSize(): TabBarButtonSize;
+    set barButtonSize(value: Bind<TabBarButtonSize>);
+    get compactScrollButtons(): boolean;
+    set compactScrollButtons(value: Bind<boolean>);
+    get compactTabSize(): TabSize;
+    set compactTabSize(value: Bind<TabSize>);
+    get compactTabMinWidth(): number;
+    set compactTabMinWidth(value: Bind<number>);
+    get compactSingleTabTitle(): boolean;
+    set compactSingleTabTitle(value: Bind<boolean>);
+    get compactBarButtons(): readonly TabBarButton[] | 'all' | 'auto';
+    set compactBarButtons(value: Bind<readonly TabBarButton[] | 'all' | 'auto'>);
+    get compactBarButtonSize(): TabBarButtonSize;
+    set compactBarButtonSize(value: Bind<TabBarButtonSize>);
+    get showDescription(): TabShowDescription;
+    set showDescription(value: Bind<TabShowDescription>);
+    get openList(): boolean;
+    set openList(value: Bind<boolean>);
+    get openListScope(): TabListScope;
+    set openListScope(value: Bind<TabListScope>);
+    get recentListScope(): TabListScope;
+    set recentListScope(value: Bind<TabListScope>);
+    get historySize(): number;
+    set historySize(value: Bind<number>);
+    get closedHistorySize(): number;
+    set closedHistorySize(value: Bind<number>);
+    get contextMenu(): boolean;
+    set contextMenu(value: Bind<boolean>);
+    get menuItems(): Partial<Record<TabMenuCommand, boolean>>;
+    set menuItems(value: Bind<Partial<Record<TabMenuCommand, boolean>>>);
+    get newDocument(): TabNewDocument | null;
+    set newDocument(value: TabNewDocument | null);
+    get allowDuplicate(): boolean;
+    set allowDuplicate(value: Bind<boolean>);
+    get splitCopies(): boolean;
+    set splitCopies(value: Bind<boolean>);
+    get allowDrag(): boolean;
+    set allowDrag(value: Bind<boolean>);
+    get allowDragGroups(): boolean;
+    set allowDragGroups(value: Bind<boolean>);
+    get groupDragHandle(): boolean;
+    set groupDragHandle(value: Bind<boolean>);
+    get layoutEdgeDrop(): boolean;
+    set layoutEdgeDrop(value: Bind<boolean>);
+    get layoutEdgeSize(): number;
+    set layoutEdgeSize(value: Bind<number>);
+    get dragThreshold(): number;
+    set dragThreshold(value: Bind<number>);
+    get longPressDelay(): number;
+    set longPressDelay(value: Bind<number>);
+    get dragHoverActivate(): boolean;
+    set dragHoverActivate(value: Bind<boolean>);
+    get dragHoverDelay(): number;
+    set dragHoverDelay(value: Bind<number>);
+    get pinOnDrag(): boolean;
+    set pinOnDrag(value: Bind<boolean>);
+    get dragGhost(): boolean;
+    set dragGhost(value: Bind<boolean>);
+    get dragAutoScroll(): boolean;
+    set dragAutoScroll(value: Bind<boolean>);
+    get allowFloat(): boolean;
+    set allowFloat(value: Bind<boolean>);
+    get allowDock(): boolean;
+    set allowDock(value: Bind<boolean>);
+    get dockSides(): readonly TabDockSide[];
+    set dockSides(value: Bind<readonly TabDockSide[]>);
+    get allowAutoHide(): boolean;
+    set allowAutoHide(value: Bind<boolean>);
+    get allowHide(): boolean;
+    set allowHide(value: Bind<boolean>);
+    get floatingWindowSize(): {
+        width: number;
+        height: number;
+    } | null;
+    set floatingWindowSize(value: Bind<{
+        width: number;
+        height: number;
+    } | null>);
+    get keepFloatingInView(): boolean;
+    set keepFloatingInView(value: Bind<boolean>);
+    get closeEmptyWindows(): boolean;
+    set closeEmptyWindows(value: Bind<boolean>);
+    get dockOnDoubleClick(): boolean;
+    set dockOnDoubleClick(value: Bind<boolean>);
+    /** The size a new dock area of each side starts with: pixels, or a share such as `'25%'`. */
+    get dockAreaSize(): Readonly<Record<TabDockSide, number | string>>;
+    set dockAreaSize(value: Bind<Partial<Record<TabDockSide, number | string>>>);
+    get dockAreaMinSize(): number;
+    set dockAreaMinSize(value: Bind<number>);
+    get autoHideHover(): boolean;
+    set autoHideHover(value: Bind<boolean>);
+    get autoHideDelay(): number;
+    set autoHideDelay(value: Bind<number>);
+    get dockGuides(): boolean;
+    set dockGuides(value: Bind<boolean>);
+    get dockGuideKinds(): readonly TabDockGuideKind[];
+    set dockGuideKinds(value: Bind<readonly TabDockGuideKind[]>);
+    get dropSides(): readonly TabDropSide[];
+    set dropSides(value: Bind<readonly TabDropSide[]>);
+    get dropEdgeSize(): number | string;
+    set dropEdgeSize(value: Bind<number | string>);
+    get copyModifier(): TabCopyModifier;
+    set copyModifier(value: Bind<TabCopyModifier>);
+    get dragGroup(): string | null;
+    set dragGroup(value: Bind<string | null>);
+    get allowNewWindow(): boolean;
+    set allowNewWindow(value: Bind<boolean>);
+    get newWindowUrl(): string;
+    set newWindowUrl(value: Bind<string>);
+    get newWindowTitle(): TabNewWindowTitle;
+    set newWindowTitle(value: Bind<TabNewWindowTitle>);
+    get newWindowSize(): {
+        width: number;
+        height: number;
+    } | null;
+    set newWindowSize(value: Bind<{
+        width: number;
+        height: number;
+    } | null>);
+    get newWindowFallback(): TabNewWindowFallback;
+    set newWindowFallback(value: Bind<TabNewWindowFallback>);
+    get newWindowCloseAction(): TabNewWindowCloseAction;
+    set newWindowCloseAction(value: Bind<TabNewWindowCloseAction>);
+    get restoreWindows(): TabRestoreWindows;
+    set restoreWindows(value: Bind<TabRestoreWindows>);
+    get openWindow(): TabOpenWindow | null;
+    set openWindow(value: TabOpenWindow | null);
+    get dragOutToNewWindow(): boolean;
+    set dragOutToNewWindow(value: Bind<boolean>);
+    get keyPreset(): TabKeyPreset;
+    set keyPreset(value: Bind<TabKeyPreset>);
+    /** The keys in use: the preset's with the `keys` prop over them. Reactive. */
+    get keys(): TabDocumentKeys;
+    set keys(value: Bind<Partial<TabDocumentKeys>>);
+    get texts(): Partial<UiStrings>;
+    set texts(value: Bind<Partial<UiStrings>>);
+    get announce(): boolean;
+    set announce(value: Bind<boolean>);
+    get factory(): TabContentFactory | null;
+    set factory(value: Bind<TabContentFactory | null>);
+    get presentation(): TabPresentation;
+    set presentation(value: Bind<TabPresentation>);
+    get tabletWidth(): number;
+    set tabletWidth(value: Bind<number>);
+    get phoneWidth(): number;
+    set phoneWidth(value: Bind<number>);
+    /** When `'auto'` shows the tablet layout: on a touch screen under `tabletWidth`, or under it whatever the pointer. */
+    get tabletWhen(): TabTabletWhen;
+    set tabletWhen(value: Bind<TabTabletWhen>);
+    /** How the bars of the documents' groups look on a tablet or a phone: compact, or as on a desktop. */
+    get narrowBars(): TabNarrowBars;
+    set narrowBars(value: Bind<TabNarrowBars>);
+    get phoneDockMode(): TabDockPresentation;
+    set phoneDockMode(value: Bind<TabDockPresentation>);
+    get tabletDockMode(): TabDockPresentation;
+    set tabletDockMode(value: Bind<TabDockPresentation>);
+    get edgeSwipe(): boolean;
+    set edgeSwipe(value: Bind<boolean>);
+    get backButton(): boolean;
+    set backButton(value: Bind<boolean>);
+    /** How the tab menus show, as set; `null` follows the presentation. */
+    get menuPresentation(): ContextMenuPresentation | null;
+    set menuPresentation(value: Bind<ContextMenuPresentation | null>);
+    /** How the layout is shown now: `presentation`, or by the manager's width when it is `'auto'`. Reactive. */
+    get currentPresentation(): TabPresentationKind;
+    /** Whether the phone's list of documents is open. Reactive. */
+    get documentListOpen(): boolean;
+    /** The groups, in layout order (left to right, top to bottom). Reactive. */
+    get groups(): readonly TabGroup[];
+    /** Every open document, group by group. Reactive. */
+    get documents(): readonly TabDocument[];
+    /** The group that has focus, or had it last. Reactive. */
+    get activeGroup(): TabGroup | null;
+    /** The active group's active document. Reactive. */
+    get activeDocument(): TabDocument | null;
+    /** The maximized group, `null` when none is. Reactive. */
+    get maximizedGroup(): TabGroup | null;
+    /** The open documents of every group, the one activated last first. Reactive. */
+    get recentDocuments(): readonly TabDocument[];
+    /** The hidden documents `show` can put back, in the order they were hidden. Reactive. */
+    get hiddenDocuments(): readonly TabDocument[];
+    /** The closed documents `reopenClosed` can open again, the one closed last first. Reactive. */
+    get closedDocuments(): readonly TabDocument[];
+    /** Whether `goBack` has somewhere to go. Reactive. */
+    get canGoBack(): boolean;
+    /** Reactive. */
+    get canGoForward(): boolean;
+    /** What is being dragged now (or moved with "Move to…"), `null` when nothing is. Reactive. */
+    get dragging(): TabDragSubject | null;
+    /** The floating windows, the one at the back first. Reactive. */
+    get floatingWindows(): readonly TabWindow[];
+    /** The new browser windows, the one used last at the end. Reactive. */
+    get browserWindows(): readonly TabBrowserWindow[];
+    /** The dock areas, the outermost first. Reactive. */
+    get dockAreas(): readonly TabDockArea[];
+    /** The dock area of a side, `null` when nothing is docked there. Reactive. */
+    dockArea(side: TabDockSide): TabDockArea | null;
+    /** The drop targets, asked in order: the dock guides and floating first, the built-in one (strips, groups, the layout's edges) last. */
+    get dropTargets(): readonly TabDropTarget[];
+    /** A document is about to open; cancelable, `group` and `index` may be changed. */
+    get onOpening(): MotifEvent<DocumentOpeningEventArgs>;
+    get onOpened(): MotifEvent<DocumentOpenedEventArgs>;
+    /** A document is about to close; cancelable, or `e.promise` asks first. */
+    get onClosing(): MotifEvent<DocumentClosingEventArgs>;
+    get onClosed(): MotifEvent<DocumentClosedEventArgs>;
+    /** A tab is about to become its group's active one; cancelable. */
+    get onDocumentActivating(): MotifEvent<DocumentActivatingEventArgs>;
+    /** A group's active tab, or the active group, changed. */
+    get onDocumentActivated(): MotifEvent<DocumentActivatedEventArgs>;
+    /** A document is about to move; cancelable. */
+    get onMoving(): MotifEvent<DocumentMovingEventArgs>;
+    get onMoved(): MotifEvent<DocumentMovedEventArgs>;
+    /** A group is about to be split; cancelable. */
+    get onSplitting(): MotifEvent<GroupSplittingEventArgs>;
+    get onSplit(): MotifEvent<GroupSplitEventArgs>;
+    /** A group is about to close, be resized, maximized or restored, or a layout to load; cancelable. */
+    get onLayoutChanging(): MotifEvent<LayoutChangingEventArgs>;
+    /** Groups were added, closed, resized, maximized or restored. */
+    get onLayoutChanged(): MotifEvent<LayoutChangedEventArgs>;
+    /** A preview tab is about to be kept open; cancelable. */
+    get onKeeping(): MotifEvent<DocumentChangingEventArgs>;
+    get onKept(): MotifEvent<DocumentChangedEventArgs>;
+    /** A document is about to be pinned; cancelable. */
+    get onPinning(): MotifEvent<DocumentChangingEventArgs>;
+    get onPinned(): MotifEvent<DocumentChangedEventArgs>;
+    /** A document is about to be unpinned; cancelable. */
+    get onUnpinning(): MotifEvent<DocumentChangingEventArgs>;
+    get onUnpinned(): MotifEvent<DocumentChangedEventArgs>;
+    /** A group is about to be locked; cancelable. */
+    get onLocking(): MotifEvent<GroupLockingEventArgs>;
+    get onLocked(): MotifEvent<GroupLockedEventArgs>;
+    /** A group is about to be unlocked; cancelable. */
+    get onUnlocking(): MotifEvent<GroupLockingEventArgs>;
+    get onUnlocked(): MotifEvent<GroupLockedEventArgs>;
+    /** The context menu of a tab or of the empty strip is about to open; change `items`, or cancel. */
+    get onContextMenuOpening(): MotifEvent<TabContextMenuEventArgs>;
+    /** A tab or a group is about to be dragged, or moved with "Move to…"; cancelable. */
+    get onDragStarting(): MotifEvent<TabDragStartingEventArgs>;
+    /** The drag is over a place: change the place, or `cancel` to refuse it. Outside every manager it comes refused. */
+    get onDragOver(): MotifEvent<TabDropEventArgs>;
+    /** The drag is about to drop; change the place, or cancel to keep everything where it is. */
+    get onDropping(): MotifEvent<TabDropEventArgs>;
+    /** A drop was made (after the `moved`, `split`… events of what it did). */
+    get onDropped(): MotifEvent<TabDroppedEventArgs>;
+    /** A drag is over, dropped or not. */
+    get onDragEnded(): MotifEvent<TabDragEndedEventArgs>;
+    /** A document or a group is about to float in a window; `rect` may be changed; cancelable. */
+    get onFloating(): MotifEvent<TabFloatingEventArgs>;
+    get onFloated(): MotifEvent<TabFloatedEventArgs>;
+    /** A document, a group or a window is about to be docked; `side` and `size` may be changed; cancelable. */
+    get onDocking(): MotifEvent<TabDockingEventArgs>;
+    get onDocked(): MotifEvent<TabDockedEventArgs>;
+    /** A dock area is about to fold to its edge (`on`) or come back; cancelable. */
+    get onAutoHiding(): MotifEvent<TabAutoHidingEventArgs>;
+    get onAutoHidden(): MotifEvent<TabAutoHiddenEventArgs>;
+    /** A document is about to be hidden; cancelable. */
+    get onHiding(): MotifEvent<DocumentChangingEventArgs>;
+    /** A document was hidden; `group` is the one it left. */
+    get onHidden(): MotifEvent<DocumentChangedEventArgs>;
+    /** A hidden document is about to be shown again; `group` and `index` may be changed; cancelable. */
+    get onShowing(): MotifEvent<DocumentShowingEventArgs>;
+    get onShown(): MotifEvent<DocumentShownEventArgs>;
+    /** A folded dock area is about to slide out (`open`) or back; cancelable. */
+    get onSlideChanging(): MotifEvent<TabSlideEventArgs>;
+    get onSlideChanged(): MotifEvent<TabSlideEventArgs>;
+    /** A floating window or a new browser window is about to close; `then` may be changed; cancelable (not a new window the user closed). */
+    get onWindowClosing(): MotifEvent<TabWindowClosingEventArgs>;
+    /** A floating window or a new browser window is gone: closed, docked, left empty, or moved into a new window. */
+    get onWindowClosed(): MotifEvent<TabWindowClosedEventArgs>;
+    /** A document, a group or a floating window is about to move into a new browser window; `rect` and `url` may be changed; cancelable. */
+    get onWindowOpening(): MotifEvent<TabWindowOpeningEventArgs>;
+    get onWindowOpened(): MotifEvent<TabWindowOpenedEventArgs>;
+    /** The browser opened no new window, or one of another origin; `fallback` may be changed. */
+    get onError(): MotifEvent<TabErrorEventArgs>;
+    /** The layout is about to be shown another way (desktop, tablet, phone); cancelable. */
+    get onPresentationChanging(): MotifEvent<PresentationChangingEventArgs>;
+    get onPresentationChanged(): MotifEvent<PresentationChangedEventArgs>;
+    /** On a phone: opens the full-screen list of open documents. `false` in another presentation. */
+    showDocumentList(): boolean;
+    hideDocumentList(): boolean;
+    /** On a tablet or a phone: opens the dock area of `document` (its drawer or sheet) with it shown. */
+    showTool(document: TabDocument): boolean;
+    /** On a tablet or a phone: closes a dock area's drawer or sheet. */
+    hideTool(area: TabDockArea): boolean;
+    /**
+     * Opens a document (or makes one from options) in a group: the active one by default, never a
+     * locked one. A document that is already open is activated, or copied into the group when it may
+     * be open twice (`allowDuplicate`). A preview replaces the group's preview tab. Returns `null`
+     * when `onOpening` cancels.
+     */
+    open(document: TabDocument | TabDocumentOptions, options?: TabOpenOptions): TabDocument | null;
+    /** Closes a document as its close button does; resolves `false` when it stays open. */
+    close(document: TabDocument): Promise<boolean>;
+    /**
+     * Closes the documents of a group, or of every group; resolves `false` when some stay open.
+     * Pinned documents stay while `keepPinned` is on, unless `pinned` is `true`.
+     */
+    closeAll(group?: TabGroup, pinned?: boolean): Promise<boolean>;
+    /** Closes the other documents of the document's group. */
+    closeOthers(document: TabDocument): Promise<boolean>;
+    /** Closes the documents after (or before) this one in its group. */
+    closeToRight(document: TabDocument): Promise<boolean>;
+    closeToLeft(document: TabDocument): Promise<boolean>;
+    /** Closes the documents of a group (or of every group) that have no unsaved changes. */
+    closeSaved(group?: TabGroup): Promise<boolean>;
+    /**
+     * Takes a document out of its group without closing it: its tab goes, its content is kept as its
+     * `contentLifetime` says, and `show` puts it back where it was. A group, a dock area or a window
+     * it leaves empty goes. `false` when it may not be hidden (`allowHide`) or `onHiding` cancels.
+     */
+    hide(document: TabDocument): boolean;
+    /**
+     * Puts a hidden document back: into the group it was hidden from, else into its dock area (made
+     * again at its size), else into a floating window where its window was, else among the documents.
+     * `options` may name a group or a dock area instead.
+     */
+    show(document: TabDocument, options?: TabShowOptions): boolean;
+    /** Makes a document its group's active one, and its group the active group. */
+    activate(document: TabDocument, focus?: boolean): boolean;
+    /** Activates the next tab of a group (the active group by default), around the end. */
+    activateNext(group?: TabGroup | null, focus?: boolean): boolean;
+    activatePrevious(group?: TabGroup | null, focus?: boolean): boolean;
+    /** Moves a document to `index` of `group` (another group, or its own). Pinned documents stay before the others. */
+    move(document: TabDocument, group: TabGroup, index?: number): boolean;
+    /**
+     * Moves a document to the next or previous group, or to the group on that side of its own; its
+     * group splits that way when there is none.
+     */
+    moveToGroup(document: TabDocument, which: 'next' | 'previous' | SplitDirection): boolean;
+    /** Moves a document a place along its strip (`-1` towards the start), not past the pinned or the other tabs. */
+    moveInGroup(document: TabDocument, by: number): boolean;
+    /** Makes a preview tab stay open. */
+    keep(document: TabDocument): boolean;
+    /** Pins a document: its tab goes to the end of the pinned ones, at the start of the strip. */
+    pin(document: TabDocument): boolean;
+    /** Unpins a document: its tab becomes the first of the others. */
+    unpin(document: TabDocument): boolean;
+    /** Opens the document closed last again, where it was. `null` when there is none to open. */
+    reopenClosed(): TabDocument | null;
+    /** Activates the document activated before the current one, in whatever group. */
+    goBack(): boolean;
+    goForward(): boolean;
+    /** Makes a new document with `newDocument` and opens it in a group (the active one by default). */
+    openNew(group?: TabGroup): TabDocument | null;
+    /** Copies a document's title to the clipboard. */
+    copyTitle(document: TabDocument): Promise<boolean>;
+    /** A document of this manager by its id: an open one first, else a hidden one. */
+    findDocument(id: string): TabDocument | null;
+    /** The content made for a document, `null` while it is not built. */
+    contentOf(document: TabDocument): ComponentBase | null;
+    /**
+     * Opens a new group beside `group`, or along that edge of the whole layout when `group` is `null`;
+     * `document` moves into it, or a copy of it opens there when it may be open twice and `splitCopies`
+     * is on. Returns the new group, `null` when `onSplitting` cancels.
+     */
+    split(group: TabGroup | null, direction: SplitDirection, document?: TabDocument): TabGroup | null;
+    /**
+     * Moves a whole group with its documents: beside another group (`left`, `right`, `up`, `down`),
+     * into it (`center`: its documents join that group), or along an edge of the layout (`target`
+     * `null`). Nothing is made again.
+     */
+    moveGroup(group: TabGroup, target: TabGroup | null, side: TabDropSide): boolean;
+    /** Closes the documents of a group, then the group (the last group stays, empty). */
+    closeGroup(group: TabGroup): Promise<boolean>;
+    /** Makes a group (or the n-th one, from 0) active and focuses what had focus in it last. */
+    focusGroup(group: TabGroup | number): boolean;
+    /** Locks a group: documents opened without naming a group go elsewhere. */
+    lock(group: TabGroup): boolean;
+    unlock(group: TabGroup): boolean;
+    /** Gives a group all the room; the others stay as they are, out of sight. */
+    maximizeGroup(group: TabGroup): boolean;
+    /** Shows every group again after `maximizeGroup`. */
+    restoreGroups(): boolean;
+    /** Gives every group of every split the same size. */
+    evenSizes(): boolean;
+    /** Sets a group's size along its split: pixels, or a share such as `'30%'`. The neighbour after it (before it, for the last) gives or takes the room. */
+    resizeGroup(group: TabGroup, size: number | string): boolean;
+    /**
+     * "Move to…": the keys choose where a document (or a whole group) goes, with the drop areas of a
+     * drag shown and each place announced; Enter moves it there, Escape leaves it.
+     */
+    showMoveTo(target: TabDocument | TabGroup): boolean;
+    /** Stops a drag or "Move to…" under way; everything goes back where it was. */
+    cancelDrag(): boolean;
+    /** Adds a drop target, asked before the built-in one (at `index` of `dropTargets`). Returns the function that removes it. */
+    addDropTarget(target: TabDropTarget, index?: number): () => void;
+    /**
+     * Moves a document, or a whole group, into a floating window of its own at `rect` (by default
+     * the size of the group it comes from, beside it). Returns the window, `null` when it may not
+     * float or `onFloating` cancels.
+     */
+    float(target: TabDocument | TabGroup, rect?: TabRect): TabWindow | null;
+    /**
+     * Docks a document, a group or a whole floating window into the dock area of `side` (made at
+     * `size`, else `dockAreaSize`, when there is none), or, without a side, puts it back where it was
+     * docked before it floated. A document not open yet opens there.
+     */
+    dock(target: TabDocument | TabGroup | TabWindow, side?: TabDockSide | null, size?: number | string): boolean;
+    /** Folds a dock area (or a document's) to the manager's edge, where only its tab titles stay; `false` brings it back. */
+    autoHide(target: TabDockArea | TabDocument, on?: boolean): boolean;
+    /** Slides a folded dock area out over the documents, with `document` shown. */
+    showAutoHidden(document: TabDocument): boolean;
+    /** Slides the folded area that is out back to its edge. */
+    hideAutoHidden(): boolean;
+    /** Moves a floating window: `x` from the left of the viewport, `y` from the top. */
+    moveWindow(window: TabWindow, x: number, y: number): boolean;
+    resizeWindow(window: TabWindow, width: number, height: number): boolean;
+    /** Gives a floating window the whole page; `restoreWindow` gives it its place back. */
+    maximizeWindow(window: TabWindow): boolean;
+    restoreWindow(window: TabWindow): boolean;
+    /**
+     * Closes a floating window with its documents (each one asks through `onClosing`), or a new
+     * browser window: its documents go back to the main window, or close, as
+     * `newWindowCloseAction` says. Resolves `false` when it stays open.
+     */
+    closeWindow(window: TabWindow | TabBrowserWindow): Promise<boolean>;
+    /** Brings a floating window or a new browser window to the front and focuses what had focus in it last. */
+    focusWindow(window: TabWindow | TabBrowserWindow): boolean;
+    /** Sets a dock area's size: pixels, or a share of the manager such as `'25%'`. */
+    resizeDockArea(area: TabDockArea, size: number | string, byUser?: boolean): boolean;
+    /** Moves focus to the next part (`-1`: the previous one): the documents, each dock area that is not folded, each floating window. */
+    focusPart(by?: 1 | -1): boolean;
+    /**
+     * Moves a document, a whole group or a floating window with all it holds into a new browser
+     * window (`window.open`, or `openWindow`), at `options.rect` on the screen (by default as large
+     * as what moves, beside it). The content moves, it is not made again. Returns the window, `null`
+     * when it may not move, `onWindowOpening` cancels, or the browser opens none (`onError` tells,
+     * and `newWindowFallback` may float it instead). A page given in `newWindowUrl` is waited for:
+     * the move is made once it has loaded (`onWindowOpened`), and this returns `null`.
+     */
+    moveToNewWindow(target: TabDocument | TabGroup | TabWindow, options?: TabNewWindowOptions): TabBrowserWindow | null;
+    /** Brings a document, a group or everything in a new window back to the main window, into the group it came from. */
+    moveToMainWindow(target: TabDocument | TabGroup | TabBrowserWindow): boolean;
+    /**
+     * Opens again the new windows a layout saved (`restoreWindows: 'reopen'`) that are floating
+     * because the browser did not let `loadLayout` open them. A browser lets a page open windows only
+     * on a click or a key: call it from one. Returns how many opened.
+     */
+    reopenWindows(): number;
+    /**
+     * Opens a group's menu of open documents (its "…" button): a search, the documents, and commands
+     * under them. In a compact bar the commands come first: the buttons the bar does not show, then the documents.
+     */
+    showOpenList(group?: TabGroup | null): boolean;
+    /** Opens the list of recently used documents with the next one (or the last one, `-1`) highlighted. */
+    showRecentList(by?: 1 | -1, event?: KeyboardEvent | null): boolean;
+    /** The layout as plain JSON: the tree of splits and groups, each document's `id`, `type`, `title`, `state` and flags. */
+    saveLayout(): TabLayout;
+    /**
+     * Puts a saved layout back in place of the current one, whose documents close without asking
+     * (and whose new windows close). `factory` makes each document again (by its `type`); without it
+     * a document is made from what was saved and its content comes from the manager's `factory`. A
+     * document saved twice comes back as a copy of the first one. Saved new windows come back as
+     * `restoreWindows` says.
+     */
+    loadLayout(layout: TabLayout, factory?: TabLayoutFactory): boolean;
+    focus(): boolean;
+    protected get focusElement(): HTMLElement;
+    /** @internal A touchmove in a bar: stopped while a finger drags a tab or a group, so the page does not scroll. */
+    holdTouch(e: TouchEvent): void;
+    /** @internal A text for this manager: `texts` first, then `uiLocale`. Reactive. */
+    textOf(key: keyof UiStrings, values?: Record<string, unknown>): string;
+    /** @internal The key that closes a focused tab, as `aria-keyshortcuts` writes it. Reactive. */
+    closeKeyHint(): string | null;
+    /** @internal Whether a tab shows its document's description now. Reactive. */
+    showsDescription(document: TabDocument): boolean;
+    /** @internal Makes the content of a document. */
+    makeContent(document: TabDocument): ComponentBase | null;
+    /** @internal Whether the content can be made again after it was let go. */
+    canRemake(document: TabDocument): boolean;
+    /** @internal A tab's title, icon or close button changed: keep the active tab in sight. */
+    tabChanged(tab: DocumentTab): void;
+    /** @internal A tab's document was pinned or unpinned: its tab moves to its side of the strip. */
+    pinChanged(tab: DocumentTab): void;
+    /** @internal A preview document got unsaved changes: it stays. */
+    keepByChange(document: TabDocument): void;
+    /** @internal Focus came into a group. */
+    groupFocused(group: TabGroup): void;
+    /** @internal */
+    activateByUser(document: TabDocument): void;
+    /** @internal A document chosen in a list: activated and focused. */
+    activateFromList(document: TabDocument): void;
+    /** @internal */
+    closeByUser(document: TabDocument): Promise<boolean>;
+    /** @internal */
+    unpinByUser(document: TabDocument): void;
+    /** @internal */
+    unlockByUser(group: TabGroup): void;
+    /** @internal The split button and key: the active document goes along when it is not the group's only one, or a copy of it. */
+    splitByUser(group: TabGroup, direction: SplitDirection): void;
+    /** @internal */
+    toggleMaximizeByUser(group: TabGroup): void;
+    /** @internal A double click keeps a preview tab, else maximizes its group or restores the groups. */
+    tabDoubleClicked(group: TabGroup, document: TabDocument): void;
+    /** @internal The drop marks shown in a document: the main window's, or a new window's. */
+    marksIn(doc: Document): DropMarks;
+    /** @internal Where the manager's things go in a document (drag pictures, guides): its element, or a new window's. */
+    hostElementIn(doc: Document): HTMLElement;
+    /** @internal The manager's element and the element of each new window: what the strip's look and a drag's cursor are written on. */
+    hostElements(): HTMLElement[];
+    /** @internal Whether a node is in the manager: in its element, or in one of its new windows. */
+    owns(node: Node | null): boolean;
+    /** @internal While a drag aims, the document whose viewport its point is in (the main one by default). */
+    get dragSpace(): Document;
+    set dragSpace(doc: Document | null);
+    /** @internal The new windows, the one focused last first, and the main window's document with when it had focus. */
+    spaces(): {
+        doc: Document;
+        at: number;
+    }[];
+    /** @internal A new window's title, as `newWindowTitle` makes it. Reactive. */
+    windowTitleOf(w: TabBrowserWindow): string;
+    /** @internal Whether what is dragged (or named) may move into a new browser window: its own documents' `allowNewWindow`, else the manager's. */
+    mayNewWindow(subject: TabDragSubject): boolean;
+    /** @internal The user closed a new window, or it went to another page: its documents come back (and close, when `then` says so). */
+    browserWindowClosed(w: TabBrowserWindow): void;
+    /** @internal A double click on the empty strip makes a new document there; in a floating window it docks the window back. */
+    stripDoubleClicked(group: TabGroup): void;
+    /** @internal */
+    contextMenuOpening(e: TabContextMenuEventArgs): void;
+    /** @internal */
+    get dropMarks(): DropMarks;
+    /** @internal */
+    get layoutTarget(): LayoutDropTarget;
+    /** @internal */
+    get dockDropTarget(): DockDropTarget;
+    /** @internal The top of the layout tree. */
+    get rootItem(): LayoutItem | null;
+    /** @internal This manager and the others of its `dragGroup` on the same page: where its drags may drop. */
+    dragPeers(): TabDocumentManager[];
+    /** @internal Whether a manager outside this one's `dragGroup` (or one of its windows) is under a point: a drop there is refused, it does not float. */
+    foreignAt(x: number, y: number): boolean;
+    /** @internal Whether the user may drag a document: its own `allowDrag`, else the manager's. */
+    mayDrag(document: TabDocument): boolean;
+    /** @internal The top of the documents' layout. */
+    get mainRoot(): LayoutItem | null;
+    /** @internal The groups, the one used last first. */
+    recentGroupsNow(): readonly TabGroup[];
+    /** @internal The headers a group's strip shows besides its own (the groups folded into it on a tablet). */
+    guestHeaders(group: TabGroup): {
+        before: HTMLElement[];
+        after: HTMLElement[];
+    } | null;
+    /** @internal Whether a group's strip shows the tabs of groups folded into it on a tablet. Reactive. */
+    groupHasGuests(group: TabGroup): boolean;
+    /** @internal Whether a group is folded into another on a tablet: its tabs show in that group's strip. */
+    groupFolded(group: TabGroup): boolean;
+    /** @internal The tab whose header holds `target`, whichever group it is in. */
+    tabOfHeader(target: EventTarget | null): DocumentTab | undefined;
+    /** @internal How the tab menus show now: `menuPresentation`, else a sheet on a phone, a sheet for a finger on a tablet, a menu on a desktop. Reactive. */
+    get menuPresentationNow(): ContextMenuPresentation;
+    /** @internal A document's commands in an action sheet (the phone's title, a row of its list). */
+    openDocumentSheet(doc: TabDocument, group: TabGroup, byKeyboard: boolean, returnFocus: HTMLElement | null): void;
+    /** @internal The phone's list closes a document (or hides one that may only be hidden). */
+    closeOrHideFromList(doc: TabDocument): Promise<boolean>;
+    /** @internal Whether the phone's list may move a document: its own `allowDrag`, else the manager's. */
+    mayMoveFromList(document: TabDocument): boolean;
+    /** @internal The phone's list moves a document to `index` of `group`. */
+    moveFromList(doc: TabDocument, group: TabGroup, index: number): boolean;
+    /** @internal A dock area's own tablet or phone setting changed. */
+    presentationSettingChanged(): void;
+    /** @internal Whether a dock area's titles show along its edge on a tablet: not when it is hidden there. Reactive. */
+    toolStripShown(area: TabDockArea): boolean;
+    /** @internal The phone's list opened or closed. */
+    listShown(open: boolean): void;
+    /** @internal Whether a drop with the copy key may open a copy of the document. */
+    mayCopyDocument(document: TabDocument | null): boolean;
+    /** @internal Where a document dropped into a group (not among its tabs) goes. */
+    insertIndexFor(group: TabGroup): number;
+    /** @internal */
+    dragStarting(e: TabDragStartingEventArgs): void;
+    /** @internal */
+    dragStarted(subject: TabDragSubject): void;
+    /** @internal */
+    dragOver(e: TabDropEventArgs): void;
+    /** @internal */
+    dropping(e: TabDropEventArgs): void;
+    /** @internal The drop was made: `onDropped`, with where it ended up. */
+    dropped(place: TabDropPlace, subject: TabDragSubject, byKeyboard: boolean): void;
+    /** @internal */
+    dragEnded(e: TabDragEndedEventArgs): void;
+    /** @internal */
+    announceCanceled(): void;
+    /** @internal Resting on a tab while dragging activates it. */
+    activateFromDrag(document: TabDocument): void;
+    /** @internal A canceled drag gives the active group back. */
+    useGroupFromDrag(group: TabGroup): void;
+    /** @internal A long press let go without moving: the tab's menu at that point. */
+    openContextMenuAt(source: HTMLElement, x: number, y: number): void;
+    /** @internal The group next to `group` on that side, `null` when it is at that edge of the layout. */
+    neighbourOf(group: TabGroup, direction: SplitDirection): TabGroup | null;
+    /** @internal The group at an edge of the layout (the one used last, when several are). */
+    edgeGroup(side: SplitDirection): TabGroup | null;
+    /**
+     * @internal Makes a drop the built-in target found, through the methods of what it does (and
+     * their events): a move or a copy into a strip or a group, a split, a group moved or merged.
+     */
+    dropAt(place: TabDropPlace, drag: TabDragSubject): boolean;
+    /** A drag let go past the edge of its window: into a new window there, or back to the main window. */
+    private dropToWindow;
+    /** A drag let go away from every guide and strip: what was dragged floats there; a window moved stays where it is. */
+    private dropFloat;
+    /**
+     * A whole window dropped on a strip or into a group (`center`: its documents join that group),
+     * beside a group, or along an edge of the documents' area (`edge`): docked there, it closes.
+     */
+    private dropWindow;
+    /** @internal Moves a document into a group of another manager: its tab, panel and content go along, nothing is made again. */
+    moveAcross(doc: TabDocument, group: TabGroup, index: number | undefined, byUser: boolean): boolean;
+    /** @internal Another manager is about to give this one a document: `onOpening` here may refuse it, or place it elsewhere. */
+    receiving(doc: TabDocument, group: TabGroup, index: number, byUser: boolean): DocumentOpeningEventArgs | null;
+    /** @internal Takes in the tab another manager let go of. */
+    receive(tab: DocumentTab, e: DocumentOpeningEventArgs, focus: boolean): void;
+    /** @internal What a context menu item does, as the user. */
+    runCommand(command: TabMenuCommand, group: TabGroup, document: TabDocument | null): void;
+    /** @internal Evens one split (a splitter's double click), or all of them. */
+    evenSizesBy(split: TabSplit | null, byUser: boolean): boolean;
+    /** @internal A splitter is about to move under the pointer or the keys. */
+    beginResize(owner?: SashOwner): boolean;
+    /** @internal */
+    endResize(moved: boolean, owner?: SashOwner): void;
+    private openDocument;
+    /** A new preview took the place of the group's old one: it closes, unless `onClosing` keeps it (then it stays for good). */
+    private replacePreview;
+    private insertTab;
+    private closeDocument;
+    /** Closes documents one after the other; pinned ones stay while `keepPinned` is on (unless `pinned`). */
+    private closeMany;
+    /** The documents after (`1`) or before (`-1`) one in its group. */
+    private sideOf;
+    private finishClose;
+    /** A window's close button: a document that may only be hidden is hidden, as a tool is; the others close. */
+    private closeOrHide;
+    /** Whether a document may be hidden: its own `allowHide`, else the manager's. */
+    private mayHide;
+    /** @internal Whether the close button of a dock area can do something with a document: close it, or hide it. Reactive. */
+    mayCloseOrHide(doc: TabDocument): boolean;
+    /** @internal The close button of a dock area's (or a window's) bar: the active document closes, or hides when it may not close. */
+    closeActiveByUser(group: TabGroup): void;
+    /** @internal "Show hidden": an item for each hidden document, which brings it back. */
+    hiddenItems(): MenuItem[];
+    private hideBy;
+    private showBy;
+    /** Where a hidden document goes back: the group named, the dock area named, its own group, its dock area, its window's place, or the documents. */
+    private showPlace;
+    /** The group a hidden document goes back into when there is none: in a dock area made again, or a floating window, or the documents' group. */
+    private makeHome;
+    /** The panel of a hidden document waits in the manager, out of sight. */
+    private stashPanel;
+    private renderHidden;
+    /** A document left this manager: it leaves the history and the recently used list. */
+    private forget;
+    /** A closed document leaves the history, and is kept for `reopenClosed` when its content can be made again. */
+    private remember;
+    private reopenBy;
+    /** The tab that becomes active when `tab`, the active one, closes. */
+    private nextAfterClose;
+    private activateDocument;
+    private fireActivated;
+    /** The manager's active document changed: it heads the recently used list and is a new step in the history. */
+    private visited;
+    private travel;
+    private renderHistory;
+    /** Activates the tab `by` places from the active one, around the ends. */
+    private step;
+    /** `force`: the window it is in is gone, nothing may keep it there. */
+    private moveDocument;
+    private moveToGroupBy;
+    private moveInGroupBy;
+    /** A drop into a group: among its tabs at `index` (`strip`), or where `openPosition` says. */
+    private dropInto;
+    /** A drop beside a group, or along an edge of the layout (`group` `null`; of a new window's, `host`): a new group there. */
+    private dropBeside;
+    /** A group of another manager dropped into one of this: its documents come over, its active one stays active. */
+    private takeGroup;
+    /** A group's documents join another group of this manager, and it closes. */
+    private mergeGroup;
+    private moveGroupBy;
+    /** A group the last document left closes when `closeEmptyGroups` says so (never the last group). */
+    private closeIfEmpty;
+    /** @internal A group whose documents all went elsewhere closes (never the documents' last group). */
+    closeMovedGroup(group: TabGroup, byUser: boolean): void;
+    /** The group of `item` nearest to where one comes from going `direction`; across that way, the one used last. */
+    private nearestGroup;
+    private keepBy;
+    private pinBy;
+    private lockBy;
+    private openNewBy;
+    /** Whether a document may get a copy in another group with content of its own. */
+    private mayCopy;
+    private copiesOnSplit;
+    private isLastCopy;
+    /** Where `open` puts a document without a group: the active group, else the one used last that is not locked. */
+    private targetGroup;
+    private insertIndex;
+    /** The first group, made on first need: a `ref` callback may call a method before the constructor is done. */
+    private ensureRoot;
+    private createGroup;
+    /**
+     * A new group beside `group`, or along an edge of the whole layout (`null`). `copy`: a copy of the
+     * document opens in it (when it can be copied); else the document moves there.
+     */
+    private splitGroup;
+    private closeGroupBy;
+    /** Takes an empty group out of the layout; a window or a dock area left without groups goes too. */
+    private removeGroup;
+    /**
+     * Takes an item out of the tree; a split left with one child gives its place to it. Returns the
+     * splits that are gone, to dispose once the tree is in place again (what they held moves out first).
+     */
+    private takeOut;
+    /** Puts `item` beside `target` in the tree, on the `direction` side; they share `target`'s room. */
+    private insertBeside;
+    /** Puts `item` along an edge of the whole layout. */
+    private insertAtEdge;
+    /** Puts `next` where `node` is in the tree and on the page. */
+    private replaceNode;
+    /** The top of a tree leaves its window or dock area, which is left empty; the documents' area gets an empty group in its place. */
+    private detachRoot;
+    /** What holds the tree `item` is in: a window, a dock area, the documents' area (`null`), or `undefined` when it is in none. */
+    private hostOf;
+    /** The groups of a window, a dock area or the documents' area (`null`), in layout order. */
+    private hostGroups;
+    private setHostRoot;
+    /** Puts `item` along an edge of a window or a dock area (`null`: the documents' area). */
+    private insertAtHostEdge;
+    private setRoot;
+    /**
+     * Puts every split's children in place, and writes down the groups in layout order: the
+     * documents' first, then each dock area's, then each floating window's.
+     */
+    private renderTree;
+    private createWindow;
+    /** A window made for a move that did not happen goes without a word. */
+    private discardWindow;
+    /** A window is gone: emptied, docked, or closed with its documents. */
+    private removeWindow;
+    /**
+     * Moves what is named into a new browser window. Returns the window; the floating window that
+     * opened in its place when the browser opened none; `null` when nothing moved (or the page it
+     * opens is still loading: the move comes once it has).
+     */
+    private newWindowBy;
+    /** `window.open`, or the app's `openWindow`; `null` when the browser opened nothing. */
+    private openView;
+    /** The browser opened no window (or one that cannot be used): `onError`, then a floating window when `fallback` says so. */
+    private windowRefused;
+    /** Where a new window opens: beside what moves into it, as large (or `newWindowSize`), on the screen. */
+    private newWindowRect;
+    /** A place on the screen as a place in the page's viewport. */
+    private viewportRect;
+    /** The new window is open and ready: the document, the group or the floating window's layout moves into it. */
+    private moveInto;
+    private createBrowserWindow;
+    /** A window made for a move that did not happen goes without a word. */
+    private discardBrowserWindow;
+    /** A new window is gone: emptied, its documents back in the main window, or closed. */
+    private removeBrowserWindow;
+    /** Takes off what a new window has from the manager, and closes it. */
+    private disposeBrowserWindow;
+    /** While new windows are open: the main window's place on the screen and its focus, and its going away (they close with it). */
+    private watchPage;
+    /**
+     * Back to the main window: a document into the group it came from (its window's `home`), else
+     * the main window's active group; a group's or a whole window's documents the same way, the
+     * active one staying active. A window left empty closes.
+     */
+    private mainWindowBy;
+    /** Closes a new window from code or a menu: its documents go back, or close (those that stay keep it open). */
+    private closeBrowserBy;
+    /** The floating windows a layout saved as new windows: each one opens as a new window again, if the browser lets it. */
+    private reopenWindowsBy;
+    private createArea;
+    private removeArea;
+    /** Windows and dock areas left without groups go. */
+    private dropEmptyHosts;
+    private orderedAreas;
+    /** The reactive lists: the dock areas in their order, the windows back to front. */
+    private renderLists;
+    /** @internal A window came to the front. */
+    windowRaised(): void;
+    /**
+     * @internal Places the dock areas, their splitters and the strips of folded ones around the
+     * documents, the outermost first: each takes its side of the room the ones before it left.
+     */
+    renderDock(): void;
+    /** @internal A dock area's size kept between its smallest and what leaves the documents their smallest. */
+    clampAreaSize(area: TabDockArea, px: number): number;
+    /** Shows the layout as `presentation` says, or by the manager's width; asks `onPresentationChanging` first. */
+    private resolvePresentation;
+    /** A screen that gets or loses its touch (a tablet with a keyboard and a mouse) may change the presentation. */
+    private watchPointer;
+    /** A dock area sized by a share follows the manager's size. */
+    private watchSize;
+    /** @internal A window kept inside the viewport (when `keepFloatingInView` is on), at least its strip in reach. */
+    keepWindowInView(w: TabWindow): void;
+    /** Where a window floated from `group` opens: at `at` (the pointer), else beside the group; as large as the group, or `floatingWindowSize`. */
+    private floatRect;
+    /** Whether the user and the code may float a document: its own `allowFloat`, else the manager's. */
+    private mayFloat;
+    /** Whether a document may go to a dock area (of `side`). */
+    private mayDock;
+    /** @internal Whether what is dragged may float, or (with `side`) go to that dock area. */
+    maySubject(drag: TabDragSubject, side: TabDockSide | 'float'): boolean;
+    /** @internal Whether a dock area may fold: the manager's `allowAutoHide`, and none of its documents says no. */
+    mayAutoHide(area: TabDockArea): boolean;
+    /** @internal Whether a group may be maximized: one of the main window's documents' groups, when there are two or more. */
+    canMaximize(group: TabGroup): boolean;
+    /** Whether a group left without documents goes: never the documents' last one; a window's last one when `closeEmptyWindows` says so; a dock area's last one, with the area. */
+    private removable;
+    /** Whether a group may close: any but the documents' last one. */
+    private closable;
+    /** @internal The top group under a point of the viewport: in the front window there, the slid out area, then the rest. */
+    groupAt(x: number, y: number, skip?: TabWindow | null): TabGroup | null;
+    /** @internal The windows, the front one first. */
+    windowsFrontFirst(): TabWindow[];
+    /** @internal Where a drag let go away from every guide and strip lands: a window at the pointer (for a window moved, where it is); `null` when it may not float. */
+    floatPlace(drag: TabDragSubject, x?: number, y?: number): TabDropPlace | null;
+    /** @internal The room a document or group docked on `side` would take: the area there, or a band of its size. */
+    dockAreaBox(side: TabDockSide): DOMRect;
+    private floatBy;
+    /** A group near `group` that stays where it is: its neighbour, else the documents' active one. */
+    private nearGroup;
+    private dockBy;
+    /** Into the dock area of `side`: a document joins its group used last, a group or a window's layout goes along its long side. */
+    private dockInto;
+    /** Back where it was docked before it floated: into that group, else that dock area, else the documents' active group. */
+    private dockBack;
+    /** The documents' group a window's documents go to: the one used last, not in a window or a dock area. */
+    private targetGroupOutside;
+    private autoHideBy;
+    /** Slides a folded area out with `doc` shown; `hover`: the pointer rests on its title, focus stays. */
+    private slideOut;
+    private slideBack;
+    /** Closes the slid out area without asking (it is going away, or another one slides out). */
+    private stopSlide;
+    /**
+     * While an area is slid out: a press outside it, Escape in it, or focus leaving it closes it. A
+     * menu or a popup opened from it (the tab's menu, a list) counts as inside.
+     */
+    private watchSlide;
+    /** @internal The pointer left a title and the area it slid out by resting on it: it slides back, unless focus went in. */
+    slideHoverEnded(area: TabDockArea): void;
+    /** @internal A title in a folded area's strip was chosen. */
+    slideByUser(doc: TabDocument, hover: boolean): void;
+    /** @internal The area slid out now. */
+    get slidArea(): TabDockArea | null;
+    private maximizeWindowBy;
+    private closeWindowBy;
+    private focusPartBy;
+    /** @internal The pin of a group in a dock area. */
+    toggleAutoHideByUser(group: TabGroup): void;
+    /** @internal */
+    toggleWindowMaximizeByUser(group: TabGroup): void;
+    /** @internal */
+    closeWindowByUser(group: TabGroup): void;
+    /** @internal "Move window…" from the keys. */
+    moveWindowByKeys(group: TabGroup | null): boolean;
+    private disposeSplits;
+    /** Makes a group the active one. */
+    private useGroup;
+    private maximizeBy;
+    private restoreBy;
+    /** Another group is used, split or closed: a maximized group gives the room back first. */
+    private restoreForChange;
+    private unmaximize;
+    private layoutChanging;
+    private layoutChanged;
+    /** @internal A floating window is about to move, be resized…: `onLayoutChanging` may stop it. */
+    windowChanging(change: TabLayoutChange, window: TabWindow, byUser: boolean): boolean;
+    /** @internal */
+    windowChanged(change: TabLayoutChange, window: TabWindow, byUser: boolean): void;
+    private writeNode;
+    private writeDocument;
+    /** A hidden document `saveLayout` wrote: made again, its content kept aside as its lifetime says, and where it goes back to. */
+    private readHidden;
+    private readNode;
+    private restoreDocument;
+    private registerKeys;
+    /** The recent list's key: opens the list, or walks it while it is open. */
+    private recentKey;
+    /** The tab of this manager (not of one inside it) whose header is `target`. */
+    private tabAt;
+    private stepByKey;
+    private stripKey;
+    private sashKey;
+    private renderTexts;
+    private renderMinSizes;
+    /**
+     * The sizes the props give a group and its tabs. Written on each group, not on the root, whose
+     * inline style is the app's to set (`style.cssText`).
+     */
+    private sizeGroup;
+    /** The strip's look: where pinned ones go and wrapping. Each group writes how its tabs are sized and its scroll buttons. */
+    private renderStrip;
+    /** A polite announcement for screen readers. */
+    private say;
+    /** @internal Said in the window that has focus: a screen reader reads the live regions of the window it is in. */
+    sayText(text: string): void;
+    private get parts();
+    private createParts;
+}