dockview-core 6.6.0 → 7.0.2

package/dist/esm/dockview/dockviewComponent.d.ts

@@ -1,6 +1,7 @@
-import { SerializedGridObject } from '../gridview/gridview';
-import { Position } from '../dnd/droptarget';
+import { SerializedGridObject, Gridview, SerializedGridview } from '../gridview/gridview';
+import { DroptargetOverlayModel, Position } from '../dnd/droptarget';
 import { DockviewPanel, IDockviewPanel } from './dockviewPanel';
+import { IDisposable } from '../lifecycle';
 import { Event, Emitter } from '../events';
 import { IWatermarkRenderer, GroupviewPanelState } from './types';
 import { AddGroupOptions, AddPanelOptions, DockviewComponentOptions, DockviewDndOverlayEvent, DockviewOptions, MovementOptions, DockviewHeaderPosition } from './options';
@@ -8,15 +9,23 @@ import { BaseGrid, IBaseGrid } from '../gridview/baseComponentGridview';
 import { DockviewApi } from '../api/component.api';
 import { Orientation } from '../splitview/splitview';
 import { GroupOptions, GroupPanelViewState, DockviewDidDropEvent, DockviewWillDropEvent } from './dockviewGroupPanelModel';
-import { DockviewWillShowOverlayLocationEvent, DockviewTabGroupChangeEvent, DockviewTabGroupCollapsedChangeEvent, DockviewTabGroupPanelChangeEvent } from './events';
+import { DockviewWillShowOverlayLocationEvent, DockviewTabGroupChangeEvent, DockviewTabGroupCollapsedChangeEvent, DockviewTabGroupPanelChangeEvent, DockviewGroupDropLocation } from './events';
 import { DockviewGroupPanel } from './dockviewGroupPanel';
 import { Parameters } from '../panel/types';
 import { DockviewFloatingGroupPanel } from './dockviewFloatingGroupPanel';
 import { GroupDragEvent, TabDragEvent } from './components/titlebar/tabsContainer';
+import { IFloatingGroupHost } from './floatingGroupService';
+import { IPopoutWindowHost } from './popoutWindowService';
+import { IWatermarkHost } from './watermarkService';
+import { IEdgeGroupServiceHost } from './edgeGroupService';
+import { IAccessibilityHost, IAdvancedDnDHost, IContextMenuHost, IContextMenuService, ITabGroupChipsHost } from './moduleContracts';
+import { IHeaderActionsHost } from './headerActionsService';
 import { AnchoredBox, AnchorPosition, Box } from '../types';
 import { DockviewPanelRenderer, OverlayRenderContainer } from '../overlay/overlayRenderContainer';
 import { PopupService } from './components/popupService';
-import { ContextMenuController } from './contextMenu';
+import { IRootDropTargetHost } from './rootDropTargetService';
+import { ILiveRegionHost } from './liveRegionService';
+import { IDragGhostSpec } from '../dnd/backend';
 import { DropTargetAnchorContainer } from '../dnd/dropTargetAnchorContainer';
 import { EdgeGroupPosition, EdgeGroupOptions, SerializedEdgeGroups } from './dockviewShell';
 import { DockviewGroupPanelApi } from '../api/dockviewGroupPanelApi';
