@nice2dev/ui 1.0.5 → 1.0.8

package/dist/navigation.d.ts

@@ -0,0 +1,1862 @@
+import { default as default_2 } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { RefAttributes } from 'react';
+
+declare interface ClosedTabEntry {
+    /** The closed tab descriptor. */
+    tab: NiceTabDescriptor;
+    /** Original index when closed. */
+    originalIndex: number;
+    /** Timestamp when closed. */
+    closedAt: number;
+    /** Optional content state to restore (serialized). */
+    state?: unknown;
+}
+
+declare interface ContextMenuProps {
+    items: NiceStartMenuItem[];
+    x: number;
+    y: number;
+    onItemClick?: (key: string) => void;
+    onClose: () => void;
+}
+
+export declare const DEFAULT_SIDEBAR_PREFS: Omit<SidebarNavUserPrefs, 'userId'>;
+
+export declare const DesktopContextMenu: default_2.FC<ContextMenuProps>;
+
+export declare const DesktopGrid: default_2.FC<DesktopGridProps>;
+
+declare interface DesktopGridProps {
+    icons: NiceDesktopIcon[];
+    gridColumns: number;
+    iconSize: NiceSize;
+    onIconClick?: (key: string) => void;
+    onIconDoubleClick?: (key: string) => void;
+}
+
+export declare const DesktopStartMenu: default_2.FC<StartMenuProps>;
+
+export declare const DesktopSystemTray: default_2.FC<SystemTrayProps>;
+
+export declare const DesktopTaskbar: default_2.FC<TaskbarProps>;
+
+/** A breadcrumb item. */
+declare interface NavbarBreadcrumb {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+}
+
+/**
+ * Per-component visibility & interaction level used by the access control system.
+ * - `'full'` — fully interactive (default)
+ * - `'readOnly'` — renders but cannot be edited
+ * - `'disabled'` — renders greyed-out
+ * - `'hidden'` — not rendered at all
+ */
+declare type NiceAccessMode = 'full' | 'readOnly' | 'disabled' | 'hidden';
+
+export declare const NiceAccordion: default_2.FC<NiceAccordionProps>;
+
+/** A panel definition for the {@link NiceAccordion}. */
+declare interface NiceAccordionItem {
+    /** Unique identifier. */
+    id: string;
+    /** Panel header text. */
+    title: string;
+    /** Panel body content. */
+    content: default_2.ReactNode;
+    /** Prevent the panel from being toggled. */
+    disabled?: boolean;
+}
+
+/** Props for the {@link NiceAccordion} component — a collapsible panel list. */
+export declare interface NiceAccordionProps extends NiceBaseProps {
+    /** Accordion size. */
+    size?: NiceSize;
+    /** Panel definitions. */
+    items: NiceAccordionItem[];
+    /** Allow multiple panels to be open at once. */
+    multiple?: boolean;
+    /** IDs of panels that are open by default. */
+    defaultOpen?: string[];
+}
+
+export declare const NiceAppLayout: default_2.ForwardRefExoticComponent<NiceAppLayoutProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for the {@link NiceAppLayout} component — a top-level application shell with header, collapsible sidebar, content area, and footer. */
+export declare interface NiceAppLayoutProps extends NiceBaseProps {
+    /** Content rendered in the top header bar. */
+    header?: default_2.ReactNode;
+    /** Content rendered in the side navigation panel. */
+    sidebar?: default_2.ReactNode;
+    /** Width of the sidebar (px or CSS value). */
+    sidebarWidth?: number | string;
+    /** Controlled collapsed state of the sidebar. */
+    sidebarCollapsed?: boolean;
+    /** Called when the sidebar toggle button is clicked. */
+    onToggleSidebar?: (collapsed: boolean) => void;
+    /** Main page content. */
+    children: default_2.ReactNode;
+    /** Content rendered at the bottom. */
+    footer?: default_2.ReactNode;
+}
+
+/** Base props inherited by every NiceToDev component. */
+declare interface NiceBaseProps {
+    /** Additional CSS class name(s). */
+    className?: string;
+    /** Inline style object. */
+    style?: React.CSSProperties;
+    /** HTML `id` attribute. When omitted a stable auto-generated id is used. */
+    id?: string;
+    /** Tooltip text shown on hover. */
+    title?: string;
+    /** Test identifier for integration / e2e test selectors. */
+    'data-testid'?: string;
+    /** Controls component visibility and interaction — see {@link NiceAccessMode}. */
+    accessMode?: NiceAccessMode;
+    /**
+     * Visual presentation style override.
+     * When set, overrides the global `displayStyle` from `NiceThemeProvider`.
+     * @see NiceDisplayStyle
+     */
+    displayStyle?: NiceDisplayStyle;
+}
+
+export declare const NiceBottomNavigation: default_2.ForwardRefExoticComponent<NiceBottomNavigationProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** A navigation item in the {@link NiceBottomNavigation} bar. */
+declare interface NiceBottomNavigationItem {
+    /** Unique key. */
+    key: string;
+    /** Label text. */
+    label: string;
+    /** Icon element. */
+    icon?: default_2.ReactNode;
+    /** Disable the item. */
+    disabled?: boolean;
+}
+
+/** Props for the {@link NiceBottomNavigation} component — a mobile-style bottom tab bar. */
+export declare interface NiceBottomNavigationProps extends NiceBaseProps {
+    /** Navigation items. */
+    items: NiceBottomNavigationItem[];
+    /** Currently active item key. */
+    activeKey?: string;
+    /** Called when the active item changes. */
+    onChange?: (key: string) => void;
+    /** Bar size preset. */
+    size?: NiceSize;
+    /** Show text labels below icons. */
+    showLabels?: boolean;
+}
+
+export declare const NiceBreadcrumb: default_2.FC<NiceBreadcrumbProps>;
+
+/** A single crumb in the {@link NiceBreadcrumb} trail. */
+declare interface NiceBreadcrumbItem {
+    /** Display text. */
+    label: string;
+    /** Navigation URL. */
+    href?: string;
+    /** Click handler (alternative to href). */
+    onClick?: () => void;
+}
+
+/** Props for the {@link NiceBreadcrumb} component — a navigation trail showing the current location hierarchy. */
+export declare interface NiceBreadcrumbProps extends NiceBaseProps {
+    /** Breadcrumb size. */
+    size?: NiceSize;
+    /** Ordered breadcrumb items (left-to-right). */
+    items: NiceBreadcrumbItem[];
+    /** Custom separator between crumbs (default "/"). */
+    separator?: default_2.ReactNode;
+}
+
+export declare const NiceCard: default_2.FC<NiceCardProps>;
+
+/** Props for the {@link NiceCard} component — a bordered content container with optional header and footer. */
+export declare interface NiceCardProps extends NiceBaseProps {
+    /** Card size. */
+    size?: NiceSize;
+    /** Card body content. */
+    children: default_2.ReactNode;
+    /** Header title text. */
+    title?: string;
+    /** Extra element rendered at the right side of the header (actions, badges, etc.). */
+    headerExtra?: default_2.ReactNode;
+    /** Footer content. */
+    footer?: default_2.ReactNode;
+    /** Elevate the card on hover. */
+    hoverable?: boolean;
+    /** Makes the entire card clickable. */
+    onClick?: () => void;
+}
+
+export declare const NiceClassicShell: ForwardRefExoticComponent<NiceShellProps & RefAttributes<HTMLDivElement>>;
+
+export declare const NiceCompactShell: ForwardRefExoticComponent<NiceCompactShellProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceCompactShellProps extends NiceBaseProps {
+    /** Top bar (minimal, icon-only navigation). */
+    topBar?: React.ReactNode;
+    /** Bottom navigation (mobile-style). */
+    bottomNav?: React.ReactNode;
+    /** Main content. */
+    children?: React.ReactNode;
+}
+
+export declare const NiceConsole: ForwardRefExoticComponent<NiceConsoleProps & RefAttributes<HTMLDivElement>>;
+
+/** A command registered in the {@link NiceConsole} command palette. */
+declare interface NiceConsoleCommand {
+    /** Unique key. */
+    key: string;
+    /** Display label. */
+    label: string;
+    /** Optional description shown beside the label. */
+    description?: string;
+    /** Keyboard shortcut hint (display only). */
+    shortcut?: string;
+    /** Optional icon. */
+    icon?: React.ReactNode;
+    /** Disable the command. */
+    disabled?: boolean;
+}
+
+/** Props for the {@link NiceConsole} component — a VS Code-inspired IDE shell with tabs, command palette, status bar, and split panels. */
+export declare interface NiceConsoleProps extends NiceBaseProps {
+    /** Tabs displayed at the top. */
+    tabs?: NiceConsoleTab[];
+    /** Active tab key */
+    activeTabKey?: string;
+    /** Called when tab changes */
+    onTabChange?: (key: string) => void;
+    /** Called when a tab is closed */
+    onTabClose?: (key: string) => void;
+    /** Show command palette on Ctrl+Shift+P */
+    commandPalette?: NiceConsoleCommand[];
+    /** Called when a command is selected */
+    onCommand?: (key: string) => void;
+    /** Status bar items */
+    statusItems?: NiceConsoleStatusItem[];
+    /** Header / toolbar content */
+    toolbar?: React.ReactNode;
+    /** Side panel content */
+    sidePanel?: React.ReactNode;
+    /** Side panel width */
+    sidePanelWidth?: number | string;
+    /** Side panel collapsed */
+    sidePanelCollapsed?: boolean;
+    /** Toggle side panel */
+    onToggleSidePanel?: (collapsed: boolean) => void;
+    /** Bottom panel content (output / terminal) */
+    bottomPanel?: React.ReactNode;
+    /** Bottom panel height */
+    bottomPanelHeight?: number | string;
+    /** Bottom panel collapsed */
+    bottomPanelCollapsed?: boolean;
+    /** Toggle bottom panel */
+    onToggleBottomPanel?: (collapsed: boolean) => void;
+    /** Main content when no tabs */
+    children?: React.ReactNode;
+    /** Size */
+    size?: NiceSize;
+    /** Console theme */
+    theme?: 'dark' | 'light';
+}
+
+/** A status-bar item in the {@link NiceConsole}. */
+declare interface NiceConsoleStatusItem {
+    /** Unique key. */
+    key: string;
+    /** Rendered content. */
+    content: React.ReactNode;
+    /** Side of the status bar. */
+    position?: 'left' | 'right';
+    /** Click handler. */
+    onClick?: () => void;
+}
+
+/** A tab inside the {@link NiceConsole} editor area. */
+declare interface NiceConsoleTab {
+    /** Unique key. */
+    key: string;
+    /** Tab header label. */
+    label: string;
+    /** Optional tab icon. */
+    icon?: React.ReactNode;
+    /** Whether the tab can be closed. */
+    closable?: boolean;
+    /** Content renderer. */
+    render: () => React.ReactNode;
+}
+
+export declare const NiceContextMenu: default_2.FC<NiceContextMenuProps>;
+
+/** Props for the {@link NiceContextMenu} component — a right-click popup menu attached to a target element. */
+export declare interface NiceContextMenuProps extends NiceBaseProps {
+    /** Size variant. */
+    size?: NiceSize;
+    /** Menu items. */
+    items: NiceMenuItem[];
+    /** Element ref that triggers the context menu on right-click. */
+    target: default_2.RefObject<HTMLElement | null>;
+    /** Called when an item is selected. */
+    onItemClick?: (item: NiceMenuItem) => void;
+}
+
+export declare const NiceDashboardLayout: default_2.ForwardRefExoticComponent<NiceDashboardLayoutProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for the {@link NiceDashboardLayout} component — a CSS-grid dashboard with draggable, resizable panels. */
+export declare interface NiceDashboardLayoutProps extends NiceBaseProps {
+    /** Panel definitions with grid positions. */
+    panels: NiceDashboardPanel[];
+    /** Number of grid columns. */
+    columns?: number;
+    /** Height of one grid row in px. */
+    rowHeight?: number;
+    /** Gap between panels in px. */
+    gap?: number;
+    /** Allow panels to be dragged to new positions. */
+    draggable?: boolean;
+    /** Allow panels to be resized. */
+    resizable?: boolean;
+    /** Called when the layout changes (after drag/resize). */
+    onLayoutChange?: (panels: NiceDashboardPanel[]) => void;
+}
+
+/** A positioned panel in the {@link NiceDashboardLayout} grid. */
+declare interface NiceDashboardPanel {
+    /** Unique key. */
+    key: string;
+    /** 0-based column position. */
+    col: number;
+    /** 0-based row position. */
+    row: number;
+    /** Number of columns this panel spans. */
+    colSpan?: number;
+    /** Number of rows this panel spans. */
+    rowSpan?: number;
+    /** Content renderer. */
+    render: () => default_2.ReactNode;
+}
+
+export declare const NiceDashboardShell: ForwardRefExoticComponent<NiceDashboardShellProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceDashboardShellProps extends NiceBaseProps {
+    /** Top bar content (app title, user menu, search). */
+    topBar?: React.ReactNode;
+    /** Optional side panel content. */
+    sidePanel?: React.ReactNode;
+    /** Side panel position. */
+    sidePanelPosition?: 'left' | 'right';
+    /** Side panel width. */
+    sidePanelWidth?: number;
+    /** Main dashboard content (widgets grid). */
+    children?: React.ReactNode;
+}
+
+export declare const NiceDesktop: ForwardRefExoticComponent<NiceDesktopProps & RefAttributes<HTMLDivElement>>;
+
+/** A shortcut icon on the {@link NiceDesktop} surface. */
+export declare interface NiceDesktopIcon {
+    /** Unique key. */
+    key: string;
+    /** Display label below the icon. */
+    label: string;
+    /** Icon element. */
+    icon: React.ReactNode;
+    /** Item type (changes visual styling). */
+    type?: 'file' | 'folder' | 'shortcut' | 'app';
+    /** Disable the icon. */
+    disabled?: boolean;
+    /** Position on the desktop grid (auto-layout if not set). */
+    gridCol?: number;
+    /** Row position on the desktop grid. */
+    gridRow?: number;
+}
+
+/** Props for the {@link NiceDesktop} component — a full OS-like desktop environment with taskbar, start menu, system tray, and windowed children. */
+export declare interface NiceDesktopProps extends NiceBaseProps {
+    /** Desktop shortcut icons. */
+    icons?: NiceDesktopIcon[];
+    /** Taskbar position */
+    taskbarPosition?: NiceTaskbarPosition;
+    /** Taskbar height/width in px */
+    taskbarSize?: number;
+    /** Start menu items */
+    startMenuItems?: NiceStartMenuItem[];
+    /** Start menu title / label */
+    startMenuLabel?: string;
+    /** Start menu icon */
+    startMenuIcon?: React.ReactNode;
+    /** Items shown in the taskbar (open windows) */
+    taskbarItems?: NiceTaskbarItem[];
+    /** System tray items (clock area) */
+    systemTrayItems?: NiceSystemTrayItem[];
+    /** Show clock in system tray */
+    showClock?: boolean;
+    /** Wallpaper CSS background value */
+    wallpaper?: string;
+    /** Desktop grid columns */
+    gridColumns?: number;
+    /** Desktop icon size */
+    iconSize?: NiceSize;
+    /** Callback when an icon is clicked */
+    onIconClick?: (key: string) => void;
+    /** Callback when an icon is double-clicked */
+    onIconDoubleClick?: (key: string) => void;
+    /** Callback when a taskbar item is clicked */
+    onTaskbarItemClick?: (key: string) => void;
+    /** Callback when start menu item is clicked */
+    onStartMenuItemClick?: (key: string) => void;
+    /** Callback when a system tray item is clicked */
+    onSystemTrayItemClick?: (key: string) => void;
+    /** Desktop right-click context menu items */
+    contextMenuItems?: NiceStartMenuItem[];
+    /** Callback when context menu item is clicked */
+    onContextMenuItemClick?: (key: string) => void;
+    /** Render children (windows, etc.) on the desktop area */
+    children?: React.ReactNode;
+}
+
+/**
+ * Cross-component visual presentation style.
+ * Each style maps 1:1 to a ThemeVariantConfig preset controlling
+ * buttons, inputs, cards, badges, tabs, toggles, tooltips, tables, etc.
+ */
+declare type NiceDisplayStyle = 'default' | 'minimal' | 'rounded' | 'sharp' | 'glass' | 'neumorphic' | 'playful' | 'enterprise' | 'modern3d' | 'brutalist' | 'luxe' | 'pill' | 'flat' | 'editorial' | 'dashboard' | 'softCloud' | 'cosmic' | 'corporate' | 'bank' | 'government' | 'military' | 'legal' | 'medical' | 'swiss' | 'scandinavian' | 'bauhaus' | 'notebook' | 'origami' | 'watercolor' | 'monochrome' | 'paper' | 'zen' | 'terminal' | 'hacker' | 'retro8bit' | 'synthwave' | 'cyberpunk' | 'steampunk' | 'vapor' | 'neon' | 'windows95' | 'material' | 'fluent' | 'cupertino' | 'ant' | 'bootstrap' | 'chakra' | 'notion' | 'linear' | 'vercel' | 'candy' | 'bubblegum' | 'cartoon' | 'kawaii' | 'circus' | 'gaming' | 'kiddo' | 'disco' | 'clown';
+
+export declare const NiceDock: ForwardRefExoticComponent<NiceDockProps & RefAttributes<HTMLDivElement>>;
+
+/** An item in the {@link NiceDock} bar. */
+declare interface NiceDockItem {
+    /** Unique key. */
+    key: string;
+    /** Icon element. */
+    icon: React.ReactNode;
+    /** Tooltip / label text. */
+    label: string;
+    /** Notification badge value. */
+    badge?: number | string;
+    /** Disable the item. */
+    disabled?: boolean;
+}
+
+export declare const NiceDockMenu: ForwardRefExoticComponent<NiceDockMenuProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceDockMenuProps extends NiceBaseProps {
+    size?: NiceSize;
+    items: NiceMenuGroupItem[];
+    activeKey?: string;
+    onItemClick?: (item: NiceMenuGroupItem) => void;
+    position?: 'bottom' | 'left' | 'right';
+    /** Auto-hide when not hovered. */
+    autoHide?: boolean;
+    /** Icon size. */
+    iconSize?: number;
+}
+
+/** Props for the {@link NiceDock} component — a macOS-style dock bar with magnification effect. */
+export declare interface NiceDockProps extends NiceBaseProps {
+    /** Dock items. */
+    items: NiceDockItem[];
+    /** Dock placement. */
+    position?: 'bottom' | 'left' | 'right';
+    /** Icon size preset. */
+    size?: NiceSize;
+    /** Enable mouse-proximity magnification. */
+    magnify?: boolean;
+    /** Magnification scale factor (e.g. 1.5). */
+    magnifyScale?: number;
+    /** Currently active item key. */
+    activeKey?: string;
+    /** Called when an item is clicked. */
+    onItemClick?: (key: string) => void;
+}
+
+export declare const NiceDynamicSidebar: ForwardRefExoticComponent<NiceDynamicSidebarProps & RefAttributes<HTMLElement>>;
+
+export declare interface NiceDynamicSidebarProps extends NiceBaseProps {
+    /** Full navigation data (modules, quickActions, favorites). */
+    menu: NiceUserMenuResponse;
+    /** Currently active route for highlighting. */
+    activeRoute?: string;
+    /** Whether sidebar starts collapsed. */
+    collapsed?: boolean;
+    /** Width in px when expanded. */
+    width?: number;
+    /** Width in px when collapsed (icon-only). */
+    collapsedWidth?: number;
+    /** Show search input. */
+    searchable?: boolean;
+    /** Show favorites section. */
+    showFavorites?: boolean;
+    /** Show quick actions. */
+    showQuickActions?: boolean;
+    /** Allow user to toggle collapse. */
+    collapsible?: boolean;
+    /** Called when user navigates to a route. */
+    onNavigate?: (route: string, entity?: NiceEntityMenuDto) => void;
+    /** Called when sidebar collapse state changes. */
+    onCollapseChange?: (collapsed: boolean) => void;
+    /** Called when user toggles a favorite. */
+    onToggleFavorite?: (item: NiceFavoriteItem) => void;
+    /** Custom header content (logo, tenant name, etc.). */
+    header?: React.ReactNode;
+    /** Custom footer content (profile, settings links, etc.). */
+    footer?: React.ReactNode;
+}
+
+/** A single entity (list view / form view) inside a module. */
+declare interface NiceEntityMenuDto {
+    id: string;
+    name: string;
+    label: string;
+    icon?: string;
+    listViewId?: string;
+    formViewId?: string;
+    route: string;
+}
+
+declare interface NiceFavoriteItem {
+    id: string;
+    label: string;
+    icon?: string;
+    route: string;
+    entityId?: string;
+    moduleId?: string;
+}
+
+/** Extended base props for form-field components (inputs, selects, etc.). */
+declare interface NiceFormFieldProps extends NiceBaseProps {
+    /** Field label displayed above or beside the control. */
+    label?: string;
+    /** Assistive text shown below the field. */
+    helperText?: string;
+    /** Validation error message — when set the field is styled as invalid. */
+    error?: string;
+    /** Marks the field as required (adds visual indicator). */
+    required?: boolean;
+    /** Disables the field. */
+    disabled?: boolean;
+    /** Makes the field read-only. */
+    readOnly?: boolean;
+    /** Visual size of the field. */
+    size?: NiceSize;
+    /** HTML `name` attribute used in form serialization. */
+    name?: string;
+    /** When true, pressing Enter will trigger the onSubmit callback (if provided). */
+    submitOnEnter?: boolean;
+    /** Callback triggered when Enter is pressed (if submitOnEnter is true). */
+    onSubmit?: () => void;
+    /** Show a keyboard shortcuts hint icon (?) next to the label. */
+    showKeyboardHints?: boolean;
+}
+
+export declare const NiceHamburgerMenu: ForwardRefExoticComponent<NiceHamburgerMenuProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceHamburgerMenuProps extends NiceBaseProps {
+    size?: NiceSize;
+    items: NiceMenuGroupItem[];
+    activeKey?: string;
+    onItemClick?: (item: NiceMenuGroupItem) => void;
+    /** Open state for controlled usage. */
+    open?: boolean;
+    /** Called when open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Slide-in direction. */
+    position?: 'left' | 'right';
+    /** Panel width. */
+    panelWidth?: number;
+    /** Custom header inside menu panel. */
+    header?: React.ReactNode;
+    /** Custom footer inside menu panel. */
+    footer?: React.ReactNode;
+}
+
+export declare const NiceKioskShell: ForwardRefExoticComponent<NiceKioskShellProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceKioskShellProps extends NiceBaseProps {
+    /** Optional minimal controls overlay (home button, logout). */
+    overlay?: React.ReactNode;
+    /** Lock screen content when idle. */
+    lockScreen?: React.ReactNode;
+    /** Whether kiosk is locked (shows lock screen). */
+    locked?: boolean;
+    /** Full-screen content (POS, terminal, etc.). */
+    children?: React.ReactNode;
+}
+
+export declare const NiceMdiWorkspace: ForwardRefExoticComponent<NiceMdiWorkspaceProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceMdiWorkspaceProps extends NiceBaseProps {
+    /** Currently open tabs. */
+    tabs: NiceTabDescriptor[];
+    /** Index of the active (visible) tab. */
+    activeIndex: number;
+    /** Render function returning the content for a given tab. */
+    renderTab: (tab: NiceTabDescriptor, index: number) => React.ReactNode;
+    /** Called when user selects a different tab. */
+    onActiveChange?: (index: number) => void;
+    /** Called when user closes a tab. Return false to cancel close. */
+    onCloseTab?: (tab: NiceTabDescriptor, index: number) => void | boolean;
+    /** Called when tabs are reordered via drag. */
+    onReorderTabs?: (tabs: NiceTabDescriptor[]) => void;
+    /** Called to persist workspace state. */
+    onSaveState?: (state: NiceWorkspaceState) => void;
+    /** Enable keyboard shortcuts (Ctrl+W close, Ctrl+Tab next, Ctrl+Shift+T reopen). */
+    enableShortcuts?: boolean;
+    /** Max number of open tabs (0 = unlimited). */
+    maxTabs?: number;
+    /** Show dirty indicator on modified tabs. */
+    showDirtyIndicator?: boolean;
+    /** Tab bar position. */
+    tabBarPosition?: 'top' | 'bottom';
+    /** Allow dragging tabs to reorder. */
+    draggable?: boolean;
+    /** Show a "+" button to add new tabs. */
+    showAddButton?: boolean;
+    /** Called when "+" is clicked. */
+    onAddTab?: () => void;
+    /** Preserve closed tab content in DOM (IndexedStack). */
+    keepAlive?: boolean;
+    /** Show warning modal when closing tabs with unsaved changes. */
+    warnOnUnsavedClose?: boolean;
+    /** Max recently closed tabs to remember (default 10). */
+    maxClosedTabs?: number;
+    /** Called when user reopens a closed tab (Ctrl+Shift+T). */
+    onUndoCloseTab?: (entry: ClosedTabEntry) => void;
+    /** Function to get current state for a tab (for restoration). */
+    getTabState?: (tab: NiceTabDescriptor) => unknown;
+    /** Custom unsaved warning message. */
+    unsavedWarningMessage?: string;
+}
+
+export declare const NiceMegaMenu: default_2.ForwardRefExoticComponent<NiceMegaMenuProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** A column within a {@link NiceMegaMenuPanel}. */
+declare interface NiceMegaMenuColumn {
+    /** Optional column header text. */
+    header?: string;
+    /** Menu items in this column. */
+    items: NiceMegaMenuItem[];
+}
+
+/** A clickable item inside a {@link NiceMegaMenuColumn}. */
+declare interface NiceMegaMenuItem {
+    /** Unique key. */
+    key: string;
+    /** Display label. */
+    label: string;
+    /** Optional icon. */
+    icon?: default_2.ReactNode;
+    /** If set, renders the item as a link. */
+    href?: string;
+    /** Click handler. */
+    onClick?: () => void;
+    /** Disable the item. */
+    disabled?: boolean;
+}
+
+/** A top-level panel (mega dropdown) in the {@link NiceMegaMenu}. */
+declare interface NiceMegaMenuPanel {
+    /** Unique key. */
+    key: string;
+    /** Panel trigger label. */
+    label: string;
+    /** Multi-column layout. */
+    columns: NiceMegaMenuColumn[];
+    /** Fully custom panel renderer (overrides columns). */
+    renderPanel?: () => default_2.ReactNode;
+}
+
+/** Props for the {@link NiceMegaMenu} component — a desktop mega-dropdown navigation bar. */
+export declare interface NiceMegaMenuProps extends NiceBaseProps {
+    /** Panel definitions. */
+    items: NiceMegaMenuPanel[];
+    /** Size preset. */
+    size?: NiceSize;
+}
+
+export declare const NiceMenu: default_2.FC<NiceMenuProps>;
+
+export declare interface NiceMenuGroupItem extends NiceMenuItem {
+    children?: NiceMenuGroupItem[];
+    badge?: string | number;
+    section?: string;
+}
+
+/** A single item (or sub-menu) in the {@link NiceMenu}. */
+declare interface NiceMenuItem {
+    /** Unique key. */
+    key: string;
+    /** Display text. */
+    text: string;
+    /** Icon element. */
+    icon?: default_2.ReactNode;
+    /** Disable this item. */
+    disabled?: boolean;
+    /** Nested sub-menu items. */
+    items?: NiceMenuItem[];
+    /** Click handler. */
+    onClick?: () => void;
+}
+
+/** Props for the {@link NiceMenu} component — a horizontal or vertical navigation menu with nested sub-menus. */
+export declare interface NiceMenuProps extends NiceBaseProps {
+    /** Size variant. */
+    size?: NiceSize;
+    /** Menu items. */
+    items: NiceMenuItem[];
+    /** Layout direction. */
+    orientation?: 'horizontal' | 'vertical';
+    /** Called when any item is clicked. */
+    onItemClick?: (item: NiceMenuItem) => void;
+}
+
+/** A work mode supported by the OmniVerk platform (test, demo, dev, prod, etc.). */
+declare interface NiceModeInfo {
+    key: string;
+    displayName: string;
+    icon?: string;
+    color?: string;
+    sourcePackage?: string;
+    description?: string;
+}
+
+export declare const NiceModeSelector: ForwardRefExoticComponent<NiceModeSelectorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceModeSelectorProps extends NiceBaseProps {
+    /** Size variant. */
+    size?: NiceSize;
+    /** Available modes. */
+    modes: NiceModeInfo[];
+    /** Currently active mode key. */
+    activeMode: string;
+    /** Called when user selects a mode. */
+    onModeChange?: (mode: NiceModeInfo) => void;
+    /** Display style. */
+    variant?: 'dropdown' | 'card-grid' | 'pills';
+    /** Grid column count (for card-grid variant). */
+    gridColumns?: number;
+    /** Show mode description. */
+    showDescription?: boolean;
+    /** Show colored indicator strip. */
+    showColorIndicator?: boolean;
+    /** Compact display (no description, smaller). */
+    compact?: boolean;
+}
+
+declare type NiceModuleAction = 'activate' | 'deactivate' | 'install' | 'uninstall' | 'update';
+
+/** A module entry in the lifecycle management panel. */
+declare interface NiceModuleInfo {
+    id: string;
+    name: string;
+    label: string;
+    description: string;
+    version: string;
+    icon?: string;
+    status: NiceModuleStatus;
+    author?: string;
+    dependencies?: string[];
+    isCore?: boolean;
+}
+
+export declare const NiceModuleLifecyclePanel: ForwardRefExoticComponent<NiceModuleLifecyclePanelProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceModuleLifecyclePanelProps extends NiceBaseProps {
+    /** List of all modules. */
+    modules: NiceModuleInfo[];
+    /** Called when an action is triggered on a module. */
+    onAction?: (moduleId: string, action: NiceModuleAction) => void;
+    /** Filter: show only specific statuses. Empty = all. */
+    statusFilter?: NiceModuleStatus[];
+    /** Allow search/filter. */
+    searchable?: boolean;
+    /** Show module dependencies. */
+    showDependencies?: boolean;
+    /** Show module author info. */
+    showAuthor?: boolean;
+    /** Show module version. */
+    showVersion?: boolean;
+    /** Modules currently processing an action (show spinner). */
+    processingModules?: Set<string>;
+    /** Display layout. */
+    layout?: 'list' | 'grid';
+    /** Grid column count (for grid layout). */
+    gridColumns?: number;
+    /** Called when module card is clicked (details view). */
+    onModuleClick?: (module: NiceModuleInfo) => void;
+}
+
+/** A top-level module in the navigation sidebar. */
+declare interface NiceModuleMenuDto {
+    id: string;
+    name: string;
+    label: string;
+    icon?: string;
+    order: number;
+    isAvailable: boolean;
+    entities: NiceEntityMenuDto[];
+    children?: NiceModuleMenuDto[];
+}
+
+declare type NiceModuleStatus = 'available' | 'installed' | 'active' | 'disabled' | 'error' | 'updating';
+
+export declare const NiceMultiView: default_2.FC<NiceMultiViewProps>;
+
+/** A view entry in the {@link NiceMultiView}. */
+declare interface NiceMultiViewItem {
+    /** Unique key. */
+    key: string;
+    /** Content renderer. */
+    render: () => default_2.ReactNode;
+}
+
+/** Props for the {@link NiceMultiView} component — a swipeable / indexed panel container (one visible at a time). */
+export declare interface NiceMultiViewProps extends NiceBaseProps {
+    /** Size variant. */
+    size?: NiceSize;
+    /** View definitions. */
+    items: NiceMultiViewItem[];
+    /** Currently visible view index. */
+    selectedIndex?: number;
+    /** Called when the visible index changes. */
+    onSelectedIndexChange?: (index: number) => void;
+    /** Enable slide transition animation. */
+    animationEnabled?: boolean;
+}
+
+/**
+ * {@link NiceNavbar} — Top navigation bar with logo, breadcrumbs, centre content,
+ * and right-side slots for tenant switcher, notifications, and user menu.
+ */
+export declare const NiceNavbar: default_2.ForwardRefExoticComponent<NiceNavbarProps & default_2.RefAttributes<HTMLElement>>;
+
+/** Props for the {@link NiceNavbar} component. */
+export declare interface NiceNavbarProps extends NiceFormFieldProps {
+    /** Application/brand title or logo element. */
+    logo?: default_2.ReactNode;
+    /** Company/brand name text. */
+    brandName?: string;
+    /** Breadcrumb items. */
+    breadcrumbs?: NavbarBreadcrumb[];
+    /** Element to render in the center area (e.g., search). */
+    centerContent?: default_2.ReactNode;
+    /** Right-side content (user menu, tenant switcher, etc.). */
+    rightContent?: default_2.ReactNode;
+    /** Left-side content (hamburger, nav items). */
+    leftContent?: default_2.ReactNode;
+    /** Whether the navbar is sticky at the top. */
+    sticky?: boolean;
+    /** Background variant. */
+    variant?: 'light' | 'dark' | 'primary' | 'transparent';
+    /** Height preset. */
+    height?: 'sm' | 'md' | 'lg';
+    /** Fires when brand/logo is clicked. */
+    onBrandClick?: () => void;
+}
+
+export declare const NiceNavigationControls: ForwardRefExoticComponent<NiceNavigationControlsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceNavigationControlsProps extends NiceBaseProps {
+    /** Whether back navigation is available. */
+    canGoBack?: boolean;
+    /** Whether forward navigation is available. */
+    canGoForward?: boolean;
+    /** Called when back button is clicked. */
+    onBack?: () => void;
+    /** Called when forward button is clicked. */
+    onForward?: () => void;
+    /** Called when refresh button is clicked. */
+    onRefresh?: () => void;
+    /** Enable keyboard shortcuts (Alt+Left, Alt+Right, F5/Ctrl+R). */
+    enableShortcuts?: boolean;
+    /** Show refresh button. */
+    showRefresh?: boolean;
+    /** Show stop button (during loading). */
+    showStop?: boolean;
+    /** Is page currently loading (shows stop instead of refresh). */
+    isLoading?: boolean;
+    /** Called when stop button is clicked. */
+    onStop?: () => void;
+    /** Size variant. */
+    size?: NiceSize;
+    /** Visual variant. */
+    variant?: 'default' | 'compact' | 'minimal';
+    /** Tooltip position. */
+    tooltipPosition?: 'top' | 'bottom';
+    /** Whether the controls are disabled. */
+    disabled?: boolean;
+    /** Custom back icon. */
+    backIcon?: React.ReactNode;
+    /** Custom forward icon. */
+    forwardIcon?: React.ReactNode;
+    /** Custom refresh icon. */
+    refreshIcon?: React.ReactNode;
+    /** Custom stop icon. */
+    stopIcon?: React.ReactNode;
+}
+
+/** Answer submitted for an onboarding question. */
+declare interface NiceOnboardingAnswer {
+    questionId: string;
+    answer: string;
+}
+
+/** A single question in the onboarding wizard. */
+declare interface NiceOnboardingQuestion {
+    id: string;
+    question: string;
+    questionType: 'text' | 'select' | 'multiSelect' | 'boolean' | 'number' | 'date';
+    category: string;
+    orderIndex: number;
+    isRequired: boolean;
+    options?: string[];
+    helpText?: string;
+    defaultValue?: string;
+}
+
+export declare const NiceOnboardingWizard: ForwardRefExoticComponent<NiceOnboardingWizardProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceOnboardingWizardProps extends NiceBaseProps {
+    /** Size variant. */
+    size?: NiceSize;
+    /** All onboarding questions. */
+    questions: NiceOnboardingQuestion[];
+    /** Pre-filled answers. */
+    initialAnswers?: NiceOnboardingAnswer[];
+    /** Step labels (if different from category names). */
+    stepLabels?: string[];
+    /** Called when user submits final answers. */
+    onComplete?: (answers: NiceOnboardingAnswer[]) => void;
+    /** Called when user leaves the wizard without finishing. */
+    onCancel?: () => void;
+    /** Called on each step transition. */
+    onStepChange?: (step: number) => void;
+    /** Welcome screen content (shown before step 1). */
+    welcomeContent?: React.ReactNode;
+    /** Completion screen content (shown after last step). */
+    completionContent?: React.ReactNode;
+    /** Show progress bar. */
+    showProgress?: boolean;
+    /** Allow going back to previous steps. */
+    allowBack?: boolean;
+    /** Logo / branding element for the wizard header. */
+    logo?: React.ReactNode;
+}
+
+/** Full organization profile DTO (30+ fields across 8 sections). */
+declare interface NiceOrganizationProfile {
+    id?: string;
+    name: string;
+    legalName?: string;
+    taxId?: string;
+    registrationNumber?: string;
+    industry?: string;
+    employeeCount?: number;
+    email?: string;
+    phone?: string;
+    website?: string;
+    fax?: string;
+    street?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    logoUrl?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    defaultLanguage?: string;
+    defaultCurrency?: string;
+    defaultTimezone?: string;
+    dateFormat?: string;
+    fiscalYearStart?: string;
+    vatEnabled?: boolean;
+    defaultVatRate?: number;
+    workingDays?: string[];
+    workingHoursStart?: string;
+    workingHoursEnd?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+export declare const NiceOrganizationProfileForm: ForwardRefExoticComponent<NiceOrganizationProfileFormProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceOrganizationProfileFormProps extends NiceBaseProps {
+    /** Current profile data. */
+    profile: NiceOrganizationProfile;
+    /** Called when any field changes. */
+    onChange?: (profile: NiceOrganizationProfile) => void;
+    /** Called when Submit/Save is clicked. */
+    onSave?: (profile: NiceOrganizationProfile) => void;
+    /** Called when Cancel is clicked. */
+    onCancel?: () => void;
+    /** Show only specific sections. Empty = all. */
+    sections?: NiceOrgProfileSection[];
+    /** Which sections start expanded. */
+    expandedSections?: NiceOrgProfileSection[];
+    /** Show save/cancel buttons. */
+    showActions?: boolean;
+    /** Custom country options for the address section. */
+    countryOptions?: {
+        value: string;
+        label: string;
+    }[];
+    /** Custom language options for localization. */
+    languageOptions?: {
+        value: string;
+        label: string;
+    }[];
+    /** Custom currency options. */
+    currencyOptions?: {
+        value: string;
+        label: string;
+    }[];
+    /** Custom timezone options. */
+    timezoneOptions?: {
+        value: string;
+        label: string;
+    }[];
+    /** Whether the form is currently submitting. */
+    saving?: boolean;
+}
+
+declare type NiceOrgProfileSection = 'basic' | 'contact' | 'address' | 'branding' | 'localization' | 'fiscal' | 'preferences';
+
+export declare const NicePagination: default_2.FC<NicePaginationProps>;
+
+/** Props for the {@link NicePagination} component — a page navigation bar with numbered buttons, prev/next, and ellipsis. */
+export declare interface NicePaginationProps extends NiceBaseProps {
+    /** Pagination size. */
+    size?: NiceSize;
+    /** Current 1-based page number. */
+    page: number;
+    /** Total number of pages. */
+    totalPages: number;
+    /** Called when the page changes. */
+    onChange: (page: number) => void;
+    /** Show "Page X of Y" info text. */
+    showInfo?: boolean;
+    /** Number of page buttons shown on each side of the current page. */
+    siblingCount?: number;
+}
+
+declare interface NiceQuickAction {
+    id: string;
+    label: string;
+    icon?: string;
+    route: string;
+    shortcut?: string;
+}
+
+export declare interface NiceRibbonGroup {
+    label: string;
+    items: NiceMenuGroupItem[];
+}
+
+export declare const NiceRibbonMenu: ForwardRefExoticComponent<NiceRibbonMenuProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceRibbonMenuProps extends NiceBaseProps {
+    size?: NiceSize;
+    tabs: NiceRibbonTab[];
+    activeTab?: string;
+    onTabChange?: (key: string) => void;
+    onItemClick?: (item: NiceMenuGroupItem) => void;
+    /** Minimize ribbon (only tab headers visible). */
+    minimized?: boolean;
+    onMinimizeToggle?: (minimized: boolean) => void;
+}
+
+export declare interface NiceRibbonTab {
+    key: string;
+    label: string;
+    groups: NiceRibbonGroup[];
+}
+
+/**
+ * {@link NiceSetupWizard} — Advanced multi-step setup wizard with branching, quick mode, and schema-driven forms.
+ *
+ * @example
+ * ```tsx
+ * <NiceSetupWizard
+ *   layout="sidebar"
+ *   steps={[
+ *     { id: 'welcome', title: 'Welcome', content: <WelcomeScreen /> },
+ *     { id: 'account', title: 'Account', fields: [
+ *       { id: 'email', type: 'email', label: 'Email', required: true },
+ *       { id: 'password', type: 'password', label: 'Password', required: true },
+ *     ]},
+ *     { id: 'preferences', title: 'Preferences', optional: true, quickModeSkip: true },
+ *     { id: 'done', title: 'Complete', content: <CompleteScreen /> },
+ *   ]}
+ *   onComplete={(values) => saveUser(values)}
+ * />
+ * ```
+ */
+export declare const NiceSetupWizard: default_2.ForwardRefExoticComponent<NiceSetupWizardProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props */
+export declare interface NiceSetupWizardProps {
+    /** Step definitions */
+    steps: SetupWizardStep[];
+    /** Initial values */
+    initialValues?: Record<string, unknown>;
+    /** Controlled current step */
+    activeStep?: string;
+    /** Layout variant */
+    layout?: SetupWizardLayout;
+    /** Size */
+    size?: NiceSize;
+    /** Whether quick mode is enabled by default */
+    defaultQuickMode?: boolean;
+    /** Allow toggling quick mode */
+    allowQuickModeToggle?: boolean;
+    /** Show step numbers */
+    showStepNumbers?: boolean;
+    /** Show progress bar */
+    showProgress?: boolean;
+    /** Show estimated time */
+    showEstimatedTime?: boolean;
+    /** Allow clicking on step indicators to navigate */
+    allowStepClick?: boolean;
+    /** Show review step before completion */
+    showReviewStep?: boolean;
+    /** Persist progress to localStorage */
+    persistKey?: string;
+    /** Animation type */
+    animation?: 'slide' | 'fade' | 'none';
+    /** Brand/logo element */
+    branding?: default_2.ReactNode;
+    /** Header content */
+    header?: default_2.ReactNode;
+    /** Footer content */
+    footer?: default_2.ReactNode;
+    /** Callbacks */
+    onStepChange?: (stepId: string, index: number) => void;
+    onValuesChange?: (values: Record<string, unknown>) => void;
+    onComplete?: (values: Record<string, unknown>) => void | Promise<void>;
+    onCancel?: () => void;
+    /** Custom labels */
+    labels?: {
+        next?: string;
+        prev?: string;
+        finish?: string;
+        cancel?: string;
+        skip?: string;
+        quickMode?: string;
+        required?: string;
+        optional?: string;
+        review?: string;
+        stepOf?: string;
+    };
+    /** Accessibility */
+    accessMode?: NiceAccessMode;
+    id?: string;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare interface NiceShellProps extends NiceBaseProps {
+    /** Navigation data for sidebar / menus. */
+    menu?: NiceUserMenuResponse;
+    /** Currently active route. */
+    activeRoute?: string;
+    /** Toolbar / top bar content. */
+    toolbar?: React.ReactNode;
+    /** Status bar content. */
+    statusBar?: React.ReactNode;
+    /** Sidebar header (logo, tenant name). */
+    sidebarHeader?: React.ReactNode;
+    /** Sidebar footer (profile, logout). */
+    sidebarFooter?: React.ReactNode;
+    /** Called when navigating. */
+    onNavigate?: (route: string) => void;
+    /** Main content area. */
+    children?: React.ReactNode;
+}
+
+export declare const NiceSidebarMenu: ForwardRefExoticComponent<NiceSidebarMenuProps & RefAttributes<HTMLElement>>;
+
+export declare interface NiceSidebarMenuProps extends NiceBaseProps {
+    size?: NiceSize;
+    items: NiceMenuGroupItem[];
+    activeKey?: string;
+    collapsed?: boolean;
+    width?: number;
+    collapsedWidth?: number;
+    onItemClick?: (item: NiceMenuGroupItem) => void;
+    onCollapseChange?: (collapsed: boolean) => void;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+}
+
+export declare const NiceSidebarNav: ForwardRefExoticComponent<NiceSidebarNavProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface NiceSidebarNavProps {
+    /** Full navigation data */
+    data: SidebarNavDataNode[];
+    /** User ID for per-user localStorage persistence */
+    userId?: string;
+    /** Currently active route (for item highlighting) */
+    activeRoute?: string;
+    /** Called when user clicks a navigable view */
+    onNavigate?: (route: string, view: SidebarNavView) => void;
+    /**
+     * Override the initial enableModeIcons flag.
+     * Can be toggled later via Preferences.
+     */
+    enableModeIcons?: boolean;
+    /**
+     * Controlled prefs — if provided, the component uses these instead of
+     * loading from localStorage. Changes still fire onPreferencesChange.
+     */
+    preferences?: Partial<SidebarNavUserPrefs>;
+    /** Called whenever preferences change (for server-side persistence) */
+    onPreferencesChange?: (prefs: SidebarNavUserPrefs) => void;
+    /** Sidebar width in px (default: 264) */
+    width?: number;
+    /** Extra CSS class on the root element */
+    className?: string;
+    /** Size variant */
+    size?: NiceSize;
+    'data-testid'?: string;
+}
+
+/** T-shirt sizing used across all components for consistent visual density. */
+declare type NiceSize = 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+
+export declare const NiceSplitter: default_2.FC<NiceSplitterProps>;
+
+/** A resizable pane inside the {@link NiceSplitter}. */
+declare interface NiceSplitterPane {
+    /** Unique key. */
+    key: string;
+    /** Content renderer. */
+    render: () => default_2.ReactNode;
+    /** Initial size (px or %). */
+    size?: number | string;
+    /** Minimum pane size in px. */
+    minSize?: number;
+    /** Maximum pane size in px. */
+    maxSize?: number;
+    /** Allow the pane to collapse completely. */
+    collapsible?: boolean;
+}
+
+/** Props for the {@link NiceSplitter} component — a resizable multi-pane layout with draggable gutters. */
+export declare interface NiceSplitterProps extends NiceBaseProps {
+    /** Pane definitions. */
+    panes: NiceSplitterPane[];
+    /** Split direction. */
+    orientation?: 'horizontal' | 'vertical';
+    /** Drag handle width/height in px. */
+    gutterSize?: number;
+    /** Called when panes are resized (new sizes in px). */
+    onResize?: (sizes: number[]) => void;
+}
+
+/** A menu entry in the {@link NiceDesktop} start menu. */
+export declare interface NiceStartMenuItem {
+    /** Unique key. */
+    key: string;
+    /** Display label. */
+    label: string;
+    /** Optional icon. */
+    icon?: React.ReactNode;
+    /** Disable the item. */
+    disabled?: boolean;
+    /** Nested sub-items. */
+    children?: NiceStartMenuItem[];
+    /** Click handler. */
+    onClick?: () => void;
+    /** Visual divider before this item. */
+    divider?: boolean;
+}
+
+/** A system-tray icon in the {@link NiceDesktop} clock area. */
+export declare interface NiceSystemTrayItem {
+    /** Unique key. */
+    key: string;
+    /** Icon element. */
+    icon: React.ReactNode;
+    /** Tooltip text on hover. */
+    tooltip?: string;
+    /** Click handler. */
+    onClick?: () => void;
+}
+
+/** Descriptor for a single MDI tab. */
+declare interface NiceTabDescriptor {
+    id: string;
+    route: string;
+    title: string;
+    icon?: string;
+    entityId?: string;
+    isDirty?: boolean;
+    isPinned?: boolean;
+    closable?: boolean;
+}
+
+/** Definition of a single tab in a {@link NiceTabs} component. */
+declare interface NiceTabItem {
+    /** Unique tab identifier. */
+    id: string;
+    /** Tab label text. */
+    label: string;
+    /** Optional icon rendered before the label. */
+    icon?: default_2.ReactNode;
+    /** Badge counter shown in the tab header. */
+    badge?: string | number;
+    /** Disable this tab. */
+    disabled?: boolean;
+    /** Tab panel content rendered when active. */
+    content?: default_2.ReactNode;
+}
+
+export declare const NiceTabPanel: default_2.FC<NiceTabPanelProps>;
+
+/** A tab definition for the {@link NiceTabPanel}. */
+declare interface NiceTabPanelItem {
+    /** Unique key. */
+    key: string;
+    /** Tab header label. */
+    title: string;
+    /** Optional tab icon. */
+    icon?: default_2.ReactNode;
+    /** Badge element shown after the title (e.g. count). */
+    badge?: default_2.ReactNode;
+    /** Disable the tab. */
+    disabled?: boolean;
+    /** Content renderer. */
+    render: () => default_2.ReactNode;
+}
+
+/** Props for the {@link NiceTabPanel} component — a keyed tab strip with content panels and flexible position. */
+export declare interface NiceTabPanelProps extends NiceBaseProps {
+    /** Tab panel size. */
+    size?: NiceSize;
+    /** Tab definitions. */
+    items: NiceTabPanelItem[];
+    /** Currently active tab key (controlled). */
+    selectedKey?: string;
+    /** Called when the active tab changes. */
+    onSelectedKeyChange?: (key: string) => void;
+    /** Side on which the tab strip is rendered. */
+    tabPosition?: 'top' | 'bottom' | 'left' | 'right';
+}
+
+export declare const NiceTabs: default_2.FC<NiceTabsProps>;
+
+/** Props for the {@link NiceTabs} component — a tabbed content panel. */
+export declare interface NiceTabsProps extends NiceBaseProps {
+    /** Array of tab definitions. */
+    tabs: NiceTabItem[];
+    /** Controlled active tab id. */
+    activeTab?: string;
+    /** Called when the active tab changes. */
+    onChange?: (id: string) => void;
+    /** Visual style variant. */
+    variant?: 'default' | 'pills' | 'enclosed';
+    /** Tabs size. */
+    size?: NiceSize;
+    /** Stack tabs vertically. */
+    vertical?: boolean;
+}
+
+/** A running-window entry in the {@link NiceDesktop} taskbar. */
+export declare interface NiceTaskbarItem {
+    /** Unique key. */
+    key: string;
+    /** Label text. */
+    label: string;
+    /** Optional icon. */
+    icon?: React.ReactNode;
+    /** Badge value (e.g. notification count). */
+    badge?: number | string;
+    /** Whether this item is focused / active. */
+    active?: boolean;
+    /** Whether the window is minimized. */
+    minimized?: boolean;
+}
+
+/** Where the taskbar is placed on the desktop. */
+export declare type NiceTaskbarPosition = 'top' | 'bottom' | 'left' | 'right';
+
+/**
+ * {@link NiceTenantSwitcher} — Tenant/organization selector dropdown
+ * for multi-tenant SaaS applications.
+ */
+export declare const NiceTenantSwitcher: default_2.ForwardRefExoticComponent<NiceTenantSwitcherProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for the {@link NiceTenantSwitcher} component. */
+export declare interface NiceTenantSwitcherProps extends NiceFormFieldProps {
+    /** Available tenants. */
+    tenants: TenantEntry[];
+    /** Currently selected tenant id. */
+    currentTenantId?: string | number;
+    /** Fires when tenant is switched. */
+    onSwitch?: (tenantId: string | number) => void;
+    /** Fires when "Manage tenants" is clicked. */
+    onManage?: () => void;
+    /** Fires when "Create tenant" is clicked. */
+    onCreate?: () => void;
+    /** Variant (inline selector or dropdown). */
+    variant?: 'dropdown' | 'inline';
+    /** Search filter enabled. */
+    searchable?: boolean;
+}
+
+export declare const NiceToolbar: default_2.FC<NiceToolbarProps>;
+
+/** A toolbar entry in the {@link NiceToolbar}. */
+declare interface NiceToolbarItem {
+    /** Unique key. */
+    key: string;
+    /** Custom render function (overrides widget/text/icon). */
+    render?: () => default_2.ReactNode;
+    /** Built-in widget type: button, visual separator, or flexible spacer. */
+    widget?: 'button' | 'separator' | 'spacer';
+    /** Button label text. */
+    text?: string;
+    /** Button icon. */
+    icon?: default_2.ReactNode;
+    /** Disable the item. */
+    disabled?: boolean;
+    /** Click handler. */
+    onClick?: () => void;
+    /** Alignment group within the toolbar. */
+    location?: 'before' | 'center' | 'after';
+}
+
+/** Props for the {@link NiceToolbar} component — a horizontal strip of action buttons and widgets. */
+export declare interface NiceToolbarProps extends NiceBaseProps {
+    /** Toolbar items. */
+    items: NiceToolbarItem[];
+    /** Toolbar size preset. */
+    size?: NiceSize;
+}
+
+export declare const NiceTopMenu: ForwardRefExoticComponent<NiceTopMenuProps & RefAttributes<HTMLElement>>;
+
+export declare interface NiceTopMenuProps extends NiceBaseProps {
+    size?: NiceSize;
+    items: NiceMenuGroupItem[];
+    activeKey?: string;
+    onItemClick?: (item: NiceMenuGroupItem) => void;
+    /** Left-side branding / logo. */
+    brand?: React.ReactNode;
+    /** Right-side actions. */
+    actions?: React.ReactNode;
+}
+
+/**
+ * {@link NiceUserMenu} — Avatar button with dropdown showing user info, role,
+ * status indicator, and action menu (profile, settings, logout).
+ */
+export declare const NiceUserMenu: default_2.ForwardRefExoticComponent<NiceUserMenuProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for the {@link NiceUserMenu} component. */
+export declare interface NiceUserMenuProps extends NiceFormFieldProps {
+    /** User's display name. */
+    userName: string;
+    /** User's email address. */
+    userEmail?: string;
+    /** User's role/title. */
+    userRole?: string;
+    /** Avatar image URL. */
+    avatarUrl?: string;
+    /** Menu items. */
+    items?: UserMenuItem[];
+    /** Whether the dropdown is open. */
+    open?: boolean;
+    /** Fires on toggle. */
+    onOpenChange?: (open: boolean) => void;
+    /** Fires when "Profile" is clicked (shortcut). */
+    onProfile?: () => void;
+    /** Fires when "Logout" is clicked (shortcut). */
+    onLogout?: () => void;
+    /** Avatar size in px. */
+    avatarSize?: number;
+    /** Status indicator. */
+    status?: 'online' | 'away' | 'busy' | 'offline';
+}
+
+/** Full API response for user-scoped navigation menu. */
+declare interface NiceUserMenuResponse {
+    modules: NiceModuleMenuDto[];
+    quickActions: NiceQuickAction[];
+    favorites: NiceFavoriteItem[];
+}
+
+/**
+ * {@link NiceWizard} — Multi-step wizard/stepper with per-step validation, optional steps, and step branching.
+ */
+export declare const NiceWizard: default_2.ForwardRefExoticComponent<NiceWizardProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for the {@link NiceWizard} component. */
+export declare interface NiceWizardProps {
+    /** Step definitions. */
+    steps: WizardStep[];
+    /** Controlled current step index. */
+    activeStep?: number;
+    /** Called when step changes. */
+    onStepChange?: (index: number) => void;
+    /** Called when wizard completes (user clicks Finish on last step). */
+    onComplete?: () => void;
+    /** Called when user cancels the wizard. */
+    onCancel?: () => void;
+    /** Whether to allow clicking step indicators to navigate. */
+    allowStepClick?: boolean;
+    /** Layout variant. */
+    variant?: 'horizontal' | 'vertical';
+    /** Custom "Next" button label. */
+    nextLabel?: string;
+    /** Custom "Previous" button label. */
+    prevLabel?: string;
+    /** Custom "Finish" button label. */
+    finishLabel?: string;
+    /** Custom "Cancel" button label. */
+    cancelLabel?: string;
+    /** Whether to show a progress bar. */
+    showProgress?: boolean;
+    /** Custom class name. */
+    className?: string;
+    /** Custom style. */
+    style?: default_2.CSSProperties;
+    /** Size variant. */
+    size?: NiceSize;
+    /** Access mode. */
+    accessMode?: NiceAccessMode;
+    id?: string;
+}
+
+/** Response from workspace state API. */
+declare interface NiceWorkspaceState {
+    tabs: NiceTabDescriptor[];
+    activeTabIndex: number;
+    layoutPreferences?: Record<string, unknown>;
+}
+
+/** Field definition for schema-driven forms */
+declare interface SetupField {
+    id: string;
+    type: SetupFieldType;
+    label: string;
+    placeholder?: string;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    options?: Array<{
+        value: string;
+        label: string;
+        icon?: default_2.ReactNode;
+    }>;
+    validation?: {
+        pattern?: RegExp;
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+        custom?: (value: unknown) => string | undefined;
+    };
+    /** Show field only when condition is met */
+    showWhen?: (values: Record<string, unknown>) => boolean;
+    /** Full-width in grid layout */
+    fullWidth?: boolean;
+    /** Custom render function */
+    render?: (props: {
+        value: unknown;
+        onChange: (v: unknown) => void;
+        field: SetupField;
+    }) => default_2.ReactNode;
+}
+
+/** Step field types for schema-driven content */
+declare type SetupFieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'textarea' | 'select' | 'radio' | 'checkbox' | 'switch' | 'date' | 'time' | 'datetime' | 'color' | 'file' | 'slider' | 'rating' | 'custom';
+
+/** Custom action button */
+declare interface SetupWizardAction {
+    id: string;
+    label: string;
+    variant?: 'primary' | 'secondary' | 'outlined' | 'text' | 'danger';
+    icon?: default_2.ReactNode;
+    onClick: (ctx: SetupWizardContext) => void;
+    disabled?: (ctx: SetupWizardContext) => boolean;
+    position?: 'left' | 'right';
+}
+
+/** Context provided to steps */
+declare interface SetupWizardContext {
+    values: Record<string, unknown>;
+    setValue: (key: string, value: unknown) => void;
+    setValues: (vals: Record<string, unknown>) => void;
+    currentStep: SetupWizardStep;
+    currentIndex: number;
+    totalSteps: number;
+    visitedSteps: Set<string>;
+    errors: Record<string, string>;
+    setError: (stepId: string, error: string) => void;
+    clearError: (stepId: string) => void;
+    goNext: () => Promise<void>;
+    goPrev: () => void;
+    goTo: (stepId: string) => void;
+    skip: () => void;
+    complete: () => void;
+    cancel: () => void;
+    isFirst: boolean;
+    isLast: boolean;
+    isQuickMode: boolean;
+    toggleQuickMode: () => void;
+    progress: number;
+    t: (key: string, defaultValue: string) => string;
+}
+
+/** Layout variant */
+declare type SetupWizardLayout = 'horizontal' | 'vertical' | 'cards' | 'minimal' | 'sidebar';
+
+/** Step definition */
+declare interface SetupWizardStep {
+    id: string;
+    title: string;
+    subtitle?: string;
+    description?: string;
+    icon?: default_2.ReactNode;
+    /** Schema-driven fields */
+    fields?: SetupField[];
+    /** OR custom content */
+    content?: default_2.ReactNode | ((ctx: SetupWizardContext) => default_2.ReactNode);
+    /** Validation function */
+    validate?: (values: Record<string, unknown>) => Promise<string | undefined> | string | undefined;
+    /** Whether step is optional */
+    optional?: boolean;
+    /** Whether step is skippable in quick mode */
+    quickModeSkip?: boolean;
+    /** Custom action buttons */
+    actions?: SetupWizardAction[];
+    /** Next step override (for branching) */
+    nextStep?: string | ((values: Record<string, unknown>) => string);
+    /** Previous step override */
+    prevStep?: string;
+    /** Minimum time on step (ms) - for steps that need time to process */
+    minDuration?: number;
+    /** Summary to show in review step */
+    summary?: (values: Record<string, unknown>) => default_2.ReactNode;
+    /** Category/group for sidebar layout */
+    category?: string;
+    /** Badge to show on step indicator */
+    badge?: default_2.ReactNode;
+    /** Estimated time to complete (displayed to user) */
+    estimatedTime?: string;
+}
+
+/** Icon/label for each mode */
+export declare const SIDEBAR_MODE_META: Record<SidebarNavMode, {
+    icon: string;
+    label: string;
+}>;
+
+/**
+ * Top-level data node: one data source with all its navigation children.
+ * modules  → used in 'all' mode     (depth: source → module → view)
+ * roles    → used in 'by-role' mode  (depth: source → role → module → view)
+ * units    → used in 'by-unit' mode  (depth: source → unit → module → view)
+ */
+export declare interface SidebarNavDataNode {
+    source: SidebarNavDataSource;
+    /** Navigation tree for "All" mode */
+    modules: SidebarNavModule[];
+    /** Navigation tree for "By-Role" mode */
+    roles: SidebarNavRole[];
+    /** Navigation tree for "By-Unit" mode */
+    units: SidebarNavUnit[];
+}
+
+/** A database / API instance that can be pinned per mode */
+export declare interface SidebarNavDataSource {
+    id: string;
+    label: string;
+    icon?: string;
+    color?: string;
+    /** Server URL or connection string hint */
+    url?: string;
+    type?: 'database' | 'instance' | 'api' | 'other';
+}
+
+/** A saved favorite item */
+export declare interface SidebarNavFavorite {
+    id: string;
+    label: string;
+    icon?: string;
+    route?: string;
+    sourceId?: string;
+    moduleId?: string;
+    addedAt: number;
+}
+
+export declare interface SidebarNavHiddenItem {
+    /** The id of the hidden entity (source/module/view/role/unit id) */
+    id: string;
+    /** What KIND it is — for display in the restore list */
+    kind: 'source' | 'module' | 'view' | 'role' | 'unit';
+    /** Human-readable label for the restore list */
+    label: string;
+}
+
+/** Display mode for the sidebar navigation */
+export declare type SidebarNavMode = 'all' | 'by-role' | 'by-unit' | 'favorites' | 'preferences';
+
+/** A module containing multiple views */
+export declare interface SidebarNavModule {
+    id: string;
+    label: string;
+    icon?: string;
+    views: SidebarNavView[];
+    /** Source this module belongs to */
+    sourceId?: string;
+}
+
+/** A role grouping modules */
+export declare interface SidebarNavRole {
+    id: string;
+    label: string;
+    icon?: string;
+    modules: SidebarNavModule[];
+    /** Source this role belongs to */
+    sourceId?: string;
+}
+
+/** An organizational unit grouping modules */
+export declare interface SidebarNavUnit {
+    id: string;
+    label: string;
+    icon?: string;
+    modules: SidebarNavModule[];
+    /** Source this unit belongs to */
+    sourceId?: string;
+}
+
+export declare interface SidebarNavUserPrefs {
+    /** Matches the userId prop to namespace localStorage keys */
+    userId: string;
+    /** Whether to show mode-switch icons at all (default: false) */
+    enableModeIcons: boolean;
+    /** Which modes are shown in the strip (preferences is always shown) */
+    enabledModes: SidebarNavMode[];
+    /** Active mode */
+    activeMode: SidebarNavMode;
+    /**
+     * When a mode has pinned source ids, only those sources are shown.
+     * Empty array / absent = show all sources in that mode.
+     */
+    pinnedSources: Partial<Record<SidebarNavMode, string[]>>;
+    hiddenItems: SidebarNavHiddenItem[];
+    favorites: SidebarNavFavorite[];
+    /**
+     * How many levels to show per mode.
+     * 1 = sources only, 2 = sources + first level, 3 = …, 4 = all (default)
+     */
+    maxDepth: Partial<Record<SidebarNavMode, number>>;
+    /** IDs that are manually collapsed */
+    collapsedIds: string[];
+    /** Start everything expanded (default: true) */
+    autoExpand: boolean;
+}
+
+/** A single navigable view / entity view */
+export declare interface SidebarNavView {
+    id: string;
+    label: string;
+    icon?: string;
+    /** Route path for navigation */
+    route?: string;
+    /** Badge counter (unread notifications, pending tasks, …) */
+    badge?: string | number;
+    isExternal?: boolean;
+    /** Module this view belongs to */
+    moduleId?: string;
+}
+
+declare interface StartMenuProps {
+    items: NiceStartMenuItem[];
+    label?: string;
+    icon?: default_2.ReactNode;
+    position: NiceTaskbarPosition;
+    onItemClick?: (key: string) => void;
+}
+
+declare interface SystemTrayProps {
+    items: NiceSystemTrayItem[];
+    showClock?: boolean;
+    onItemClick?: (key: string) => void;
+}
+
+declare interface TaskbarProps {
+    items: NiceTaskbarItem[];
+    position: NiceTaskbarPosition;
+    size: number;
+    startMenu?: default_2.ReactNode;
+    systemTray?: default_2.ReactNode;
+    onItemClick?: (key: string) => void;
+}
+
+/** A tenant/organization entry. */
+declare interface TenantEntry {
+    id: string | number;
+    /** Display name. */
+    name: string;
+    /** Logo/icon URL. */
+    logoUrl?: string;
+    /** Subtitle (e.g. role, plan). */
+    subtitle?: string;
+    /** Whether the tenant is active/current. */
+    isCurrent?: boolean;
+}
+
+/** A menu item in the user menu. */
+declare interface UserMenuItem {
+    id: string;
+    label: string;
+    icon?: default_2.ReactNode;
+    /** Whether this item is a divider (label is ignored). */
+    isDivider?: boolean;
+    /** Fires when clicked. */
+    onClick?: () => void;
+    /** Whether this is a "danger" action (e.g. logout). */
+    danger?: boolean;
+    /** Whether the item is disabled. */
+    disabled?: boolean;
+}
+
+/** A single step in the wizard. */
+declare interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: default_2.ReactNode;
+    /** Validation function — return error message string or undefined/true for valid. */
+    validate?: () => string | true | undefined;
+    /** Whether this step is optional (can be skipped). */
+    optional?: boolean;
+    /** Content renderer. */
+    content: default_2.ReactNode | ((ctx: WizardStepContext) => default_2.ReactNode);
+}
+
+/** Context provided to each step's content renderer. */
+declare interface WizardStepContext {
+    stepIndex: number;
+    totalSteps: number;
+    goNext: () => void;
+    goPrev: () => void;
+    goTo: (id: string) => void;
+    isFirst: boolean;
+    isLast: boolean;
+}
+
+export { }