@anymux/ui-kit 0.1.0

package/dist/index-kHr9udZD.d.ts

@@ -0,0 +1,1025 @@
+import React$1 from "react";
+import * as mobx0 from "mobx";
+import * as mobx1 from "mobx";
+import * as mobx2 from "mobx";
+import * as mobx3 from "mobx";
+import * as mobx4 from "mobx";
+import * as mobx5 from "mobx";
+import * as mobx_dist_internal6 from "mobx/dist/internal";
+import * as mobx_dist_internal7 from "mobx/dist/internal";
+
+//#region src/tree/types/TreeTypes.d.ts
+/**
+* Core type definitions for TreeComponent
+*
+* These types define the fundamental data structures used throughout
+* the tree component system, including node data, loading results,
+* and configuration options.
+*/
+/**
+* Represents a single node in the tree structure
+*
+* This interface defines the core properties that every tree node must have,
+* along with optional properties for enhanced functionality like lazy loading,
+* custom styling, and metadata storage.
+*/
+/**
+ * Core type definitions for TreeComponent
+ *
+ * These types define the fundamental data structures used throughout
+ * the tree component system, including node data, loading results,
+ * and configuration options.
+ */
+/**
+ * Represents a single node in the tree structure
+ *
+ * This interface defines the core properties that every tree node must have,
+ * along with optional properties for enhanced functionality like lazy loading,
+ * custom styling, and metadata storage.
+ */
+interface TreeNodeData {
+  /** Unique identifier for the node */
+  id: string;
+  /** Display name of the node */
+  name: string;
+  /** Full path or identifier for the node */
+  path: string;
+  /** Type of node (file, directory, custom types) */
+  type: 'file' | 'directory' | string;
+  /** Whether this node has children (for lazy loading) */
+  hasChildren?: boolean;
+  /** Child nodes (if loaded) */
+  children?: TreeNodeData[];
+  /** Custom metadata for the node */
+  metadata?: Record<string, any>;
+  /** Size in bytes (for files) */
+  size?: number;
+  /** Last modified date */
+  lastModified?: Date;
+  /** Custom icon identifier */
+  icon?: string;
+  /** Custom CSS class */
+  className?: string;
+  /** Whether the node is disabled */
+  disabled?: boolean;
+  /** Custom render data for this specific node */
+  renderData?: Record<string, any>;
+}
+/**
+ * Result of loading tree nodes
+ *
+ * This interface defines what providers return when loading tree data,
+ * including the nodes themselves and metadata about the loading operation.
+ */
+interface TreeLoadResult {
+  /** The loaded nodes */
+  nodes: TreeNodeData[];
+  /** Whether there are more nodes to load */
+  hasMore?: boolean;
+  /** Total count of nodes (for virtual scrolling) */
+  totalCount?: number;
+  /** Any loading errors */
+  error?: Error;
+}
+/**
+ * Configuration options for loading tree data
+ */
+interface TreeLoadOptions {
+  /**
+   * Filter to apply when loading nodes
+   */
+  filter?: string;
+  /**
+   * Whether to force reload even if data is cached
+   */
+  forceReload?: boolean;
+  /**
+   * Maximum depth to load initially
+   */
+  maxDepth?: number;
+}
+/**
+ * Context menu item definition
+ */
+interface TreeContextMenuItem {
+  /**
+   * Unique identifier for the menu item
+   */
+  id: string;
+  /**
+   * Display label for the menu item
+   */
+  label: string;
+  /**
+   * Optional icon for the menu item
+   */
+  icon?: string;
+  /**
+   * Whether the menu item is disabled
+   */
+  disabled?: boolean;
+  /**
+   * Whether to show a separator after this item
+   */
+  separator?: boolean;
+  /**
+   * Type of menu item (for separators)
+   */
+  type?: 'separator' | 'item';
+  /**
+   * Handler function for menu item clicks
+   */
+  handler?: (node: TreeNodeData) => void;
+  /**
+   * Submenu items (for nested menus)
+   */
+  submenu?: TreeContextMenuItem[];
+}
+/**
+ * Context menu event data
+ */
+interface TreeContextMenuEvent {
+  /**
+   * The menu item that was clicked
+   */
+  menuItem: TreeContextMenuItem;
+  /**
+   * The nodes that the context menu was triggered for
+   */
+  nodes: TreeNodeData[];
+  /**
+   * The mouse event that triggered the menu
+   */
+  originalEvent: MouseEvent;
+}
+/**
+ * Column configuration for table view display
+ */
+interface TreeTableColumn {
+  /** Unique identifier for the column */
+  id: string;
+  /** Display label for the column header */
+  label: string;
+  /** Property path in TreeNodeData to display (supports dot notation) */
+  dataKey: string;
+  /** Column width (CSS value) */
+  width?: string;
+  /** Minimum width (CSS value) */
+  minWidth?: string;
+  /** Column alignment */
+  align?: 'left' | 'center' | 'right';
+  /** Whether column is sortable */
+  sortable?: boolean;
+  /** Whether column is filterable */
+  filterable?: boolean;
+  /** Whether this column displays the tree hierarchy */
+  isTreeColumn?: boolean;
+  /** Custom CSS classes for the column */
+  className?: string;
+  /** Custom cell renderer function */
+  renderCell?: (value: any, node: TreeNodeData) => React.ReactNode;
+  /** Custom value formatter */
+  formatValue?: (value: any, node: TreeNodeData) => string;
+}
+/**
+ * Sort configuration for table view
+ */
+interface TreeTableSort {
+  /** Column ID to sort by */
+  columnId: string;
+  /** Sort direction */
+  direction: 'asc' | 'desc';
+}
+/**
+ * Export configuration for table view
+ */
+interface TreeTableExportOptions {
+  /** Export format */
+  format: 'csv' | 'json' | 'tsv';
+  /** Column IDs to include (empty = all columns) */
+  columns?: string[];
+  /** Whether to include hierarchy structure */
+  includeHierarchy?: boolean;
+  /** Whether to flatten nested data */
+  flatten?: boolean;
+  /** Custom filename for download */
+  filename?: string;
+}
+/**
+ * Selection theme color scheme
+ */
+type SelectionColorScheme = 'primary' | 'secondary' | 'accent' | 'custom';
+/**
+ * Selection intensity levels
+ */
+type SelectionIntensity = 'subtle' | 'prominent' | 'high-contrast';
+/**
+ * Focus indicator style
+ */
+type FocusIndicatorStyle = 'ring' | 'outline' | 'border' | 'underline';
+/**
+ * Enhanced selection theme configuration
+ */
+interface TreeSelectionTheme {
+  /** Color scheme for selection highlighting */
+  colorScheme: SelectionColorScheme;
+  /** Selection intensity level */
+  intensity: SelectionIntensity;
+  /** Focus indicator style */
+  focusStyle: FocusIndicatorStyle;
+  /** Custom colors when using 'custom' color scheme */
+  customColors?: {
+    /** Background color for selected items */
+    background: string;
+    /** Text color for selected items */
+    foreground: string;
+    /** Border/focus color */
+    accent: string;
+  };
+  /** Whether to animate selection changes */
+  animated?: boolean;
+  /** Whether to show selection even when component loses focus */
+  persistSelection?: boolean;
+} //#endregion
+//#region src/tree/providers/TreeProvider.d.ts
+
+//# sourceMappingURL=TreeTypes.d.ts.map
+interface TreeNodeRenderer {
+  /** Render node as string (for non-React environments) */
+  renderText?(node: TreeNodeData): string;
+  /** Render node icon as string/identifier */
+  renderIcon?(node: TreeNodeData): string;
+  /** Get node display properties */
+  getDisplayProps?(node: TreeNodeData): {
+    className?: string;
+    style?: Record<string, string>;
+    title?: string;
+    ariaLabel?: string;
+  };
+  /** Custom React component for node (if in React environment) */
+  renderComponent?: React$1.ComponentType<{
+    node: TreeNodeData;
+    [key: string]: any;
+  }>;
+}
+interface TreeDragDropInfo {
+  /** Source node being dragged */
+  sourceNode: TreeNodeData;
+  /** Target node being dropped on */
+  targetNode: TreeNodeData;
+  /** Drop position relative to target */
+  position: 'before' | 'after' | 'inside';
+  /** Additional drag data */
+  dragData?: any;
+}
+interface TreeSelectionInfo {
+  /** Selected nodes */
+  selectedNodes: TreeNodeData[];
+  /** Previously selected nodes */
+  previousSelection: TreeNodeData[];
+  /** Selection type */
+  selectionType: 'single' | 'multi' | 'range';
+  /** Selection trigger */
+  trigger: 'click' | 'keyboard' | 'api';
+}
+interface TreeProvider {
+  /** Provider identifier */
+  readonly id: string;
+  /** Human-readable name */
+  readonly name: string;
+  /** Provider version */
+  readonly version: string;
+  /**
+   * Whether multi-selection is enabled
+   */
+  isMultiSelectEnabled: boolean;
+  /**
+   * Whether drag and drop is enabled
+   */
+  readonly isDragDropEnabled: boolean;
+  /**
+   * Whether virtualization is enabled for large trees
+   */
+  readonly isVirtualizationEnabled: boolean;
+  /**
+   * Whether to use checkbox-based selection instead of highlight selection
+   */
+  readonly useCheckboxSelection?: boolean;
+  /**
+   * Whether to allow partial (indeterminate) checkbox selection for parent nodes
+   */
+  readonly allowPartialSelection?: boolean;
+  /**
+   * Whether table view is enabled for this provider
+   */
+  readonly isTableViewEnabled?: boolean;
+  /**
+   * Get virtualization configuration
+   */
+  getVirtualizationConfig?(): {
+    itemHeight: number;
+    overscan: number;
+    threshold: number;
+  };
+  /**
+   * Get table column configuration for table view
+   */
+  getTableColumns?(): TreeTableColumn[];
+  /**
+   * Get default sort configuration for table view
+   */
+  getDefaultTableSort?(): TreeTableSort | null;
+  /**
+   * Get selection theme configuration
+   */
+  getSelectionTheme?(): TreeSelectionTheme;
+  /**
+   * Load tree nodes
+   * @param options Loading options
+   * @returns Promise resolving to loaded nodes
+   */
+  loadNodes(options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Load children for a specific node
+   * @param node Parent node
+   * @param options Loading options
+   * @returns Promise resolving to child nodes
+   */
+  loadChildren(node: TreeNodeData, options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Refresh/reload nodes
+   * @param path Specific path to refresh (optional)
+   * @returns Promise resolving to refreshed nodes
+   */
+  refresh(path?: string): Promise<TreeLoadResult>;
+  /**
+   * Search nodes
+   * @param query Search query
+   * @param options Search options
+   * @returns Promise resolving to search results
+   */
+  search?(query: string, options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Get context menu items for a specific node
+   * @param node Target node
+   * @returns Array of context menu items
+   */
+  getNodeContextMenu?(node: TreeNodeData): TreeContextMenuItem[];
+  /**
+   * Get context menu items for multiple selected nodes
+   * @param nodes Selected nodes
+   * @returns Array of context menu items
+   */
+  getMultiNodeContextMenu?(nodes: TreeNodeData[]): TreeContextMenuItem[];
+  /**
+   * Get context menu items for empty space (no node)
+   * @param parentNode Parent node where right-click occurred
+   * @returns Array of context menu items
+   */
+  getEmptySpaceContextMenu?(parentNode?: TreeNodeData): TreeContextMenuItem[];
+  /**
+   * Get custom renderer for a specific node
+   * @param node Target node
+   * @returns Node renderer or null for default rendering
+   */
+  getNodeRenderer?(node: TreeNodeData): TreeNodeRenderer | null;
+  /**
+   * Get default renderer for all nodes of this provider
+   * @returns Default node renderer
+   */
+  getDefaultRenderer?(): TreeNodeRenderer;
+  /**
+   * Get custom icon for a node
+   * @param node Target node
+   * @returns Icon identifier or component
+   */
+  getNodeIcon?(node: TreeNodeData): string | React$1.ComponentType<any>;
+  /**
+   * Check if a node can be expanded
+   * @param node Target node
+   * @returns Whether node can be expanded
+   */
+  canExpand?(node: TreeNodeData): boolean;
+  /**
+   * Check if a node can be selected
+   * @param node Target node
+   * @returns Whether node can be selected
+   */
+  canSelect?(node: TreeNodeData): boolean;
+  /**
+   * Check if nodes can be dragged
+   * @param nodes Nodes to check
+   * @returns Whether nodes can be dragged
+   */
+  canDrag?(nodes: TreeNodeData[]): boolean;
+  /**
+   * Check if a drop operation is allowed
+   * @param dragInfo Drag and drop information
+   * @returns Whether drop is allowed
+   */
+  canDrop?(dragInfo: TreeDragDropInfo): boolean;
+  /**
+   * Called when node selection changes
+   * @param selectionInfo Selection information
+   */
+  onSelectionChange?(selectionInfo: TreeSelectionInfo): void;
+  /**
+   * Called when a node is expanded or collapsed
+   * @param node Target node
+   * @param expanded New expansion state
+   */
+  onNodeExpansion?(node: TreeNodeData, expanded: boolean): void;
+  /**
+   * Called when a node is double-clicked
+   * @param node Target node
+   */
+  onNodeDoubleClick?(node: TreeNodeData): void;
+  /**
+   * Called when a drag and drop operation completes
+   * @param dragInfo Drag and drop information
+   * @returns Promise resolving when operation is complete
+   */
+  onDragDrop?(dragInfo: TreeDragDropInfo): Promise<void>;
+  /**
+   * Called when a context menu item is selected
+   * @param menuItemId Menu item identifier
+   * @param node Target node (or nodes for multi-selection)
+   */
+  onContextMenuAction?(menuItemId: string, nodes: TreeNodeData[]): void;
+  /**
+   * Called when a node is focused
+   * @param node Target node or null if focus lost
+   */
+  onNodeFocus?(node: TreeNodeData | null): void;
+  /**
+   * Called when table sort changes
+   * @param sort New sort configuration
+   */
+  onTableSort?(sort: TreeTableSort | null): void;
+  /**
+   * Called when table data export is requested
+   * @param options Export configuration
+   * @returns Promise resolving to exported data or download trigger
+   */
+  onTableExport?(options: TreeTableExportOptions): Promise<string | void>;
+  /**
+   * Initialize the provider
+   * @returns Promise resolving when initialization is complete
+   */
+  initialize?(): Promise<void>;
+  /**
+   * Cleanup provider resources
+   */
+  dispose?(): void;
+  /**
+   * Provider-specific configuration
+   */
+  readonly config?: Record<string, any>;
+} //#endregion
+//#region src/tree/providers/TestTreeProvider.d.ts
+
+//# sourceMappingURL=TreeProvider.d.ts.map
+declare class TestTreeProvider implements TreeProvider {
+  readonly id = "test-tree-provider";
+  readonly name = "Test Tree Provider";
+  readonly version = "1.0.0";
+  isMultiSelectEnabled: boolean;
+  readonly isDragDropEnabled = false;
+  readonly isVirtualizationEnabled = false;
+  readonly isTableViewEnabled = true;
+  useCheckboxSelection: boolean;
+  readonly allowPartialSelection = true;
+  readonly config: {};
+  selectionTheme: TreeSelectionTheme;
+  slowLoading: boolean;
+  simulateErrors: boolean;
+  maxDepth: number;
+  nodesPerLevel: number;
+  loadingDelay: number;
+  onSelectionChange?: (selectionInfo: TreeSelectionInfo) => void;
+  onNodeExpansion?: (node: TreeNodeData, isExpanded: boolean) => void;
+  onNodeFocus?: (node: TreeNodeData | null) => void;
+  constructor();
+  /**
+   * Update selection theme reactively
+   */
+  updateSelectionTheme: (theme: Partial<TreeSelectionTheme>) => void;
+  /**
+   * Update multi-select setting
+   */
+  setMultiSelectEnabled: (enabled: boolean) => void;
+  /**
+   * Update checkbox selection setting
+   */
+  setCheckboxSelection: (enabled: boolean) => void;
+  /**
+   * Get selection theme configuration
+   */
+  getSelectionTheme(): TreeSelectionTheme;
+  /**
+   * Load tree nodes
+   */
+  loadNodes(options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Load child nodes for a given parent
+   */
+  loadChildren(node: TreeNodeData, options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Refresh tree data
+   */
+  refresh(path?: string): Promise<TreeLoadResult>;
+  canExpand(node: TreeNodeData): boolean;
+  canSelect(node: TreeNodeData): boolean;
+  getNodeContextMenu(node: TreeNodeData): TreeContextMenuItem[];
+  getMultiNodeContextMenu(nodes: TreeNodeData[]): TreeContextMenuItem[];
+  onContextMenuAction(menuItemId: string, nodes: TreeNodeData[]): void;
+  getTableColumns(): TreeTableColumn[];
+  getDefaultTableSort(): TreeTableSort;
+  onTableSort(sort: TreeTableSort | null): void;
+  onTableExport(options: TreeTableExportOptions): Promise<string | void>;
+  private simulateDelay;
+  private generateMockNodes;
+  private generateFileName;
+  private getFolderDescription;
+  private getFileCategory;
+  private getFileDescription;
+  /**
+   * Get custom icon for a node based on file type and category
+   */
+  getNodeIcon(node: TreeNodeData): string | React$1.ComponentType<any>;
+}
+
+//#endregion
+//#region src/tree/providers/SimpleTreeProvider.d.ts
+//# sourceMappingURL=TestTreeProvider.d.ts.map
+interface SimpleTreeProviderOptions {
+  /** Whether to enable multi-select functionality */
+  enableMultiSelect?: boolean;
+  /** Whether to enable drag and drop */
+  enableDragDrop?: boolean;
+  /** Static tree data to display */
+  data?: TreeNodeData[];
+  /** Custom context menu items */
+  contextMenuItems?: TreeContextMenuItem[];
+  /** Callback when nodes are selected */
+  onSelectionChange?: (selectionInfo: TreeSelectionInfo) => void;
+  /** Callback when context menu actions are triggered */
+  onContextMenuAction?: (actionId: string, nodes: TreeNodeData[]) => void;
+}
+declare class SimpleTreeProvider implements TreeProvider {
+  readonly id = "simple-tree-provider";
+  readonly name = "Simple Tree Provider";
+  readonly version = "1.0.0";
+  isMultiSelectEnabled: boolean;
+  readonly isDragDropEnabled = false;
+  readonly isVirtualizationEnabled = false;
+  readonly isTableViewEnabled = false;
+  useCheckboxSelection: boolean;
+  readonly allowPartialSelection = true;
+  readonly config: {};
+  selectionTheme: TreeSelectionTheme;
+  private nodes;
+  private contextMenuItems;
+  onSelectionChange?: (selectionInfo: TreeSelectionInfo) => void;
+  onNodeExpansion?: (node: TreeNodeData, isExpanded: boolean) => void;
+  onNodeFocus?: (node: TreeNodeData | null) => void;
+  onContextMenuAction?: (actionId: string, nodes: TreeNodeData[]) => void;
+  constructor(options?: SimpleTreeProviderOptions);
+  /**
+   * Load root nodes
+   */
+  loadNodes(options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Load children for a specific node
+   */
+  loadChildren(node: TreeNodeData, options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  /**
+   * Refresh/reload nodes
+   */
+  refresh(path?: string): Promise<TreeLoadResult>;
+  /**
+   * Get context menu for a single node
+   */
+  getNodeContextMenu(node: TreeNodeData): TreeContextMenuItem[];
+  /**
+   * Get context menu for multiple selected nodes
+   */
+  getMultiNodeContextMenu(nodes: TreeNodeData[]): TreeContextMenuItem[];
+  /**
+   * Get selection theme configuration
+   */
+  getSelectionTheme(): TreeSelectionTheme;
+  /**
+   * Update the static data
+   */
+  setData(data: TreeNodeData[]): void;
+  /**
+   * Get current data
+   */
+  getData(): TreeNodeData[];
+  /**
+   * Add a new node to the tree
+   */
+  addNode(parentPath: string | null, newNode: TreeNodeData): boolean;
+  /**
+   * Remove a node from the tree
+   */
+  removeNode(nodePath: string): boolean;
+  /**
+   * Find a node by its path
+   */
+  findNodeByPath(path: string): TreeNodeData | null;
+  /**
+   * Create default sample data
+   */
+  private createDefaultData;
+  /**
+   * Create default context menu items
+   */
+  private createDefaultContextMenu;
+  /**
+   * Helper method to remove node from children recursively
+   */
+  private removeNodeFromChildren;
+  /**
+   * Update selection theme reactively
+   */
+  updateSelectionTheme: (theme: Partial<TreeSelectionTheme>) => void;
+  /**
+   * Update multi-select setting
+   */
+  setMultiSelectEnabled: (enabled: boolean) => void;
+  /**
+   * Update checkbox selection setting
+   */
+  setCheckboxSelection: (enabled: boolean) => void;
+}
+
+//#endregion
+//#region src/tree/components/TreeCheckbox.d.ts
+//# sourceMappingURL=SimpleTreeProvider.d.ts.map
+type CheckboxState = 'unchecked' | 'checked' | 'indeterminate';
+interface TreeCheckboxProps {
+  /** Current checkbox state */
+  state: CheckboxState;
+  /** Callback when checkbox is clicked */
+  onChange: (newState: CheckboxState) => void;
+  /** Whether the checkbox is disabled */
+  disabled?: boolean;
+  /** Additional CSS classes */
+  className?: string;
+  /** ARIA label for accessibility */
+  ariaLabel?: string;
+  /** Size of the checkbox */
+  size?: 'sm' | 'md' | 'lg';
+  /** Node ID for logging purposes */
+  nodeId?: string;
+}
+/**
+ * TreeCheckbox Component - 3-state checkbox for tree selection
+ */
+declare const TreeCheckbox: React$1.FunctionComponent<TreeCheckboxProps>;
+
+//#endregion
+//#region src/tree/models/TreeModel.d.ts
+//# sourceMappingURL=TreeCheckbox.d.ts.map
+declare class TreeModel {
+  provider: TreeProvider;
+  nodes: TreeNodeData[];
+  nodeMap: mobx0.ObservableMap<string, TreeNodeData>;
+  isLoading: boolean;
+  errors: mobx1.ObservableMap<string, Error>;
+  selectedNodes: mobx2.ObservableMap<string, TreeNodeData>;
+  focusedNode: string | null;
+  checkboxStates: mobx3.ObservableMap<string, CheckboxState>;
+  expandedNodes: mobx4.ObservableMap<string, boolean>;
+  loadingNodes: mobx5.ObservableMap<string, boolean>;
+  contextMenuVisible: boolean;
+  contextMenuPosition: {
+    x: number;
+    y: number;
+  };
+  contextMenuItems: TreeContextMenuItem[];
+  contextMenuNodes: TreeNodeData[];
+  constructor(provider: TreeProvider);
+  /**
+   * Whether the tree has any nodes loaded
+   */
+  get hasNodes(): boolean;
+  /**
+   * Total count of nodes currently loaded
+   */
+  get nodeCount(): number;
+  /**
+   * Whether data has been loaded (regardless of success/failure)
+   */
+  get isLoaded(): boolean;
+  /**
+   * Array of currently selected nodes (computed from selectedNodes map)
+   */
+  get selectedNodesArray(): TreeNodeData[];
+  /**
+   * Whether any nodes are currently selected
+   */
+  get hasSelection(): boolean;
+  /**
+   * Check if a specific node is selected
+   */
+  isNodeSelected(nodeId: string): boolean;
+  /**
+   * Check if a specific node is expanded
+   */
+  isNodeExpanded(nodeId: string): boolean;
+  /**
+   * Check if a specific node is loading
+   */
+  isNodeLoading(nodeId: string): boolean;
+  /**
+   * Load nodes from the provider
+   * Uses MobX flow for proper async action handling
+   */
+  loadNodes: (options?: TreeLoadOptions | undefined) => mobx_dist_internal6.CancellablePromise<void>;
+  /**
+   * Select a specific node
+   * @param node Node to select
+   */
+  selectNode(node: TreeNodeData): void;
+  /**
+   * Deselect a specific node
+   * @param node Node to deselect
+   */
+  deselectNode(node: TreeNodeData): void;
+  /**
+   * Clear all selected nodes
+   */
+  clearSelection(): void;
+  /**
+   * Select all nodes (only if multi-select is enabled)
+   */
+  selectAll(): void;
+  /**
+   * Get checkbox state for a specific node
+   */
+  getCheckboxState(nodeId: string): CheckboxState;
+  /**
+   * Handle checkbox click for a node
+   */
+  handleCheckboxChange(node: TreeNodeData, newState: CheckboxState): void;
+  /**
+   * Update all child checkboxes when parent state changes
+   */
+  private updateChildCheckboxes;
+  /**
+   * Update parent checkbox state based on children
+   */
+  private updateParentCheckboxes;
+  /**
+   * Find parent node of a given node ID
+   */
+  private findParentNode;
+  /**
+   * Set focus to a specific node
+   * @param nodeId ID of node to focus
+   */
+  setFocus(nodeId: string): void;
+  /**
+   * Move focus to next visible node
+   */
+  focusNext(): boolean;
+  /**
+   * Move focus to previous visible node
+   */
+  focusPrevious(): boolean;
+  /**
+   * Move focus to first visible node
+   */
+  focusFirst(): boolean;
+  /**
+   * Move focus to last visible node
+   */
+  focusLast(): boolean;
+  /**
+   * Get flattened list of all currently visible nodes
+   * @private
+   */
+  private getFlattenedVisibleNodes;
+  /**
+   * Expand a specific node
+   * @param node Node to expand
+   */
+  expandNode: (node: TreeNodeData) => mobx_dist_internal7.CancellablePromise<void>;
+  /**
+   * Collapse a specific node
+   * @param node Node to collapse
+   */
+  collapseNode(node: TreeNodeData): void;
+  /**
+   * Toggle expansion state of a specific node
+   * @param node Node to toggle
+   */
+  toggleExpansion(node: TreeNodeData): void;
+  /**
+   * Show context menu for a specific node
+   * @param node Target node
+   * @param event Mouse event
+   */
+  showContextMenu(node: TreeNodeData, event: MouseEvent): void;
+  /**
+   * Show context menu for multiple selected nodes
+   * @param nodes Selected nodes
+   * @param event Mouse event
+   */
+  showMultiNodeContextMenu(nodes: TreeNodeData[], event: MouseEvent): void;
+  /**
+   * Hide context menu
+   */
+  hideContextMenu(): void;
+  /**
+   * Handle context menu item click
+   * @param menuItem Clicked menu item
+   */
+  handleContextMenuAction(menuItem: TreeContextMenuItem): void;
+}
+
+//#endregion
+//#region src/tree/components/Tree.d.ts
+//# sourceMappingURL=TreeModel.d.ts.map
+interface TreeProps {
+  /** Provider that supplies tree data and operations */
+  provider: TreeProvider;
+  /** Optional pre-created TreeModel (if provided, component won't create its own) */
+  model?: TreeModel;
+  /** Optional loading options to pass to the provider */
+  loadOptions?: TreeLoadOptions;
+  /** Additional CSS classes to apply to the tree container */
+  className?: string;
+}
+/**
+ * Tree Component - Reactive tree display with loading states
+ *
+ * This is the main tree component that:
+ * - Creates and manages TreeModel
+ * - Shows loading/error states
+ * - Renders tree nodes
+ * - Follows MobX observer pattern for reactivity
+ * - Handles keyboard navigation
+ */
+declare const Tree: React$1.FunctionComponent<TreeProps>;
+
+//#endregion
+//#region src/tree/components/TreeNodeList.d.ts
+//# sourceMappingURL=Tree.d.ts.map
+interface TreeNodeListProps {
+  /** Tree nodes to render */
+  nodes: TreeNodeData[];
+  /** Tree model instance */
+  treeModel: TreeModel;
+  /** Current depth level (for indentation) */
+  depth?: number;
+  /** Additional CSS classes */
+  className?: string;
+}
+/**
+ * TreeNodeList component renders a list of tree nodes with proper nesting and interaction
+ */
+declare const TreeNodeList: React$1.FunctionComponent<TreeNodeListProps>;
+
+//#endregion
+//#region src/tree/components/TreeContextMenu.d.ts
+//# sourceMappingURL=TreeNodeList.d.ts.map
+/**
+ * Props for the TreeContextMenu component
+ */
+interface TreeContextMenuProps {
+  /**
+   * Menu items to display
+   */
+  items: TreeContextMenuItem[];
+  /**
+   * Position of the context menu
+   */
+  position: {
+    x: number;
+    y: number;
+  };
+  /**
+   * Whether the menu is visible
+   */
+  visible: boolean;
+  /**
+   * Callback when menu is closed
+   */
+  onClose: () => void;
+  /**
+   * Callback when menu item is clicked
+   */
+  onItemClick: (menuItem: TreeContextMenuItem) => void;
+  /**
+   * Additional CSS classes
+   */
+  className?: string;
+}
+/**
+ * TreeContextMenu - Context menu component for tree nodes
+ *
+ * Features:
+ * - Renders context menu items with proper styling (no icons)
+ * - Handles click outside to close
+ * - Supports separators and disabled items
+ * - Positioned absolutely at cursor position
+ * - Keyboard navigation support
+ */
+declare const TreeContextMenu: React$1.FunctionComponent<TreeContextMenuProps>;
+
+//#endregion
+//#region src/tree/components/TreeTable.d.ts
+interface TreeTableProps {
+  /** The tree model managing state */
+  treeModel: TreeModel;
+  /** Table columns configuration */
+  columns?: TreeTableColumn[];
+  /** Enable animations for expand/collapse transitions */
+  enableAnimations?: boolean;
+  /** Additional CSS classes */
+  className?: string;
+  /** Whether to show export functionality */
+  enableExport?: boolean;
+  /** Whether to enable filtering */
+  enableFiltering?: boolean;
+  /** Whether to enable sorting */
+  enableSorting?: boolean;
+}
+/**
+ * TreeTable Component - Table view of tree data
+ */
+declare const TreeTable: React$1.FunctionComponent<TreeTableProps>;
+
+//#endregion
+//#region src/tree/utils/SelectionTheme.d.ts
+//# sourceMappingURL=TreeTable.d.ts.map
+/**
+ * Default selection theme configuration
+ */
+declare const DEFAULT_SELECTION_THEME: TreeSelectionTheme;
+/**
+ * Generate selection background classes based on color scheme and intensity
+ */
+
+/**
+ * Generate complete selection classes for a tree node
+ */
+declare function getSelectionClasses(theme: TreeSelectionTheme, isSelected: boolean, isFocused: boolean, useCheckboxes?: boolean): string;
+/**
+ * Generate CSS custom properties for custom color schemes
+ * NOTE: This function is now simplified since we handle custom colors with inline styles
+ */
+declare function getCustomColorVariables(theme: TreeSelectionTheme): Record<string, string>;
+
+//#endregion
+//#region src/tree/utils/logger.d.ts
+//# sourceMappingURL=SelectionTheme.d.ts.map
+interface LogContext {
+  component?: string;
+  nodeId?: string;
+  operation?: string;
+  [key: string]: any;
+}
+interface LogEntry {
+  timestamp: string;
+  level: 'debug' | 'info' | 'warn' | 'error';
+  message: string;
+  context?: LogContext;
+  data?: any;
+}
+declare class TreeLogger {
+  private isEnabled;
+  private logs;
+  private maxLogs;
+  enable(): void;
+  disable(): void;
+  private log;
+  private getPrefix;
+  private formatContext;
+  debug(message: string, context?: LogContext, data?: any): void;
+  info(message: string, context?: LogContext, data?: any): void;
+  warn(message: string, context?: LogContext, data?: any): void;
+  error(message: string, context?: LogContext, data?: any): void;
+  selection(operation: string, nodeId: string, data?: any): void;
+  expansion(operation: string, nodeId: string, data?: any): void;
+  interaction(operation: string, nodeId: string, data?: any): void;
+  rendering(component: string, nodeId: string, data?: any): void;
+  cssClasses(nodeId: string, classes: string, selected: boolean, focused: boolean): void;
+  providerCall(method: string, data?: any): void;
+  stateChange(component: string, property: string, oldValue: any, newValue: any): void;
+  getLogs(filter?: {
+    level?: LogEntry['level'];
+    component?: string;
+  }): LogEntry[];
+  clearLogs(): void;
+  exportLogs(): string;
+}
+declare const logger: TreeLogger;
+
+//#endregion
+export { CheckboxState, DEFAULT_SELECTION_THEME as DEFAULT_SELECTION_THEME$1, FocusIndicatorStyle, SelectionColorScheme, SelectionIntensity, SimpleTreeProvider as SimpleTreeProvider$1, TestTreeProvider as TestTreeProvider$1, Tree as Tree$1, TreeCheckbox as TreeCheckbox$1, TreeContextMenu as TreeContextMenu$1, TreeContextMenuEvent, TreeContextMenuItem, TreeContextMenuProps, TreeDragDropInfo, TreeLoadOptions, TreeLoadResult, TreeModel as TreeModel$1, TreeNodeData, TreeNodeList as TreeNodeList$1, TreeNodeListProps, TreeNodeRenderer, TreeProps, TreeProvider, TreeSelectionInfo, TreeSelectionTheme, TreeTable as TreeTable$1, TreeTableColumn, TreeTableExportOptions, TreeTableProps, TreeTableSort, getCustomColorVariables as getCustomColorVariables$1, getSelectionClasses as getSelectionClasses$1, logger as logger$1 };
+//# sourceMappingURL=index-kHr9udZD.d.ts.map