import { default as default_2 } from 'react';
import { ForwardRefExoticComponent } from 'react';
import { NiceAccessMode } from '@nice2dev/ui-core';
import { NiceBaseProps } from '@nice2dev/ui-core';
import { NiceEntityMenuDto } from '@nice2dev/ui-core';
import { NiceFavoriteItem } from '@nice2dev/ui-core';
import { NiceFormFieldProps } from '@nice2dev/ui-core';
import { NiceModeInfo } from '@nice2dev/ui-core';
import { NiceModuleInfo } from '@nice2dev/ui-core';
import { NiceModuleStatus } from '@nice2dev/ui-core';
import { NiceOnboardingAnswer } from '@nice2dev/ui-core';
import { NiceOnboardingQuestion } from '@nice2dev/ui-core';
import { NiceOrganizationProfile } from '@nice2dev/ui-core';
import { NiceSize } from '@nice2dev/ui-core';
import { NiceTabDescriptor } from '@nice2dev/ui-core';
import { NiceTenantInfo } from '@nice2dev/ui-core';
import { NiceUserMenuResponse } from '@nice2dev/ui-core';
import { NiceWorkspaceState } from '@nice2dev/ui-core';
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;
}

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[];
    /** Constrain the accordion to a specific width (px or any CSS length). When unset the accordion fills its parent (`100%`). */
    width?: number | string;
    /** Optional maximum width (px or any CSS length). */
    maxWidth?: number | string;
    /** Open / close animation duration in milliseconds. Defaults to `220`. Set to `0` to disable animation. */
    animationDuration?: number;
}

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;
}

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;
    /** Render a 1px border around the card. Defaults to `true`. Set to `false` for a frameless / shadow-only look. */
    bordered?: 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;
    /** Convenience alias for `content` (string label). */
    label?: 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 (function form). */
    render?: () => React.ReactNode;
    /** Content renderer (node form — convenience alias for `render`). */
    content?: 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;
}

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;
    /** Render inline within a parent container instead of fixed to viewport. */
    contained?: boolean;
}

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;
}

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 NiceHybridShell: ForwardRefExoticComponent<NiceHybridShellProps & RefAttributes<HTMLDivElement>>;

export declare interface NiceHybridShellProps extends NiceBaseProps {
    /** Sidebar navigation data. */
    menu?: NiceUserMenuResponse;
    /** Active route. */
    activeRoute?: string;
    /** Tenant info shown in the top bar. */
    tenant?: NiceTenantInfo;
    /** Top bar content. */
    toolbar?: React.ReactNode;
    /** Optional right inspector panel. */
    inspector?: React.ReactNode;
    /** Inspector default visibility. */
    inspectorOpen?: boolean;
    /** Status bar. */
    statusBar?: React.ReactNode;
    /** Navigation handler. */
    onNavigate?: (route: string) => void;
    /** Main content. */
    children?: 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;
}

export declare const NiceMinimalShell: ForwardRefExoticComponent<NiceMinimalShellProps & RefAttributes<HTMLDivElement>>;

export declare interface NiceMinimalShellProps extends NiceBaseProps {
    /** Optional slim header. */
    header?: React.ReactNode;
    /** Optional tenant info shown in the header. */
    tenant?: NiceTenantInfo;
    /** Maximum content width (px or css value). */
    maxWidth?: number | string;
    /** Centered? Default true. */
    centered?: boolean;
    /** Main content. */
    children?: React.ReactNode;
}

export declare const NiceModernShell: ForwardRefExoticComponent<NiceModernShellProps & RefAttributes<HTMLDivElement>>;

