@widgetstools/dock-manager-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1478 @@
+/**
+ * Core types for the dock manager layout system.
+ *
+ * These types define the shape of the layout tree, panel configuration,
+ * floating/popout/unpinned panel state, and dock events.
+ *
+ * @module dock
+ */
+/**
+ * Direction of a split divider.
+ * - `'horizontal'` splits children left-to-right.
+ * - `'vertical'` splits children top-to-bottom.
+ */
+type SplitDirection = 'horizontal' | 'vertical';
+/**
+ * Position for docking a panel relative to a target tab group.
+ * - `'center'` adds the panel as a new tab in the group.
+ * - `'left' | 'right' | 'top' | 'bottom'` creates a new split beside the target.
+ */
+type DockPosition = 'left' | 'right' | 'top' | 'bottom' | 'center';
+/**
+ * Edge of the dock container where an unpinned panel strip can appear.
+ * Bottom, left, and right are supported; top is not.
+ */
+type DockEdge = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * Position of the tab header bar within a tab group.
+ */
+type HeaderPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Configuration for a single panel in the dock manager.
+ *
+ * Panels are the atomic content units displayed inside tab groups,
+ * floating windows, or unpinned strips.
+ */
+interface PanelConfig {
+    /** Unique identifier for this panel. */
+    id: string;
+    /** Display title shown in the tab header. */
+    title: string;
+    /** Optional icon key or URL rendered beside the title. */
+    icon?: string;
+    /** If true, prevents ALL user interactions with this pane (drag, close, resize, etc.) */
+    disabled?: boolean;
+    /** Whether the user can close this panel. Defaults to `true`. */
+    closable?: boolean;
+    /** Whether the user can float this panel into a separate window. Defaults to `true`. */
+    floatable?: boolean;
+    /** Whether other panels can be docked to this one. Defaults to `true`. */
+    allowDocking?: boolean;
+    /** Whether to show the maximize button in the tab group header. Defaults to `true`. */
+    allowMaximize?: boolean;
+    /** Whether to show the pin/unpin button. Defaults to `true`. */
+    allowPinning?: boolean;
+    /** If `true`, the panel is restricted to the document host area only. Defaults to `false`. */
+    documentOnly?: boolean;
+    /**
+     * Whether this panel is currently maximized.
+     * @deprecated Use `DockManagerState.maximizedPanelId` instead.
+     */
+    isMaximized?: boolean;
+    /** Minimum size in pixels (applies to both width and height). */
+    minimumSize?: number;
+    /** Minimum width in pixels. */
+    minimumWidth?: number;
+    /** Maximum width in pixels. */
+    maximumWidth?: number;
+    /** Minimum height in pixels. */
+    minimumHeight?: number;
+    /** Maximum height in pixels. */
+    maximumHeight?: number;
+    /** Component key used to resolve the panel's content renderer. */
+    content?: string;
+    /** Component key used to resolve a custom tab renderer. */
+    tabComponent?: string;
+    /** Whether this floating panel can be resized. Defaults to true. */
+    floatingResizable?: boolean;
+    /**
+     * Widget type identifier. Used by the consuming app's widget registry
+     * to resolve which component to render in this panel.
+     * @example `"chart"`, `"table"`, `"editor"`, `"route"`
+     */
+    widgetType?: string;
+    /**
+     * Widget-specific props/configuration. Passed to the component via PanelApi.
+     * Must be JSON-serializable (no functions, no DOM refs).
+     * @example `{ symbol: "AAPL", timeframe: "1D" }`
+     */
+    widgetProps?: Record<string, unknown>;
+    /**
+     * Badge text displayed after the panel title (e.g. notification count, unsaved dot).
+     * Set via PanelApi.setBadge(). Persists across serialization.
+     */
+    badge?: string | null;
+    /**
+     * Whether this panel is hidden (invisible but not removed from layout).
+     * Hidden panels don't render content but retain their position in the tree.
+     */
+    hidden?: boolean;
+}
+/**
+ * A leaf node in the layout tree representing a tab group.
+ *
+ * A tab group displays one or more panels as tabs. Exactly one panel
+ * is visible (the `activePanel`) at any time.
+ */
+interface TabGroupNode {
+    /** Discriminator for the layout node union. Always `'tabgroup'`. */
+    type: 'tabgroup';
+    /** Unique identifier for this tab group (e.g. `'tg_abc123'`). */
+    id: string;
+    /** Ordered list of panel IDs contained in this group. */
+    panels: string[];
+    /** The panel ID of the currently visible tab. */
+    activePanel: string;
+    /** Where to render the tab header bar. Defaults to `'top'` if omitted. */
+    headerPosition?: HeaderPosition;
+}
+/**
+ * A branch node in the layout tree representing a split container.
+ *
+ * A split node divides its space among two or more child nodes
+ * (tab groups or nested splits) separated by draggable dividers.
+ */
+interface SplitNode {
+    /** Discriminator for the layout node union. Always `'split'`. */
+    type: 'split';
+    /** Unique identifier for this split (e.g. `'split_abc123'`). */
+    id: string;
+    /** Whether children are arranged horizontally or vertically. */
+    direction: SplitDirection;
+    /** Child layout nodes. Must have at least two entries. */
+    children: LayoutNode[];
+    /** Size of each child as a percentage. Must sum to 100. */
+    sizes: number[];
+}
+/**
+ * A node in the layout tree. Either a leaf {@link TabGroupNode} or
+ * a branch {@link SplitNode}.
+ */
+type LayoutNode = TabGroupNode | SplitNode;
+/**
+ * Describes a panel that has been detached from the layout tree
+ * and is rendered as a draggable, resizable floating window.
+ */
+interface FloatingPanel {
+    /** The ID of the panel being floated. */
+    panelId: string;
+    /** Horizontal offset in pixels from the dock container's left edge. */
+    x: number;
+    /** Vertical offset in pixels from the dock container's top edge. */
+    y: number;
+    /** Width of the floating window in pixels. */
+    width: number;
+    /** Height of the floating window in pixels. */
+    height: number;
+    /** CSS z-index controlling stacking order among floating panels. */
+    zIndex: number;
+    /** The tab group ID this panel was in before being floated. Used to dock back to original location. */
+    sourceTabGroupId?: string;
+}
+/**
+ * Describes a panel rendered in a separate browser window (popout).
+ */
+interface PopoutPanel {
+    /** The ID of the panel shown in the popout window. */
+    panelId: string;
+    /** The `window.name` of the popout browser window. */
+    windowName: string;
+    /** Horizontal screen position of the popout window in pixels. */
+    x: number;
+    /** Vertical screen position of the popout window in pixels. */
+    y: number;
+    /** Width of the popout window in pixels. */
+    width: number;
+    /** Height of the popout window in pixels. */
+    height: number;
+}
+/**
+ * Describes a panel that has been unpinned from the layout and is
+ * rendered as an auto-hide strip along a container edge.
+ */
+interface UnpinnedPanel {
+    /** The ID of the unpinned panel. */
+    panelId: string;
+    /** The edge of the dock container where the strip is rendered. */
+    edge: DockEdge;
+    /** Width (for left/right edges) or height (for bottom) in pixels when expanded. */
+    size: number;
+    /** The tab group ID the panel was removed from (used to restore on pin-back). */
+    sourceTabGroupId?: string;
+}
+/**
+ * Complete state of the dock manager.
+ *
+ * This is the single source of truth for layout, panel configuration,
+ * floating windows, popouts, and unpinned strips. It is fully serializable
+ * and can be persisted/restored via `LOAD_STATE`.
+ *
+ * @example
+ * ```ts
+ * const state: DockManagerState = createDefaultState();
+ * ```
+ */
+interface DockManagerState {
+    /** The root of the layout tree describing docked panels. */
+    layout: LayoutNode;
+    /** Map of panel ID to its configuration. */
+    panels: Record<string, PanelConfig>;
+    /** Panels currently rendered as floating windows. */
+    floatingPanels: FloatingPanel[];
+    /** Panels currently rendered in separate browser windows. */
+    popoutPanels: PopoutPanel[];
+    /** Panels removed from the layout and shown as auto-hide strips. */
+    unpinnedPanels: UnpinnedPanel[];
+    /** Counter used to assign z-index values to floating panels. */
+    nextZIndex: number;
+    /** The panel ID that is currently focused (shown with an active indicator). */
+    activePaneId: string;
+    /** The panel ID currently displayed in maximized (full-container) mode, if any. */
+    maximizedPanelId?: string;
+}
+/** Discriminated event type identifiers emitted by the dock manager. */
+type DockEventType = 'paneClose' | 'paneDragStart' | 'paneDragOver' | 'paneDragEnd' | 'activePaneChanged' | 'splitterResizeStart' | 'splitterResizeEnd' | 'layoutChanged' | 'paneMaximized' | 'paneRestored' | 'willDrop' | 'willFocus' | 'willClose' | 'willMaximize';
+/** Base dock manager event. */
+interface DockEvent {
+    /** The event type identifier. */
+    type: DockEventType;
+    /** The panel associated with this event, if any. */
+    panelId?: string;
+    /** Whether the event was cancelled by a listener. */
+    cancelled?: boolean;
+}
+/** An event that can be prevented from executing its default behavior */
+interface PreventableDockEvent extends DockEvent {
+    defaultPrevented: boolean;
+    preventDefault(): void;
+}
+/**
+ * Create a {@link PreventableDockEvent} that listeners can cancel
+ * by calling `event.preventDefault()`.
+ *
+ * @param type - The event type identifier.
+ * @param panelId - Optional panel ID associated with the event.
+ * @returns A new preventable event instance.
+ */
+declare function createPreventableEvent(type: DockEventType, panelId?: string): PreventableDockEvent;
+/** Aggregated size constraints for a layout node, derived from its children. */
+interface LayoutConstraints {
+    /** Minimum width in pixels. */
+    minimumWidth?: number;
+    /** Maximum width in pixels. */
+    maximumWidth?: number;
+    /** Minimum height in pixels. */
+    minimumHeight?: number;
+    /** Maximum height in pixels. */
+    maximumHeight?: number;
+}
+
+/**
+ * Resource strings for localization of dock manager UI elements.
+ *
+ * Consumers can provide partial overrides via `DockviewComponentOptions.resourceStrings`.
+ */
+interface DockResourceStrings {
+    close: string;
+    closeOthers: string;
+    closeAll: string;
+    float: string;
+    pin: string;
+    unpin: string;
+    maximize: string;
+    restore: string;
+    dock: string;
+}
+declare const defaultResourceStrings: DockResourceStrings;
+
+/**
+ * Dock Manager Reducer
+ *
+ * Pure reducer function for immutable state management.
+ * Uses LayoutTree module for all tree operations.
+ */
+
+type DockAction = {
+    type: 'ADD_PANEL';
+    payload: {
+        panelId: string;
+        title: string;
+        icon?: string;
+        closable?: boolean;
+        floatable?: boolean;
+        tabComponent?: string;
+        widgetType?: string;
+        widgetProps?: Record<string, unknown>;
+    };
+} | {
+    type: 'MOVE_PANEL';
+    payload: {
+        panelId: string;
+        targetTabGroupId: string;
+        position: DockPosition;
+    };
+} | {
+    type: 'CLOSE_PANEL';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'FLOAT_PANEL';
+    payload: {
+        panelId: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'DOCK_FLOATING';
+    payload: {
+        panelId: string;
+        targetTabGroupId: string;
+        position: DockPosition;
+    };
+} | {
+    type: 'UPDATE_FLOATING';
+    payload: {
+        panelId: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    };
+} | {
+    type: 'SET_ACTIVE_PANEL';
+    payload: {
+        tabGroupId: string;
+        panelId: string;
+    };
+} | {
+    type: 'RESIZE_SPLIT';
+    payload: {
+        splitId: string;
+        sizes: number[];
+    };
+} | {
+    type: 'BRING_TO_FRONT';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'UNPIN_PANEL';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'PIN_PANEL';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'LOAD_STATE';
+    payload: DockManagerState;
+} | {
+    type: 'MAXIMIZE_PANEL';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'RESTORE_PANEL';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'SET_ACTIVE_PANE';
+    payload: {
+        panelId: string;
+    };
+} | {
+    type: 'UPDATE_PANEL_CONFIG';
+    payload: {
+        panelId: string;
+        updates: Partial<PanelConfig>;
+    };
+} | {
+    type: 'POPOUT_PANEL';
+    payload: {
+        panelId: string;
+        windowName: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'DOCK_POPOUT';
+    payload: {
+        panelId: string;
+        targetTabGroupId: string;
+        position: DockPosition;
+    };
+} | {
+    type: 'UPDATE_POPOUT';
+    payload: {
+        panelId: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    };
+} | {
+    type: 'SET_HEADER_POSITION';
+    payload: {
+        tabGroupId: string;
+        headerPosition: HeaderPosition | undefined;
+    };
+} | {
+    type: 'NAVIGATE';
+    payload: {
+        direction: 'next' | 'previous';
+    };
+} | {
+    type: 'ACTIVATE_OVERFLOW_TAB';
+    payload: {
+        tabGroupId: string;
+        panelId: string;
+    };
+} | {
+    type: 'DOCK_TO_EDGE';
+    payload: {
+        panelId: string;
+        edge: DockPosition;
+    };
+} | {
+    type: 'REORDER_TABS';
+    payload: {
+        tabGroupId: string;
+        panelId: string;
+        newIndex: number;
+    };
+};
+declare function dockReducer(state: DockManagerState, action: DockAction): DockManagerState;
+declare function validateState(state: DockManagerState): DockManagerState;
+declare function createDefaultState(): DockManagerState;
+
+/**
+ * Options for adding a new panel via {@link DockviewApi.addPanel}.
+ */
+interface AddPanelOptions {
+    /** Unique identifier for the new panel. Use `id` or `panelId`. */
+    id?: string;
+    /** Unique identifier for the new panel. Alias for `id`. */
+    panelId?: string;
+    /** Display title shown in the tab header. */
+    title: string;
+    /** Optional icon key or URL rendered beside the title. */
+    icon?: string;
+    /** Whether the panel can be closed by the user. Defaults to `true`. */
+    closable?: boolean;
+    /** Whether the panel can be floated by the user. Defaults to `true`. */
+    floatable?: boolean;
+    /** Component key for a custom tab renderer. */
+    tabComponent?: string;
+    /** Widget type identifier for the widget registry. */
+    widgetType?: string;
+    /** Widget-specific props/configuration (must be JSON-serializable). */
+    widgetProps?: Record<string, unknown>;
+    /** Target tab group to add to. If omitted, adds to the first tab group. */
+    targetGroupId?: string;
+    /** Position relative to the target group. Defaults to `'center'` (add as tab). */
+    position?: DockPosition;
+}
+/**
+ * Options for floating a panel via {@link DockviewApi.floatPanel}.
+ */
+interface FloatPanelOptions {
+    /** The ID of the panel to float. */
+    panelId: string;
+    /** Horizontal offset in pixels from the container's left edge. Defaults to `100`. */
+    x?: number;
+    /** Vertical offset in pixels from the container's top edge. Defaults to `100`. */
+    y?: number;
+    /** Width of the floating window in pixels. Defaults to `400`. */
+    width?: number;
+    /** Height of the floating window in pixels. Defaults to `300`. */
+    height?: number;
+}
+/**
+ * Options for moving a panel via {@link DockviewApi.movePanel}.
+ */
+interface MovePanelOptions {
+    /** The ID of the panel to move. */
+    panelId: string;
+    /** The target tab group to move the panel into. */
+    targetGroupId: string;
+    /** Where to place the panel relative to the target group. */
+    position: DockPosition;
+}
+/**
+ * Typed, high-level API for programmatic control of the dock manager.
+ *
+ * Wraps the low-level reducer dispatch with validated, documented methods.
+ * Use this instead of dispatching raw {@link DockAction} objects directly.
+ *
+ * The API is stateless itself -- it reads from and writes to the state
+ * via the `getState` and `dispatch` callbacks provided at construction time.
+ *
+ * @example
+ * ```ts
+ * const api = new DockviewApi(getState, dispatch);
+ * api.addPanel({ id: 'editor', title: 'Editor' });
+ * api.movePanel({ panelId: 'editor', targetGroupId: 'tg_right', position: 'center' });
+ * api.floatPanel({ panelId: 'editor', x: 100, y: 100, width: 400, height: 300 });
+ * api.closePanel('editor');
+ * ```
+ */
+declare class DockviewApi {
+    private readonly getState;
+    private readonly dispatch;
+    private readonly _onUndo?;
+    private readonly _onRedo?;
+    /**
+     * @param getState - Returns the current {@link DockManagerState} snapshot.
+     * @param dispatch - Sends a {@link DockAction} to mutate state.
+     * @param _onUndo - Optional undo callback wired by DockviewComponent.
+     * @param _onRedo - Optional redo callback wired by DockviewComponent.
+     */
+    constructor(getState: () => DockManagerState, dispatch: (action: DockAction) => void, _onUndo?: (() => void) | undefined, _onRedo?: (() => void) | undefined);
+    /** Get the current dock manager state (read-only snapshot) */
+    get state(): Readonly<DockManagerState>;
+    /** Get the currently active pane's panel ID */
+    get activePanelId(): string;
+    /** Get the currently maximized panel ID, or undefined */
+    get maximizedPanelId(): string | undefined;
+    /**
+     * Get a panel's configuration by ID.
+     *
+     * @param panelId - The panel to look up.
+     * @returns The panel config, or `undefined` if no panel with that ID exists.
+     */
+    getPanel(panelId: string): PanelConfig | undefined;
+    /**
+     * Get all panel IDs in the docked layout tree (excludes floating and unpinned panels).
+     *
+     * @returns Panel IDs in depth-first order.
+     */
+    getLayoutPanelIds(): string[];
+    /** Get all panel IDs across the entire dock manager */
+    getAllPanelIds(): string[];
+    /** Get the total number of panels */
+    get panelCount(): number;
+    /**
+     * Check if a panel exists in the dock manager.
+     *
+     * @param panelId - The panel ID to check.
+     * @returns `true` if the panel is registered (regardless of placement).
+     */
+    hasPanel(panelId: string): boolean;
+    /**
+     * Check if a panel is placed somewhere visible (in the layout tree, floating, or unpinned).
+     *
+     * @param panelId - The panel ID to check.
+     * @returns `true` if the panel occupies a slot in the UI.
+     */
+    isPanelPlaced(panelId: string): boolean;
+    /**
+     * Get the tab group ID that contains a given panel.
+     *
+     * @param panelId - The panel to search for.
+     * @returns The containing tab group ID, or `null` if the panel is not in any group.
+     */
+    getGroupForPanel(panelId: string): string | null;
+    /**
+     * Get a tab group by its ID.
+     *
+     * @param groupId - The tab group ID.
+     * @returns The tab group node, or `null` if not found.
+     */
+    getGroup(groupId: string): TabGroupNode | null;
+    /** Get all tab groups */
+    getAllGroups(): TabGroupNode[];
+    /** Get all floating panels */
+    getFloatingPanels(): readonly FloatingPanel[];
+    /**
+     * Check if a panel is currently rendered as a floating window.
+     *
+     * @param panelId - The panel ID to check.
+     * @returns `true` if the panel is floating.
+     */
+    isFloating(panelId: string): boolean;
+    /** Check if a panel is the active pane */
+    isActive(panelId: string): boolean;
+    /** Check if a panel is maximized */
+    isMaximized(panelId: string): boolean;
+    /** Get the layout tree */
+    get layout(): LayoutNode;
+    /**
+     * Add a new panel to the dock manager.
+     *
+     * By default the panel is inserted as a new tab in the first tab group.
+     * Use `targetGroupId` and `position` to control placement.
+     *
+     * @param options - Panel creation and placement options.
+     *
+     * @example
+     * ```ts
+     * api.addPanel({ id: 'terminal', title: 'Terminal', closable: true });
+     * api.addPanel({ id: 'output', title: 'Output', targetGroupId: 'tg_2', position: 'bottom' });
+     * ```
+     */
+    addPanel(options: AddPanelOptions): void;
+    /**
+     * Remove a panel from the dock manager entirely.
+     *
+     * The panel is removed from the layout tree, floating list, and unpinned list,
+     * and its {@link PanelConfig} is deleted.
+     *
+     * @param panelId - The ID of the panel to close.
+     */
+    closePanel(panelId: string): void;
+    /**
+     * Move a panel to a different location in the layout.
+     *
+     * @param options - Target group and position for the move.
+     */
+    movePanel(options: MovePanelOptions): void;
+    /**
+     * Set the active (visible) panel within a tab group, switching the displayed tab.
+     *
+     * @param groupId - The tab group containing the panel.
+     * @param panelId - The panel to make active.
+     */
+    setActivePanel(groupId: string, panelId: string): void;
+    /**
+     * Set the globally active pane (highlighted with the focus indicator).
+     *
+     * @param panelId - The panel to focus.
+     */
+    setActivePane(panelId: string): void;
+    /**
+     * Update a panel's configuration (title, icon, closable, etc.).
+     *
+     * Only the provided fields are merged; unspecified fields remain unchanged.
+     *
+     * @param panelId - The panel to update.
+     * @param updates - Partial config to merge.
+     */
+    updatePanel(panelId: string, updates: Partial<PanelConfig>): void;
+    /**
+     * Float a panel by removing it from the layout tree and rendering it
+     * as a draggable, resizable floating window.
+     *
+     * @param options - Position and size for the floating window.
+     */
+    floatPanel(options: FloatPanelOptions): void;
+    /**
+     * Dock a floating panel back into the layout tree.
+     *
+     * @param panelId - The floating panel to dock.
+     * @param targetGroupId - The tab group to dock into. Defaults to `'default'` (first group).
+     * @param position - Where to place it relative to the target. Defaults to `'center'`.
+     */
+    dockFloatingPanel(panelId: string, targetGroupId?: string, position?: DockPosition): void;
+    /**
+     * Update a floating panel's position and/or size.
+     *
+     * @param panelId - The floating panel to update.
+     * @param updates - Partial position/size values to merge.
+     */
+    updateFloatingPanel(panelId: string, updates: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    }): void;
+    /**
+     * Bring a floating panel to the front by assigning it the highest z-index.
+     *
+     * @param panelId - The floating panel to bring forward.
+     */
+    bringToFront(panelId: string): void;
+    /**
+     * Maximize a panel so it occupies the full container space.
+     *
+     * @param panelId - The panel to maximize.
+     */
+    maximizePanel(panelId: string): void;
+    /** Restore the maximized panel to its original position */
+    restorePanel(): void;
+    /**
+     * Toggle maximize state for a panel. Maximizes if not already maximized,
+     * restores if it is.
+     *
+     * @param panelId - The panel to toggle.
+     */
+    toggleMaximize(panelId: string): void;
+    /** Navigate to the next panel (Ctrl+Tab behavior) */
+    navigateNext(): void;
+    /** Navigate to the previous panel (Ctrl+Shift+Tab behavior) */
+    navigatePrevious(): void;
+    /**
+     * Resize the children of a split node.
+     *
+     * @param splitId - The split node to resize.
+     * @param sizes - New size percentages for each child. Must sum to 100.
+     */
+    resizeSplit(splitId: string, sizes: number[]): void;
+    /**
+     * Set the header (tab bar) position for a tab group.
+     *
+     * @param groupId - The tab group to update.
+     * @param position - The new header position, or `undefined` to reset to default.
+     */
+    setHeaderPosition(groupId: string, position: HeaderPosition | undefined): void;
+    /**
+     * Unpin a panel, removing it from the layout tree and displaying it
+     * as an auto-hide strip along the nearest edge.
+     *
+     * @param panelId - The panel to unpin.
+     */
+    unpinPanel(panelId: string): void;
+    /**
+     * Pin an unpinned panel back into the layout tree as a tab in the first group.
+     *
+     * @param panelId - The unpinned panel to restore.
+     */
+    pinPanel(panelId: string): void;
+    /**
+     * Replace the entire dock manager state (e.g., to restore a serialized layout).
+     *
+     * The state is validated and repaired before being applied.
+     *
+     * @param state - The complete state to load.
+     */
+    loadState(state: DockManagerState): void;
+    /** Close all panels */
+    closeAllPanels(): void;
+    /** Undo the last state change. */
+    undo(): void;
+    /** Redo a previously undone state change. */
+    redo(): void;
+    private presets;
+    /** Reset layout to a given default state. */
+    resetLayout(defaultState: DockManagerState): void;
+    /** Save the current state as a named preset. Returns the preset object. */
+    savePreset(name: string): {
+        name: string;
+        state: DockManagerState;
+    };
+    /** Load a previously saved preset. */
+    loadPreset(preset: {
+        name: string;
+        state: DockManagerState;
+    }): void;
+    /** Get all saved presets. */
+    getPresets(): {
+        name: string;
+        state: DockManagerState;
+    }[];
+    /** Dock all floating panels back into the layout. */
+    dockAllFloating(): void;
+    /** Export the current state as a base64 URL-safe string. */
+    exportAsUrl(): string;
+    /** Import state from a base64 URL-safe string. */
+    importFromUrl(urlString: string): void;
+    private _debugMode;
+    private _debugOverlayHandler;
+    /** Enable/disable debug overlay showing group IDs, panel IDs, split ratios. */
+    setDebugMode(enabled: boolean): void;
+    /** @internal Set the debug overlay handler (called by DockviewComponent). */
+    _setDebugOverlayHandler(handler: (enabled: boolean) => void): void;
+    /** Whether debug mode is currently enabled. */
+    get debugMode(): boolean;
+}
+
+/**
+ * PanelApi — Per-panel API for widget-to-header communication.
+ *
+ * Each panel receives a PanelApi instance via the `createContent` callback.
+ * Widgets use this API to manipulate their own pane header at runtime
+ * (change title, add icons, show badges, request attention).
+ *
+ * All changes are reflected in the state (PanelConfig) so they persist
+ * across serialization/deserialization.
+ */
+
+type DisposeCallback = () => void;
+type VisibilityCallback = (visible: boolean) => void;
+declare class PanelApi {
+    /** Panel identity (read-only) */
+    readonly panelId: string;
+    private _disposed;
+    private _visible;
+    private _disposeCallbacks;
+    private _visibilityCallbacks;
+    private _onUpdateConfig;
+    private _onRequestAttention;
+    private _getConfig;
+    constructor(panelId: string);
+    /** Get the widget type string */
+    get widgetType(): string;
+    /** Get the widget props */
+    get widgetProps(): Record<string, unknown>;
+    /** Get the current panel title */
+    getTitle(): string;
+    /** Set the panel title (updates tab header text) */
+    setTitle(title: string): void;
+    /** Set the panel icon (prefix before title text) */
+    setIcon(icon: string | null): void;
+    /**
+     * Set a badge on the panel tab (notification count, unsaved dot, etc.)
+     * @param badge - Badge text (e.g. "3", "!", "●"), or null to clear
+     */
+    setBadge(badge: string | null): void;
+    /**
+     * Request attention for this panel (triggers a CSS pulse animation on the tab).
+     * Call with `false` to clear the attention state.
+     */
+    setAttention(attention: boolean): void;
+    /** Set the hidden state (hide without removing from layout) */
+    setHidden(hidden: boolean): void;
+    /** Check if the panel is currently hidden */
+    get isHidden(): boolean;
+    /**
+     * Update widget props (partial merge). Triggers state update + re-serialization.
+     * @param props - Partial props to merge into existing widgetProps
+     */
+    updateProps(props: Partial<Record<string, unknown>>): void;
+    /** Register a callback to be called when the panel is closed/disposed */
+    onDidDispose(callback: DisposeCallback): void;
+    /** Register a callback for visibility changes (hidden/shown) */
+    onDidChangeVisibility(callback: VisibilityCallback): void;
+    /** Check if the panel content is currently visible */
+    get isVisible(): boolean;
+    /** @internal Set the config accessor */
+    _setConfigAccessor(getConfig: () => PanelConfig | undefined): void;
+    /** @internal Set the update handler */
+    _setUpdateHandler(handler: (panelId: string, updates: Partial<PanelConfig>) => void): void;
+    /** @internal Set the attention handler */
+    _setAttentionHandler(handler: (panelId: string, attention: boolean) => void): void;
+    /** @internal Notify visibility change */
+    _setVisible(visible: boolean): void;
+    /** @internal Dispose this API (called when panel is closed) */
+    _dispose(): void;
+    private _updateConfig;
+}
+
+/**
+ * Dock Manager Theme System
+ *
+ * Themes are plain objects that define all visual properties.
+ * The DockviewComponent applies themes by setting CSS custom properties
+ * on its container element, so themes are scoped and don't leak globally.
+ *
+ * Users can:
+ *   1. Use a built-in theme: `theme: themes.vsCodeLight`
+ *   2. Create a custom theme: `theme: { name: 'custom', mode: 'light', colors: { ... } }`
+ *   3. Extend a built-in theme: `theme: { ...themes.vsCodeLight, colors: { ...themes.vsCodeLight.colors, primary: '#ff0000' } }`
+ */
+interface DockThemeColors {
+    /** Main background behind all panels */
+    bg: string;
+    /** Panel content surface */
+    surface: string;
+    /** Alternate surface (e.g., sidebar) */
+    surfaceAlt: string;
+    /** Panel header / tab bar background */
+    panelHeader: string;
+    /** Tab bar background */
+    tabBar: string;
+    /** Active/selected tab background */
+    tabActive: string;
+    /** Unselected tab text color */
+    tabText: string;
+    /** Selected + active tab text color (blue) */
+    tabTextActive: string;
+    /** Primary content text */
+    text: string;
+    /** Secondary text (labels, descriptions) */
+    textSecondary: string;
+    /** Muted text (placeholders, hints) */
+    textMuted: string;
+    /** Border color for panels, tabs, splitters */
+    border: string;
+    /** Splitter bar color */
+    splitter: string;
+    /** Splitter bar hover color */
+    splitterHover: string;
+    /** Hover state background */
+    hover: string;
+    /** Primary accent color (active indicators, selected tabs) */
+    primary: string;
+    /** Floating window shadow color */
+    floatShadow: string;
+}
+interface DockTheme {
+    /** Human-readable theme name */
+    name: string;
+    /** Whether this is a light or dark theme */
+    mode: 'light' | 'dark';
+    /** Theme colors */
+    colors: DockThemeColors;
+}
+/**
+ * Apply a theme to a container element by setting CSS custom properties.
+ * This scopes the theme to that element's subtree.
+ */
+declare function applyTheme(container: HTMLElement, theme: DockTheme): void;
+/** VS Code-inspired light theme — clean whites and grays */
+declare const vsCodeLight: DockTheme;
+/** GitHub-inspired light theme — warm grays with subtle blue accent */
+declare const githubLight: DockTheme;
+/** Soft warm light theme — cream tones with amber accent */
+declare const warmLight: DockTheme;
+/** Solarized Light — low-contrast cream with teal accents, designed for all-day use */
+declare const solarizedLight: DockTheme;
+/** Sepia — book-like warmth with brown tones, very gentle on eyes */
+declare const sepiaLight: DockTheme;
+/** Mint — soft green tones, refreshing and calming */
+declare const mintLight: DockTheme;
+/** Lavender — soft purple-gray, elegant and easy on eyes */
+declare const lavenderLight: DockTheme;
+/** VS Code-inspired dark theme — deep blues and grays */
+declare const vsCodeDark: DockTheme;
+/** Dracula-inspired dark theme — purple accents on dark gray */
+declare const draculaDark: DockTheme;
+/** Nord-inspired dark theme — arctic blue-gray palette */
+declare const nordDark: DockTheme;
+/** Solarized Dark — low-contrast dark with teal accents, designed for all-day use */
+declare const solarizedDark: DockTheme;
+/** Midnight Blue — deep navy with soft blue accents, very easy on eyes at night */
+declare const midnightDark: DockTheme;
+/** Forest — deep green-gray with emerald accents, nature-inspired calm */
+declare const forestDark: DockTheme;
+/** Slate — neutral gray with warm undertones, minimalist and gentle */
+declare const slateDark: DockTheme;
+/** All built-in themes */
+declare const themes: {
+    readonly vsCodeLight: DockTheme;
+    readonly githubLight: DockTheme;
+    readonly warmLight: DockTheme;
+    readonly solarizedLight: DockTheme;
+    readonly sepiaLight: DockTheme;
+    readonly mintLight: DockTheme;
+    readonly lavenderLight: DockTheme;
+    readonly vsCodeDark: DockTheme;
+    readonly draculaDark: DockTheme;
+    readonly nordDark: DockTheme;
+    readonly solarizedDark: DockTheme;
+    readonly midnightDark: DockTheme;
+    readonly forestDark: DockTheme;
+    readonly slateDark: DockTheme;
+};
+/** Get a theme by name */
+declare function getThemeByName(name: string): DockTheme | undefined;
+/** Get all themes for a given mode */
+declare function getThemesByMode(mode: 'light' | 'dark'): DockTheme[];
+
+/** A resource that can release its DOM and event listener references. */
+interface IDisposable {
+    /** Release all resources held by this object. */
+    dispose(): void;
+}
+/**
+ * Configuration options for {@link DockviewComponent}.
+ */
+interface DockviewComponentOptions {
+    /** The initial layout and panel state to render. */
+    initialState: DockManagerState;
+    /**
+     * Factory called to render a panel's content into a container element.
+     *
+     * @param panelId - The panel to render.
+     * @param container - The DOM element to mount content into.
+     * @param api - PanelApi instance for this panel (widget-to-header communication).
+     * @returns A disposable that cleans up the rendered content.
+     */
+    createContent: (panelId: string, container: HTMLElement, api: PanelApi) => IDisposable;
+    /**
+     * Optional factory to render a custom tab for a panel.
+     *
+     * @param panelId - The panel the tab belongs to.
+     * @param container - The DOM element to mount the tab into.
+     * @param isActive - Whether the tab is currently active.
+     * @returns A disposable that cleans up the rendered tab.
+     */
+    createTab?: (panelId: string, container: HTMLElement, isActive: boolean) => IDisposable;
+    /**
+     * Optional factory to render custom header action buttons in a tab group.
+     *
+     * @param slot - Which slot to render into (`'left'`, `'right'`, or `'prefix'`).
+     * @param tabGroupId - The tab group the actions belong to.
+     * @param container - The DOM element to mount actions into.
+     * @returns A disposable that cleans up the rendered actions.
+     */
+    createHeaderActions?: (slot: 'left' | 'right' | 'prefix', tabGroupId: string, container: HTMLElement) => IDisposable;
+    /** Called after every state change with the new state. */
+    onStateChange?: (state: DockManagerState) => void;
+    /** Called before a panel is closed. Call `event.preventDefault()` to cancel. */
+    onWillClose?: (event: PreventableDockEvent, panelId: string) => void;
+    /** Called before a drag-and-drop completes. Call `event.preventDefault()` to cancel. */
+    onWillDrop?: (event: PreventableDockEvent, sourceId: string, targetId: string, position: DockPosition) => void;
+    /**
+     * Color theme. Can be:
+     *   - `'light'` / `'dark'` — uses the default VS Code-style theme
+     *   - A `DockTheme` object — applies custom colors via CSS custom properties
+     *
+     * Defaults to `'light'`.
+     */
+    theme?: 'light' | 'dark' | DockTheme;
+    /** Whether to show edge dock indicators. Defaults to true. */
+    allowRootDock?: boolean;
+    /** Whether to allow dropping on splitters. Defaults to true. */
+    allowSplitterDock?: boolean;
+    /** Custom strings for UI elements (tooltips, context menu, etc.) */
+    resourceStrings?: Partial<DockResourceStrings>;
+}
+/**
+ * Framework-agnostic dock layout manager.
+ *
+ * `DockviewComponent` owns the entire DOM tree for the dock layout.
+ * It accepts a host element and a set of renderer callbacks, then
+ * manages tab groups, split panes, floating windows, unpinned strips,
+ * drag-and-drop, and keyboard navigation internally.
+ *
+ * Framework wrappers (React, Vue, Angular) typically instantiate this
+ * class and supply framework-specific content renderers.
+ *
+ * @example
+ * ```ts
+ * const dock = new DockviewComponent(document.getElementById('root')!, {
+ *   initialState: createDefaultState(),
+ *   createContent: (panelId, container) => {
+ *     container.textContent = panelId;
+ *     return { dispose: () => { container.textContent = ''; } };
+ *   },
+ * });
+ * dock.dispatch({ type: 'ADD_PANEL', payload: { panelId: 'p1', title: 'Panel 1' } });
+ * // Later:
+ * dock.dispose();
+ * ```
+ */
+declare class DockviewComponent {
+    private container;
+    private options;
+    private state;
+    private dragManager;
+    private focusManager;
+    private keyboardManager;
+    private historyManager;
+    private tabGroupViews;
+    private splitViews;
+    private floatingViews;
+    private unpinnedStripViews;
+    private panelApis;
+    /** Global content cache: content containers persist across layout changes (float/dock/move) */
+    private contentCache;
+    private _api;
+    private maximizeOverlay;
+    private maximizeOverlayPanelId;
+    private panelFinder;
+    private debugOverlayEl;
+    private rootEl;
+    private layoutRowEl;
+    private topStripContainer;
+    private leftStripContainer;
+    private centerEl;
+    private rightStripContainer;
+    private bottomStripContainer;
+    private layoutContentEl;
+    /**
+     * Create a new dock layout manager.
+     *
+     * @param element - The host DOM element. The dock layout will fill this element.
+     * @param options - Configuration including initial state and renderer callbacks.
+     */
+    constructor(element: HTMLElement, options: DockviewComponentOptions);
+    /**
+     * Dispatch a {@link DockAction} to update state and re-render.
+     *
+     * If the reducer throws, the error is logged and the previous valid state
+     * is preserved. If the state did not change (same reference), rendering is skipped.
+     *
+     * @param action - The action to dispatch.
+     */
+    /** Actions that are purely visual / navigational — don't push undo state for these */
+    private static readonly NON_UNDOABLE_ACTIONS;
+    dispatch(action: DockAction): void;
+    /** Undo the last state change. */
+    undo(): void;
+    /** Redo a previously undone state change. */
+    redo(): void;
+    /**
+     * Get the current dock manager state.
+     *
+     * @returns The current {@link DockManagerState}.
+     */
+    getState(): DockManagerState;
+    /** Get a high-level API for programmatic control (lazy-initialized). */
+    get api(): DockviewApi;
+    /** Resolve a theme option to a 'light' | 'dark' mode string */
+    private resolveThemeMode;
+    /** Apply theme option — handles string ('light'/'dark') or DockTheme object */
+    private applyThemeOption;
+    /**
+     * Update component options at runtime (e.g., switch theme or change callbacks).
+     *
+     * @param options - Partial options to merge into the current configuration.
+     */
+    updateOptions(options: Partial<DockviewComponentOptions>): void;
+    /**
+     * Get or create a {@link PanelApi} for a given panel.
+     *
+     * The returned API is wired to dispatch `UPDATE_PANEL_CONFIG` actions
+     * back into this component. Panel APIs are cached and reused across renders.
+     *
+     * @param panelId - The panel to get an API for.
+     * @returns The PanelApi instance for the given panel.
+     */
+    getPanelApi(panelId: string): PanelApi;
+    /**
+     * Dispose PanelApis for panels that no longer exist in state.
+     */
+    private cleanupPanelApis;
+    /** Enable or disable the debug overlay showing layout IDs and split ratios. */
+    private setDebugOverlay;
+    /** Update the debug overlay with current layout info. */
+    private updateDebugOverlay;
+    /**
+     * Clean up all resources: dispose sub-managers, views, panel APIs, and
+     * remove the root DOM element from the container.
+     *
+     * After calling `dispose()`, this instance must not be used again.
+     */
+    dispose(): void;
+    private onActionClick;
+    /**
+     * Get or create a content container for a panel. The container is cached
+     * so that when a panel moves between locations (tab group → floating → tab group),
+     * the content is preserved by reparenting the DOM element instead of destroying
+     * and recreating it.
+     */
+    private getOrCreateContent;
+    /**
+     * Permanently destroy a panel's cached content (called when panel is closed).
+     */
+    private destroyContent;
+    private render;
+    private renderLayout;
+    private renderLayoutNode;
+    private renderTabGroup;
+    private renderSplit;
+    private renderFloatingPanels;
+    private renderUnpinnedStrips;
+    private renderMaximizeOverlay;
+    private cleanupStaleViews;
+    private collectNodeIds;
+}
+
+/**
+ * LayoutTree — Clean, immutable layout tree operations.
+ *
+ * Replaces the scattered helpers in layoutHelpers.ts with a cohesive module
+ * that handles all tree mutations correctly:
+ *
+ * 1. removePanel — always returns a valid tree (never null), auto-collapses
+ * 2. insertAtEdge — inserts at the correct root-level edge (left/right/top/bottom)
+ * 3. insertInGroup — adds panel to existing tab group (center drop)
+ * 4. movePanel — combines remove + insert atomically
+ * 5. normalizeSizes — ensures sizes always sum to 100
+ * 6. collapseTree — removes empty groups and single-child splits
+ *
+ * All functions are pure (no side effects) and return new objects (immutable).
+ */
+
+declare function genId(prefix: string): string;
+declare function resetIdCounter(): void;
+/**
+ * Remove a panel from the layout tree.
+ * Returns null if the tree becomes completely empty (no panels remain).
+ *
+ * Automatically:
+ * - Removes the panel from its tab group
+ * - Collapses empty tab groups
+ * - Promotes single-child splits (removes unnecessary nesting)
+ * - Normalizes sizes after child removal
+ */
+declare function removePanel(root: LayoutNode, panelId: string): LayoutNode | null;
+/**
+ * Insert a panel into a specific tab group (center/tab drop).
+ * If the group doesn't exist, the tree is returned unchanged.
+ */
+declare function insertInGroup(root: LayoutNode, targetGroupId: string, panelId: string): LayoutNode;
+/**
+ * Insert a panel next to a specific tab group by splitting it.
+ * Creates a new split with the existing group and a new tab group
+ * at the given position (left/right/top/bottom).
+ */
+declare function insertBySplit(root: LayoutNode, targetGroupId: string, panelId: string, position: DockPosition): LayoutNode;
+/**
+ * Insert a panel at a root-level edge of the layout.
+ * This adds a new tab group flush against the left/right/top/bottom
+ * edge of the entire layout, not nested inside any existing split.
+ *
+ * If the root split direction matches the edge axis, the new group is
+ * appended/prepended as a direct child. Otherwise, the layout is
+ * wrapped in a new split.
+ */
+declare function insertAtEdge(root: LayoutNode, panelId: string, edge: DockEdge, sizePercent?: number): LayoutNode;
+/**
+ * Move a panel from its current location to a new target.
+ * Combines remove + insert atomically. Handles all drop positions:
+ * - center: add as tab in target group
+ * - left/right/top/bottom: split target group
+ *
+ * Returns unchanged tree if:
+ * - Dropping on same group as center (no-op)
+ * - Panel doesn't exist in tree
+ */
+declare function movePanel(root: LayoutNode, panelId: string, targetGroupId: string, position: DockPosition): LayoutNode;
+/** Find which tab group contains a panel */
+declare function findTabGroupForPanel(node: LayoutNode, panelId: string): string | null;
+/** Find the first tab group (DFS) */
+declare function findFirstTabGroup(node: LayoutNode): string | null;
+/** Find a tab group by ID */
+declare function findTabGroupById(node: LayoutNode, id: string): TabGroupNode | null;
+/** Find all tab groups in DFS order */
+declare function findAllTabGroups(node: LayoutNode): TabGroupNode[];
+/** Collect all panel IDs in the layout tree */
+declare function collectLayoutPanelIds(node: LayoutNode): Set<string>;
+/** Collect all panels in DFS order (for keyboard navigation) */
+declare function collectAllPanelsOrdered(node: LayoutNode): string[];
+/** Count total panels */
+declare function countPanels(node: LayoutNode): number;
+/**
+ * Detect which edge a panel is closest to in the layout.
+ * Used by UNPIN_PANEL to determine which edge strip to place the panel on.
+ */
+declare function detectPanelEdge(node: LayoutNode, panelId: string): DockEdge;
+/**
+ * Find the tab group at a specific edge of the layout.
+ * Only matches tab groups at the outermost level on the correct axis.
+ */
+declare function findTabGroupByEdge(node: LayoutNode, edge: DockEdge): string | null;
+/** Check if a panel exists anywhere in the state */
+declare function isPanelPlaced(state: {
+    layout: LayoutNode;
+    floatingPanels: {
+        panelId: string;
+    }[];
+    unpinnedPanels: {
+        panelId: string;
+    }[];
+    popoutPanels?: {
+        panelId: string;
+    }[];
+}, panelId: string): boolean;
+
+interface SerializedDockLayout {
+    version: 1 | 2;
+    timestamp: number;
+    state: DockManagerState;
+    /** Layout format version for forward compatibility. Added in v2. */
+    layoutVersion?: number;
+}
+/** Serialize dock manager state to JSON string */
+declare function serialize(state: DockManagerState): string;
+/** Export the state as a base64 URL-safe string. */
+declare function exportAsUrl(state: DockManagerState): string;
+/** Import state from a base64 URL-safe string. */
+declare function importFromUrl(urlString: string): DockManagerState;
+/** Deserialize dock manager state from JSON string */
+declare function deserialize(json: string): {
+    state: DockManagerState;
+    warnings: string[];
+};
+declare function saveToLocalStorage(state: DockManagerState): void;
+declare function loadFromLocalStorage(): {
+    state: DockManagerState;
+    warnings: string[];
+} | null;
+declare function clearLocalStorage(): void;
+declare function exportToFile(state: DockManagerState, filename?: string): void;
+declare function importFromFile(): Promise<{
+    state: DockManagerState;
+    warnings: string[];
+}>;
+
+/**
+ * Minimal typed event emitter for dock manager events.
+ */
+type Listener<T> = (value: T) => void;
+declare class EventEmitter<T = void> {
+    private listeners;
+    on(listener: Listener<T>): () => void;
+    emit(value: T): void;
+    dispose(): void;
+}
+
+/**
+ * KeyboardManager handles comprehensive keyboard shortcuts for the dock manager.
+ *
+ * All shortcuts are bound to the container element's `keydown` event.
+ * Shortcuts are suppressed when the event target is an input, textarea, or
+ * contenteditable element so that normal text editing is not interrupted.
+ */
+
+interface KeyboardManagerOptions {
+    /** The container element to attach the keydown listener to. */
+    containerElement: HTMLElement;
+    /** Dispatch a DockAction to the reducer. */
+    dispatch: (action: DockAction) => void;
+    /** Returns the current dock manager state. */
+    getState: () => DockManagerState;
+    /** Called when undo is requested (Ctrl+Z). */
+    onUndo?: () => void;
+    /** Called when redo is requested (Ctrl+Shift+Z). */
+    onRedo?: () => void;
+    /** Called when panel finder is requested (Ctrl+P). */
+    onPanelFinder?: () => void;
+}
+declare class KeyboardManager {
+    private options;
+    private container;
+    constructor(options: KeyboardManagerOptions);
+    /** Remove the keydown listener. */
+    dispose(): void;
+    private onKeyDown;
+    /** Set a handler for Ctrl+Tab pane navigation events. */
+    setPaneNavigatorHandler(handler: ((direction: 'next' | 'previous') => void) | null): void;
+    private paneNavigatorHandler;
+}
+
+/**
+ * ContextMenuManager handles right-click context menus on tab elements.
+ *
+ * It uses event delegation on the container element to listen for
+ * `contextmenu` events on `[data-tab-id]` elements, and shows a
+ * floating context menu with relevant panel actions.
+ */
+
+interface ContextMenuManagerOptions {
+    /** The container element to attach the contextmenu listener to. */
+    containerElement: HTMLElement;
+    /** Dispatch a DockAction to the reducer. */
+    dispatch: (action: DockAction) => void;
+    /** Returns the current dock manager state. */
+    getState: () => DockManagerState;
+    /** Current theme mode for styling. */
+    theme?: 'light' | 'dark';
+    /** Custom resource strings for localization. */
+    resourceStrings?: Partial<DockResourceStrings>;
+}
+declare class ContextMenuManager {
+    private options;
+    private container;
+    private menuEl;
+    private outsideClickHandler;
+    private escapeHandler;
+    private resourceStrings;
+    constructor(options: ContextMenuManagerOptions);
+    /** Remove the contextmenu listener and close any open menu. */
+    dispose(): void;
+    private onContextMenu;
+    private buildMenuEntries;
+    private showMenu;
+    closeMenu(): void;
+    private findTabGroup;
+}
+
+/**
+ * PaneNavigator — Ctrl+Tab overlay for switching between panels.
+ *
+ * Shows a visual overlay with two columns: "Active Files" (documentOnly panels)
+ * and "Tool Windows" (non-documentOnly panels). The user can cycle through
+ * items while holding Ctrl, and releasing Ctrl activates the selected panel.
+ */
+
+interface PaneNavigatorOptions {
+    /** The container element to append the overlay to. */
+    containerElement: HTMLElement;
+    /** Returns the current dock manager state. */
+    getState: () => DockManagerState;
+    /** Called when a panel is selected for activation. */
+    onActivate: (panelId: string) => void;
+}
+declare class PaneNavigator {
+    private options;
+    private overlayEl;
+    private items;
+    private selectedIndex;
+    private isVisible;
+    private boundKeyDown;
+    private boundKeyUp;
+    constructor(options: PaneNavigatorOptions);
+    /** Show the navigator and highlight the next/previous panel. */
+    show(direction: 'next' | 'previous'): void;
+    /** Hide the navigator and activate the selected panel. */
+    hide(): void;
+    /** Whether the navigator is currently visible. */
+    get visible(): boolean;
+    /** Clean up all listeners and DOM elements. */
+    dispose(): void;
+    private buildItems;
+    private moveSelection;
+    private onKeyDown;
+    private onKeyUp;
+    private createOverlay;
+    private updateHighlight;
+}
+
+/**
+ * StateHistoryManager — Maintains an undo/redo stack for dock manager state.
+ *
+ * Keeps the last N states (default 20) and provides undo/redo operations.
+ * Used by DockviewComponent to enable Ctrl+Z / Ctrl+Shift+Z support.
+ */
+
+declare class StateHistoryManager {
+    private undoStack;
+    private redoStack;
+    private maxHistory;
+    constructor(maxHistory?: number);
+    /**
+     * Push a state onto the undo stack. Clears the redo stack.
+     * Call this BEFORE applying a mutation so the previous state can be restored.
+     */
+    push(state: DockManagerState): void;
+    /** Whether there are states to undo to. */
+    get canUndo(): boolean;
+    /** Whether there are states to redo to. */
+    get canRedo(): boolean;
+    /**
+     * Undo: pop from undo stack, push current state to redo stack.
+     * @param currentState - The current state before undoing (will be pushed to redo stack).
+     * @returns The previous state to restore, or null if nothing to undo.
+     */
+    undo(currentState: DockManagerState): DockManagerState | null;
+    /**
+     * Redo: pop from redo stack, push current state to undo stack.
+     * @param currentState - The current state before redoing (will be pushed to undo stack).
+     * @returns The next state to restore, or null if nothing to redo.
+     */
+    redo(currentState: DockManagerState): DockManagerState | null;
+    /** Clear all history. */
+    clear(): void;
+}
+
+/**
+ * PanelFinder — Modal overlay with search input for finding and activating panels.
+ *
+ * Triggered by Ctrl+P. Lists all panels (docked, floating, unpinned) filtered
+ * by title. Clicking an item activates that panel.
+ */
+
+interface PanelFinderOptions {
+    /** The container element to append the overlay to. */
+    containerElement: HTMLElement;
+    /** Returns the current dock manager state. */
+    getState: () => DockManagerState;
+    /** Called when a panel is selected. */
+    onActivatePanel: (panelId: string) => void;
+}
+declare class PanelFinder {
+    private options;
+    private overlayEl;
+    private isOpen;
+    constructor(options: PanelFinderOptions);
+    /** Toggle the panel finder modal. */
+    toggle(): void;
+    /** Open the panel finder modal. */
+    open(): void;
+    /** Close the panel finder modal. */
+    close(): void;
+    dispose(): void;
+}
+
+export { AddPanelOptions, ContextMenuManager, ContextMenuManagerOptions, DockAction, DockEdge, DockManagerState, DockPosition, DockResourceStrings, DockTheme, DockThemeColors, DockviewApi, DockviewComponent, DockviewComponentOptions, EventEmitter, FloatPanelOptions, FloatingPanel, HeaderPosition, IDisposable, KeyboardManager, KeyboardManagerOptions, LayoutConstraints, LayoutNode, MovePanelOptions, PaneNavigator, PaneNavigatorOptions, PanelApi, PanelConfig, PanelFinder, PanelFinderOptions, PopoutPanel, PreventableDockEvent, SerializedDockLayout, SplitDirection, SplitNode, StateHistoryManager, TabGroupNode, UnpinnedPanel, applyTheme, clearLocalStorage, collectAllPanelsOrdered, collectLayoutPanelIds, countPanels, createDefaultState, createPreventableEvent, defaultResourceStrings, deserialize, detectPanelEdge, dockReducer, draculaDark, exportAsUrl, exportToFile, findAllTabGroups, findFirstTabGroup, findTabGroupByEdge, findTabGroupById, findTabGroupForPanel, forestDark, genId, getThemeByName, getThemesByMode, githubLight, importFromFile, importFromUrl, insertAtEdge, insertBySplit, insertInGroup, isPanelPlaced, lavenderLight, loadFromLocalStorage, midnightDark, mintLight, movePanel, nordDark, removePanel, resetIdCounter, saveToLocalStorage, sepiaLight, serialize, slateDark, solarizedDark, solarizedLight, themes, validateState, vsCodeDark, vsCodeLight, warmLight };