@@ -32,7 +41,6 @@ export interface DockviewPopoutGroupOptions {
      * Defaults to `/popout.html` if not provided
      */
     popoutUrl?: string;
-    referenceGroup?: DockviewGroupPanel;
     onDidOpen?: (event: {
         id: string;
         window: Window;
@@ -41,7 +49,15 @@ export interface DockviewPopoutGroupOptions {
         id: string;
         window: Window;
     }) => void;
+}
+interface DockviewPopoutGroupOptionsInternal extends DockviewPopoutGroupOptions {
+    referenceGroup?: DockviewGroupPanel;
     overridePopoutGroup?: DockviewGroupPanel;
+    /**
+     * Restore into a pre-built nested gridview (multi-group popout window)
+     * rather than creating one around a single group.
+     */
+    overridePopoutGridview?: Gridview;
 }
 export interface PanelReference {
     update: (event: {
@@ -52,11 +68,29 @@ export interface PanelReference {
     remove: () => void;
 }
 export interface SerializedFloatingGroup {
-    data: GroupPanelViewState;
+    /**
+     * Legacy single-group form. Still written when a floating window hosts a
+     * single group (for stable round-trips) and always accepted on read.
+     */
+    data?: GroupPanelViewState;
+    /**
+     * Nested layout of the floating window. Written when the window hosts more
+     * than one group; mutually exclusive with `data`.
+     */
+    grid?: SerializedGridview<GroupPanelViewState>;
     position: AnchoredBox;
 }
 export interface SerializedPopoutGroup {
-    data: GroupPanelViewState;
+    /**
+     * Legacy single-group form. Still written when a popout window hosts a
+     * single group (for stable round-trips) and always accepted on read.
+     */
+    data?: GroupPanelViewState;
+    /**
+     * Nested layout of the popout window. Written when the window hosts more
+     * than one group; mutually exclusive with `data`.
+     */
+    grid?: SerializedGridview<GroupPanelViewState>;
     url?: string;
     gridReferenceGroup?: string;
     position: Box | null;
@@ -108,16 +142,45 @@ export interface FloatingGroupOptions {
     height?: number;
     width?: number;
     position?: AnchorPosition;
+    /**
+     * Override the component-level `floatingGroupDragHandle` option for this
+     * group only. See {@link DockviewOptions.floatingGroupDragHandle}.
+     */
+    dragHandle?: 'titlebar' | 'tabbar';
 }
 interface FloatingGroupOptionsInternal extends FloatingGroupOptions {
     skipRemoveGroup?: boolean;
     inDragMode?: boolean;
     skipActiveGroup?: boolean;
 }
-export interface DockviewMaximizedGroupChanged {
+export interface DockviewMaximizedGroupChangeEvent {
     group: DockviewGroupPanel;
     isMaximized: boolean;
 }
+/** The coarse kind of a structural layout mutation (see `onWillMutateLayout`). */
+export type DockviewLayoutMutationKind = 'add' | 'remove' | 'move' | 'float' | 'popout' | 'maximize' | 'tab-group' | 'load' | 'clear';
+/**
+ * Who caused an operation: `'user'` for changes driven by direct interaction
+ * (drag-and-drop, tab UI, keyboard docking) and `'api'` for those entered
+ * through a {@link DockviewApi} method called by application code. Lets
+ * consumers (e.g. an undo stack, or a context-sync listener) treat the app's
+ * own programmatic changes differently from end-user gestures.
+ */
+export type DockviewOrigin = 'user' | 'api';
+export interface DockviewLayoutMutationEvent {
+    readonly kind: DockviewLayoutMutationKind;
+    readonly origin: DockviewOrigin;
+}
+/**
+ * Fired by `onDidActivePanelChange` when the active panel changes. Carries the
+ * {@link DockviewOrigin} so consumers can distinguish a user clicking a tab
+ * from a programmatic `setActive` call (e.g. to avoid feedback loops when
+ * syncing context off the active panel).
+ */
+export interface DockviewActivePanelChangeEvent {
+    readonly panel: IDockviewPanel | undefined;
+    readonly origin: DockviewOrigin;
+}
 export interface PopoutGroupChangeSizeEvent {
     width: number;
     height: number;
@@ -128,6 +191,18 @@ export interface PopoutGroupChangePositionEvent {
     screenY: number;
     group: DockviewGroupPanel;
 }
+/** A spatial (visual) direction for group-to-group navigation. */
+export type GroupNavigationDirection = 'left' | 'right' | 'up' | 'down';
+/**
+ * A popout group currently open in its own window. `window` is the live
+ * `Window` handle of the popout, so consumers can route focus, attach
+ * per-document listeners, or place the window.
+ */
+export interface PopoutGroup {
+    readonly id: string;
+    readonly group: DockviewGroupPanel;
+    readonly window: Window;
+}
 export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     readonly activePanel: IDockviewPanel | undefined;
     readonly totalPanels: number;
@@ -135,22 +210,29 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     readonly orientation: Orientation;
     readonly onDidDrop: Event<DockviewDidDropEvent>;
     readonly onWillDrop: Event<DockviewWillDropEvent>;
+    readonly onWillMutateLayout: Event<DockviewLayoutMutationEvent>;
+    readonly onDidMutateLayout: Event<DockviewLayoutMutationEvent>;
+    currentOrigin(): DockviewOrigin;
+    withOrigin<T>(origin: DockviewOrigin, func: () => T): T;
     readonly onWillShowOverlay: Event<DockviewWillShowOverlayLocationEvent>;
     readonly onDidRemovePanel: Event<IDockviewPanel>;
     readonly onDidAddPanel: Event<IDockviewPanel>;
     readonly onDidLayoutFromJSON: Event<void>;
-    readonly onDidActivePanelChange: Event<IDockviewPanel | undefined>;
+    readonly onDidActivePanelChange: Event<DockviewActivePanelChangeEvent>;
     readonly onWillDragPanel: Event<TabDragEvent>;
     readonly onWillDragGroup: Event<GroupDragEvent>;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
     readonly onDidAddGroup: Event<DockviewGroupPanel>;
     readonly onDidActiveGroupChange: Event<DockviewGroupPanel | undefined>;
-    readonly onUnhandledDragOverEvent: Event<DockviewDndOverlayEvent>;
+    readonly onUnhandledDragOver: Event<DockviewDndOverlayEvent>;
     readonly onDidMovePanel: Event<MovePanelEvent>;
-    readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChanged>;
+    readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChangeEvent>;
     readonly onDidPopoutGroupSizeChange: Event<PopoutGroupChangeSizeEvent>;
     readonly onDidPopoutGroupPositionChange: Event<PopoutGroupChangePositionEvent>;
+    readonly onDidAddPopoutGroup: Event<PopoutGroup>;
+    readonly onDidRemovePopoutGroup: Event<PopoutGroup>;
     readonly onDidOpenPopoutWindowFail: Event<void>;
+    getPopouts(): PopoutGroup[];
     readonly onDidCreateTabGroup: Event<DockviewTabGroupChangeEvent>;
     readonly onDidDestroyTabGroup: Event<DockviewTabGroupChangeEvent>;
     readonly onDidAddPanelToTabGroup: Event<DockviewTabGroupPanelChangeEvent>;
@@ -170,6 +252,7 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     createWatermarkComponent(): IWatermarkRenderer;
     addGroup(options?: AddGroupOptions): DockviewGroupPanel;
     closeAllGroups(): void;
+    adjacentGroupInDirection(group: DockviewGroupPanel, direction: GroupNavigationDirection): DockviewGroupPanel | undefined;
     moveToNext(options?: MovementOptions): void;
     moveToPrevious(options?: MovementOptions): void;
     setActivePanel(panel: IDockviewPanel): void;
@@ -177,18 +260,7 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     toJSON(): SerializedDockview;
     fromJSON(data: SerializedDockview): void;
     addFloatingGroup(item: IDockviewPanel | DockviewGroupPanel, options?: FloatingGroupOptions): void;
-    addPopoutGroup(item: IDockviewPanel | DockviewGroupPanel, options?: {
-        position?: Box;
-        popoutUrl?: string;
-        onDidOpen?: (event: {
-            id: string;
-            window: Window;
-        }) => void;
-        onWillClose?: (event: {
-            id: string;
-            window: Window;
-        }) => void;
-    }): Promise<boolean>;
+    addPopoutGroup(item: IDockviewPanel | DockviewGroupPanel, options?: DockviewPopoutGroupOptions): Promise<boolean>;
     fromJSON(data: any, options?: {
         reuseExistingPanels: boolean;
     }): void;
@@ -198,18 +270,16 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     isEdgeGroupVisible(position: EdgeGroupPosition): boolean;
     removeEdgeGroup(position: EdgeGroupPosition): void;
 }
-export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> implements IDockviewComponent {
+export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> implements IDockviewComponent, IFloatingGroupHost, IPopoutWindowHost, IWatermarkHost, IEdgeGroupServiceHost, ITabGroupChipsHost, IContextMenuHost, IRootDropTargetHost, IHeaderActionsHost, IAdvancedDnDHost, ILiveRegionHost, IAccessibilityHost {
     private readonly nextGroupId;
     private readonly _deserializer;
     private readonly _api;
+    private readonly _moduleRegistry;
     private _options;
     private _tabGroupColorPalette;
-    private _watermark;
     private _shellThemeClassnames;
     readonly overlayRenderContainer: OverlayRenderContainer;
     readonly popupService: PopupService;
-    private readonly _popoutPopupServices;
-    readonly contextMenuController: ContextMenuController;
     readonly rootDropTargetContainer: DropTargetAnchorContainer;
     private readonly _onWillDragPanel;
     readonly onWillDragPanel: Event<TabDragEvent>;
@@ -219,10 +289,17 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     readonly onDidDrop: Event<DockviewDidDropEvent>;
     private readonly _onWillDrop;
     readonly onWillDrop: Event<DockviewWillDropEvent>;
+    private _mutationDepth;
+    private _origin;
+    private _originDepth;
+    private readonly _onWillMutateLayout;
+    readonly onWillMutateLayout: Event<DockviewLayoutMutationEvent>;
+    private readonly _onDidMutateLayout;
+    readonly onDidMutateLayout: Event<DockviewLayoutMutationEvent>;
     private readonly _onWillShowOverlay;
     readonly onWillShowOverlay: Event<DockviewWillShowOverlayLocationEvent>;
-    private readonly _onUnhandledDragOverEvent;
-    readonly onUnhandledDragOverEvent: Event<DockviewDndOverlayEvent>;
+    private readonly _onUnhandledDragOver;
+    readonly onUnhandledDragOver: Event<DockviewDndOverlayEvent>;
     private readonly _onDidRemovePanel;
     readonly onDidRemovePanel: Event<IDockviewPanel>;
     private readonly _onDidAddPanel;
@@ -231,12 +308,16 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     readonly onDidPopoutGroupSizeChange: Event<PopoutGroupChangeSizeEvent>;
     private readonly _onDidPopoutGroupPositionChange;
     readonly onDidPopoutGroupPositionChange: Event<PopoutGroupChangePositionEvent>;
+    private readonly _onDidAddPopoutGroup;
+    readonly onDidAddPopoutGroup: Event<PopoutGroup>;
+    private readonly _onDidRemovePopoutGroup;
+    readonly onDidRemovePopoutGroup: Event<PopoutGroup>;
     private readonly _onDidOpenPopoutWindowFail;
     readonly onDidOpenPopoutWindowFail: Event<void>;
     private readonly _onDidLayoutFromJSON;
     readonly onDidLayoutFromJSON: Event<void>;
     private readonly _onDidActivePanelChange;
-    readonly onDidActivePanelChange: Event<IDockviewPanel | undefined>;
+    readonly onDidActivePanelChange: Event<DockviewActivePanelChangeEvent>;
     private readonly _onDidMovePanel;
     readonly onDidMovePanel: Event<MovePanelEvent>;
     private readonly _onDidCreateTabGroup;
@@ -250,20 +331,18 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     private readonly _onDidTabGroupChange;
     readonly onDidTabGroupChange: Event<DockviewTabGroupChangeEvent>;
     private readonly _onDidTabGroupCollapsedChange;
-    readonly onDidTabGroupCollapsedChange: Event<DockviewTabGroupChangeEvent>;
+    readonly onDidTabGroupCollapsedChange: Event<DockviewTabGroupCollapsedChangeEvent>;
+    fireDidCreateTabGroup(event: DockviewTabGroupChangeEvent): void;
+    fireDidDestroyTabGroup(event: DockviewTabGroupChangeEvent): void;
+    fireDidAddPanelToTabGroup(event: DockviewTabGroupPanelChangeEvent): void;
+    fireDidRemovePanelFromTabGroup(event: DockviewTabGroupPanelChangeEvent): void;
+    fireDidTabGroupChange(event: DockviewTabGroupChangeEvent): void;
+    fireDidTabGroupCollapsedChange(event: DockviewTabGroupCollapsedChangeEvent): void;
     private readonly _onDidMaximizedGroupChange;
-    readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChanged>;
+    readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChangeEvent>;
     private _shellManager;
     private _floatingOverlayHost;
     private _inShellLayout;
-    private readonly _edgeGroups;
-    private readonly _edgeGroupDisposables;
-    private readonly _floatingGroups;
-    private readonly _popoutGroups;
-    private readonly _rootDropTarget;
-    private readonly _rootPointerDropTarget;
-    private _popoutRestorationPromise;
-    private readonly _popoutRestorationCleanups;
     private readonly _onDidRemoveGroup;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
     protected readonly _onDidAddGroup: Emitter<DockviewGroupPanel>;
@@ -281,7 +360,62 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     get renderer(): DockviewPanelRenderer;
     get defaultHeaderPosition(): DockviewHeaderPosition;
     get api(): DockviewApi;
-    get floatingGroups(): DockviewFloatingGroupPanel[];
+    get floatingGroups(): readonly DockviewFloatingGroupPanel[];
+    /**
+     * Boxes of the floating groups other than `exclude`, in coordinates
+     * relative to the floating overlay container. Supplied to a
+     * `transformFloatingGroupDrag` callback as `context.others` so it can
+     * align the dragged float against its siblings.
+     */
+    private _gatherFloatingGroupBoxes;
+    private get _floatingGroupService();
+    private get _popoutWindowService();
+    private get _watermarkService();
+    private get _edgeGroupService();
+    private get _rootDropTargetService();
+    private get _advancedDnDService();
+    get headerActionsService(): import("./headerActionsService").IHeaderActionsService | undefined;
+    isGridEmpty(): boolean;
+    rootDropTargetOverrideTarget(): import("../dnd/droptarget").DropTargetTargetModel | undefined;
+    dispatchUnhandledDragOver(nativeEvent: DragEvent | PointerEvent, position: Position): boolean;
+    fireWillDragPanel(event: TabDragEvent): void;
+    fireWillDragGroup(event: GroupDragEvent): void;
+    fireWillDrop(event: DockviewWillDropEvent): void;
+    fireWillShowOverlay(event: DockviewWillShowOverlayLocationEvent): void;
+    /**
+     * Resolve the custom group drag ghost (via the AdvancedDnD module), or
+     * `undefined` to fall back to the default chip. Returns `undefined` when
+     * the module is absent — the default ghost then renders.
+     */
+    buildGroupDragGhost(group: DockviewGroupPanel): IDragGhostSpec | undefined;
+    /**
+     * Resolve the app-supplied drop overlay model (via the AdvancedDnD module)
+     * for a group drop target, or `undefined` to keep the target's default.
+     */
+    resolveDropOverlayModel(location: DockviewGroupDropLocation, group?: DockviewGroupPanel): DroptargetOverlayModel | undefined;
+    /** Outermost element — the shell (incl. edge groups) once built, else the gridview. */
+    get rootElement(): HTMLElement;
+    /**
+     * The next / previous group in gridview (spatial) order, wrapping round.
+     * The keyboard accessibility module's focus navigation is built on this
+     * primitive — the only piece that needs the grid internals; the rest of
+     * the navigation logic lives in the AccessibilityService.
+     */
+    adjacentGroup(group: DockviewGroupPanel, reverse: boolean): DockviewGroupPanel | undefined;
+    /**
+     * The nearest grid group in a spatial direction from `group`, by
+     * comparing group centre points. Floating and popout groups sit outside
+     * the grid's geometry and are ignored. Returns `undefined` when there is
+     * no group in that direction.
+     */
+    adjacentGroupInDirection(group: DockviewGroupPanel, direction: GroupNavigationDirection): DockviewGroupPanel | undefined;
+    showDropPreview(group: DockviewGroupPanel, position: Position): IDisposable;
+    announce(message: string): void;
+    dockPanel(panel: IDockviewPanel, group: DockviewGroupPanel, position: Position): void;
+    get contextMenuService(): IContextMenuService | undefined;
+    get mountElement(): HTMLElement;
+    hasVisibleGridGroup(): boolean;
+    fireLayoutChange(): void;
     /**
      * Promise that resolves when all popout groups from the last fromJSON call are restored.
      * Useful for tests that need to wait for delayed popout creation.
@@ -296,8 +430,46 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * and dismisses on events from that window.
      */
     getPopupServiceForGroup(group: DockviewGroupPanel): PopupService;
-    addPopoutGroup(itemToPopout: DockviewPanel | DockviewGroupPanel, options?: DockviewPopoutGroupOptions): Promise<boolean>;
+    addPopoutGroup(itemToPopout: DockviewPanel | DockviewGroupPanel, options?: DockviewPopoutGroupOptionsInternal): Promise<boolean>;
+    /** Enumerate the popout groups currently open in their own windows. */
+    getPopouts(): PopoutGroup[];
+    private _doAddPopoutGroup;
+    /**
+     * The popout window was blocked (e.g. by the browser's popup blocker —
+     * common when restoring popouts on load). Fall back gracefully so the
+     * group(s) end up valid and visible in the main grid rather than as
+     * orphans that later crash clear()/remove().
+     */
+    private handleBlockedPopout;
+    /**
+     * Wire a group that has been displaced from a floating / popout window back
+     * to the main grid's render & drop-target containers and dock it at the
+     * root. The caller is responsible for first detaching it from its old
+     * gridview — the detach strategy differs between the window-teardown path
+     * (`doRemoveGroup`) and the blocked-window path (`gridview.remove`).
+     */
+    private redockGroupToMainGrid;
+    /**
+     * Teardown for a popout window's `popoutWindowDisposable`. Runs when the
+     * window closes (by user, by `removeGroup`, or by component disposal):
+     * relocates every member group back to the main grid (or to a floating
+     * window when the anchor came from one), then disposes the nested gridview.
+     * `closeResult.returnedGroup` is read by the entry's `dispose()` contract.
+     */
+    private disposePopoutWindow;
     addFloatingGroup(item: DockviewPanel | DockviewGroupPanel, options?: FloatingGroupOptionsInternal): void;
+    private _doAddFloatingGroup;
+    /**
+     * Build an empty gridview configured to match the main grid's styling, for
+     * hosting a nested layout inside a floating or popout window.
+     */
+    private createNestedGridview;
+    /**
+     * Wrap a (populated) floating gridview in an overlay window: title bar /
+     * move handle, drag wiring, the floating-group service entry and the
+     * `floating` location tag for every member group.
+     */
+    private mountFloatingWindow;
     private orthogonalize;
     updateOptions(options: Partial<DockviewComponentOptions>): void;
     layout(width: number, height: number, forceResize?: boolean | undefined): void;
@@ -326,17 +498,30 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     fromJSON(data: SerializedDockview, options?: {
         reuseExistingPanels: boolean;
     }): void;
+    private _doFromJSON;
+    /**
+     * Rebuild a floating / popout window's nested gridview from its serialized
+     * tree, collecting the member groups (in deserialization order) so the
+     * caller can mount or restore the window.
+     */
+    private deserializeNestedGridview;
+    private deserializeEdgeGroups;
+    private deserializeFloatingWindows;
+    private deserializePopoutWindows;
     clear(): void;
+    private _doClear;
     closeAllGroups(): void;
     addPanel<T extends object = Parameters>(options: AddPanelOptions<T>): DockviewPanel;
+    private _doAddPanel;
     removePanel(panel: IDockviewPanel, options?: {
         removeEmptyGroup: boolean;
         skipDispose?: boolean;
         skipSetActiveGroup?: boolean;
     }): void;
+    private _doRemovePanel;
     createWatermarkComponent(): IWatermarkRenderer;
-    private updateWatermark;
     addGroup(options?: AddGroupOptions): DockviewGroupPanel;
+    private _doAddGroup;
     private getLocationOrientation;
     removeGroup(group: DockviewGroupPanel, options?: {
         skipActive?: boolean;
@@ -344,6 +529,27 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
         skipPopoutAssociated?: boolean;
         skipPopoutReturn?: boolean;
     } | undefined): void;
+    /**
+     * Detach a single group from the nested gridview of its floating / popout
+     * window, keeping the window and its remaining members alive, and reassign
+     * the window's anchor if the detached group was it.
+     *
+     * @returns `true` if the group was detached from a multi-member window;
+     * `false` if `group` is not in a nested window, or is the window's only
+     * member — in which case the caller is responsible for disposing the whole
+     * window.
+     */
+    private detachFromNestedWindow;
+    /**
+     * Dispose a group and forget it: remove it from `_groups` and fire the
+     * removed event.
+     */
+    private disposeGroupRecord;
+    /**
+     * When `removed` was the active group, fall the active selection back to
+     * the first remaining group (or clear it when none remain).
+     */
+    private activateFallbackGroupIfRemoved;
     protected doRemoveGroup(group: DockviewGroupPanel, options?: {
         skipActive?: boolean;
         skipDispose?: boolean;
@@ -354,18 +560,67 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     private _updatePositionsFrameId;
     private debouncedUpdateAllPositions;
     movingLock<T>(func: () => T): T;
+    /**
+     * Bracket a structural mutation with `onWillMutateLayout` /
+     * `onDidMutateLayout`. Re-entrant: nested calls (a compound operation such
+     * as a drag that relocates a panel) join the outermost transaction, so the
+     * events fire exactly once around the whole operation. `kind` reflects the
+     * outermost mutation.
+     */
+    mutation<T>(kind: DockviewLayoutMutationKind, func: () => T): T;
+    /**
+     * The origin of the operation currently in progress (`'user'` by default).
+     * Read inside a `mutation()` or active-panel change to learn whether the
+     * change was driven by application code (via the {@link DockviewApi}) or a
+     * user gesture.
+     */
+    currentOrigin(): DockviewOrigin;
+    /**
+     * Run `func` with the operation origin set to `origin`, restoring the
+     * previous value afterwards. Used by the DockviewApi boundary to tag
+     * programmatic operations as `'api'`, and by user-gesture handlers to tag
+     * `'user'`. Only the outermost caller sets the origin — a nested call (or a
+     * call made while a mutation is already in flight) keeps whatever the
+     * enclosing operation established, so the trigger always wins.
+     */
+    withOrigin<T>(origin: DockviewOrigin, func: () => T): T;
+    /**
+     * Fire `onDidActivePanelChange` with the panel and the current operation
+     * {@link DockviewOrigin}. Callers keep their own dedupe guards.
+     */
+    private fireActivePanelChange;
     moveGroupOrPanel(options: MoveGroupOrPanelOptions): void;
+    private _doMoveGroupOrPanel;
     private moveTabGroupToGroup;
     moveGroup(options: MoveGroupOptions): void;
+    maximizeGroup(panel: DockviewGroupPanel): void;
+    exitMaximizedGroup(): void;
+    private _doMoveGroup;
     doSetGroupActive(group: DockviewGroupPanel | undefined): void;
     doSetGroupAndPanelActive(group: DockviewGroupPanel | undefined): void;
     private getNextGroupId;
     createGroup(options?: GroupOptions): DockviewGroupPanel;
     private createPanel;
     private createGroupAtLocation;
+    /**
+     * Tag a group with the location and render / drop-target containers
+     * matching the gridview root it now lives in: the main grid, a floating
+     * window (shares the main containers), or a popout window (uses its own
+     * window-local containers).
+     */
+    private setGroupLocationForRoot;
+    /**
+     * Resolve which gridview root currently owns a group: the main grid, or
+     * the nested gridview of the floating / popout window it lives in.
+     */
+    getGridviewForGroup(group: DockviewGroupPanel): Gridview;
+    /**
+     * The groups that live within the same floating / popout window as `group`
+     * (including `group` itself). Empty when `group` is in the main grid.
+     */
+    private nestedWindowMembers;
     private findGroup;
     private orientationAtLocation;
-    private updateDropTargetModel;
     private updateTheme;
 }
 export {};