export declare interface NiceModernShellProps extends NiceBaseProps {
    /** Navigation data for the rail. */
    menu?: NiceUserMenuResponse;
    /** Currently active route. */
    activeRoute?: string;
    /** Tenant info shown in the top bar. */
    tenant?: NiceTenantInfo;
    /** Top bar right-aligned content (user menu, notifications). */
    topBarActions?: React.ReactNode;
    /** Optional global search slot. */
    globalSearch?: React.ReactNode;
    /** Footer content. */
    footer?: React.ReactNode;
    /** Called when navigating. */
    onNavigate?: (route: string) => void;
    /** Main content. */
    children?: React.ReactNode;
}

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';

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;
}

export declare const NiceMultiView: default_2.FC<NiceMultiViewProps>;

/** A view entry in the {@link NiceMultiView}. */
declare interface NiceMultiViewItem {
    /** Unique key. */
    key: string;
    /** Optional label shown in tabs / header. */
    label?: string;
    /** Optional icon shown in tabs / header. */
    icon?: string;
    /** Content renderer. */
    render: () => default_2.ReactNode;
}

/** Navigation style for the NiceMultiView. */
declare type NiceMultiViewNav = 'tabs' | 'dots' | 'arrows' | 'none';

/** Props for the {@link NiceMultiView} component. */
export declare interface NiceMultiViewProps extends NiceBaseProps {
    /** Size variant. */
    size?: NiceSize;
    /** View definitions. */
    items: NiceMultiViewItem[];
    /** Currently visible view index (controlled). */
    selectedIndex?: number;
    /** Called when the visible index changes. */
    onSelectedIndexChange?: (index: number) => void;
    /** Enable slide transition animation (default: true). */
    animationEnabled?: boolean;
    /** Navigation style (default: 'tabs'). */
    nav?: NiceMultiViewNav;
    /** Show prev/next arrows alongside any nav style (default: true for 'dots' / 'none'). */
    showArrows?: boolean;
    /** Auto-cycle interval in ms (0 = disabled). */
    autoPlay?: number;
}

/**
 * {@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;
}

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;
}

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, ellipsis, optional first/last, jump-to-page input and page-size selector. */
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;
    /** Show ⏮ / ⏭ first/last page buttons. */
    showFirstLast?: boolean;
    /** Show a "Go to page" number input (uses NiceNumberInput). */
    showJumpInput?: boolean;
    /** Label for the jump input. Defaults to "Go to". */
    jumpInputLabel?: string;
    /** Show a page-size selector. Provide {@link pageSizeOptions} together with {@link onPageSizeChange}. */
    showPageSize?: boolean;
    /** Available page sizes. */
    pageSizeOptions?: number[];
    /** Currently selected page size. */
    pageSize?: number;
    /** Called when user selects a different page size. */
    onPageSizeChange?: (size: number) => void;
    /** Disable all interactions. */
    disabled?: boolean;
}

export declare const NicePwaShell: ForwardRefExoticComponent<NicePwaShellProps & RefAttributes<HTMLDivElement>>;

export declare interface NicePwaShellProps extends NiceBaseProps {
    /** App title shown in the top bar. */
    appTitle?: string;
    /** Optional tenant info (replaces the title when present). */
    tenant?: NiceTenantInfo;
    /** Top bar trailing actions (notifications, profile). */
    topBarActions?: React.ReactNode;
    /** Bottom tab items. */
    tabs?: Array<{
        id: string;
        label: string;
        icon?: React.ReactNode;
        route: string;
    }>;
    /** Active tab id. */
    activeTabId?: string;
    /** Tab-change handler. */
    onTabChange?: (id: string, route: string) => void;
    /** Optional FAB. */
    fab?: React.ReactNode;
    /** Main content. */
    children?: React.ReactNode;
}

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;
    /** Collapsed (icon-only) mode */
    collapsed?: boolean;
    /** Called when collapsed state changes (for toggle button) */
    onCollapsedChange?: (collapsed: boolean) => void;
    /** Extra CSS class on the root element */
    className?: string;
    /** Size variant */
    size?: NiceSize;
    'data-testid'?: string;
}

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;
}

/** 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';
}

/**
 * {@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;
}

/** 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 { }
