@atlashub/smartstack-react 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1492 @@
+import { AxiosInstance } from 'axios';
+import { ElementType } from 'react';
+import { HubConnectionState } from '@microsoft/signalr';
+import { JSX } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import * as signalR from '@microsoft/signalr';
+
+export declare interface AccentColors {
+    bg: string;
+    text: string;
+    border: string;
+}
+
+export declare function AdminHeader({ onMenuToggle }: AdminHeaderProps): JSX.Element;
+
+declare interface AdminHeaderProps {
+    onMenuToggle?: () => void;
+}
+
+export declare function AdminLayout(): JSX.Element;
+
+export declare function AdminSidebar({ isOpen, onClose }: AdminSidebarProps): JSX.Element;
+
+declare interface AdminSidebarProps {
+    isOpen?: boolean;
+    onClose?: () => void;
+}
+
+export declare const api: {
+    get: <T>(url: string, config?: Parameters<typeof apiClient.get>[1]) => Promise<T>;
+    post: <T>(url: string, data?: unknown, config?: Parameters<typeof apiClient.post>[2]) => Promise<T>;
+    put: <T>(url: string, data?: unknown, config?: Parameters<typeof apiClient.put>[2]) => Promise<T>;
+    patch: <T>(url: string, data?: unknown, config?: Parameters<typeof apiClient.patch>[2]) => Promise<T>;
+    delete: <T>(url: string, config?: Parameters<typeof apiClient.delete>[1]) => Promise<T>;
+};
+
+export declare const apiClient: AxiosInstance;
+
+export declare interface ApiError {
+    message: string;
+    details?: Record<string, string[]> | string[];
+    statusCode?: number;
+}
+
+export declare class AppError extends Error {
+    statusCode?: number;
+    details?: Record<string, string[]> | string[];
+    constructor(message: string, statusCode?: number, details?: Record<string, string[]> | string[]);
+}
+
+declare interface ApplicationDto {
+    id: string;
+    code: string;
+    label: string;
+    icon: string | null;
+    route: string | null;
+    displayOrder: number;
+    modules: ModuleDto[];
+}
+
+export declare function AppSwitcher(): JSX.Element;
+
+declare interface AuthContextType {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    availableContexts: NavigationContext[];
+    currentContext: string;
+    login: (token: string, user: User) => void;
+    logout: () => Promise<void>;
+    setCurrentContext: (context: string) => void;
+    hasPermission: (permission: string) => boolean;
+    refreshPermissions: () => Promise<void>;
+}
+
+export declare class AuthenticationError extends Error {
+    code?: LoginErrorCode;
+    constructor(message?: string, code?: LoginErrorCode);
+}
+
+export declare function AuthLayout(): JSX.Element;
+
+export declare function AuthProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare function AvatarMenu(): JSX.Element;
+
+export declare interface BackgroundColors {
+    app: string;
+    primary: string;
+    secondary: string;
+    tertiary: string;
+    card: string;
+    hover: string;
+    active: string;
+}
+
+export declare const BORDER_RADIUS_LABELS: Record<BorderRadiusSize, string>;
+
+export declare const BORDER_RADIUS_VALUES: Record<BorderRadiusSize, string>;
+
+export declare interface BorderColors {
+    default: string;
+    subtle: string;
+    strong: string;
+}
+
+export declare interface BorderRadiusConfig {
+    card: BorderRadiusSize;
+    button: BorderRadiusSize;
+    badge: BorderRadiusSize;
+    input: BorderRadiusSize;
+    modal: BorderRadiusSize;
+    menuItem: BorderRadiusSize;
+}
+
+export declare type BorderRadiusSize = 'none' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';
+
+export declare function Breadcrumb({ items, className }: BreadcrumbProps): JSX.Element;
+
+declare interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    icon?: React.ReactNode;
+}
+
+declare interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    className?: string;
+}
+
+declare interface BrowserInfoDto {
+    name?: string;
+    version?: string;
+    language?: string;
+}
+
+export declare function BusinessHeader({ onMenuToggle }: BusinessHeaderProps): JSX.Element;
+
+declare interface BusinessHeaderProps {
+    onMenuToggle?: () => void;
+}
+
+export declare function BusinessLayout(): JSX.Element;
+
+/**
+ * PermissionMatrix - Composant de matrice de permissions standardisé SmartStack
+ *
+ * Fonctionnalités:
+ * - Grille rows × columns avec états
+ * - Groupes de lignes (collapsibles)
+ * - En-têtes de colonnes rotatifs
+ * - États: granted, denied, partial, inherited
+ * - Click pour toggle
+ * - Légende automatique
+ *
+ * Usage:
+ * ```tsx
+ * <PermissionMatrix
+ *   rows={resources}
+ *   columns={roles}
+ *   getRowId={(r) => r.id}
+ *   getRowLabel={(r) => r.name}
+ *   getRowGroup={(r) => r.category}
+ *   getColumnId={(c) => c.id}
+ *   getColumnLabel={(c) => c.name}
+ *   getCellState={(rowId, colId) => assignments[rowId]?.[colId]}
+ *   onCellClick={(rowId, colId) => toggleAssignment(rowId, colId)}
+ * />
+ * ```
+ */
+declare type CellState = 'granted' | 'denied' | 'partial' | 'inherited' | 'none';
+
+declare interface ClientContextDto {
+    sourceUrl?: string;
+    browser?: BrowserInfoDto;
+    os?: OsInfoDto;
+    device?: DeviceInfoDto;
+    recentErrors?: ErrorInfoDto[];
+    screenshotAttachmentId?: string;
+}
+
+export declare interface ClientErrorLog {
+    message: string;
+    stack?: string;
+    url?: string;
+    component?: string;
+    level?: 'Error' | 'Warning' | 'Critical';
+    metadata?: Record<string, unknown>;
+}
+
+export declare interface ClientEventLog {
+    event: string;
+    category: string;
+    data?: Record<string, unknown>;
+}
+
+export declare interface ColorPalette {
+    name: string;
+    primary: ColorShades;
+    accent: ColorShades;
+    backgrounds: BackgroundColors;
+    text: TextColors;
+    border: BorderColors;
+    status: StatusColors;
+    accentTransparent: AccentColors;
+}
+
+export declare interface ColorShades {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+    950: string;
+}
+
+declare interface ContextMenuDto {
+    id: string;
+    code: string;
+    label: string;
+    icon: string | null;
+    displayOrder: number;
+    applications: ApplicationDto[];
+}
+
+export declare function DataTable<T>({ data, columns, loading, searchable, searchPlaceholder, pagination, onRowClick, getRowKey, emptyMessage, emptyIcon, headerActions, striped, compact, className, selectable, selectedKeys, onSelectionChange, searchFilter, defaultSortKey, defaultSortDirection, }: DataTableProps<T>): JSX.Element;
+
+/**
+ * DataTable - Composant de tableau de données standardisé SmartStack
+ *
+ * Fonctionnalités:
+ * - Tri par colonnes
+ * - Pagination
+ * - Recherche globale
+ * - Colonnes personnalisables
+ * - États vide/chargement
+ * - Sélection de lignes (optionnel)
+ *
+ * Usage:
+ * ```tsx
+ * <DataTable
+ *   data={users}
+ *   columns={[
+ *     { key: 'name', label: 'Nom', sortable: true },
+ *     { key: 'email', label: 'Email', sortable: true },
+ *     { key: 'role', label: 'Rôle', render: (user) => <Badge>{user.role}</Badge> },
+ *   ]}
+ *   pagination={{ pageSize: 10 }}
+ *   searchable
+ *   onRowClick={(user) => navigate(`/users/${user.id}`)}
+ * />
+ * ```
+ */
+declare interface DataTableColumn<T> {
+    /** Unique key (matches data field or custom) */
+    key: string;
+    /** Column header label */
+    label: string;
+    /** Is column sortable */
+    sortable?: boolean;
+    /** Custom render function */
+    render?: (item: T, index: number) => ReactNode;
+    /** Column width (CSS value) */
+    width?: string;
+    /** Column alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Hide on mobile */
+    hideOnMobile?: boolean;
+    /** Sticky column */
+    sticky?: 'left' | 'right';
+}
+
+declare interface DataTablePagination {
+    /** Items per page */
+    pageSize: number;
+    /** Available page sizes */
+    pageSizeOptions?: number[];
+    /** Show page size selector */
+    showSizeSelector?: boolean;
+}
+
+declare interface DataTableProps<T> {
+    /** Data array */
+    data: T[];
+    /** Column definitions */
+    columns: DataTableColumn<T>[];
+    /** Loading state */
+    loading?: boolean;
+    /** Enable global search */
+    searchable?: boolean;
+    /** Search placeholder */
+    searchPlaceholder?: string;
+    /** Pagination config */
+    pagination?: DataTablePagination;
+    /** Row click handler */
+    onRowClick?: (item: T, index: number) => void;
+    /** Get unique key for each row */
+    getRowKey?: (item: T, index: number) => string;
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Empty state icon */
+    emptyIcon?: ReactNode;
+    /** Custom header actions */
+    headerActions?: ReactNode;
+    /** Stripe rows */
+    striped?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Enable row selection */
+    selectable?: boolean;
+    /** Selected row keys */
+    selectedKeys?: Set<string>;
+    /** Selection change handler */
+    onSelectionChange?: (keys: Set<string>) => void;
+    /** Custom search filter function */
+    searchFilter?: (item: T, searchTerm: string) => boolean;
+    /** Default sort column */
+    defaultSortKey?: string;
+    /** Default sort direction */
+    defaultSortDirection?: 'asc' | 'desc';
+}
+
+declare function DataView_2<T>({ data, viewMode: controlledViewMode, onViewModeChange, renderTable, renderCards, renderKanban, showTableView, showCardsView, showKanbanView, tableLabel, cardsLabel, kanbanLabel, }: DataViewProps<T>): JSX.Element;
+export { DataView_2 as DataView }
+
+declare interface DataViewProps<T> {
+    data: T[];
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    renderTable?: (data: T[]) => ReactNode;
+    renderCards?: (data: T[]) => ReactNode;
+    renderKanban?: (data: T[]) => ReactNode;
+    showTableView?: boolean;
+    showCardsView?: boolean;
+    showKanbanView?: boolean;
+    tableLabel?: string;
+    cardsLabel?: string;
+    kanbanLabel?: string;
+}
+
+declare interface DeviceInfoDto {
+    type?: string;
+    screenResolution?: string;
+}
+
+export declare function DocEdgeButton(): JSX.Element | null;
+
+export declare function DocPanel(): JSX.Element | null;
+
+declare interface DocPanelContextType {
+    isOpen: boolean;
+    panelSize: number;
+    docUrl: string | null;
+    openDocPanel: (url?: string) => void;
+    closeDocPanel: () => void;
+    toggleDocPanel: () => void;
+    setPanelSize: (size: number) => void;
+}
+
+export declare function DocPanelProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare function DocsLayout(): JSX.Element;
+
+export declare function DocToggleButton({ className, customDocUrl }: DocToggleButtonProps): JSX.Element;
+
+declare interface DocToggleButtonProps {
+    className?: string;
+    customDocUrl?: string;
+}
+
+export declare function EntityCard({ avatar, title, subtitle, description, stats, badge, links, actions, tags, onClick, className, customHeader, customBody, customFooter, }: EntityCardProps): JSX.Element;
+
+declare interface EntityCardAction {
+    /** Button label */
+    label: string;
+    /** URL (makes it an <a> tag) */
+    href?: string;
+    /** Or onClick handler (makes it a <button>) */
+    onClick?: () => void;
+    /** Button variant */
+    variant?: 'primary' | 'secondary' | 'ghost';
+    /** Optional icon */
+    icon?: ElementType;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Loading state */
+    loading?: boolean;
+}
+
+/**
+ * EntityCard - Composant de card standardisé SmartStack
+ *
+ * Design de référence: /platform/administration/ai/settings (Provider cards)
+ *
+ * Caractéristiques:
+ * - Header coloré distinct avec avatar carré arrondi
+ * - Badge avec tooltip en haut à droite du header
+ * - Corps avec description, stats, liens
+ * - Boutons d'action en bas (push to bottom avec flex)
+ * - Support des couleurs d'accent dynamiques
+ *
+ * Usage:
+ * ```tsx
+ * <EntityCard
+ *   avatar={{ letter: 'O', color: '#10a37f' }}
+ *   title="OpenAI"
+ *   subtitle="openai"
+ *   description="OpenAI GPT models (GPT-4, GPT-4o, GPT-3.5)"
+ *   stats="15 modèle(s)"
+ *   badge={{ icon: Shield, tooltip: 'API Admin supportée' }}
+ *   links={[
+ *     { icon: ExternalLink, label: 'Site officiel', href: 'https://openai.com' },
+ *     { icon: BookOpen, label: 'Documentation API', href: 'https://platform.openai.com/docs' },
+ *   ]}
+ *   actions={[
+ *     { label: 'Obtenir une clé API', href: 'https://...', variant: 'primary', icon: Key },
+ *     { label: 'Obtenir une clé API Admin', href: 'https://...', variant: 'secondary', icon: Shield },
+ *   ]}
+ * />
+ * ```
+ */
+declare interface EntityCardAvatar {
+    /** Single letter to display */
+    letter: string;
+    /** Background color (CSS color) */
+    color: string;
+    /** Optional image URL (replaces letter if provided) */
+    imageUrl?: string;
+}
+
+declare interface EntityCardBadge {
+    /** Icon component */
+    icon?: ElementType;
+    /** Tooltip text */
+    tooltip?: string;
+    /** Custom color override */
+    color?: string;
+}
+
+declare interface EntityCardLink {
+    /** Icon component */
+    icon: ElementType;
+    /** Link label */
+    label: string;
+    /** URL (opens in new tab) */
+    href?: string;
+    /** Or onClick handler */
+    onClick?: () => void;
+}
+
+declare interface EntityCardProps {
+    /** Avatar configuration */
+    avatar?: EntityCardAvatar;
+    /** Card title */
+    title: string;
+    /** Subtitle/code below title */
+    subtitle?: string;
+    /** Description text */
+    description?: string | ReactNode;
+    /** Stats text (e.g., "15 modèle(s)") */
+    stats?: string | ReactNode;
+    /** Optional badge in header top-right */
+    badge?: EntityCardBadge;
+    /** Array of link items */
+    links?: EntityCardLink[];
+    /** Array of action buttons */
+    actions?: EntityCardAction[];
+    /** Array of tags */
+    tags?: EntityCardTag[];
+    /** Click handler for entire card */
+    onClick?: () => void;
+    /** Additional className */
+    className?: string;
+    /** Custom header content (replaces default header) */
+    customHeader?: ReactNode;
+    /** Custom body content (replaces default body) */
+    customBody?: ReactNode;
+    /** Custom footer content (replaces default footer) */
+    customFooter?: ReactNode;
+}
+
+declare interface EntityCardTag {
+    /** Tag label */
+    label: string;
+    /** Tag variant/color */
+    variant?: 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+    /** Click handler (makes tag interactive) */
+    onClick?: () => void;
+}
+
+declare interface ErrorInfoDto {
+    message?: string;
+    stack?: string;
+    component?: string;
+    timestamp?: string;
+}
+
+declare interface FavoriteApplication {
+    id: string;
+    code: string;
+    label: string;
+    icon: string | null;
+    route: string | null;
+    displayOrder: number;
+}
+
+declare interface FavoriteModule {
+    id: string;
+    code: string;
+    label: string;
+    icon: string;
+    route: string;
+    applicationId?: string;
+    applicationCode: string;
+    applicationLabel: string;
+    displayOrder?: number;
+}
+
+declare interface FavoritesContextType {
+    favorites: FavoriteModule[];
+    loading: boolean;
+    error: string | null;
+    addFavorite: (module: FavoriteModule) => Promise<boolean>;
+    removeFavorite: (moduleId: string) => Promise<boolean>;
+    toggleFavorite: (module: FavoriteModule) => Promise<boolean>;
+    isFavorite: (moduleId: string) => boolean;
+    reorderFavorites: (newOrder: FavoriteModule[]) => Promise<boolean>;
+    canAddMore: boolean;
+    maxFavorites: number;
+    reload: () => Promise<void>;
+    expandFavorites: boolean;
+    triggerExpand: () => void;
+    clearExpand: () => void;
+}
+
+export declare function FavoritesProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare function Footer(): JSX.Element;
+
+export declare class ForbiddenError extends Error {
+    constructor(message?: string);
+}
+
+export declare function GlobalErrorBoundary({ children }: GlobalErrorBoundaryProps): JSX.Element;
+
+declare interface GlobalErrorBoundaryProps {
+    children: React.ReactNode;
+}
+
+export declare function Header(): JSX.Element;
+
+declare interface InheritanceMap {
+    [roleId: string]: Map<string, PermissionInheritanceInfo>;
+}
+
+declare interface InheritanceMap_2 {
+    [roleId: string]: Map<string, PermissionInheritanceInfo_2>;
+}
+
+export declare const ITEM_PALETTE_LABELS: Record<ItemPaletteKey, string>;
+
+export declare interface ItemPaletteColors {
+    light: string;
+    medium: string;
+    dark: string;
+    border: string;
+}
+
+export declare type ItemPaletteKey = 'neutral' | 'ocean' | 'forest' | 'sunset' | 'lavender' | 'rose';
+
+export declare function KanbanBoard<T>({ columns, items, getItemId, getItemColumn, onMoveItem, renderCard, loading, onAddItem, onCardClick, cardActions, emptyColumnMessage, className, columnMinWidth, disabled, }: KanbanBoardProps<T>): JSX.Element;
+
+declare interface KanbanBoardProps<T> {
+    /** Column definitions */
+    columns: KanbanColumn[];
+    /** All items */
+    items: T[];
+    /** Get unique item ID */
+    getItemId: (item: T) => string;
+    /** Get item's column ID */
+    getItemColumn: (item: T) => string;
+    /** Move item to new column */
+    onMoveItem: (itemId: string, newColumnId: string, newIndex?: number) => void;
+    /** Render card content */
+    renderCard: (item: T, index: number) => ReactNode;
+    /** Loading state */
+    loading?: boolean;
+    /** Add item handler */
+    onAddItem?: (columnId: string) => void;
+    /** Card click handler */
+    onCardClick?: (item: T) => void;
+    /** Card menu actions */
+    cardActions?: (item: T) => {
+        label: string;
+        onClick: () => void;
+        icon?: ReactNode;
+    }[];
+    /** Empty column message */
+    emptyColumnMessage?: string;
+    /** Custom className */
+    className?: string;
+    /** Column min width */
+    columnMinWidth?: string;
+    /** Disable drag & drop */
+    disabled?: boolean;
+}
+
+/**
+ * KanbanBoard - Composant Kanban drag-and-drop standardisé SmartStack
+ *
+ * Fonctionnalités:
+ * - Colonnes avec compteurs
+ * - Drag & drop des cartes (natif HTML5)
+ * - Actions sur cartes et colonnes
+ * - États vide/chargement
+ * - Personnalisation des cartes
+ *
+ * Usage:
+ * ```tsx
+ * <KanbanBoard
+ *   columns={[
+ *     { id: 'todo', title: 'À faire', color: 'var(--warning-text)' },
+ *     { id: 'in-progress', title: 'En cours', color: 'var(--info-text)' },
+ *     { id: 'done', title: 'Terminé', color: 'var(--success-text)' },
+ *   ]}
+ *   items={tasks}
+ *   getItemColumn={(task) => task.status}
+ *   onMoveItem={(taskId, newColumnId) => updateTask(taskId, { status: newColumnId })}
+ *   renderCard={(task) => <TaskCard task={task} />}
+ * />
+ * ```
+ */
+declare interface KanbanColumn {
+    /** Unique column ID */
+    id: string;
+    /** Column title */
+    title: string;
+    /** Optional color (CSS value) */
+    color?: string;
+    /** Max items in column (optional limit) */
+    maxItems?: number;
+    /** Can add items to this column */
+    canAddItem?: boolean;
+}
+
+export declare function LanguageSwitcher(): JSX.Element;
+
+declare interface LicenseContextType {
+    license: LicenseInfo | null;
+    isLoading: boolean;
+    error: string | null;
+    isFeatureEnabled: (feature: string) => boolean;
+    isReadOnlyMode: boolean;
+    refreshLicense: () => Promise<void>;
+    activateLicense: (key: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+
+declare interface LicenseInfo {
+    productId: string;
+    companyId: string;
+    edition: string;
+    status: string;
+    activatedAt: string | null;
+    expiresAt: string;
+    daysUntilExpiration: number;
+    isValid: boolean;
+    isInTrial: boolean;
+    trialDaysRemaining: number;
+    isReadOnlyMode: boolean;
+    enabledFeatures: string[];
+    limits: LicenseLimits;
+}
+
+declare interface LicenseLimits {
+    users: number;
+    storageGb: number;
+    apiCallsPerDay: number;
+    custom: Record<string, number>;
+}
+
+export declare function LicenseProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare type LoginErrorCode = 'INVALID_CREDENTIALS' | 'ACCOUNT_DISABLED' | 'ACCOUNT_LOCKED' | 'EXTERNAL_AUTH_REQUIRED' | 'INVALID_PASSWORD';
+
+declare class LogService {
+    private queue;
+    private recentErrors;
+    private isProcessing;
+    private batchSize;
+    private batchDelay;
+    logError(error: Error | string, component?: string, metadata?: Record<string, unknown>): Promise<void>;
+    logCritical(error: Error | string, component?: string, metadata?: Record<string, unknown>): Promise<void>;
+    getRecentErrors(): Array<ClientErrorLog & {
+        timestamp: Date;
+    }>;
+    clearRecentErrors(): void;
+    private storeRecentError;
+    logEvent(event: string, category: string, data?: Record<string, unknown>): Promise<void>;
+    private processQueue;
+    private sendError;
+    private sendEvent;
+}
+
+export declare const logService: LogService;
+
+declare interface MatrixFilters {
+    selectedRoleIds: string[];
+    resourceSearch: string;
+    contextFilter: string;
+    applicationFilter: string;
+    moduleFilter: string;
+}
+
+declare interface MatrixFilters_2 {
+    selectedRoleIds: string[];
+    resourceSearch: string;
+    contextFilter: string;
+    applicationFilter: string;
+    moduleFilter: string;
+}
+
+declare interface MatrixRoleDto {
+    id: string;
+    name: string;
+    shortName: string;
+    category: RoleCategory;
+    description: string | null;
+    isSystem: boolean;
+    permissionIds: string[];
+}
+
+declare interface MenuDto {
+    contexts: ContextMenuDto[];
+}
+
+declare interface ModuleDto {
+    id: string;
+    code: string;
+    label: string;
+    icon: string | null;
+    route: string | null;
+    displayOrder: number;
+    sections: SectionDto[];
+}
+
+export declare function ModuleSidebar({ isOpen, onClose }: ModuleSidebarProps): JSX.Element | null;
+
+declare interface ModuleSidebarProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+
+declare interface NavigationContext {
+    code: string;
+    label: string;
+    icon: string;
+    route: string;
+    color: string;
+}
+
+declare interface NavigationContextType {
+    menu: MenuDto | null;
+    favorites: FavoriteApplication[];
+    currentContextCode: string | null;
+    currentAppCode: string | null;
+    currentModuleCode: string | null;
+    isLoading: boolean;
+    getCurrentContext: () => ContextMenuDto | undefined;
+    getCurrentApplication: () => ApplicationDto | undefined;
+    getCurrentModule: () => ModuleDto | undefined;
+    getApplicationsForContext: (contextCode: string) => ApplicationDto[];
+    toggleFavorite: (applicationId: string) => Promise<void>;
+    isFavorite: (applicationId: string) => boolean;
+    refreshMenu: () => Promise<void>;
+}
+
+export declare function NavigationProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare class NetworkError extends Error {
+    constructor(message?: string);
+}
+
+declare interface NotificationDto {
+    id: string;
+    type: string;
+    title: string;
+    message: string;
+    relatedEntityType: string | null;
+    relatedEntityId: string | null;
+    actionUrl: string | null;
+    isRead: boolean;
+    readAt: string | null;
+    createdAt: string;
+}
+
+declare interface OsInfoDto {
+    name?: string;
+    version?: string;
+}
+
+export declare function PageHeader({ title, subtitle, icon, actions, }: PageHeaderProps): JSX.Element;
+
+declare interface PageHeaderProps {
+    title: string;
+    subtitle?: string;
+    icon?: ReactNode;
+    actions?: ReactNode;
+}
+
+declare interface PermissionInheritanceInfo {
+    isDirect: boolean;
+    isInherited: boolean;
+    inheritedFromPath?: string;
+    inheritedFromId?: string;
+}
+
+declare interface PermissionInheritanceInfo_2 {
+    isDirect: boolean;
+    isInherited: boolean;
+    inheritedFromPath?: string;
+    inheritedFromId?: string;
+}
+
+declare interface PermissionListDto {
+    id: string;
+    path: string;
+    level: string;
+    action: string | null;
+    isWildcard: boolean;
+    description: string | null;
+    rolesCount: number;
+}
+
+export declare function PermissionMatrix<R, C>({ rows, columns, getRowId, getRowLabel, getRowGroup, getRowSubGroup, getRowIcon, isRowLocked, getRowChildCount, getColumnId, getColumnLabel, getColumnShortLabel, isColumnLocked, getColumnColor, getCellState, onCellClick, loading, showLegend, searchable, rowColumnWidth, cellWidth, className, emptyMessage, canEditLocked, }: PermissionMatrixProps<R, C>): JSX.Element;
+
+declare interface PermissionMatrixProps<R, C> {
+    /** Row data array */
+    rows: R[];
+    /** Column data array */
+    columns: C[];
+    /** Get unique row ID */
+    getRowId: (row: R) => string;
+    /** Get row display label */
+    getRowLabel: (row: R) => string;
+    /** Get row group (for collapsible sections) */
+    getRowGroup?: (row: R) => string | undefined;
+    /** Get row sub-group */
+    getRowSubGroup?: (row: R) => string | undefined;
+    /** Get row icon */
+    getRowIcon?: (row: R) => ReactNode;
+    /** Is row locked (read-only) */
+    isRowLocked?: (row: R) => boolean;
+    /** Get row child count (for display) */
+    getRowChildCount?: (row: R) => number | undefined;
+    /** Get unique column ID */
+    getColumnId: (col: C) => string;
+    /** Get column display label */
+    getColumnLabel: (col: C) => string;
+    /** Get column short label (for rotated header) */
+    getColumnShortLabel?: (col: C) => string;
+    /** Is column locked (read-only) */
+    isColumnLocked?: (col: C) => boolean;
+    /** Get column color */
+    getColumnColor?: (col: C) => string | undefined;
+    /** Get cell state */
+    getCellState: (rowId: string, colId: string) => CellState;
+    /** Cell click handler */
+    onCellClick?: (rowId: string, colId: string) => void;
+    /** Loading state */
+    loading?: boolean;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Show search */
+    searchable?: boolean;
+    /** Row column width */
+    rowColumnWidth?: string;
+    /** Cell width */
+    cellWidth?: string;
+    /** Custom className */
+    className?: string;
+    /** Empty message */
+    emptyMessage?: string;
+    /** Can edit locked columns */
+    canEditLocked?: boolean;
+}
+
+export declare function PublicLayout(): JSX.Element;
+
+export declare function ResizableMainContent({ children }: ResizableMainContentProps): JSX.Element;
+
+declare interface ResizableMainContentProps {
+    children: ReactNode;
+}
+
+declare interface ResourceDto {
+    id: string;
+    code: string;
+    label: string;
+    route: string | null;
+    displayOrder: number;
+}
+
+declare interface ResourceNode {
+    id: string;
+    path: string;
+    label: string;
+    contextLabel: string;
+    applicationLabel: string;
+    moduleLabel: string;
+    parentModuleLabel?: string;
+    parentModuleId?: string;
+    parentSectionLabel?: string;
+    parentSectionId?: string;
+    level: 'module' | 'section' | 'resource';
+    permissions: ResourcePermission[];
+    totalPermissions: number;
+    childSections?: ResourceNode[];
+    childResources?: ResourceNode[];
+}
+
+declare interface ResourceNode_2 {
+    id: string;
+    path: string;
+    label: string;
+    contextLabel: string;
+    applicationLabel: string;
+    moduleLabel: string;
+    parentModuleLabel?: string;
+    parentModuleId?: string;
+    parentSectionLabel?: string;
+    parentSectionId?: string;
+    level: 'module' | 'section' | 'resource';
+    permissions: ResourcePermission_2[];
+    totalPermissions: number;
+    childSections?: ResourceNode_2[];
+    childResources?: ResourceNode_2[];
+}
+
+declare interface ResourcePermission {
+    id: string;
+    action: string;
+    path: string;
+}
+
+declare interface ResourcePermission_2 {
+    id: string;
+    action: string;
+    path: string;
+}
+
+declare type RoleCategory = 'Global' | 'Admin' | 'Manager' | 'Contributor' | 'Viewer' | 'Custom';
+
+declare interface RoleDto {
+    id: string;
+    name: string;
+    shortName: string;
+    category: RoleCategory;
+    description: string | null;
+}
+
+declare interface RolePermissions {
+    [roleId: string]: Set<string>;
+}
+
+declare interface RolePermissions_2 {
+    [roleId: string]: Set<string>;
+}
+
+declare interface SectionDto {
+    id: string;
+    code: string;
+    label: string;
+    icon: string | null;
+    route: string | null;
+    displayOrder: number;
+    resources: ResourceDto[];
+}
+
+declare interface SessionContextType {
+    isSessionActive: boolean;
+    timeRemainingSeconds: number;
+    isWarning: boolean;
+    refreshSession: () => Promise<boolean>;
+}
+
+declare interface SessionInfoResponse {
+    sessionId: string;
+    loginAt: string;
+    lastActivityAt: string;
+    timeUntilIdleExpirySeconds: number;
+    timeUntilAbsoluteExpirySeconds: number;
+    isWarningThreshold: boolean;
+    idleTimeoutMinutes: number;
+    absoluteTimeoutHours: number;
+    warningThresholdMinutes: number;
+}
+
+export declare function SessionProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+/**
+ * Set the base URL for all API calls.
+ * Call this before making any API requests, typically in your app initialization.
+ */
+export declare function setApiBaseUrl(url: string): void;
+
+declare interface SidebarContextType {
+    isCollapsed: boolean;
+    toggleCollapsed: () => void;
+    setCollapsed: (collapsed: boolean) => void;
+    sidebarWidth: number;
+}
+
+export declare function SidebarProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+/**
+ * Main wrapper component for SmartStack applications.
+ * Provides all necessary contexts and providers.
+ *
+ * @example
+ * ```tsx
+ * import { SmartStackApp, SmartStackRoutes } from '@smartstack/react';
+ *
+ * function App() {
+ *   return (
+ *     <SmartStackApp config={{ apiUrl: 'http://localhost:5142' }}>
+ *       <SmartStackRoutes />
+ *     </SmartStackApp>
+ *   );
+ * }
+ * ```
+ */
+export declare function SmartStackApp({ config, children }: SmartStackAppProps): JSX.Element;
+
+declare interface SmartStackAppProps {
+    /** SmartStack configuration */
+    config: SmartStackConfig;
+    /** Child routes/components */
+    children: React.ReactNode;
+}
+
+/**
+ * Configuration options for SmartStack application
+ */
+export declare interface SmartStackConfig {
+    /** Base URL for the API (e.g., 'http://localhost:5142') */
+    apiUrl: string;
+    /** Enable page tracking */
+    enablePageTracking?: boolean;
+}
+
+/**
+ * All SmartStack routes.
+ * Include this component in your app to get all SmartStack functionality.
+ *
+ * @example
+ * ```tsx
+ * import { SmartStackApp, SmartStackRoutes } from '@smartstack/react';
+ * import { Routes, Route } from 'react-router-dom';
+ *
+ * function App() {
+ *   return (
+ *     <SmartStackApp config={{ apiUrl: 'http://localhost:5142' }}>
+ *       <Routes>
+ *         {/* SmartStack routes *\/}
+ *         <Route path="/*" element={<SmartStackRoutes />} />
+ *         {/* Your custom routes *\/}
+ *         <Route path="/my-module" element={<MyCustomPage />} />
+ *       </Routes>
+ *     </SmartStackApp>
+ *   );
+ * }
+ * ```
+ */
+export declare function SmartStackRoutes(): JSX.Element;
+
+export declare interface StatusColor {
+    bg: string;
+    text: string;
+    border: string;
+    dot: string;
+}
+
+export declare interface StatusColors {
+    success: StatusColor;
+    warning: StatusColor;
+    error: StatusColor;
+    info: StatusColor;
+}
+
+export declare interface TextColors {
+    primary: string;
+    secondary: string;
+    tertiary: string;
+    muted: string;
+    inverse: string;
+}
+
+export declare interface ThemeConfig {
+    mode: ThemeMode;
+    borderRadius: BorderRadiusConfig;
+    colors: {
+        light: ColorPalette;
+        dark: ColorPalette;
+    };
+    accentColorKey: string;
+    itemPaletteKey: ItemPaletteKey;
+}
+
+declare interface ThemeContextType {
+    config: ThemeConfig;
+    mode: ThemeMode;
+    toggleMode: () => void;
+    setMode: (mode: ThemeMode) => void;
+    setBorderRadius: (element: keyof BorderRadiusConfig, size: BorderRadiusSize) => void;
+    setAccentColor: (colorKey: string) => void;
+    setItemPalette: (paletteKey: ItemPaletteKey) => void;
+    applyPreset: (presetConfig: Partial<ThemeConfig>) => void;
+    resetToDefault: () => void;
+    getBorderRadius: (element: keyof BorderRadiusConfig) => string;
+    loadFromServer: () => Promise<void>;
+    isSyncing: boolean;
+}
+
+export declare function ThemeCustomizer(): JSX.Element;
+
+export declare type ThemeMode = 'light' | 'dark';
+
+export declare interface ThemePreset {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    config: Partial<ThemeConfig>;
+}
+
+export declare function ThemeProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare function ThemeSwitcher(): JSX.Element;
+
+declare interface TicketCommentDto {
+    id: string;
+    ticketId: string;
+    userName: string;
+    content: string;
+    isInternal: boolean;
+    isEdited: boolean;
+    createdAt: string;
+}
+
+declare interface TicketUpdateDto {
+    ticketId: string;
+    updateType: string;
+    oldValue?: string;
+    newValue?: string;
+    changedByName?: string;
+    changedAt: string;
+}
+
+export declare function Tooltip({ content, children, position, variant, delay, disabled, className, }: TooltipProps): JSX.Element;
+
+declare type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+
+declare interface TooltipProps {
+    content: ReactNode;
+    children: ReactNode;
+    position?: TooltipPosition;
+    variant?: TooltipVariant;
+    delay?: number;
+    disabled?: boolean;
+    className?: string;
+}
+
+declare type TooltipVariant = 'default' | 'error' | 'warning' | 'success' | 'info';
+
+export declare function UnderDevelopment({ title, description, icon, showBackButton, backUrl, children }: UnderDevelopmentProps): JSX.Element;
+
+declare interface UnderDevelopmentProps {
+    /** Title to display, defaults to i18n key */
+    title?: string;
+    /** Description to display, defaults to i18n key */
+    description?: string;
+    /** Icon to display, defaults to Construction */
+    icon?: React.ReactNode;
+    /** Show back button */
+    showBackButton?: boolean;
+    /** Custom back URL */
+    backUrl?: string;
+    /** Additional content to display below the message */
+    children?: React.ReactNode;
+}
+
+export declare function UnlockAccountModal({ isOpen, onClose, onConfirm, userName, }: UnlockAccountModalProps): JSX.Element | null;
+
+declare interface UnlockAccountModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (reason: UnlockReason, mustChangePassword: boolean) => void;
+    userName: string;
+}
+
+declare const UnlockReason: {
+    readonly PasswordResetMalfunction: 1;
+    readonly FalsePositive: 2;
+    readonly UrgentBusinessNeed: 3;
+    readonly TechnicalSystemError: 4;
+    readonly SupportTicketVerified: 5;
+};
+
+declare type UnlockReason = typeof UnlockReason[keyof typeof UnlockReason];
+
+export declare function useAuth(): AuthContextType;
+
+/**
+ * Hook to capture client context for ticket creation.
+ * Captures browser info, OS info, device type, and recent errors.
+ */
+export declare function useClientContext(): {
+    captureContext: () => ClientContextDto;
+};
+
+/**
+ * Hook to manage collapse/expand state for hierarchical lists.
+ * Used by permission matrix components to track collapsed contexts and applications.
+ */
+export declare function useCollapsibleState(): {
+    collapsedContexts: Set<string>;
+    collapsedApps: Set<string>;
+    toggleContext: (context: string) => void;
+    toggleApp: (appKey: string) => void;
+    expandAll: () => void;
+    collapseAll: (contexts: string[], apps: string[]) => void;
+    isContextCollapsed: (context: string) => boolean;
+    isAppCollapsed: (appKey: string) => boolean;
+};
+
+export declare function useDocPanel(): DocPanelContextType;
+
+declare function useFavorites(): FavoritesContextType;
+export { useFavorites as useFavoriteModules }
+export { useFavorites }
+
+export declare function useLicense(): LicenseContextType;
+
+export declare function useNavigation(): NavigationContextType;
+
+export declare function usePageTracking(): void;
+
+export declare function usePermissionMatrix(options?: UsePermissionMatrixOptions): UsePermissionMatrixResult;
+
+declare interface UsePermissionMatrixOptions {
+    canEditSystemRoles?: boolean;
+}
+
+declare interface UsePermissionMatrixResult {
+    loading: boolean;
+    error: string | null;
+    saveError: string | null;
+    saving: boolean;
+    saveSuccess: boolean;
+    roles: MatrixRoleDto[];
+    resources: ResourceNode[];
+    permissions: Map<string, PermissionListDto>;
+    assignments: RolePermissions;
+    inheritanceMap: InheritanceMap;
+    filters: MatrixFilters;
+    filteredRoles: MatrixRoleDto[];
+    filteredResources: ResourceNode[];
+    hasChanges: boolean;
+    canEditSystemRoles: boolean;
+    contexts: string[];
+    applications: {
+        context: string;
+        app: string;
+        label: string;
+    }[];
+    modules: {
+        context: string;
+        app: string;
+        module: string;
+        label: string;
+    }[];
+    togglePermission: (roleId: string, permissionId: string) => void;
+    toggleAllForRole: (roleId: string, grant: boolean) => void;
+    toggleAllForResource: (resourceNode: ResourceNode, grant: boolean) => void;
+    updateFilters: (filters: Partial<MatrixFilters>) => void;
+    reloadData: () => Promise<void>;
+    resetChanges: () => void;
+    saveChanges: () => Promise<void>;
+    clearSaveError: () => void;
+    getPermissionInheritance: (roleId: string, permissionId: string) => PermissionInheritanceInfo;
+}
+
+export declare function usePermissionSync(): {
+    isConnected: boolean;
+    connectionState: HubConnectionState;
+    isAuthenticated: boolean;
+};
+
+declare interface User {
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    roles: string[];
+    permissions: string[];
+}
+
+declare interface UserDetailDto {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    fullName: string;
+    isActive: boolean;
+    userType: string;
+    roles: RoleDto[];
+    lastLoginAt: string | null;
+    createdAt: string;
+    updatedAt: string | null;
+    isLocked: boolean;
+    lockoutEnd: string | null;
+    lastUnlockReason: number | null;
+    lockedBy: string | null;
+    lockedAt: string | null;
+    isTemporarilyLocked: boolean;
+    temporaryLockoutEnd: string | null;
+    entraObjectId: string | null;
+    authProvider: string | null;
+    lastEntraSyncAt: string | null;
+    entraUserPurpose: string | null;
+    departmentId: string | null;
+    departmentName: string | null;
+    jobTitleId: string | null;
+    jobTitleName: string | null;
+    companyId: string | null;
+    companyName: string | null;
+    officeId: string | null;
+    officeName: string | null;
+    employeeId: string | null;
+    employeeType: string | null;
+    employeeHireDate: string | null;
+    employeeOrgData: string | null;
+    managerId: string | null;
+    managerName: string | null;
+    sponsors: string | null;
+    phoneNumber: string | null;
+    mobilePhone: string | null;
+    faxNumber: string | null;
+    streetAddress: string | null;
+    city: string | null;
+    state: string | null;
+    postalCode: string | null;
+    country: string | null;
+    otherEmails: string | null;
+    proxyAddresses: string | null;
+    imAddresses: string | null;
+    mailNickname: string | null;
+    emailConfirmed: boolean;
+    hasCompletedOnboarding: boolean;
+    mustChangePassword: boolean;
+}
+
+export declare function UserHeader({ onMenuToggle }: UserHeaderProps): JSX.Element;
+
+declare interface UserHeaderProps {
+    onMenuToggle?: () => void;
+}
+
+export declare function UserLayout(): JSX.Element;
+
+export declare function UserSidebar({ isOpen, onClose }: UserSidebarProps): JSX.Element;
+
+declare interface UserSidebarProps {
+    isOpen?: boolean;
+    onClose?: () => void;
+}
+
+export declare function useSession(): SessionContextType;
+
+export declare function useSessionMonitor(options?: UseSessionMonitorOptions): {
+    isRefreshing: boolean;
+    refreshSession: () => Promise<boolean>;
+    checkSession: () => Promise<void>;
+    isActive: boolean;
+    timeRemainingSeconds: number;
+    isWarning: boolean;
+    sessionInfo: SessionInfoResponse | null;
+};
+
+declare interface UseSessionMonitorOptions {
+    checkIntervalMs?: number;
+    onSessionExpired?: () => void;
+    onWarningThreshold?: () => void;
+    enabled?: boolean;
+}
+
+export declare function useSidebar(): SidebarContextType;
+
+export declare function useSignalR(options?: UseSignalROptions): {
+    connectionState: signalR.HubConnectionState;
+    isConnected: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+};
+
+declare interface UseSignalROptions {
+    onNotification?: (notification: NotificationDto) => void;
+    onUnreadCountUpdate?: (count: number) => void;
+    onPermissionsChanged?: () => void;
+    onConnectionStateChange?: (state: signalR.HubConnectionState) => void;
+}
+
+export declare function useTheme(): ThemeContextType;
+
+export declare function useTicketSignalR(options: UseTicketSignalROptions): {
+    connectionState: signalR.HubConnectionState;
+    isConnected: boolean;
+    joinTicket: (id: string) => Promise<void>;
+    leaveTicket: (id: string) => Promise<void>;
+};
+
+declare interface UseTicketSignalROptions {
+    ticketId: string | undefined;
+    onCommentAdded?: (comment: TicketCommentDto) => void;
+    onTicketUpdated?: (update: TicketUpdateDto) => void;
+    onConnectionStateChange?: (state: signalR.HubConnectionState) => void;
+}
+
+export declare function useUserPermissions(options: UseUserPermissionsOptions): UseUserPermissionsResult;
+
+declare interface UseUserPermissionsOptions {
+    userId: string;
+}
+
+declare interface UseUserPermissionsResult {
+    loading: boolean;
+    error: string | null;
+    user: UserDetailDto | null;
+    userRoles: RoleDto[];
+    resources: ResourceNode_2[];
+    assignments: RolePermissions_2;
+    inheritanceMap: InheritanceMap_2;
+    effectivePermissions: Set<string>;
+    filters: MatrixFilters_2;
+    filteredResources: ResourceNode_2[];
+    contexts: string[];
+    applications: {
+        context: string;
+        app: string;
+        label: string;
+    }[];
+    modules: {
+        context: string;
+        app: string;
+        module: string;
+        label: string;
+    }[];
+    updateFilters: (filters: Partial<MatrixFilters_2>) => void;
+    getPermissionInheritance: (roleId: string, permissionId: string) => PermissionInheritanceInfo_2;
+    getPermissionSources: (permissionId: string) => RoleDto[];
+    reloadData: () => Promise<void>;
+}
+
+declare type ViewMode = 'table' | 'cards' | 'kanban';
+
+export { }