@xui/dock-manager 2.0.0-alpha.11

package/types/xui-dock-manager.d.ts

@@ -0,0 +1,571 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { ClassValue } from 'clsx';
+
+/**
+ * Declares the body of one content pane.
+ *
+ * The `contentId` links the template to the `contentId` of a
+ * {@link XuiDockContentPane} in the layout — the dock manager's equivalent of
+ * Ignite UI's `slot="…"` children.
+ *
+ * ```html
+ * <xui-dock-manager [(layout)]="layout">
+ *   <ng-template xuiDockContent="explorer">…</ng-template>
+ *   <ng-template xuiDockContent="editor">…</ng-template>
+ * </xui-dock-manager>
+ * ```
+ *
+ * The template is instantiated once, the first time its pane is shown, and the
+ * resulting view is then kept for as long as the pane is in the layout — docking,
+ * floating, unpinning and tab switching all move its DOM rather than rebuilding
+ * it, so scroll offsets, half-typed input and component state survive.
+ */
+declare class XuiDockContent {
+    /** Matches the `contentId` of a content pane in the layout. */
+    readonly contentId: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XuiDockContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<XuiDockContent, "ng-template[xuiDockContent]", never, { "contentId": { "alias": "xuiDockContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** What {@link XuiDockContentOutlet} needs from the dock manager above it. */
+interface XuiDockContentMounter {
+    /** Move the view for `contentId` into `host`, creating it on first use. */
+    mountContent(contentId: string, host: HTMLElement): void;
+    /** Park the view for `contentId` if — and only if — it still sits in `host`. */
+    releaseContent(contentId: string, host: HTMLElement): void;
+}
+declare const XUI_DOCK_CONTENT_MOUNTER: InjectionToken<XuiDockContentMounter>;
+/**
+ * Fills its host element with the content view for a `contentId`.
+ *
+ * Used internally by `xui-dock-manager` wherever a pane body is rendered.
+ */
+declare class XuiDockContentOutlet {
+    private readonly host;
+    private readonly mounter;
+    readonly contentId: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XuiDockContentOutlet, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<XuiDockContentOutlet, "[xuiDockContentOutlet]", never, { "contentId": { "alias": "xuiDockContentOutlet"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The dock manager's layout is a plain, serialisable tree — the same shape Ignite
+ * UI's `IgcDockManagerLayout` uses, so layouts port across with only the `Igc`
+ * prefix dropped. Nothing in the tree holds a DOM reference or an Angular type,
+ * which is what makes a layout safe to persist and restore.
+ */
+/** Discriminator for the four node kinds a layout tree is built from. */
+type XuiDockPaneType = 'splitPane' | 'contentPane' | 'tabGroupPane' | 'documentHost';
+/** Which axis a split pane lays its children out along. */
+type XuiDockSplitOrientation = 'horizontal' | 'vertical';
+/**
+ * Where a dragged pane lands relative to the pane it was dropped on. `start` and
+ * `end` are inline-relative, so they follow the reading direction.
+ */
+type XuiDockPosition = 'start' | 'end' | 'top' | 'bottom' | 'center';
+/** Which edge of the dock manager an unpinned pane's tab sits on. */
+type XuiDockUnpinnedLocation = 'start' | 'end' | 'top' | 'bottom';
+/** A floating pane's top-left corner, in pixels relative to the dock manager. */
+interface XuiDockPoint {
+    x: number;
+    y: number;
+}
+interface XuiDockPaneBase {
+    /**
+     * The pane's share of its parent split pane's main axis, as a weight relative
+     * to its siblings — two children sized `1` and `3` split the space 25/75.
+     * Defaults to `1`.
+     */
+    size?: number;
+}
+/**
+ * A leaf pane: a header and a body, where the body is whichever
+ * `[xuiDockContent]` template declares the matching `contentId`.
+ */
+interface XuiDockContentPane extends XuiDockPaneBase {
+    type: 'contentPane';
+    /** Links the pane to its `<ng-template [xuiDockContent]="…">`. Must be unique. */
+    contentId: string;
+    /** Text shown in the pane header, or in its tab when it sits in a tab group. */
+    header?: string;
+    /**
+     * `false` collapses the pane to a tab on one of the dock manager's edges; its
+     * position in the tree is kept, so re-pinning puts it back where it was.
+     * Defaults to `true`.
+     */
+    isPinned?: boolean;
+    /** Which edge an unpinned pane's tab sits on. Derived from the tree when unset. */
+    unpinnedLocation?: XuiDockUnpinnedLocation;
+    /** Thickness of the fly-out an unpinned pane opens, in pixels. Defaults to 280. */
+    unpinnedSize?: number;
+    /** `true` fills the whole dock manager, hiding every other pane. */
+    isMaximized?: boolean;
+    /**
+     * Restricts the pane to the document host — it cannot be docked outside one,
+     * floated or unpinned. Use it for editor-style tabs.
+     */
+    documentOnly?: boolean;
+    /** Show the close button and allow programmatic closing. Defaults to `true`. */
+    allowClose?: boolean;
+    /** Allow the pane to be dragged out of the layout into a floating window. Defaults to `true`. */
+    allowFloating?: boolean;
+    /** Allow the pane to be dragged and docked elsewhere in the layout. Defaults to `true`. */
+    allowDocking?: boolean;
+    /** Show the pin button. Defaults to `true`. */
+    allowPinning?: boolean;
+    /** Show the maximize button. Defaults to `true`. */
+    allowMaximize?: boolean;
+}
+/**
+ * Lays its children out along one axis with a draggable splitter between each
+ * pair. Doubles as the root of a floating window, which is where the `floating*`
+ * properties apply.
+ */
+interface XuiDockSplitPane extends XuiDockPaneBase {
+    type: 'splitPane';
+    orientation: XuiDockSplitOrientation;
+    panes: XuiDockPane[];
+    /**
+     * Keep the split pane in the tree once its last child is gone. Needed on a
+     * document host's root pane, which must survive closing every document.
+     */
+    allowEmpty?: boolean;
+    /** Top-left corner of the floating window, when this is a floating root. */
+    floatingLocation?: XuiDockPoint;
+    /** Floating window width in pixels. Defaults to 400. */
+    floatingWidth?: number;
+    /** Floating window height in pixels. Defaults to 300. */
+    floatingHeight?: number;
+    /** Show resize handles on the floating window. Defaults to `true`. */
+    floatingResizable?: boolean;
+}
+/** Stacks content panes as tabs, showing one at a time. */
+interface XuiDockTabGroupPane extends XuiDockPaneBase {
+    type: 'tabGroupPane';
+    panes: XuiDockContentPane[];
+    /** Index of the visible tab. Defaults to 0, and is clamped to the tab count. */
+    selectedIndex?: number;
+    /** Keep the tab group in the tree once its last tab is gone. */
+    allowEmpty?: boolean;
+}
+/**
+ * The area `documentOnly` panes live in — the editor surface of an IDE layout.
+ * A layout has at most one, and it is the only valid drop target for documents.
+ */
+interface XuiDockDocumentHost extends XuiDockPaneBase {
+    type: 'documentHost';
+    rootPane: XuiDockSplitPane;
+}
+/** Any node in the layout tree. */
+type XuiDockPane = XuiDockContentPane | XuiDockSplitPane | XuiDockTabGroupPane | XuiDockDocumentHost;
+/** A pane that holds children, and so can be a docking target for `center`. */
+type XuiDockParentPane = XuiDockSplitPane | XuiDockTabGroupPane;
+/** The whole layout: one docked tree plus any number of floating windows. */
+interface XuiDockManagerLayout {
+    rootPane: XuiDockSplitPane | XuiDockDocumentHost;
+    /** Each entry is the root of one floating window. */
+    floatingPanes?: XuiDockSplitPane[];
+}
+/** Emitted whenever a pane's pinned, maximized or floating state is toggled. */
+interface XuiDockPaneStateEvent {
+    pane: XuiDockContentPane;
+    value: boolean;
+}
+declare function isContentPane(pane: XuiDockPane): pane is XuiDockContentPane;
+declare function isSplitPane(pane: XuiDockPane): pane is XuiDockSplitPane;
+declare function isTabGroupPane(pane: XuiDockPane): pane is XuiDockTabGroupPane;
+declare function isDocumentHost(pane: XuiDockPane): pane is XuiDockDocumentHost;
+declare function isParentPane(pane: XuiDockPane): pane is XuiDockParentPane;
+
+/**
+ * A stable string key for a pane object, allocated on first use.
+ *
+ * Used for `@for` tracking and for finding the pane behind a DOM element during a
+ * drag. Keyed by object identity, so it survives every operation in this file and
+ * is *not* preserved by {@link cloneDockLayout}.
+ */
+declare function dockPaneKey(pane: XuiDockPane): string;
+/**
+ * A structural copy of the layout, safe to keep as an undo snapshot.
+ *
+ * A round-trip through JSON, which the layout's own contract allows: every node
+ * is plain data. The copy is a *different* set of objects, so its panes get fresh
+ * {@link dockPaneKey}s and restoring it replaces the rendered panes rather than
+ * moving them.
+ */
+declare function cloneDockLayout(layout: XuiDockManagerLayout): XuiDockManagerLayout;
+/** The child panes of `pane`, or an empty array for a leaf. */
+declare function dockChildren(pane: XuiDockPane): readonly XuiDockPane[];
+/** Every root of the layout: the docked tree, then each floating window. */
+declare function dockRoots(layout: XuiDockManagerLayout): XuiDockPane[];
+/**
+ * Depth-first walk over every pane in the layout, floating windows included.
+ * Returning `false` from `visitor` skips that pane's subtree.
+ */
+declare function visitDockPanes(layout: XuiDockManagerLayout, visitor: (pane: XuiDockPane) => boolean | void): void;
+/** The pane whose `panes` array holds `pane`, or `null` for a root. */
+declare function findDockParent(layout: XuiDockManagerLayout, pane: XuiDockPane): XuiDockParentPane | null;
+/** `pane`'s ancestors, nearest first. */
+declare function dockAncestors(layout: XuiDockManagerLayout, pane: XuiDockPane): XuiDockPane[];
+/** The layout's document host, if it has one. */
+declare function findDocumentHost(layout: XuiDockManagerLayout): XuiDockDocumentHost | null;
+/** Whether `pane` sits inside the document host. */
+declare function isInDocumentHost(layout: XuiDockManagerLayout, pane: XuiDockPane): boolean;
+/** Whether `pane` is the root of a floating window. */
+declare function isFloatingRoot(layout: XuiDockManagerLayout, pane: XuiDockPane): boolean;
+/** Whether `pane` is a root that must not be collapsed away. */
+declare function isDockRoot(layout: XuiDockManagerLayout, pane: XuiDockPane): boolean;
+/** Every content pane in the layout, in tree order. */
+declare function collectContentPanes(layout: XuiDockManagerLayout): XuiDockContentPane[];
+/** The content pane that is currently maximized, if any. */
+declare function findMaximizedPane(layout: XuiDockManagerLayout): XuiDockContentPane | null;
+/**
+ * Whether the pane takes up space in the docked layout. An unpinned content pane
+ * does not, and neither does a split pane or tab group whose whole subtree is
+ * unpinned — otherwise collapsing a sidebar would leave a gap behind it.
+ */
+declare function isDockPaneVisible(pane: XuiDockPane): boolean;
+/** The children of `pane` that take up space, in order. */
+declare function visibleDockChildren(pane: XuiDockPane): XuiDockPane[];
+/** The tab a tab group shows: its `selectedIndex`, or the first pinned tab. */
+declare function selectedTabPane(group: XuiDockTabGroupPane): XuiDockContentPane | null;
+/**
+ * Which edge an unpinned pane collapses to when `unpinnedLocation` is unset.
+ *
+ * Follows the pane's own position in the tree — a pane in the first branch of a
+ * horizontal split goes to the inline start, one in the last branch to the inline
+ * end — so a sidebar collapses to the side it was already on.
+ */
+declare function defaultUnpinnedLocation(layout: XuiDockManagerLayout, pane: XuiDockPane): XuiDockUnpinnedLocation;
+/** The unpinned content panes, grouped by the edge their tabs sit on. */
+declare function unpinnedDockPanes(layout: XuiDockManagerLayout): Record<XuiDockUnpinnedLocation, XuiDockContentPane[]>;
+/**
+ * Tidy the tree after a mutation: drop empty parents, unwrap split panes down to
+ * a single child, merge nested splits that run along the same axis, and clamp
+ * every tab group's selected index.
+ *
+ * Roots survive all of this — `layout.rootPane`, a floating window's root and a
+ * document host's root pane are structural and stay put even when empty. A root
+ * left with a single split pane beneath it absorbs that child rather than being
+ * replaced by it.
+ */
+declare function normalizeDockLayout(layout: XuiDockManagerLayout): void;
+/**
+ * Detach `pane` from wherever it sits — a parent's `panes`, or the floating
+ * window list — and tidy up behind it. Returns `false` if it was not in the
+ * layout at all.
+ */
+declare function removeDockPane(layout: XuiDockManagerLayout, pane: XuiDockPane): boolean;
+/**
+ * Whether `pane` may be dropped onto `target`.
+ *
+ * A `documentOnly` pane is confined to the document host; anything else may dock
+ * anywhere. A pane can never be dropped onto itself or into its own subtree.
+ */
+declare function canDockInto(layout: XuiDockManagerLayout, pane: XuiDockPane, target: XuiDockPane, position: XuiDockPosition): boolean;
+/**
+ * Attach `pane` to the layout next to `target`.
+ *
+ * `center` tabs the pane together with the target — turning a lone content pane
+ * into a two-tab group — while the four edge positions split the space. An edge
+ * drop reuses the target's parent when it already runs along the right axis, so
+ * dropping three panes to the right of each other yields one three-way split
+ * rather than three nested ones.
+ */
+declare function insertDockPane(layout: XuiDockManagerLayout, pane: XuiDockPane, target: XuiDockPane, position: XuiDockPosition): boolean;
+/** Move `pane` out of the layout and into a floating window of its own. */
+declare function floatDockPane(layout: XuiDockManagerLayout, pane: XuiDockPane, location: XuiDockPoint, size?: {
+    width: number;
+    height: number;
+}): XuiDockSplitPane | null;
+/** Move `pane` from wherever it is to `position` relative to `target`. */
+declare function dockPaneAt(layout: XuiDockManagerLayout, pane: XuiDockPane, target: XuiDockPane, position: XuiDockPosition): boolean;
+
+interface DropTarget {
+    pane: XuiDockPane;
+    position: XuiDockPosition;
+}
+/**
+ * One square of the docking joystick, positioned in coordinates relative to the
+ * dock manager. `side` is the *visual* half it fills in, which is the mirror of
+ * `position` on the inline axis in RTL.
+ */
+interface DockIndicator extends DropTarget {
+    key: string;
+    side: 'left' | 'right' | 'top' | 'bottom' | 'center';
+    left: number;
+    top: number;
+    active: boolean;
+}
+interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/**
+ * An IDE-style docking layout: resizable split panes, tab groups, a document
+ * host, collapsible edge panels and floating windows, all driven by one
+ * serialisable {@link XuiDockManagerLayout} tree.
+ *
+ * ```html
+ * <xui-dock-manager [(layout)]="layout" class="h-[32rem]">
+ *   <ng-template xuiDockContent="explorer">…</ng-template>
+ *   <ng-template xuiDockContent="editor">…</ng-template>
+ * </xui-dock-manager>
+ * ```
+ *
+ * The layout shape follows Ignite UI's `IgcDockManagerLayout`, so existing
+ * layouts port over by dropping the `Igc` prefix and using string literals in
+ * place of its enums.
+ *
+ * Panes carry no content of their own: each one names a `contentId`, and the
+ * matching `[xuiDockContent]` template supplies the body. Those bodies are
+ * instantiated once and then *moved* as the layout changes, so a pane keeps its
+ * scroll position and component state when it is dragged to another dock, tabbed,
+ * floated or collapsed.
+ *
+ * `layout` is two-way bindable and the dock manager edits the tree **in place**
+ * before emitting, which is what keeps pane identity stable across a drag. Bind a
+ * signal to it and snapshot with `cloneDockLayout()` if you need an undo buffer.
+ *
+ * Dragging is a pointer gesture. Picking up a pane raises Visual Studio's docking
+ * targets: a five-way joystick over whichever pane is under the pointer — four
+ * arms to split it, the centre to tab with it — and an outer ring at the dock
+ * manager's edges to dock against the whole layout. Only the targets the dragged
+ * pane is allowed to take are drawn, and the one that would be used is
+ * highlighted while an outline previews the space it would claim.
+ *
+ * Off the targets, the two gestures differ. A header or tab drag has no other
+ * purpose, so the whole pane stays live and the nearest edge wins; dropping
+ * outside the layout floats the pane. Dragging a floating window's title bar is
+ * mostly about *moving* the window, so it docks from the targets alone.
+ *
+ * Every other operation — close, pin, maximize, float, tab selection, splitter
+ * resize — is reachable from the keyboard, and the public methods (`closePane`,
+ * `unpinPane`, `dockPane`, …) drive the same paths for code. Docking itself has no
+ * keyboard equivalent yet.
+ */
+declare class XuiDockManager implements XuiDockContentMounter {
+    private readonly el;
+    private readonly document;
+    private readonly vcr;
+    private readonly direction;
+    /** Detached parking space for the content views of panes that are not on screen. */
+    private readonly holder;
+    private readonly views;
+    private readonly contents;
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    /**
+     * The layout tree. Two-way bindable, and edited **in place** — see the class
+     * docs for why, and use `cloneDockLayout()` for snapshots.
+     */
+    readonly layout: _angular_core.ModelSignal<XuiDockManagerLayout>;
+    /** A pane was closed and removed from the layout. */
+    readonly paneClose: _angular_core.OutputEmitterRef<XuiDockContentPane>;
+    /** The pane the user last interacted with, or `null` once it is gone. */
+    readonly activePaneChange: _angular_core.OutputEmitterRef<XuiDockContentPane | null>;
+    readonly panePinnedChange: _angular_core.OutputEmitterRef<XuiDockPaneStateEvent>;
+    readonly paneMaximizedChange: _angular_core.OutputEmitterRef<XuiDockPaneStateEvent>;
+    readonly paneFloatingChange: _angular_core.OutputEmitterRef<XuiDockPaneStateEvent>;
+    /** A pointer drag on a pane header or tab began. */
+    readonly paneDragStart: _angular_core.OutputEmitterRef<XuiDockPane>;
+    /** A pointer drag ended, whether or not it changed the layout. */
+    readonly paneDragEnd: _angular_core.OutputEmitterRef<XuiDockPane>;
+    /** The pane last interacted with. Drives the active header accent. */
+    readonly activePane: _angular_core.WritableSignal<XuiDockContentPane | null>;
+    private readonly drag;
+    private readonly dropTarget;
+    protected readonly dropRect: _angular_core.WritableSignal<Rect | null>;
+    protected readonly dockIndicators: _angular_core.WritableSignal<DockIndicator[]>;
+    /** The unpinned pane whose fly-out is open. */
+    protected readonly flyout: _angular_core.WritableSignal<XuiDockContentPane | null>;
+    protected readonly maximized: _angular_core.Signal<XuiDockContentPane | null>;
+    protected readonly unpinned: _angular_core.Signal<Record<XuiDockUnpinnedLocation, XuiDockContentPane[]>>;
+    protected readonly floatingPanes: _angular_core.Signal<XuiDockSplitPane[]>;
+    protected readonly dragGhost: _angular_core.Signal<{
+        x: number;
+        y: number;
+        label: string;
+    } | null>;
+    /** Exposed to the template so an indicator's box matches its hit area exactly. */
+    protected readonly INDICATOR_SIZE = 30;
+    /** Exposed to the template; the ids double as the axis to resize along. */
+    protected readonly RESIZE_HANDLES: readonly [{
+        readonly id: "top";
+        readonly class: "absolute -top-1 inset-x-2 h-2 cursor-ns-resize";
+    }, {
+        readonly id: "bottom";
+        readonly class: "absolute -bottom-1 inset-x-2 h-2 cursor-ns-resize";
+    }, {
+        readonly id: "left";
+        readonly class: "absolute -left-1 inset-y-2 w-2 cursor-ew-resize";
+    }, {
+        readonly id: "right";
+        readonly class: "absolute -right-1 inset-y-2 w-2 cursor-ew-resize";
+    }, {
+        readonly id: "top-left";
+        readonly class: "absolute -top-1 -left-1 size-3 cursor-nwse-resize";
+    }, {
+        readonly id: "top-right";
+        readonly class: "absolute -top-1 -right-1 size-3 cursor-nesw-resize";
+    }, {
+        readonly id: "bottom-left";
+        readonly class: "absolute -bottom-1 -left-1 size-3 cursor-nesw-resize";
+    }, {
+        readonly id: "bottom-right";
+        readonly class: "absolute -right-1 -bottom-1 size-3 cursor-nwse-resize";
+    }];
+    constructor();
+    mountContent(contentId: string, host: HTMLElement): void;
+    releaseContent(contentId: string, host: HTMLElement): void;
+    /** Remove `pane` from the layout. Respects `allowClose`. */
+    closePane(pane: XuiDockContentPane): void;
+    /** Close every pane in a floating window. */
+    closeWindow(window: XuiDockSplitPane): void;
+    /** Collapse `pane` to a tab on the nearest edge, keeping its place in the tree. */
+    unpinPane(pane: XuiDockContentPane): void;
+    /** Restore `pane` to the position it was collapsed from. */
+    pinPane(pane: XuiDockContentPane): void;
+    togglePinned(pane: XuiDockContentPane): void;
+    /** Blow `pane` up to fill the whole dock manager, hiding everything else. */
+    maximizePane(pane: XuiDockContentPane): void;
+    restorePane(pane: XuiDockContentPane): void;
+    toggleMaximized(pane: XuiDockContentPane): void;
+    /** Move `pane` into a floating window of its own. */
+    floatPane(pane: XuiDockPane, location?: XuiDockPoint, size?: {
+        width: number;
+        height: number;
+    }): void;
+    /** Dock `pane` at `position` relative to `target`. */
+    dockPane(pane: XuiDockPane, target: XuiDockPane, position: XuiDockPosition): boolean;
+    /** Make `pane` the active one, selecting its tab and opening its fly-out. */
+    selectPane(pane: XuiDockContentPane): void;
+    protected readonly key: typeof dockPaneKey;
+    protected childrenOf(pane: XuiDockPane): XuiDockPane[];
+    protected unpinnedAt(location: XuiDockUnpinnedLocation): XuiDockContentPane[];
+    protected pinnedTabs(group: XuiDockTabGroupPane): XuiDockContentPane[];
+    protected selectedTab(group: XuiDockTabGroupPane): XuiDockContentPane | null;
+    protected flexOf(pane: XuiDockPane): string;
+    protected headerOf(pane: XuiDockPane): string;
+    /** The pane a floating window's title bar drags: its lone pane, or the root. */
+    protected floatingContent(window: XuiDockSplitPane): XuiDockPane;
+    protected singlePane(window: XuiDockSplitPane): XuiDockContentPane | null;
+    protected floatingTitle(window: XuiDockSplitPane): string;
+    protected isFloating(pane: XuiDockPane): boolean;
+    protected toggleFlyout(pane: XuiDockContentPane): void;
+    protected activate(pane: XuiDockContentPane): void;
+    protected onEscape(): void;
+    /** Dock a whole floating window back into the layout root. */
+    protected dockBack(window: XuiDockSplitPane): void;
+    private dockBackPane;
+    protected bringToFront(window: XuiDockSplitPane): void;
+    protected startSplitterDrag(parent: XuiDockSplitPane, gutter: number, event: PointerEvent): void;
+    protected onSplitterKeydown(parent: XuiDockSplitPane, gutter: number, event: KeyboardEvent): void;
+    private clampSplitterDelta;
+    /** Re-weight two siblings so `before` takes `beforePx` of their shared `totalPx`. */
+    private resizeSiblings;
+    protected startFloatingResize(window: XuiDockSplitPane, handle: string, event: PointerEvent): void;
+    /**
+     * Start a drag on a pane header, a tab, or a floating window's title bar.
+     *
+     * A window drag moves the window as it goes and docks it if it is released over
+     * a valid target; a pane drag shows a ghost and either docks the pane or floats
+     * it where it was dropped.
+     */
+    protected startPaneDrag(pane: XuiDockPane, window: XuiDockSplitPane | null, event: PointerEvent): void;
+    protected cancelDrag(): void;
+    private clearDrag;
+    private floatAtPointer;
+    /**
+     * Work out where a drop at these coordinates would land, and size the preview
+     * rectangle to match.
+     *
+     * The dock manager's own edges win over whatever pane happens to be under the
+     * pointer, so there is always a way to dock against the full height or width of
+     * the layout.
+     */
+    private updateDropTarget;
+    /**
+     * The target for a drop that missed every indicator.
+     *
+     * A header or tab drag has no purpose other than docking, so the whole pane
+     * stays live and the nearest edge wins. Dragging a floating window is mostly
+     * about *moving* it, so it docks from the indicators alone.
+     */
+    private looseTargetAt;
+    /**
+     * The joystick over the pane under the pointer, plus the outer ring that docks
+     * against the whole layout — Visual Studio's docking targets.
+     *
+     * Only the positions the dragged pane is actually allowed to take are built, so
+     * a document dragged over a tool window simply offers nothing.
+     */
+    private buildIndicators;
+    /** A drop within `OUTER_EDGE` of the dock manager's frame docks the whole layout. */
+    private outerEdgeAt;
+    /**
+     * The pane under the pointer.
+     *
+     * Hit-tested against the rendered rectangles rather than `elementFromPoint`, so
+     * the drag ghost, the indicators and the floating window riding along with the
+     * pointer cannot get in the way. The innermost rectangle wins, and on a tie the
+     * one painted last does.
+     */
+    private paneAt;
+    /** Split `pane` along whichever edge the pointer sits nearest, or tab at its centre. */
+    private zoneTargetAt;
+    /** The slice of `rect` a drop would occupy, in coordinates relative to the host. */
+    private previewRect;
+    private elementForPane;
+    private paneForKey;
+    private release;
+    /** Follow the pointer until it is released, then clean up after ourselves. */
+    private trackPointer;
+    private stopPointerTracking;
+    /**
+     * Publish the in-place edits made to the tree.
+     *
+     * Skip normalisation for the continuous gestures — a resize or a window move
+     * cannot change the tree's shape, and re-walking it on every pointer event is
+     * wasted work.
+     */
+    private commit;
+    private contentPanesOf;
+    private tabGroupOf;
+    protected onTabKeydown(group: XuiDockTabGroupPane, event: KeyboardEvent): void;
+    protected readonly computedClass: _angular_core.Signal<string>;
+    protected splitClass(pane: XuiDockPane): string;
+    protected frameClass(pane: XuiDockPane): string;
+    /** Whether the pane on screen in this frame is the active one. */
+    private isActiveFrame;
+    protected headerClass(pane: XuiDockPane): string;
+    protected tabStripClass(): string;
+    protected tabClass(group: XuiDockTabGroupPane, tab: XuiDockContentPane): string;
+    protected tabCloseClass(): string;
+    protected actionClass(): string;
+    protected gutterClass(pane: XuiDockPane): string;
+    protected gutterHandleClass(pane: XuiDockPane): string;
+    protected stripClass(location: XuiDockUnpinnedLocation): string;
+    protected stripTabClass(location: XuiDockUnpinnedLocation, pane: XuiDockContentPane): string;
+    protected flyoutClass(): string;
+    protected flyoutStyle(pane: XuiDockContentPane): Record<string, string>;
+    protected floatingClass(): string;
+    protected floatingStyle(window: XuiDockSplitPane): Record<string, string>;
+    protected indicatorClass(indicator: DockIndicator): string;
+    /**
+     * The shaded block inside an indicator, showing which part of the target the
+     * pane will take — the same visual language as Visual Studio's dock targets.
+     */
+    protected indicatorFillClass(indicator: DockIndicator): string;
+    protected titleBarClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XuiDockManager, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XuiDockManager, "xui-dock-manager", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": true; "isSignal": true; }; }, { "layout": "layoutChange"; "paneClose": "paneClose"; "activePaneChange": "activePaneChange"; "panePinnedChange": "panePinnedChange"; "paneMaximizedChange": "paneMaximizedChange"; "paneFloatingChange": "paneFloatingChange"; "paneDragStart": "paneDragStart"; "paneDragEnd": "paneDragEnd"; }, ["contents"], never, true, never>;
+}
+
+declare const XuiDockManagerImports: readonly [typeof XuiDockManager, typeof XuiDockContent];
+
+export { XUI_DOCK_CONTENT_MOUNTER, XuiDockContent, XuiDockContentOutlet, XuiDockManager, XuiDockManagerImports, canDockInto, cloneDockLayout, collectContentPanes, defaultUnpinnedLocation, dockAncestors, dockChildren, dockPaneAt, dockPaneKey, dockRoots, findDockParent, findDocumentHost, findMaximizedPane, floatDockPane, insertDockPane, isContentPane, isDockPaneVisible, isDockRoot, isDocumentHost, isFloatingRoot, isInDocumentHost, isParentPane, isSplitPane, isTabGroupPane, normalizeDockLayout, removeDockPane, selectedTabPane, unpinnedDockPanes, visibleDockChildren, visitDockPanes };
+export type { XuiDockContentMounter, XuiDockContentPane, XuiDockDocumentHost, XuiDockManagerLayout, XuiDockPane, XuiDockPaneStateEvent, XuiDockPaneType, XuiDockParentPane, XuiDockPoint, XuiDockPosition, XuiDockSplitOrientation, XuiDockSplitPane, XuiDockTabGroupPane, XuiDockUnpinnedLocation };