react-dockable-desktop 3.2.0 → 4.1.0

package/dist/index.d.cts

@@ -1,6 +1,64 @@
 import React$1, { ComponentType, Context, Provider, ReactNode } from 'react';
-import { ContextMenuItem } from 'replace-react-contexify';
-export { ContextMenuItem, ContextMenuSeparator, ContextMenuSimpleItem, ContextMenuSubMenu } from 'replace-react-contexify';
+
+interface ContextMenuPredefinedMessage$1 {
+    id: string;
+    defaultMessage?: string;
+    values?: Record<string, string | number>;
+}
+type MessageFormatter$1 = (msg: ContextMenuPredefinedMessage$1) => string;
+type ContextMenuLabel = string | ContextMenuPredefinedMessage$1;
+type MenuItemAction = () => void;
+
+interface ContextMenuCheckbox {
+    /** Whether the checkbox column renders at all (default: true). */
+    active?: boolean;
+    /** Whether the item is interactive (default: true). Prefer top-level `disabled` on the item instead. */
+    enabled?: boolean;
+    /** Current checked state. */
+    value: boolean;
+}
+interface ContextMenuSimpleItem {
+    label: ContextMenuLabel;
+    icon?: React$1.ReactNode;
+    title?: ContextMenuLabel;
+    checkbox?: ContextMenuCheckbox;
+    action?: MenuItemAction;
+    cyAction?: string;
+    disabled?: boolean;
+}
+interface ContextMenuSeparator {
+    separator: true;
+}
+interface ContextMenuSubMenu {
+    label: ContextMenuLabel;
+    title?: ContextMenuLabel;
+    items?: ContextMenuItem[];
+}
+type ContextMenuItem = ContextMenuSimpleItem | ContextMenuSeparator | ContextMenuSubMenu;
+interface ShowContextMenuOptions {
+    event?: React$1.MouseEvent | React$1.TouchEvent | MouseEvent | TouchEvent;
+    x?: number;
+    y?: number;
+    items: ContextMenuItem[];
+}
+interface ContextMenuHandle {
+    show(options: ShowContextMenuOptions): void;
+}
+interface ContextMenuProps {
+    theme?: string;
+    animation?: string;
+    formatMessageProvider?: MessageFormatter$1;
+    onShow?: () => void;
+    onHide?: () => void;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+interface ContextMenuAdapter {
+    Component: React$1.ForwardRefExoticComponent<ContextMenuProps & React$1.RefAttributes<ContextMenuHandle>>;
+}
+declare const ContextMenu: React$1.ForwardRefExoticComponent<ContextMenuProps & React$1.RefAttributes<ContextMenuHandle>>;
+declare const DefaultContextMenuAdapter: ContextMenuAdapter;
 
 /**
  * @file WindowManager.tsx
@@ -9,79 +67,167 @@ export { ContextMenuItem, ContextMenuSeparator, ContextMenuSimpleItem, ContextMe
  * resize handles, context menus, and taskbar docks. Exposes lifecycle event listeners.
  */
 
+/** Controls when the minimized-panel taskbar is visible. */
+type TaskbarVisibility = 'always' | 'compact' | 'autohide';
+/** Props for `<WindowManager>`. */
 interface WindowManagerProps {
+    /** Built-in skin name or a custom skin key registered via CSS. @default 'vscode' */
     skin?: string;
+    /** Fallback icon shown in panel tabs when no panel-specific icon is provided. */
     defaultPanelIcon?: React$1.ReactNode;
-    taskbarVisibility?: 'always' | 'compact' | 'autohide';
+    /**
+     * Controls taskbar visibility.
+     * - `'always'` — permanent bar at the bottom (default)
+     * - `'compact'` — only visible when minimized panels exist
+     * - `'autohide'` — overlay bar with 8 px peek strip
+     * @default 'always'
+     */
+    taskbarVisibility?: TaskbarVisibility;
+    /** Custom context menu renderer. Defaults to the built-in `DefaultContextMenuAdapter`. */
+    contextMenuAdapter?: ContextMenuAdapter;
 }
 declare const WindowManager: React$1.FC<WindowManagerProps>;
 
-/**
- * Represents a registered component configuration template inside the panel catalog registry.
- */
-interface PanelRegistryEntry {
-    /** The React component type registered. */
-    Component: ComponentType<any>;
-    /** Default metadata settings configuration applied on instantiation. */
-    defaultOptions?: {
-        /** Tab and window headers text — plain string or i18n descriptor. */
-        title?: string | {
-            id: string;
-            defaultMessage?: string;
-            values?: Record<string, string | number>;
-        };
-        /** Icon placed next to title tags. */
-        icon?: React.ReactNode;
-        /** Initial mounting state inside the desktop layout grid. */
-        initialTarget?: 'floating' | 'docked' | 'tabbed';
-        /** Custom default bounds applied when the container is floated. */
-        favoritePosition?: {
-            x: number | string;
-            y: number | string;
-            width: number | string;
-            height: number | string;
-        };
-        /** Enables/disables window drag interactions. */
-        canDrag?: boolean;
-        /** Enables/disables minimizing of the panel instance. */
-        canMinimize?: boolean;
-        /** Enables/disables closing actions for the tab/window. */
-        canClose?: boolean;
-        /** Affixes the panel to the right edge. */
-        defaultStickyRight?: boolean;
-        /** Affixes the panel to the bottom edge. */
-        defaultStickyBottom?: boolean;
-        /** Disables live WebGL rendering canvas thumbnails inside the taskbar hover popup previews. */
-        disableLivePreview?: boolean;
-        /** Custom header actions renderer, placing custom components in the window/tab titlebar. */
-        renderHeaderActions?: (panelId: string) => React.ReactNode;
+/** Built-in lifecycle events always available on the WorkspaceClient event bus. */
+interface BuiltInPanelEvents {
+    'panel:opened': {
+        id: string;
+        component: string;
+    };
+    'panel:closed': {
+        id: string;
+    };
+    'panel:minimized': {
+        id: string;
+    };
+    'panel:restored': {
+        id: string;
     };
 }
-/**
- * Registry mapping catalog entries to allow programmatic panel instantiation
- * inside dynamic layout cells or floating windows.
- * Exported so WorkspaceClient can create scoped, per-instance registries.
- */
-declare class PanelRegistryClass {
-    private registry;
+/** Per-panel definition supplied to WorkspaceClient constructor. */
+interface PanelDefinition {
+    component: ComponentType<any>;
+    defaultOptions?: PanelRegistryEntry['defaultOptions'];
+}
+/** Configuration object accepted by the WorkspaceClient constructor. */
+interface WorkspaceClientConfig {
     /**
-     * Register a new component to the panel catalog registry.
-     * @param id - Unique string identifier.
-     * @param Component - React component instance template.
-     * @param defaultOptions - Custom default settings configuration.
+     * Declarative panel catalog. Replaces imperative PanelRegistry.register() calls.
+     * Keys are the component identifiers used in openPanel() and serialised layouts.
      */
-    register<P extends object>(id: string, Component: ComponentType<P>, defaultOptions?: PanelRegistryEntry['defaultOptions']): void;
+    panels?: Record<string, PanelDefinition>;
     /**
-     * Retrieve a registered panel configuration by identifier.
+     * Serialised layout produced by a previous saveLayout() call.
+     * Pass null or omit to start with an empty canvas.
      */
-    get(id: string): PanelRegistryEntry | undefined;
+    initialState?: string | null;
+    /** Custom i18n formatter for all internal strings. */
+    formatMessage?: MessageFormatter;
+    /** Override any subset of the built-in predefined message catalog. */
+    predefinedMessages?: Record<string, ContextMenuPredefinedMessage>;
+    /** Initial layout direction. */
+    dir?: 'ltr' | 'rtl';
     /**
-     * Returns a list of all registered panel entry identifiers.
+     * Fraction of the target panel the new panel takes when dropped on a panel's
+     * top/bottom/left/right cross target. Range 0.1–0.9. Default: 0.5.
      */
-    getRegisteredIds(): string[];
+    defaultSplitRatio?: number;
+    /**
+     * Fraction of the workspace the new panel takes when dropped on the workspace
+     * outer edge. Range 0.1–0.9. Default: 0.2.
+     */
+    defaultEdgeSplitRatio?: number;
+}
+/**
+ * WorkspaceClient is the central configuration and imperative API object for
+ * react-dockable-desktop. Create one instance outside the React tree and pass
+ * it to `<WindowManagerProvider client={client}>`.
+ *
+ * Pattern: TanStack QueryClient / Redux store — configuration and imperative
+ * access live on the client; rendering is delegated to the thin React provider.
+ *
+ * @remarks
+ * Calls made before the provider mounts are queued and replayed automatically
+ * in order once `_connect()` fires. Duplicate `openPanel` calls for the same
+ * ID are deduplicated while queued. Subscriptions made before mount are
+ * buffered and re-registered on each connect/reconnect.
+ *
+ * @example
+ * const workspace = new WorkspaceClient<MyEvents>({
+ *   panels: {
+ *     map:    { component: MapPanel },
+ *     editor: { component: EditorPanel, defaultOptions: { title: 'Code Editor' } },
+ *   },
+ *   initialState: localStorage.getItem('layout'),
+ * });
+ *
+ * <WindowManagerProvider client={workspace}>
+ *   <WindowManager />
+ * </WindowManagerProvider>
+ *
+ * // Imperative access from anywhere:
+ * workspace.saveLayout();
+ * workspace.openPanel('map-1', 'map');
+ * workspace.focusPanel('map-1');
+ */
+declare class WorkspaceClient<TUserEvents extends Record<string, unknown> = Record<string, unknown>> {
+    /** Scoped panel registry — fully independent from the global singleton. */
+    readonly registry: PanelRegistryClass;
+    /** Serialised layout to restore on mount, or null to start with an empty canvas. */
+    readonly initialState: string | null;
+    /** Non-rendering configuration forwarded to the provider. */
+    readonly config: Pick<WorkspaceClientConfig, 'formatMessage' | 'predefinedMessages' | 'dir' | 'defaultSplitRatio' | 'defaultEdgeSplitRatio'>;
+    private _actions;
+    private _initialized;
+    /** Calls queued before _connect() fires — replayed in order on first connect. */
+    private _pendingCalls;
+    /** Tracks openPanel IDs in the pending queue to prevent duplicates before mount. */
+    private _pendingOpenPanelIds;
+    /** Subscriptions buffered before connect — re-registered on every connect/reconnect. */
+    private _pendingSubscriptions;
+    /** Timer that emits an error if _connect() is never called with pending work. */
+    private _disconnectedWarnTimer;
+    constructor(config?: WorkspaceClientConfig);
+    /** @internal Called by WindowManagerProvider after mount. */
+    _connect(actions: WindowActions): void;
+    /** @internal Called by WindowManagerProvider on unmount. */
+    _disconnect(): void;
+    /** True while the provider is mounted and React state is accessible. */
+    get isConnected(): boolean;
+    private _startWarnTimer;
+    private _dispatch;
+    private _subscribeRaw;
+    openPanel(...args: Parameters<WindowActions['openPanel']>): void;
+    closePanel(id: string): void;
+    minimizePanel(id: string): void;
+    restorePanel(id: string): void;
+    floatPanel(...args: Parameters<WindowActions['floatPanel']>): void;
+    dockPanel(...args: Parameters<WindowActions['dockPanel']>): void;
+    maximizePanel(id: string): void;
+    /**
+     * Activates the given panel regardless of its current state.
+     * For floating panels: raises z-index so the window appears on top.
+     * For docked panels: selects the tab within its leaf group.
+     */
+    focusPanel(id: string): void;
+    /** Returns `true` if a panel with this ID is currently open. */
+    isOpen(id: string): boolean;
+    /** Returns the IDs of all currently open panels. */
+    getOpenPanelIds(): string[];
+    saveLayout(): string;
+    loadLayout(json: string): boolean;
+    setDirection(dir: 'ltr' | 'rtl'): void;
+    publish<K extends keyof (TUserEvents & BuiltInPanelEvents)>(event: K, data: (TUserEvents & BuiltInPanelEvents)[K]): void;
+    subscribe<K extends keyof (TUserEvents & BuiltInPanelEvents)>(event: K, callback: (data: (TUserEvents & BuiltInPanelEvents)[K]) => void): () => void;
+    /** Subscribe to panel open events. Fires only for newly created panels. */
+    onPanelOpen(callback: (id: string, component: string) => void): () => void;
+    /** Subscribe to panel close events. */
+    onPanelClose(callback: (id: string) => void): () => void;
+    /** Subscribe to panel minimize events. */
+    onPanelMinimize(callback: (id: string) => void): () => void;
+    /** Subscribe to panel restore events. */
+    onPanelRestore(callback: (id: string) => void): () => void;
 }
-/** Global singleton instance of the Panel Registry. */
-declare const PanelRegistry: PanelRegistryClass;
 
 /**
  * @file predefinedMessages.ts
@@ -144,18 +290,6 @@ declare const defaultPredefinedMessages: {
         readonly id: "dockable-desktop-closeEmptyGroup";
         readonly defaultMessage: "Close empty split group";
     };
-    readonly anchorToRightEdge: {
-        readonly id: "dockable-desktop-anchorToRightEdge";
-        readonly defaultMessage: "Anchor to Right Edge";
-    };
-    readonly anchorToBottomEdge: {
-        readonly id: "dockable-desktop-anchorToBottomEdge";
-        readonly defaultMessage: "Anchor to Bottom Edge";
-    };
-    readonly windowAnchoringOptions: {
-        readonly id: "dockable-desktop-windowAnchoringOptions";
-        readonly defaultMessage: "Window Anchoring Options";
-    };
     readonly unsavedChangesTitle: {
         readonly id: "dockable-desktop-unsavedChangesTitle";
         readonly defaultMessage: "Unsaved Changes";
@@ -290,6 +424,8 @@ interface LayoutLeafNode {
 }
 /** Union type representing either a branch or a leaf node in the layout grid. */
 type LayoutNode = LayoutGridNode | LayoutLeafNode;
+/** Corner of the workspace a floating window is pinned to. */
+type FloatAnchor = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 /**
  * Bounds and depth metadata for floated panel windows.
  */
@@ -308,10 +444,8 @@ interface FloatingWindow {
     z: number;
     /** True if the window is currently maximized to full workspace bounds. */
     maximized?: boolean;
-    /** Sticky right flag. */
-    stickyRight?: boolean;
-    /** Sticky bottom flag. */
-    stickyBottom?: boolean;
+    /** Corner of the workspace this window is pinned to, or null when free-floating. */
+    anchor?: FloatAnchor | null;
 }
 /**
  * Stores active runtime properties and status metadata for individual panel instances.
@@ -333,8 +467,7 @@ interface PanelInfo {
         y: number;
         width: number;
         height: number;
-        stickyRight?: boolean;
-        stickyBottom?: boolean;
+        anchor?: FloatAnchor | null;
     };
     /** The leaf group ID this panel was docked in prior to being floated. */
     lastLeafId?: string;
@@ -367,6 +500,10 @@ interface WindowState {
     dir: 'ltr' | 'rtl';
     /** Convenient boolean flag indicating RTL direction */
     isRtl: boolean;
+    /** Split ratio for panel cross-target drops (0.1–0.9). Default 0.5. */
+    splitRatio: number;
+    /** Split ratio for workspace outer-edge drops (0.1–0.9). Default 0.2. */
+    edgeSplitRatio: number;
 }
 /**
  * All layout mutation methods, event bus handles, and serialization methods
@@ -399,8 +536,7 @@ interface WindowActions {
     openPanel: (id: string, component: string, options?: {
         title?: string | ContextMenuPredefinedMessage;
         initialTarget?: 'floating' | 'docked' | 'tabbed';
-        stickyRight?: boolean;
-        stickyBottom?: boolean;
+        anchor?: FloatAnchor | null;
     }) => void;
     /**
      * Closes a panel immediately, bypassing dirty-state close guards.
@@ -428,7 +564,7 @@ interface WindowActions {
         y: number;
         width: number;
         height: number;
-    }) => void;
+    }, anchor?: FloatAnchor | null) => void;
     /**
      * Returns a floating window to a docked grid tab group.
      * @param id - Panel instance ID.
@@ -449,9 +585,9 @@ interface WindowActions {
     /**
      * Updates the position or size of a floating window.
      * @param id - Panel instance ID.
-     * @param updates - Partial update to `x`, `y`, `width`, `height`, `stickyRight`, or `stickyBottom`.
+     * @param updates - Partial update to `x`, `y`, `width`, `height`, or `anchor`.
      */
-    updateFloatingPosition: (id: string, updates: Partial<Pick<FloatingWindow, 'x' | 'y' | 'width' | 'height' | 'stickyRight' | 'stickyBottom'>>) => void;
+    updateFloatingPosition: (id: string, updates: Partial<Pick<FloatingWindow, 'x' | 'y' | 'width' | 'height' | 'anchor'>>) => void;
     /**
      * Activates the given panel regardless of its current state.
      * - Floating panel: raises z-index so the window appears on top of others.
@@ -615,19 +751,37 @@ declare const useStyleClasses: () => StyleClasses;
  * ```
  */
 declare const useRegistry: () => PanelRegistryClass;
+/**
+ * Props for `<DockableDesktopProvider>` and `<WindowManagerProvider>`.
+ * Also exported as `DockableDesktopProviderProps` for consumers who use
+ * the composite provider.
+ * @see DockableDesktopProviderProps
+ */
 interface WindowManagerProviderProps {
     children: React$1.ReactNode;
-    /** WorkspaceClient instance created outside the React tree. When provided, its registry
-     *  and config take precedence over the individual props below. */
+    /** `WorkspaceClient` instance created outside the React tree. When provided, its panel
+     *  registry and config take precedence over the individual props below. */
     client?: WorkspaceClient;
+    /** Custom i18n formatter. Receives a `{ id, defaultMessage }` descriptor and returns
+     *  the translated string. When omitted, `defaultMessage` is used as-is. */
     formatMessage?: MessageFormatter;
+    /** Override the built-in predefined UI strings (confirm button labels, close tooltips, etc.).
+     *  Merge with or replace `defaultPredefinedMessages` to localise system strings. */
     predefinedMessages?: Record<string, ContextMenuPredefinedMessage>;
+    /** Layout direction. `'rtl'` mirrors all controls, tab order, and drop zones.
+     *  Can also be changed at runtime via `WorkspaceClient.setDirection()`. @default 'ltr' */
     dir?: 'ltr' | 'rtl';
+    /** CSS class applied to the outer wrapper element of every modal overlay. */
     modalClass?: string;
+    /** CSS class applied to the inner content area of every modal overlay. */
     modalBodyClass?: string;
+    /** CSS class applied to the outer wrapper of left/right side-panel drawers. */
     sidePanelClass?: string;
+    /** CSS class applied to the inner content area of side-panel drawers. */
     sidePanelBodyClass?: string;
+    /** CSS class applied to the outer wrapper of floating panel windows. */
     windowClass?: string;
+    /** CSS class applied to the inner content area of floating panel windows. */
     windowBodyClass?: string;
 }
 declare const WindowManagerProvider: React$1.FC<WindowManagerProviderProps>;
@@ -706,137 +860,76 @@ declare const usePanelId: () => string;
  */
 declare function usePanelContextMenu(items: ContextMenuItem[]): void;
 
-/** Built-in lifecycle events always available on the WorkspaceClient event bus. */
-interface BuiltInPanelEvents {
-    'panel:opened': {
-        id: string;
-        component: string;
-    };
-    'panel:closed': {
-        id: string;
-    };
-    'panel:minimized': {
-        id: string;
-    };
-    'panel:restored': {
-        id: string;
+/**
+ * Represents a registered component configuration template inside the panel catalog registry.
+ */
+interface PanelRegistryEntry {
+    /** The React component type registered. */
+    Component: ComponentType<any>;
+    /** Default metadata settings configuration applied on instantiation. */
+    defaultOptions?: {
+        /** Tab and window headers text — plain string or i18n descriptor. */
+        title?: string | {
+            id: string;
+            defaultMessage?: string;
+            values?: Record<string, string | number>;
+        };
+        /** Icon placed next to title tags. */
+        icon?: React.ReactNode;
+        /** Initial mounting state inside the desktop layout grid. */
+        initialTarget?: 'floating' | 'docked' | 'tabbed';
+        /** Custom default bounds applied when the container is floated. */
+        favoritePosition?: {
+            x: number | string;
+            y: number | string;
+            width: number | string;
+            height: number | string;
+        };
+        /** Enables/disables window drag interactions. */
+        canDrag?: boolean;
+        /** Enables/disables minimizing of the panel instance. */
+        canMinimize?: boolean;
+        /** Enables/disables closing actions for the tab/window. */
+        canClose?: boolean;
+        /** Corner of the workspace to anchor newly-opened floating windows to. */
+        defaultAnchor?: FloatAnchor;
+        /** Disables live WebGL rendering canvas thumbnails inside the taskbar hover popup previews. */
+        disableLivePreview?: boolean;
+        /** Custom header actions renderer, placing custom components in the window/tab titlebar. */
+        renderHeaderActions?: (panelId: string) => React.ReactNode;
     };
 }
-/** Per-panel definition supplied to WorkspaceClient constructor. */
-interface PanelDefinition {
-    component: ComponentType<any>;
-    defaultOptions?: PanelRegistryEntry['defaultOptions'];
-}
-/** Configuration object accepted by the WorkspaceClient constructor. */
-interface WorkspaceClientConfig {
+/**
+ * Registry mapping catalog entries to allow programmatic panel instantiation
+ * inside dynamic layout cells or floating windows.
+ * Exported so WorkspaceClient can create scoped, per-instance registries.
+ */
+declare class PanelRegistryClass {
+    private registry;
     /**
-     * Declarative panel catalog. Replaces imperative PanelRegistry.register() calls.
-     * Keys are the component identifiers used in openPanel() and serialised layouts.
+     * Register a new component to the panel catalog registry.
+     * @param id - Unique string identifier.
+     * @param Component - React component instance template.
+     * @param defaultOptions - Custom default settings configuration.
      */
-    panels?: Record<string, PanelDefinition>;
+    register<P extends object>(id: string, Component: ComponentType<P>, defaultOptions?: PanelRegistryEntry['defaultOptions']): void;
     /**
-     * Serialised layout produced by a previous saveLayout() call.
-     * Pass null or omit to start with an empty canvas.
+     * Retrieve a registered panel configuration by identifier.
      */
-    initialState?: string | null;
-    /** Custom i18n formatter for all internal strings. */
-    formatMessage?: MessageFormatter;
-    /** Override any subset of the built-in predefined message catalog. */
-    predefinedMessages?: Record<string, ContextMenuPredefinedMessage>;
-    /** Initial layout direction. */
-    dir?: 'ltr' | 'rtl';
-}
-/**
- * WorkspaceClient is the central configuration and imperative API object for
- * react-dockable-desktop. Create one instance outside the React tree and pass
- * it to `<WindowManagerProvider client={client}>`.
- *
- * Pattern: TanStack QueryClient / Redux store — configuration and imperative
- * access live on the client; rendering is delegated to the thin React provider.
- *
- * @remarks
- * Calls made before the provider mounts are queued and replayed automatically
- * in order once `_connect()` fires. Duplicate `openPanel` calls for the same
- * ID are deduplicated while queued. Subscriptions made before mount are
- * buffered and re-registered on each connect/reconnect.
- *
- * @example
- * const workspace = new WorkspaceClient<MyEvents>({
- *   panels: {
- *     map:    { component: MapPanel },
- *     editor: { component: EditorPanel, defaultOptions: { title: 'Code Editor' } },
- *   },
- *   initialState: localStorage.getItem('layout'),
- * });
- *
- * <WindowManagerProvider client={workspace}>
- *   <WindowManager />
- * </WindowManagerProvider>
- *
- * // Imperative access from anywhere:
- * workspace.saveLayout();
- * workspace.openPanel('map-1', 'map');
- * workspace.focusPanel('map-1');
- */
-declare class WorkspaceClient<TUserEvents extends Record<string, unknown> = Record<string, unknown>> {
-    /** Scoped panel registry — fully independent from the global singleton. */
-    readonly registry: PanelRegistryClass;
-    /** Serialised layout to restore on mount, or null to start with an empty canvas. */
-    readonly initialState: string | null;
-    /** Non-rendering configuration forwarded to the provider. */
-    readonly config: Pick<WorkspaceClientConfig, 'formatMessage' | 'predefinedMessages' | 'dir'>;
-    private _actions;
-    private _initialized;
-    /** Calls queued before _connect() fires — replayed in order on first connect. */
-    private _pendingCalls;
-    /** Tracks openPanel IDs in the pending queue to prevent duplicates before mount. */
-    private _pendingOpenPanelIds;
-    /** Subscriptions buffered before connect — re-registered on every connect/reconnect. */
-    private _pendingSubscriptions;
-    /** Timer that emits an error if _connect() is never called with pending work. */
-    private _disconnectedWarnTimer;
-    constructor(config?: WorkspaceClientConfig);
-    /** @internal Called by WindowManagerProvider after mount. */
-    _connect(actions: WindowActions): void;
-    /** @internal Called by WindowManagerProvider on unmount. */
-    _disconnect(): void;
-    /** True while the provider is mounted and React state is accessible. */
-    get isConnected(): boolean;
-    private _startWarnTimer;
-    private _dispatch;
-    private _subscribeRaw;
-    openPanel(...args: Parameters<WindowActions['openPanel']>): void;
-    closePanel(id: string): void;
-    minimizePanel(id: string): void;
-    restorePanel(id: string): void;
-    floatPanel(...args: Parameters<WindowActions['floatPanel']>): void;
-    dockPanel(...args: Parameters<WindowActions['dockPanel']>): void;
-    maximizePanel(id: string): void;
+    get(id: string): PanelRegistryEntry | undefined;
     /**
-     * Activates the given panel regardless of its current state.
-     * For floating panels: raises z-index so the window appears on top.
-     * For docked panels: selects the tab within its leaf group.
+     * Returns a list of all registered panel entry identifiers.
      */
-    focusPanel(id: string): void;
-    /** Returns `true` if a panel with this ID is currently open. */
-    isOpen(id: string): boolean;
-    /** Returns the IDs of all currently open panels. */
-    getOpenPanelIds(): string[];
-    saveLayout(): string;
-    loadLayout(json: string): boolean;
-    setDirection(dir: 'ltr' | 'rtl'): void;
-    publish<K extends keyof (TUserEvents & BuiltInPanelEvents)>(event: K, data: (TUserEvents & BuiltInPanelEvents)[K]): void;
-    subscribe<K extends keyof (TUserEvents & BuiltInPanelEvents)>(event: K, callback: (data: (TUserEvents & BuiltInPanelEvents)[K]) => void): () => void;
-    /** Subscribe to panel open events. Fires only for newly created panels. */
-    onPanelOpen(callback: (id: string, component: string) => void): () => void;
-    /** Subscribe to panel close events. */
-    onPanelClose(callback: (id: string) => void): () => void;
-    /** Subscribe to panel minimize events. */
-    onPanelMinimize(callback: (id: string) => void): () => void;
-    /** Subscribe to panel restore events. */
-    onPanelRestore(callback: (id: string) => void): () => void;
+    getRegisteredIds(): string[];
 }
+/** Global singleton instance of the Panel Registry. */
+declare const PanelRegistry: PanelRegistryClass;
 
+/**
+ * Props for `<DockableDesktopProvider>`. Alias of `WindowManagerProviderProps`.
+ * @see WindowManagerProviderProps
+ */
+type DockableDesktopProviderProps = WindowManagerProviderProps;
 /**
  * Composite provider that wraps both `WindowManagerProvider` and `PanelProvider`
  * in the correct order. Drop-in replacement for manually nesting both providers.
@@ -1259,7 +1352,7 @@ interface ToolbarToggleItem {
     disabled?: boolean;
 }
 /** A visual divider between button groups. */
-interface ToolbarSeparator {
+interface ToolbarSeparator$1 {
     type: 'separator';
 }
 /**
@@ -1314,12 +1407,12 @@ interface ToolbarGroupItem {
      */
     onActiveItemChange?: (id: string) => void;
 }
-type ToolbarItem = ToolbarActionItem | ToolbarRadioItem | ToolbarToggleItem | ToolbarGroupItem | ToolbarSeparator;
+type ToolbarItem$1 = ToolbarActionItem | ToolbarRadioItem | ToolbarToggleItem | ToolbarGroupItem | ToolbarSeparator$1;
 interface ToolbarProps {
     /** Side the strip is attached to. Controls strip orientation. Default: 'left' */
     position?: 'left' | 'right' | 'top' | 'bottom';
     /** Ordered list of items to render. */
-    items: ToolbarItem[];
+    items: ToolbarItem$1[];
     /** Collapse the strip to zero width/height. State is preserved — no unmount. */
     visible?: boolean;
     /** Called when show/hide/toggle is invoked on the imperative handle. */
@@ -1334,4 +1427,375 @@ interface ToolbarHandle {
 }
 declare const Toolbar: React$1.ForwardRefExoticComponent<ToolbarProps & React$1.RefAttributes<ToolbarHandle>>;
 
-export { type BuiltInPanelEvents, type CloseOptions, ConfirmationForm, type ConfirmationFormProps, type ContextMenuPredefinedMessage, DockableDesktopProvider, type DropPosition, type DropTarget, type FloatingWindow, FormContainerContext, type FormContainerContract, FormContainerProvider, type LayoutGridNode, type LayoutLeafNode, type LayoutNode, LeftPanelRenderer, type MessageFormatter, type ModalOptions, ModalStackRenderer, type PanelActions, type PanelDefinition, type PanelInfo, type PanelInstance, type PanelInstanceId, PanelProvider, PanelRegistry, PanelRegistryClass, type PanelRegistryEntry, type PanelState, type PanelTitle, type PredefinedMessageKey, RightPanelRenderer, type SidePanelOptions, SidePanelRenderer, type SidePanelRendererProps, Sidebar, type SidebarContextValue, type SidebarHandle, type SidebarProps, type SidebarTab, type SidebarTabContextValue, type SplitDirection, type SplitOrientation, type StyleClasses, Toolbar, type ToolbarActionItem, type ToolbarContextValue, type ToolbarGroupEntry, type ToolbarGroupItem, type ToolbarGroupSubItem, type ToolbarHandle, type ToolbarItem, type ToolbarProps, ToolbarProvider, type ToolbarRadioItem, type ToolbarSeparator, type ToolbarToggleItem, type WindowActions, WindowManager, WindowManagerProvider, type WindowState, WorkspaceClient, type WorkspaceClientConfig, defaultPredefinedMessages, formatLabel, useFormContainer, useFormatMessage, usePanelActions, usePanelContext, usePanelContextMenu, usePanelId, usePanelState, usePredefinedMessages, useRegistry, useSidebar, useSidebarTab, useStyleClasses, useToolbar, useWindowManagerActions, useWindowManagerState };
+/** Visual type of a toast notification. Determines the icon and accent color. */
+type ToastType = 'info' | 'success' | 'warning' | 'error';
+/** Corner position of the `<ToastContainer>` relative to the viewport. */
+type ToastPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/**
+ * Per-notification options passed to `toast()`, `toast.info()`, etc.
+ * All fields are optional and fall back to `<ToastContainer>` defaults when unset.
+ */
+interface ToastOptions {
+    /** Visual type. Overridden by the `toast.info/success/warning/error` shorthands. @default 'info' */
+    type?: ToastType;
+    /** Auto-dismiss delay in ms. `0` = sticky (never auto-dismisses). @default from container */
+    duration?: number;
+    /** Explicit ID for dedup — calling `toast.*` with the same `id` updates the existing card in-place. */
+    id?: string;
+    /** Show the × close button on this notification. @default from container */
+    closable?: boolean;
+    /** Override the built-in type icon with arbitrary content. */
+    icon?: React$1.ReactNode;
+    /** Replace the string message with arbitrary JSX. */
+    content?: React$1.ReactNode;
+    /** Called when the notification is dismissed by timer, close button, or `toast.dismiss()`. */
+    onClose?: () => void;
+}
+/**
+ * Fully-resolved options passed to `ToastAdapter.show()` and `ToastAdapter.update()`.
+ * All optional `ToastOptions` fields are resolved against the container defaults.
+ */
+interface ResolvedToastOptions {
+    id: string;
+    type: ToastType;
+    duration: number;
+    closable: boolean;
+    icon?: React$1.ReactNode;
+    content?: React$1.ReactNode;
+    onClose?: () => void;
+}
+/**
+ * Props for `<ToastContainer>`. Mount one instance at your app root alongside `ModalStackRenderer`.
+ * @example
+ * <ToastContainer position="top-right" progressBar />
+ */
+interface ToastContainerProps {
+    /** Where notifications appear in the viewport. @default 'top-right' */
+    position?: ToastPosition;
+    /** Maximum number of notifications shown simultaneously. Extras are queued. @default 3 */
+    maxVisible?: number;
+    /** Default auto-dismiss delay in ms. `0` = all notifications sticky. @default 5000 */
+    defaultDuration?: number;
+    /** Show the × close button on all notifications unless overridden per-toast. @default true */
+    defaultClosable?: boolean;
+    /** Pause the auto-dismiss timer while the cursor is over a notification. @default true */
+    pauseOnHover?: boolean;
+    /** Entry/exit animation style. @default 'slide' */
+    animation?: 'slide' | 'fade' | 'none';
+    /** When `true`, newest notification appears at the top of the stack. @default false */
+    newestOnTop?: boolean;
+    /** Show a countdown progress bar at the bottom of each notification. @default false */
+    progressBar?: boolean;
+    /** Width of each notification card in pixels. @default 320 */
+    width?: number;
+    /** Delegate all `toast.*` calls to a custom renderer (Ant Design, MUI, Sonner, etc.). */
+    adapter?: ToastAdapter;
+}
+/**
+ * Message set for `toast.promise()`. Each field may be static content or a function
+ * that receives the resolved/rejected value and returns renderable content.
+ * @template T The resolved value type of the tracked promise.
+ */
+interface ToastPromiseMessages<T> {
+    /** Shown while the promise is pending. */
+    pending: React$1.ReactNode;
+    /** Shown on fulfillment. Pass a function to include the resolved value. */
+    success: React$1.ReactNode | ((result: T) => React$1.ReactNode);
+    /** Shown on rejection. Pass a function to include the error reason. */
+    error: React$1.ReactNode | ((err: unknown) => React$1.ReactNode);
+}
+/**
+ * Strategy interface for replacing the built-in toast renderer with an external library.
+ * Pass an instance via `<ToastContainer adapter={...} />` to redirect all `toast.*` calls
+ * without changing any call sites in your application.
+ * @see ToastContainerProps.adapter
+ */
+interface ToastAdapter {
+    /** Called when a new notification is requested. */
+    show(id: string, message: React$1.ReactNode, options: ResolvedToastOptions): void;
+    /** Called when an existing notification is updated (e.g. after `toast.promise()` resolves). */
+    update(id: string, message: React$1.ReactNode, options: Partial<ResolvedToastOptions>): void;
+    /** Called to dismiss one notification (`id` provided) or all active notifications (no `id`). */
+    dismiss(id?: string): void;
+    /**
+     * `null` means the adapter manages its own DOM and `<ToastContainer>` renders nothing.
+     * A component causes `<ToastContainer>` to portal-render it with a `position` prop.
+     */
+    Container: React$1.ComponentType<{
+        position: ToastPosition;
+    }> | null;
+}
+/**
+ * Type of the `toast` singleton. Callable directly or via named shorthand methods.
+ * Import this type to annotate variables or props that accept the `toast` object.
+ * @example
+ * function notify(fn: ToastFunction) { fn.success('Done!'); }
+ */
+interface ToastFunction {
+    /** Show a notification. `opts.type` defaults to `'info'`. Returns the notification ID. */
+    (msg: React$1.ReactNode, opts?: ToastOptions): string;
+    /** Show an info notification. Returns the notification ID. */
+    info: (msg: React$1.ReactNode, opts?: ToastOptions) => string;
+    /** Show a success notification. Returns the notification ID. */
+    success: (msg: React$1.ReactNode, opts?: ToastOptions) => string;
+    /** Show a warning notification. Returns the notification ID. */
+    warning: (msg: React$1.ReactNode, opts?: ToastOptions) => string;
+    /** Show an error notification. Returns the notification ID. */
+    error: (msg: React$1.ReactNode, opts?: ToastOptions) => string;
+    /** Dismiss a notification by ID, or all active notifications when called with no argument. */
+    dismiss: (id?: string) => void;
+    /**
+     * Track a promise through pending → success/error states.
+     * Shows a sticky pending notification immediately, then transitions it on settlement.
+     * @template T The resolved value type of the promise.
+     */
+    promise: <T>(promise: Promise<T>, messages: ToastPromiseMessages<T>, opts?: ToastOptions) => Promise<T>;
+}
+/**
+ * Imperative notification singleton. Call from anywhere — inside or outside React.
+ * Mount `<ToastContainer>` once at your app root to activate the renderer.
+ * @example
+ * toast.success('File saved.');
+ * toast.error('Upload failed.', { duration: 0 }); // sticky
+ * toast.promise(saveFile(), { pending: 'Saving…', success: 'Saved!', error: 'Failed.' });
+ */
+declare const toast: ToastFunction;
+/**
+ * Portal-rendered notification host. Mount once at your app root, outside the workspace
+ * container. All `toast.*` calls are routed here automatically via the internal event emitter.
+ * @example
+ * <ToastContainer position="top-right" progressBar />
+ */
+declare function ToastContainer({ position, maxVisible, defaultDuration, defaultClosable, pauseOnHover, animation, newestOnTop, progressBar, width, adapter, }: ToastContainerProps): React$1.ReactElement | null;
+
+/** Edge of a panel to which a `PanelToolbar` attaches. */
+type ToolbarPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Configuration for a window spawned imperatively via `usePanelFloatingWindowManager().open()`.
+ * @see usePanelFloatingWindowManager
+ */
+interface ManagedWindowConfig {
+    /** Text shown in the window's header bar. */
+    title: string;
+    /** Optional icon shown to the left of the title in the header. */
+    icon?: React$1.ReactNode;
+    /** Window body content. */
+    content: React$1.ReactNode;
+    /** Corner of the panel to dock to on first render. @default 'top-right' */
+    anchor?: FloatAnchor;
+    /** Initial width in pixels. */
+    width?: number;
+    /** Initial height in pixels. */
+    height?: number;
+}
+/** Props for `<PanelOverlayRoot>`. */
+interface PanelOverlayRootProps {
+    children: React$1.ReactNode;
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+/**
+ * Context provider and layout root for the Panel Overlay system. Wrap your panel content
+ * with this to enable `PanelToolbar`, `PanelFloatingWindow`, and `usePanelFloatingWindowManager`.
+ * @example
+ * function MyPanel() {
+ *   return (
+ *     <PanelOverlayRoot style={{ position: 'relative', width: '100%', height: '100%' }}>
+ *       <PanelToolbar position="top">...</PanelToolbar>
+ *       <div className="panel-body">content</div>
+ *     </PanelOverlayRoot>
+ *   );
+ * }
+ */
+declare function PanelOverlayRoot({ children, className, style }: PanelOverlayRootProps): React$1.ReactElement;
+/** Background style of a `PanelToolbar`. */
+type ToolbarVariant = 'transparent' | 'frosted' | 'solid';
+/** Visual style applied to `ToolbarButton` and `ToolbarToggle` components. */
+type ButtonVariant = 'ghost' | 'soft' | 'outlined' | 'filled';
+/** Props for `<PanelToolbar>`. */
+interface PanelToolbarProps {
+    /** Edge of the panel overlay to attach to. @see ToolbarPosition */
+    position: ToolbarPosition;
+    /** Background style of the toolbar strip. @default 'transparent' */
+    variant?: ToolbarVariant;
+    /** Default button style inherited by `ToolbarButton` and `ToolbarToggle` children. @default 'ghost' */
+    buttonVariant?: ButtonVariant;
+    /** Icon size in pixels for all buttons in this toolbar. Falls back to CSS default when unset. */
+    buttonSize?: number;
+    style?: React$1.CSSProperties;
+    className?: string;
+    children?: React$1.ReactNode;
+}
+/**
+ * Toolbar strip that attaches to any edge of a `PanelOverlayRoot`.
+ * Left/right toolbars inset automatically to avoid overlapping top/bottom toolbars.
+ * RTL layouts are detected and handled automatically.
+ * @example
+ * <PanelToolbar position="top" variant="frosted">
+ *   <ToolbarButton icon={<SaveIcon />} title="Save" onClick={save} />
+ *   <ToolbarToggle icon={<GridIcon />} title="Grid" active={grid} onToggle={() => setGrid(v => !v)} />
+ * </PanelToolbar>
+ */
+declare function PanelToolbar({ position, variant, buttonVariant, buttonSize, style, className, children }: PanelToolbarProps): React$1.ReactElement;
+/** Props for `<ToolbarButton>`. */
+interface ToolbarButtonProps {
+    /** Button icon — typically a small SVG component. */
+    icon: React$1.ReactNode;
+    /** Click handler. */
+    onClick(): void;
+    disabled?: boolean;
+    /** Tooltip text and accessible `aria-label`. */
+    title?: string;
+    /** Visual style override. Falls back to the parent `PanelToolbar`'s `buttonVariant`. */
+    variant?: ButtonVariant;
+}
+/** Icon button for use inside a `PanelToolbar`. */
+declare function ToolbarButton({ icon, onClick, disabled, title, variant }: ToolbarButtonProps): React$1.ReactElement;
+/** Props for `<ToolbarToggle>`. */
+interface ToolbarToggleProps {
+    /** Button icon — typically a small SVG component. */
+    icon: React$1.ReactNode;
+    /** Whether the toggle is in the active/pressed state. Sets `aria-pressed` automatically. */
+    active: boolean;
+    /** Called when the button is clicked. Toggle `active` in response. */
+    onToggle(): void;
+    disabled?: boolean;
+    /** Tooltip text and accessible `aria-label`. */
+    title?: string;
+    /** Visual style override. Falls back to the parent `PanelToolbar`'s `buttonVariant`. */
+    variant?: ButtonVariant;
+}
+/** Two-state icon toggle button for use inside a `PanelToolbar`. Sets `aria-pressed` automatically. */
+declare function ToolbarToggle({ icon, active, onToggle, disabled, title, variant }: ToolbarToggleProps): React$1.ReactElement;
+/** Vertical (or horizontal) divider line between groups of toolbar items. */
+declare function ToolbarSeparator(): React$1.ReactElement;
+/** Flex-grow spacer that pushes subsequent toolbar items to the far edge. */
+declare function ToolbarSpacer(): React$1.ReactElement;
+/** Wrapper for a custom non-button control (e.g. a dropdown or input) inside a `PanelToolbar`. */
+declare function ToolbarItem({ children }: {
+    children: React$1.ReactNode;
+}): React$1.ReactElement;
+/** Centers its children within the toolbar using absolute positioning. */
+declare function ToolbarCenter({ children }: {
+    children: React$1.ReactNode;
+}): React$1.ReactElement;
+/** A single result item returned by `ToolbarSearchInputProps.onSearch`. */
+interface SearchResult {
+    /** Unique identifier for this result — passed to `onSelect`. */
+    id: string;
+    /** Primary display text. */
+    label: string;
+    /** Optional secondary text shown below the label in the dropdown. */
+    description?: string;
+    /** Optional group header used to bucket results visually. */
+    group?: string;
+    /** Optional icon shown to the left of the label. */
+    icon?: React$1.ReactNode;
+}
+/** Props for `<ToolbarSearchInput>`. */
+interface ToolbarSearchInputProps {
+    /** Placeholder text shown in the expanded input field. @default 'Search…' */
+    placeholder?: string;
+    /**
+     * Called with the current query and an `AbortSignal` each time the input changes (debounced).
+     * Return `SearchResult[]` directly for synchronous sources, or `Promise<SearchResult[]>` for async.
+     * Abort in-flight requests when the signal fires to prevent stale result races.
+     */
+    onSearch(query: string, signal: AbortSignal): Promise<SearchResult[]> | SearchResult[];
+    /** Called when the user selects a result from the dropdown. */
+    onSelect(result: SearchResult): void;
+}
+/**
+ * Debounced async search field for use inside a `PanelToolbar`.
+ * Renders as a compact icon button that expands into a text input on activation.
+ * Results appear in a portal-rendered dropdown below the input.
+ * @example
+ * <ToolbarSearchInput
+ *   placeholder="Find layer…"
+ *   onSearch={(q, signal) => fetchLayers(q, { signal })}
+ *   onSelect={result => workspace.focusLayer(result.id)}
+ * />
+ */
+declare function ToolbarSearchInput({ placeholder, onSearch, onSelect }: ToolbarSearchInputProps): React$1.ReactElement;
+/** Props for `<PanelFloatingWindow>`. */
+interface PanelFloatingWindowProps {
+    /** Unique identifier within the panel overlay. Used for z-order and stack tracking. */
+    id: string;
+    /** Text shown in the window's header bar. */
+    title: string;
+    /** Optional icon shown to the left of the title in the header. */
+    icon?: React$1.ReactNode;
+    /** Whether the window is mounted and visible. Set to `false` to close/unmount it. */
+    open: boolean;
+    /** Called when the user clicks the × button. Set `open` to `false` in response. */
+    onClose(): void;
+    /** Corner of the panel to dock to on first render. @see FloatAnchor */
+    defaultAnchor: FloatAnchor;
+    /** Initial width in pixels. */
+    defaultWidth: number;
+    /** Initial height in pixels. */
+    defaultHeight: number;
+    children?: React$1.ReactNode;
+}
+/**
+ * Declarative floating window anchored inside a `PanelOverlayRoot`.
+ * Supports 8-direction resize, drag-to-free, and drag-to-dock at any corner.
+ * Multiple windows docked to the same corner stack vertically with animated offsets.
+ * @example
+ * const info = usePanelFloatingWindow();
+ * <PanelFloatingWindow
+ *   id="layer-info" title="Layer Info"
+ *   open={info.isOpen} onClose={info.close}
+ *   defaultAnchor="top-right" defaultWidth={300} defaultHeight={200}
+ * >
+ *   <LayerInfoContent />
+ * </PanelFloatingWindow>
+ */
+declare function PanelFloatingWindow(props: PanelFloatingWindowProps): React$1.ReactElement | null;
+/** Return type of `usePanelFloatingWindow`. @see usePanelFloatingWindow */
+interface UsePanelFloatingWindowReturn {
+    /** Whether the floating window is currently open. */
+    isOpen: boolean;
+    /** Open the floating window. */
+    open(): void;
+    /** Close the floating window. */
+    close(): void;
+}
+/**
+ * Manages the open/close boolean state for a single `PanelFloatingWindow`.
+ * Pass `isOpen` to `open`, `close` to `onClose` on the component directly.
+ * @returns A stable `UsePanelFloatingWindowReturn` object.
+ * @example
+ * const info = usePanelFloatingWindow();
+ * <PanelFloatingWindow id="info" open={info.isOpen} onClose={info.close} ... />
+ */
+declare function usePanelFloatingWindow(): UsePanelFloatingWindowReturn;
+/**
+ * Imperative handle returned by `usePanelFloatingWindowManager`.
+ * @see usePanelFloatingWindowManager
+ */
+interface PanelFloatingWindowManagerHandle {
+    /** Spawn or reconfigure a named window. Safe to call with an already-open ID to update config. */
+    open(id: string, config: ManagedWindowConfig): void;
+    /** Close a named window by ID. No-op if the window is not open. */
+    close(id: string): void;
+    /** Close all managed windows. */
+    closeAll(): void;
+    /** Returns `true` if the named window is currently open. */
+    isOpen(id: string): boolean;
+    /** IDs of all currently open managed windows. Changes to this array trigger re-renders. */
+    openIds: string[];
+}
+/**
+ * Imperative hook for spawning N named floating windows at runtime from data or event handlers.
+ * All windows share z-ordering, drag, and corner-docking infrastructure of the `PanelOverlayRoot`.
+ *
+ * Must be called inside a **descendant** of `PanelOverlayRoot`, not in the component that renders the root.
+ * @returns A stable `PanelFloatingWindowManagerHandle`.
+ * @example
+ * const manager = usePanelFloatingWindowManager();
+ * manager.open('feature-42', { title: 'Feature 42', content: <FeatureDetail id={42} />, anchor: 'top-right' });
+ */
+declare function usePanelFloatingWindowManager(): PanelFloatingWindowManagerHandle;
+
+export { type BuiltInPanelEvents, type ButtonVariant, type CloseOptions, ConfirmationForm, type ConfirmationFormProps, ContextMenu, type ContextMenuAdapter, type ContextMenuCheckbox, type ContextMenuHandle, type ContextMenuItem, type ContextMenuLabel, type ContextMenuPredefinedMessage, type ContextMenuProps, type ContextMenuSeparator, type ContextMenuSimpleItem, type ContextMenuSubMenu, DefaultContextMenuAdapter, DockableDesktopProvider, type DockableDesktopProviderProps, type DropPosition, type DropTarget, type FloatAnchor, type FloatingWindow, FormContainerContext, type FormContainerContract, FormContainerProvider, type LayoutGridNode, type LayoutLeafNode, type LayoutNode, LeftPanelRenderer, type ManagedWindowConfig, type MenuItemAction, type MessageFormatter, type ModalOptions, ModalStackRenderer, type PanelActions, type PanelDefinition, PanelFloatingWindow, type PanelFloatingWindowManagerHandle, type PanelFloatingWindowProps, type PanelInfo, type PanelInstance, type PanelInstanceId, PanelOverlayRoot, type PanelOverlayRootProps, PanelProvider, PanelRegistry, PanelRegistryClass, type PanelRegistryEntry, type PanelState, type PanelTitle, PanelToolbar, ToolbarItem as PanelToolbarItem, type PanelToolbarProps, ToolbarSeparator as PanelToolbarSeparator, type PredefinedMessageKey, type ResolvedToastOptions, RightPanelRenderer, type SearchResult, type ShowContextMenuOptions, type SidePanelOptions, SidePanelRenderer, type SidePanelRendererProps, Sidebar, type SidebarContextValue, type SidebarHandle, type SidebarProps, type SidebarTab, type SidebarTabContextValue, type SplitDirection, type SplitOrientation, type StyleClasses, type TaskbarVisibility, type ToastAdapter, ToastContainer, type ToastContainerProps, type ToastFunction, type ToastOptions, type ToastPosition, type ToastPromiseMessages, type ToastType, Toolbar, type ToolbarActionItem, ToolbarButton, type ToolbarButtonProps, ToolbarCenter, type ToolbarContextValue, type ToolbarGroupEntry, type ToolbarGroupItem, type ToolbarGroupSubItem, type ToolbarHandle, type ToolbarItem$1 as ToolbarItem, type ToolbarPosition, type ToolbarProps, ToolbarProvider, type ToolbarRadioItem, ToolbarSearchInput, type ToolbarSearchInputProps, type ToolbarSeparator$1 as ToolbarSeparator, ToolbarSpacer, ToolbarToggle, type ToolbarToggleItem, type ToolbarToggleProps, type ToolbarVariant, type UsePanelFloatingWindowReturn, type WindowActions, WindowManager, type WindowManagerProps, WindowManagerProvider, type WindowManagerProviderProps, type WindowState, WorkspaceClient, type WorkspaceClientConfig, defaultPredefinedMessages, formatLabel, toast, useFormContainer, useFormatMessage, usePanelActions, usePanelContext, usePanelContextMenu, usePanelFloatingWindow, usePanelFloatingWindowManager, usePanelId, usePanelState, usePredefinedMessages, useRegistry, useSidebar, useSidebarTab, useStyleClasses, useToolbar, useWindowManagerActions, useWindowManagerState };