react-dockable-desktop 1.0.0 → 1.2.0

package/dist/index.d.cts

@@ -1,42 +1,89 @@
 import * as React$1 from 'react';
 import React__default, { ComponentType, ReactNode } from 'react';
 
+/**
+ * @file WindowManager.tsx
+ * @description Core component for react-dockable-desktop layout engine.
+ * Renders the workspace desktop containing docked splits, tabbed panels, floated windows,
+ * resize handles, context menus, and taskbar docks. Exposes lifecycle event listeners.
+ */
+
 interface WindowManagerProps {
     skin?: string;
     defaultPanelIcon?: React__default.ReactNode;
 }
 declare const WindowManager: React__default.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?: {
-        title?: string;
+        /** 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;
     };
 }
+/**
+ * Registry mapping catalog entries to allow programmatic panel instantiation
+ * inside dynamic layout cells or floating windows.
+ */
 declare class PanelRegistryClass {
     private registry;
+    /**
+     * 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.
+     */
     register<P extends object>(id: string, Component: ComponentType<P>, defaultOptions?: PanelRegistryEntry['defaultOptions']): void;
+    /**
+     * Retrieve a registered panel configuration by identifier.
+     */
     get(id: string): PanelRegistryEntry | undefined;
+    /**
+     * Returns a list of all registered panel entry identifiers.
+     */
     getRegisteredIds(): string[];
 }
+/** Global singleton instance of the Panel Registry. */
 declare const PanelRegistry: PanelRegistryClass;
 
 /**
- * Default English messages for every action exposed by Dockable Desktop.
+ * @file predefinedMessages.ts
+ * @description Provides the default localizable message catalogs and translation keys
+ * utilized by Dockable Desktop's context menus, headers, and tooltips.
  *
  * Each value's `id` is the react-intl message ID that the consumer should
  * define in their IntlProvider messages table. The `defaultMessage` is used
@@ -106,6 +153,42 @@ declare const defaultPredefinedMessages: {
         readonly id: "dockable-desktop-windowAnchoringOptions";
         readonly defaultMessage: "Window Anchoring Options";
     };
+    readonly unsavedChangesTitle: {
+        readonly id: "dockable-desktop-unsavedChangesTitle";
+        readonly defaultMessage: "Unsaved Changes";
+    };
+    readonly unsavedChangesMessage: {
+        readonly id: "dockable-desktop-unsavedChangesMessage";
+        readonly defaultMessage: "\"{title}\" has unsaved changes. Do you want to discard your changes and close?";
+    };
+    readonly discardChanges: {
+        readonly id: "dockable-desktop-discardChanges";
+        readonly defaultMessage: "Discard Changes";
+    };
+    readonly cancel: {
+        readonly id: "dockable-desktop-cancel";
+        readonly defaultMessage: "Cancel";
+    };
+    readonly yes: {
+        readonly id: "dockable-desktop-yes";
+        readonly defaultMessage: "Yes";
+    };
+    readonly no: {
+        readonly id: "dockable-desktop-no";
+        readonly defaultMessage: "No";
+    };
+    readonly ok: {
+        readonly id: "dockable-desktop-ok";
+        readonly defaultMessage: "OK";
+    };
+    readonly closePanelTooltip: {
+        readonly id: "dockable-desktop-closePanelTooltip";
+        readonly defaultMessage: "Close panel";
+    };
+    readonly closeTooltip: {
+        readonly id: "dockable-desktop-closeTooltip";
+        readonly defaultMessage: "Close";
+    };
 };
 /**
  * Union of every key in `defaultPredefinedMessages`.
@@ -119,47 +202,120 @@ declare const defaultPredefinedMessages: {
  */
 type PredefinedMessageKey = keyof typeof defaultPredefinedMessages;
 
+/**
+ * @file dirtyOptions.ts
+ * @description Type definitions for customizing automatic close warning overlays.
+ */
+
+/**
+ * Represents custom configuration options applied to the automatic unsaved changes modal.
+ */
+interface DirtyStateOptions {
+    /**
+     * Custom header title text or localizable message descriptor.
+     * Replaces the default "Unsaved Changes" title.
+     */
+    title?: string | ContextMenuPredefinedMessage;
+    /**
+     * Custom warning explanation text or localizable message descriptor.
+     * Replaces the standard default message body templates.
+     */
+    message?: string | ContextMenuPredefinedMessage;
+    /**
+     * Optional custom alert notification banner text.
+     * Typically lists missing validation field requirements or backup statuses.
+     */
+    alert?: string;
+    /**
+     * Color scheme severity level of the validation banner.
+     * Maps to theme highlight alerts. Default: 'info'
+     */
+    alertType?: 'info' | 'warning' | 'success' | 'danger';
+}
+
+/**
+ * Structure representing localizable message descriptors used in context menus.
+ */
 interface ContextMenuPredefinedMessage {
+    /** Translation dictionary key. */
     id: string;
+    /** Fallback label text if translation key is missing. */
     defaultMessage?: string;
+    /** Values injected into the translated text placeholder. */
     values?: Record<string, string | number>;
 }
+/** Function type interface responsible for resolving localizable messages to flat strings. */
 type MessageFormatter = (msg: ContextMenuPredefinedMessage) => string;
+/** Orientation modifier indicating split directions. */
 type SplitOrientation = 'horizontal' | 'vertical';
+/**
+ * Grid layout branch node containing nested splits and relative flex sizes.
+ */
 interface LayoutGridNode {
     type: 'branch';
+    /** Split orientation orientation indicator. */
     orientation: SplitOrientation;
+    /** Children branches or leaf panels. */
     children: LayoutNode[];
+    /** Relative percentage sizes of each child layout block. */
     sizes: number[];
 }
+/**
+ * Grid layout leaf node containing active tab groups and panel arrays.
+ */
 interface LayoutLeafNode {
     type: 'leaf';
+    /** Unique leaf identifier. */
     id: string;
+    /** Array of panel IDs mounted inside this group. */
     panels: string[];
+    /** The currently active panel tab ID. */
     activePanelId: string | null;
+    /** If false, close menu buttons are disabled for this group's tabs. */
     canClose?: boolean;
-    /** When true the leaf group persists in the layout even after its last panel
-     *  is closed/floated/minimised. Defaults to false (auto-remove). */
+    /** When true, the group persists in the layout even after its last panel is closed. */
     keepOnEmpty?: boolean;
 }
+/** Union type representing either a branch or a leaf node in the layout grid. */
 type LayoutNode = LayoutGridNode | LayoutLeafNode;
+/**
+ * Bounds and depth metadata for floated panel windows.
+ */
 interface FloatingWindow {
+    /** Unique ID of the floating window. */
     id: string;
+    /** CSS left position offset (supports number/px or percentage strings). */
     x: number | string;
+    /** CSS top position offset. */
     y: number | string;
+    /** CSS width value. */
     width: number | string;
+    /** CSS height value. */
     height: number | string;
+    /** Rendering depth stack index layer. */
     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;
 }
+/**
+ * Stores active runtime properties and status metadata for individual panel instances.
+ */
 interface PanelInfo {
+    /** Unique panel identifier. */
     id: string;
+    /** Plain text label or localizable message descriptor. */
     title: string | ContextMenuPredefinedMessage;
+    /** String matching the component registration ID in the {@link PanelRegistry}. */
     component: string;
+    /** Current workspace placement mode. */
     state: 'docked' | 'floating' | 'minimized';
+    /** Last state held before panel was minimized. */
     previousState?: 'docked' | 'floating';
+    /** Saved position boundaries used when returning the panel to a floating state. */
     lastFloatingRect?: {
         x: number;
         y: number;
@@ -168,63 +324,109 @@ interface PanelInfo {
         stickyRight?: boolean;
         stickyBottom?: boolean;
     };
+    /** The leaf group ID this panel was docked in prior to being floated. */
     lastLeafId?: string;
+    /** True if the panel contains unsaved user edits. */
     dirty?: boolean;
+    /** Custom options applied to the automatic unsaved changes modal. */
+    dirtyOptions?: DirtyStateOptions;
 }
+/**
+ * Global window manager state tree representing grid nodes, windows, and panels.
+ */
 interface WindowState {
+    /** Root branch node representing the grid. */
     gridRoot: LayoutNode;
+    /** Array of active floated windows. */
     floating: FloatingWindow[];
+    /** Array of minimized panels waiting in the taskbar dock. */
     minimized: {
         id: string;
         title: string | ContextMenuPredefinedMessage;
         component: string;
     }[];
+    /** Map indexing panel metadata descriptors. */
     panels: Record<string, PanelInfo>;
+    /** The ID of the panel tab currently being dragged. */
     draggedPanelId: string | null;
-    pendingClose: {
-        id: string;
-        resolve: (discard: boolean) => void;
-    } | null;
+    /** The ID of the active/focused panel. */
+    activePanelId: string | null;
+    /** Current layout direction ('ltr' or 'rtl') */
+    dir: 'ltr' | 'rtl';
+    /** Convenient boolean flag indicating RTL direction */
+    isRtl: boolean;
 }
+/**
+ * Interface mapping layout actions, event bus handles, and serialization methods.
+ */
 interface WindowActions {
+    /** Instantiates a registered panel into the workspace. */
     openPanel: (id: string, component: string, options?: {
         title?: string | ContextMenuPredefinedMessage;
         initialTarget?: 'floating' | 'docked' | 'tabbed';
         stickyRight?: boolean;
         stickyBottom?: boolean;
     }) => void;
+    /** Directly closes a panel by ID, bypassing close confirmation dialogs. */
     closePanel: (id: string) => void;
+    /** Minimizes a panel to the bottom taskbar, saving its current layout positioning. */
     minimizePanel: (id: string) => void;
+    /** Restores a minimized panel back to its previous position in the grid or as a float. */
     restorePanel: (id: string) => void;
+    /** Detaches a docked panel, turning it into a floating resizable window. */
     floatPanel: (id: string, rect?: {
         x: number;
         y: number;
         width: number;
         height: number;
     }) => void;
+    /** Returns a floating window back to a docked grid tab group. */
     dockPanel: (id: string, targetLeafId?: string) => void;
+    /** Maximizes a floating window to cover the entire layout screen boundaries. */
     maximizePanel: (id: string) => void;
+    /** Resizes flex dimensions of children inside split layout rows/columns. */
     updateSplitSizes: (path: number[], sizes: number[]) => void;
+    /** Updates bounds or positioning attributes on a floating window. */
     updateFloatingPosition: (id: string, updates: Partial<Pick<FloatingWindow, 'x' | 'y' | 'width' | 'height' | 'stickyRight' | 'stickyBottom'>>) => void;
+    /** Pushes a floating window z-index layer to render on top of others. */
     bringToFront: (id: string) => void;
+    /** Serializes the active grid node structures and panel targets to JSON. */
     saveLayout: () => string;
+    /** Rebuilds the grid layouts and floating window placements from a JSON string. */
     loadLayout: (layoutJson: string) => void;
+    /** Publishes an event to the global inter-panel message bus. */
     publish: (event: string, data: any) => void;
+    /** Subscribes callback listeners to inter-panel event messages. */
     subscribe: (event: string, callback: (data: any) => void) => () => void;
+    /** Stores reference to the active tab ID being dragged. */
     setDraggedPanelId: (id: string | null) => void;
+    /** Splits an existing tab group to dock a dragged panel next to it. */
     dockPanelToGroup: (id: string, targetLeafId: string, position: 'left' | 'right' | 'top' | 'bottom' | 'center') => void;
+    /** Reorders tab indices inside a docked leaf group. */
     movePanelOrder: (panelId: string, targetLeafId: string, targetIndex: number) => void;
+    /** Closes an empty split group. */
     closeLeafGroup: (leafId: string) => void;
+    /** Binds a close intercept confirmation guard. */
     registerCloseGuard: (id: string, guard: () => boolean | Promise<boolean>) => void;
+    /** Removes close confirmation guards. */
     unregisterCloseGuard: (id: string) => void;
-    setPanelDirty: (id: string, dirty: boolean) => void;
+    /** Set panel dirty state flag. */
+    setPanelDirty: (id: string, dirty: boolean, options?: DirtyStateOptions) => void;
+    /** Change title header. */
     updatePanelTitle: (id: string, title: string | ContextMenuPredefinedMessage) => void;
+    /** Intercepts close panel requests, prompting warning dialogs if dirty. */
     requestClosePanel: (id: string, options?: {
         force?: boolean;
+        onConfirm?: (opts?: DirtyStateOptions) => Promise<boolean>;
     }) => Promise<void>;
-    resolvePendingClose: (discard: boolean) => void;
+    /** Docks a panel directly to workspace edges. */
     dockPanelToWorkspaceEdge: (id: string, position: 'left' | 'right' | 'top' | 'bottom') => void;
+    /** Update active focused tab reference. */
+    setActivePanel: (id: string | null) => void;
+    /** Explicitly set or override layout direction */
+    setDirection: (dir: 'ltr' | 'rtl') => void;
 }
+/** Represents custom CSS classes injected into layout parts. */
 interface StyleClasses {
     modalClass?: string;
     modalBodyClass?: string;
@@ -233,11 +435,13 @@ interface StyleClasses {
     windowClass?: string;
     windowBodyClass?: string;
 }
+/** Custom hook to read configured style class contexts. */
 declare const useStyleClasses: () => StyleClasses;
 interface WindowManagerProviderProps {
     children: React__default.ReactNode;
     formatMessage?: MessageFormatter;
     predefinedMessages?: Record<string, ContextMenuPredefinedMessage>;
+    dir?: 'ltr' | 'rtl';
     modalClass?: string;
     modalBodyClass?: string;
     sidePanelClass?: string;
@@ -246,91 +450,198 @@ interface WindowManagerProviderProps {
     windowBodyClass?: string;
 }
 declare const WindowManagerProvider: React__default.FC<WindowManagerProviderProps>;
+/**
+ * React hook to retrieve the active Window Manager layout state.
+ * @throws Error if used outside of a {@link WindowManagerProvider}.
+ */
 declare const useWindowManagerState: () => WindowState;
+/**
+ * React hook to retrieve layouts mutation actions (dock, float, minimize, save/load).
+ * @throws Error if used outside of a {@link WindowManagerProvider}.
+ */
 declare const useWindowManagerActions: () => WindowActions;
+/**
+ * React hook to retrieve the active i18n formatter.
+ */
 declare const useFormatMessage: () => MessageFormatter;
+/**
+ * Helper to resolve dynamic label strings or localizable descriptor objects into text.
+ */
 declare const formatLabel: (label: string | ContextMenuPredefinedMessage | undefined, formatter: MessageFormatter) => string;
+/**
+ * React hook providing pub-sub helper methods for inter-panel event messaging.
+ */
 declare const usePanelContext: () => {
     publish: (event: string, data: any) => void;
     subscribe: (event: string, callback: (data: any) => void) => () => void;
 };
-declare const usePredefinedMessages: () => Record<"floatWindow" | "minimizePanel" | "closeTab" | "restorePanel" | "maximizePanel" | "closePanel" | "dockWindow" | "minimize" | "maximize" | "restoreSize" | "close" | "closeEmptyGroup" | "anchorToRightEdge" | "anchorToBottomEdge" | "windowAnchoringOptions", ContextMenuPredefinedMessage>;
+/**
+ * React hook to fetch the localizable predefined message map catalog.
+ */
+declare const usePredefinedMessages: () => Record<"floatWindow" | "minimizePanel" | "closeTab" | "restorePanel" | "maximizePanel" | "closePanel" | "dockWindow" | "minimize" | "maximize" | "restoreSize" | "close" | "closeEmptyGroup" | "anchorToRightEdge" | "anchorToBottomEdge" | "windowAnchoringOptions" | "unsavedChangesTitle" | "unsavedChangesMessage" | "discardChanges" | "cancel" | "yes" | "no" | "ok" | "closePanelTooltip" | "closeTooltip", ContextMenuPredefinedMessage>;
 
+/**
+ * Options used when requesting to close a container.
+ */
 interface CloseOptions {
+    /** If true, bypasses any dirty state warnings or custom close guards. */
     force?: boolean;
 }
+/** Represents the type of container context a panel/form is currently rendered inside. */
 type ContainerType = 'left-panel' | 'right-panel' | 'modal' | 'dockable-panel' | 'standalone';
+/**
+ * Contract interface exposed by a container (like a tab, window, modal, or side-panel)
+ * to its children forms, enabling them to control or listen to container events.
+ */
 interface FormContainerContract {
+    /** Request the container to close itself. Bypassed by default unless options.force is true. */
     requestClose: (options?: CloseOptions) => void;
-    setDirty: (dirty: boolean) => void;
+    /** Mark the form's content as dirty (having unsaved changes), triggering alert dialogs on close. */
+    setDirty: (dirty: boolean, options?: DirtyStateOptions) => void;
+    /** Register a custom close guard handler. Returning false or a promise resolving to false blocks closing. */
     onCloseRequested: (handler: () => boolean | Promise<boolean>) => (() => void);
+    /** Change the display title of the containing tab or window dynamically. */
     setTitle: (title: string | {
         id: string;
         defaultMessage: string;
         values?: Record<string, any>;
     }) => void;
+    /** Change the tab or window icon dynamically. */
     setIcon?: (icon: React.ReactNode) => void;
+    /** The type of container the panel is mounted in. */
     containerType?: ContainerType;
+    /** Unique identifier of the panel or window instance. */
     instanceId: string;
+    /** Subscribe to the container's close event. Returns an unsubscribe function. */
     onClose?: (handler: () => void) => () => void;
+    /** Subscribe to the container's minimize event. Returns an unsubscribe function. */
     onMinimize?: (handler: () => void) => () => void;
+    /** Subscribe to the container's restore event. Returns an unsubscribe function. */
     onRestore?: (handler: () => void) => () => void;
+    /** Subscribe to the container's window resize event, returning width and height. */
     onResize?: (handler: (width: number, height: number) => void) => () => void;
 }
+/**
+ * Context that supplies the {@link FormContainerContract} to panels inside the Window Manager.
+ */
 declare const FormContainerContext: React$1.Context<FormContainerContract>;
 declare const FormContainerProvider: React$1.Provider<FormContainerContract>;
+/**
+ * React hook to retrieve the current {@link FormContainerContract} from context.
+ * Enables sub-forms to trigger close requests, mark themselves dirty, rename their tabs, or listen to resize events.
+ */
 declare const useFormContainer: () => FormContainerContract;
 
+/** Unique string identifier for panel/modal instances. */
 type PanelInstanceId = string;
+/**
+ * Descriptor object for localizable panel titles, supporting context translation systems.
+ */
 interface PanelTitleDescriptor {
+    /** The translation dictionary key. */
     id: string;
+    /** Fallback string if translation key is missing. */
     defaultMessage?: string;
+    /** Parameters to inject into the translated text string. */
     values?: Record<string, string | number>;
 }
+/** Union type representing either a plain string or a localizable title descriptor. */
 type PanelTitle = string | PanelTitleDescriptor;
+/** Configuration options applied when opening a SidePanel. */
 interface SidePanelOptions {
+    /** Display title for the side-panel header. */
     title?: PanelTitle;
+    /** Icon displayed next to the panel title. */
     icon?: React__default.ReactNode;
+    /** Specific CSS width (e.g. 300, '40%') for the panel container. */
     width?: number | string;
 }
+/** Configuration options applied when opening a Modal. */
 interface ModalOptions {
+    /** Display title for the modal header. */
     title?: PanelTitle;
+    /** Icon displayed in the modal title bar. */
     icon?: React__default.ReactNode;
+    /** Size modifier affecting CSS max-width rules. */
     size?: 'small' | 'medium' | 'large' | 'fullscreen' | 'auto';
+    /** If false, hides the modal backdrop exit click and header close button. */
     closable?: boolean;
 }
+/**
+ * Represents a rendered instance of a panel or modal in the layout.
+ */
 interface PanelInstance {
+    /** Unique ID generated for this instance. */
     id: PanelInstanceId;
+    /** React Component to mount inside the panel. */
     Component: ComponentType<any>;
+    /** Property props passed to the Component. */
     props: Record<string, any>;
+    /** The target rendering layout zone. */
     containerType: 'left-panel' | 'right-panel' | 'modal';
+    /** Configuration metadata settings. */
     options: SidePanelOptions | ModalOptions;
+    /** True if the form container has unsaved user edits. */
     dirty?: boolean;
+    /** Custom warning options applied to the automatic unsaved changes modal. */
+    dirtyOptions?: DirtyStateOptions;
 }
+/** Stores the active layout structures for floating overlays. */
 interface PanelState {
+    /** The currently open left drawer panel instance, or null. */
     leftPanel: PanelInstance | null;
+    /** The currently open right drawer panel instance, or null. */
     rightPanel: PanelInstance | null;
+    /** Stack containing all active floating modal instances. */
     modals: PanelInstance[];
 }
+/** Exposes methods to trigger state actions on drawers and modals. */
 interface PanelActions {
+    /** Mounts a panel in the left-side container drawer. */
     openLeftPanel: <P extends object>(Component: ComponentType<P>, props: P, options?: SidePanelOptions) => Promise<PanelInstanceId | null>;
+    /** Mounts a panel in the right-side container drawer. */
     openRightPanel: <P extends object>(Component: ComponentType<P>, props: P, options?: SidePanelOptions) => Promise<PanelInstanceId | null>;
+    /** Pushes a new modal component instance to the top of the stack. */
     openModal: <P extends object>(Component: ComponentType<P>, props: P, options?: ModalOptions) => PanelInstanceId;
+    /** Closes an instance by ID. */
     close: (id: PanelInstanceId) => void;
+    /** Closes all drawers and modals in a single action. */
     closeAll: () => void;
+    /** Closes all open modals. */
     closeAllModals: () => void;
+    /** Retrieves metadata for an active instance by ID. */
     getInstance: (id: PanelInstanceId) => PanelInstance | undefined;
-    updateInstance: (id: PanelInstanceId, updates: Partial<Pick<PanelInstance, 'props' | 'options' | 'dirty'>>) => void;
-    setDirty: (id: PanelInstanceId, dirty: boolean) => void;
+    /** Updates the props, configuration options, or dirty flag of an active panel. */
+    updateInstance: (id: PanelInstanceId, updates: Partial<Pick<PanelInstance, 'props' | 'options' | 'dirty' | 'dirtyOptions'>>) => void;
+    /** Flags an instance as dirty (contains unsaved changes). */
+    setDirty: (id: PanelInstanceId, dirty: boolean, options?: DirtyStateOptions) => void;
+    /** Subscribes a custom close confirmation intercept handler. */
     registerCloseHandler: (id: PanelInstanceId, handler: () => Promise<boolean>) => void;
+    /** Unsubscribes close confirmation handler. */
     unregisterCloseHandler: (id: PanelInstanceId) => void;
 }
+/**
+ * PanelProvider component manages the state and action handlers
+ * for drawers (left/right) and active stacked modal overlays.
+ */
 declare const PanelProvider: React__default.FC<{
     children: ReactNode;
 }>;
+/**
+ * React hook to retrieve the active floating/drawer panels state.
+ * @throws Error if used outside of a {@link PanelProvider}.
+ */
 declare const usePanelState: () => PanelState;
+/**
+ * React hook to retrieve actions enabling drawer toggles and modal push actions.
+ * @throws Error if used outside of a {@link PanelProvider}.
+ */
 declare const usePanelActions: () => PanelActions;
 
+/**
+ * ModalStackRenderer component acts as the global container rendering
+ * all active stacked modal windows in the workspace.
+ */
 declare const ModalStackRenderer: React__default.FC;
 
 interface SidePanelRendererProps {
@@ -341,29 +652,59 @@ interface SidePanelRendererProps {
      */
     defaultWidth?: number | string;
 }
+/**
+ * SidePanelRenderer component acts as the global container rendering both
+ * left and right side drawers if they are currently active.
+ */
 declare const SidePanelRenderer: React__default.FC<SidePanelRendererProps>;
+/**
+ * LeftPanelRenderer component renders ONLY the left side drawer if it is currently active.
+ */
 declare const LeftPanelRenderer: React__default.FC<SidePanelRendererProps>;
+/**
+ * RightPanelRenderer component renders ONLY the right side drawer if it is currently active.
+ */
 declare const RightPanelRenderer: React__default.FC<SidePanelRendererProps>;
 
+/**
+ * Props for the {@link ConfirmationForm} component.
+ */
 interface ConfirmationFormProps {
+    /** Optional custom title text or localizable descriptor for the dialog container. */
     title?: string | {
         id: string;
         defaultMessage?: string;
         values?: any;
     };
+    /** Main message text or localizable descriptor to display. */
     message: string | {
         id: string;
         defaultMessage?: string;
         values?: any;
     };
+    /** Optional auxiliary top alert notification text. */
     alert?: string;
+    /** Type style classification for the alert notice banner. */
     alertType?: 'info' | 'warning' | 'success' | 'danger';
+    /** If true, changes action button labels to 'Yes' and 'No' instead of 'OK' and 'Cancel'. */
     useYesNoTitles?: boolean;
+    /** Callback fired when the user selects the confirm button. */
     onOK?: () => void;
+    /** Callback fired when the user selects the cancel button. */
     onCancel?: () => void;
 }
+/**
+ * ConfirmationForm component renders a standard dialog content layout,
+ * allowing users to confirm actions or abort them. Exposes action callbacks.
+ */
 declare const ConfirmationForm: React__default.FC<ConfirmationFormProps>;
 
+/**
+ * @file Sidebar.tsx
+ * @description Sidebar navigation strip and drawer container component.
+ * Supports eager/lazy mounting, state preservation (display: none), and positioning (left/right).
+ */
+
 /**
  * Per-tab configuration supplied by the consuming application.
  */
@@ -422,6 +763,10 @@ interface SidebarHandle {
     /** Returns the currently active tab id, or null if the drawer is collapsed. */
     getActiveTab: () => string | null;
 }
+/**
+ * Sidebar component rendering a tab strip and a collapsible content drawer.
+ * Supports imperative method bindings like openTab and closeDrawer via forwardRef.
+ */
 declare const Sidebar: React__default.ForwardRefExoticComponent<SidebarProps & React__default.RefAttributes<SidebarHandle>>;
 
 export { type CloseOptions, ConfirmationForm, type ConfirmationFormProps, type ContextMenuPredefinedMessage, type FloatingWindow, FormContainerContext, type FormContainerContract, FormContainerProvider, type LayoutGridNode, type LayoutLeafNode, type LayoutNode, LeftPanelRenderer, type MessageFormatter, type ModalOptions, ModalStackRenderer, type PanelActions, type PanelInfo, type PanelInstance, type PanelInstanceId, PanelProvider, PanelRegistry, type PanelState, type PanelTitle, type PredefinedMessageKey, RightPanelRenderer, type SidePanelOptions, SidePanelRenderer, type SidePanelRendererProps, Sidebar, type SidebarHandle, type SidebarProps, type SidebarTab, type SplitOrientation, type StyleClasses, type WindowActions, WindowManager, WindowManagerProvider, type WindowState, defaultPredefinedMessages, formatLabel, useFormContainer, useFormatMessage, usePanelActions, usePanelContext, usePanelState, usePredefinedMessages, useStyleClasses, useWindowManagerActions, useWindowManagerState };