@anymux/ui-kit 0.1.0

package/dist/index-Bryv_GCG.d.ts

@@ -0,0 +1,1481 @@
+import React$1, { Component, ErrorInfo, ReactNode } from "react";
+import * as mobx15 from "mobx";
+import * as mobx16 from "mobx";
+import * as mobx17 from "mobx";
+import * as mobx18 from "mobx";
+import * as react_jsx_runtime14 from "react/jsx-runtime";
+import * as mobx_dist_internal19 from "mobx/dist/internal";
+import * as mobx_dist_internal20 from "mobx/dist/internal";
+import * as mobx_dist_internal21 from "mobx/dist/internal";
+import * as mobx_dist_internal22 from "mobx/dist/internal";
+import * as mobx_dist_internal23 from "mobx/dist/internal";
+import * as mobx_dist_internal24 from "mobx/dist/internal";
+
+//#region src/list/types/ListTypes.d.ts
+/**
+* Core Type Definitions for ListItemsComponent
+*
+* Defines the fundamental interfaces and types used throughout the component.
+* These types support the provider pattern and multiple view types.
+*/
+/**
+ * Core Type Definitions for ListItemsComponent
+ *
+ * Defines the fundamental interfaces and types used throughout the component.
+ * These types support the provider pattern and multiple view types.
+ */
+interface ListItemData {
+  /** Unique identifier for the item */
+  id: string;
+  /** Display name of the item */
+  name: string;
+  /** Optional type classification (file, folder, etc.) */
+  type?: string;
+  /** Optional size in bytes */
+  size?: number;
+  /** Optional modification date */
+  modified?: Date;
+  /** Optional icon identifier or URL */
+  icon?: string;
+  /** Optional thumbnail URL */
+  thumbnail?: string;
+  /** Optional thumbnail URL (alias for image display) */
+  thumbnailUrl?: string;
+  /** Additional custom properties */
+  [key: string]: any;
+  isDirectory?: boolean;
+  children?: ListItemData[];
+  metadata?: Record<string, any>;
+  imageUrl?: string;
+  aspectRatio?: number;
+  getDimensions?(): {
+    width: number;
+    height: number;
+  };
+}
+interface ListLoadOptions {
+  /** Number of items to load (for pagination) */
+  limit?: number;
+  /** Starting offset for pagination */
+  offset?: number;
+  /** Search query to filter items */
+  searchQuery?: string;
+  /** Sort field */
+  sortBy?: string;
+  /** Sort direction */
+  sortDirection?: 'asc' | 'desc';
+  /** Additional filter criteria */
+  filters?: Record<string, any>;
+}
+interface ListLoadResult {
+  /** Array of loaded items */
+  items: ListItemData[];
+  /** Total number of items available (for virtualization) */
+  totalCount?: number;
+  /** Whether there are more items to load */
+  hasMore?: boolean;
+  /** Loading cursor for pagination */
+  nextCursor?: string;
+}
+interface ListSelectionInfo {
+  /** Currently selected items */
+  selectedItems: ListItemData[];
+  /** Previously selected items */
+  previousSelection: ListItemData[];
+  /** Type of selection operation */
+  selectionType: 'single' | 'multi' | 'range';
+  /** What triggered the selection change */
+  trigger: 'click' | 'keyboard' | 'api';
+}
+interface ListDragDropInfo {
+  /** Items being dragged */
+  draggedItems: ListItemData[];
+  /** Target item being dropped on */
+  targetItem: ListItemData | null;
+  /** Drop position relative to target */
+  position: 'before' | 'after' | 'inside';
+  /** Original drag event */
+  event: DragEvent;
+}
+interface VirtualizationConfig {
+  /** Fixed item height for current view type */
+  itemHeight: number;
+  /** Items to render outside visible area */
+  overscan?: number;
+  /** Minimum items before enabling virtualization */
+  threshold?: number;
+  /** Dynamic loading range size */
+  rangeSize?: number;
+}
+interface ListViewType$1 {
+  /** Unique identifier for the view type */
+  readonly id: string;
+  /** Human-readable name */
+  readonly name: string;
+  /** Optional icon for the view type */
+  readonly icon?: string;
+  /** Number of items per row (1 for list, 'auto' for responsive grid) */
+  readonly itemsPerRow?: number | 'auto' | 'custom';
+  /** Whether to show detailed information */
+  readonly showDetails?: boolean;
+  /** Whether to show thumbnails */
+  readonly showThumbnails?: boolean;
+  /** Available thumbnail sizes */
+  readonly thumbnailSizes?: ThumbnailSize[];
+  /** Column definitions for details view */
+  readonly columns?: string[];
+  /** Custom renderer for this view type */
+  readonly customRenderer?: any;
+}
+type ThumbnailSize = 'small' | 'medium' | 'large' | 'extra-large';
+interface ListContextMenuItem {
+  /** Menu item identifier */
+  id: string;
+  /** Display label */
+  label: string;
+  /** Optional icon (string or React component) */
+  icon?: string | React.ComponentType<any>;
+  /** Whether item is disabled */
+  disabled?: boolean;
+  /** Whether this is a separator */
+  type?: 'item' | 'separator';
+  /** Whether this is a destructive action */
+  destructive?: boolean;
+  /** Tooltip text */
+  tooltip?: string;
+  /** Keyboard shortcut display */
+  shortcut?: string;
+  /** Submenu items */
+  submenu?: ListContextMenuItem[];
+}
+interface ListItemRenderer {
+  /** Render item as text (for non-React environments) */
+  renderText?(item: ListItemData): string;
+  /** Render item icon */
+  renderIcon?(item: ListItemData): string;
+  /** Render item thumbnail */
+  renderThumbnail?(item: ListItemData): string;
+  /** Get display properties */
+  getDisplayProps?(item: ListItemData): {
+    className?: string;
+    style?: React.CSSProperties;
+    title?: string;
+    ariaLabel?: string;
+  };
+  /** Custom React component for item rendering */
+  renderComponent?: React.ComponentType<{
+    item: ListItemData;
+    [key: string]: any;
+  }>;
+}
+interface ListError {
+  /** Error message */
+  message: string;
+  /** Error code */
+  code?: string;
+  /** Whether error is recoverable */
+  recoverable?: boolean;
+  /** Retry function */
+  retry?: () => void;
+} //#endregion
+//#region src/list/providers/ListItemsProvider.d.ts
+
+//# sourceMappingURL=ListTypes.d.ts.map
+interface ListItemsProviderListener {
+  onItemsCountChanged(count: number): void;
+  onItemChanged(itemIndex: number): void;
+}
+interface ListViewType extends ListViewType$1 {}
+declare const LIST_VIEW_TYPE: ListViewType;
+declare const GRID_VIEW_TYPE: ListViewType;
+declare const DETAILS_VIEW_TYPE: ListViewType;
+declare const MASONRY_HORIZONTAL_VIEW_TYPE: ListViewType;
+declare const MASONRY_VERTICAL_VIEW_TYPE: ListViewType;
+declare const TREEMAP_VIEW_TYPE: ListViewType;
+/** Recursive tree node for treemap view */
+interface TreemapNodeData {
+  name: string;
+  path: string;
+  size?: number;
+  isDirectory: boolean;
+  children?: TreemapNodeData[];
+}
+/** Progress info reported during recursive directory scan */
+interface TreemapScanProgress {
+  directoriesScanned: number;
+  filesFound: number;
+  totalSize: number;
+}
+interface ListItemsProvider {
+  /** Provider identifier */
+  readonly id: string;
+  /** Human-readable name */
+  readonly name: string;
+  /** Supported view types for this provider */
+  readonly supportedViewTypes: ListViewType[];
+  /** Whether multi-selection is enabled */
+  readonly isMultiSelectEnabled: boolean;
+  /** Whether virtualization is enabled */
+  readonly isVirtualizationEnabled: boolean;
+  /**
+   * Load items from the data source
+   * @param options Loading options for filtering, sorting, pagination
+   * @returns Promise resolving to loaded items
+   */
+  loadItems(options?: ListLoadOptions): Promise<ListLoadResult>;
+  /**
+   * Get total count of items (for virtualization)
+   * @returns Promise resolving to total item count
+   */
+  getItemCount(): Promise<number>;
+  /**
+   * Load a specific range of items (for virtualization)
+   * @param start Starting index
+   * @param end Ending index
+   * @returns Promise resolving to items in range
+   */
+  loadItemRange?(start: number, end: number): Promise<ListLoadResult>;
+  /**
+   * Refresh/reload items
+   * @returns Promise resolving to refreshed items
+   */
+  refresh?(): Promise<ListLoadResult>;
+  /**
+   * Get item height for a specific view type (for virtualization)
+   * @param viewType The view type to get height for
+   * @returns Fixed height in pixels
+   */
+  getItemHeight(viewType: ListViewType): number;
+  /**
+   * Get item width for grid-based view types
+   * @param viewType The view type to get width for
+   * @returns Fixed width in pixels
+   */
+  getItemWidth?(viewType: ListViewType): number;
+  /**
+   * Get virtualization configuration
+   * @returns Virtualization config object
+   */
+  getVirtualizationConfig?(): VirtualizationConfig;
+  /**
+   * Called when selection changes
+   * @param selectionInfo Information about the selection change
+   */
+  onSelectionChange?(selectionInfo: ListSelectionInfo): void;
+  /**
+   * Called when view type changes
+   * @param viewType New view type
+   */
+  onViewTypeChange?(viewType: ListViewType): void;
+  /**
+   * Called when an item is double-clicked
+   * @param item The item that was double-clicked
+   */
+  onItemDoubleClick?(item: ListItemData): void;
+  /**
+   * Called when keyboard navigation requests going up one level (Escape key).
+   * Providers that support hierarchical navigation should implement this.
+   */
+  onNavigateUp?(): void;
+  addListener(listener: ListItemsProviderListener): void;
+  removeListener(listener: ListItemsProviderListener): void;
+  /**
+   * Get custom icon for an item
+   * @param item Target item
+   * @returns Icon identifier or React component
+   */
+  getItemIcon?(item: ListItemData): string | React.ComponentType<any>;
+  /**
+   * Resolve a thumbnail URL for an item. Providers with async thumbnail
+   * loading return blob URLs from an observable cache — MobX observer
+   * components re-render when the URL becomes available.
+   */
+  resolveThumbnailUrl?(item: ListItemData): string | undefined;
+  /**
+   * Get measured aspect ratio (width/height) for an item by path.
+   * Used by masonry layout to size items correctly instead of using
+   * deterministic random fallback ratios.
+   */
+  getAspectRatio?(path: string): number | undefined;
+  /**
+   * Load recursive directory data for treemap view.
+   * Returns a nested tree of items including subfolder contents.
+   * @param onProgress Optional callback reporting scan progress
+   */
+  loadTreemapData?(onProgress?: (progress: TreemapScanProgress) => void): Promise<TreemapNodeData[]>;
+  /**
+   * Get context menu items for a specific item
+   * @param item Target item
+   * @returns Array of context menu items
+   */
+  getItemContextMenu?(item: ListItemData): ListContextMenuItem[];
+  /**
+   * Get context menu items for multiple selected items
+   * @param items Selected items
+   * @returns Array of context menu items
+   */
+  getMultiItemContextMenu?(items: ListItemData[]): ListContextMenuItem[];
+  /**
+   * Get context menu items for empty space (no item right-clicked)
+   * @returns Array of context menu items
+   */
+  getEmptySpaceContextMenu?(): ListContextMenuItem[];
+  /**
+   * Called when a context menu action is selected
+   * @param menuItemId Menu item identifier
+   * @param items Items the action applies to (empty array for empty-space actions)
+   */
+  onContextMenuAction?(menuItemId: string, items: ListItemData[]): void;
+  /**
+   * Whether drag and drop is enabled
+   */
+  readonly isDragDropEnabled?: boolean;
+  /**
+   * Check if an item can be dragged
+   * @param item Item to check
+   * @returns Whether the item can be dragged
+   */
+  canDragItem?(item: ListItemData): boolean;
+  /**
+   * Check if items can be dropped on a target
+   * @param draggedItems Items being dragged
+   * @param targetItem Target item (null for empty space)
+   * @param position Drop position relative to target
+   * @returns Whether the drop is allowed
+   */
+  canDropItems?(draggedItems: ListItemData[], targetItem: ListItemData | null, position: 'before' | 'after' | 'inside'): boolean;
+  /**
+   * Called when drag operation starts
+   * @param draggedItems Items being dragged
+   * @param event Original drag event
+   */
+  onDragStart?(draggedItems: ListItemData[], event: DragEvent): void;
+  /**
+   * Called when items are dropped
+   * @param dragDropInfo Information about the drag and drop operation
+   */
+  onDrop?(dragDropInfo: ListDragDropInfo): void;
+  /**
+   * Called when drag operation ends (whether successful or not)
+   * @param draggedItems Items that were being dragged
+   * @param success Whether the drop was successful
+   */
+  onDragEnd?(draggedItems: ListItemData[], success: boolean): void;
+} //#endregion
+//#region src/list/utils/GridLayoutCalculator.d.ts
+
+//# sourceMappingURL=ListItemsProvider.d.ts.map
+interface GridLayoutConfig {
+  containerWidth: number;
+  containerHeight: number;
+  itemsPerRow: number | 'auto';
+  gap: number;
+  padding: number;
+  minItemWidth: number;
+  maxItemWidth: number;
+  aspectRatio: number;
+}
+interface GridItemLayout {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  thumbnailSize: number;
+  textHeight: number;
+}
+interface GridLayoutResult {
+  itemsPerRow: number;
+  itemWidth: number;
+  itemHeight: number;
+  totalRows: number;
+  totalHeight: number;
+  items: GridItemLayout[];
+}
+declare class GridLayoutCalculator {
+  private config;
+  constructor(config: GridLayoutConfig);
+  updateConfig(updates: Partial<GridLayoutConfig>): void;
+  get currentConfig(): GridLayoutConfig;
+  calculateItemsPerRow(): number;
+  calculateItemDimensions(itemsPerRow: number): {
+    width: number;
+    height: number;
+  };
+  calculateThumbnailSize(itemWidth: number, itemHeight: number): number;
+  calculateLayout(totalItems: number): GridLayoutResult;
+  calculateVisibleItems(totalItems: number, scrollTop: number, viewportHeight: number, overscan?: number): {
+    startIndex: number;
+    endIndex: number;
+    visibleItems: GridItemLayout[];
+  };
+  getItemPosition(itemIndex: number, totalItems: number): GridItemLayout | null;
+  getItemAtPosition(x: number, y: number, totalItems: number): number | null;
+}
+declare function createGridCalculator(containerWidth: number, containerHeight: number, options?: Partial<GridLayoutConfig>): GridLayoutCalculator;
+declare const GRID_PRESETS: {
+  readonly compact: {
+    readonly gap: 8;
+    readonly padding: 12;
+    readonly minItemWidth: 120;
+    readonly maxItemWidth: 200;
+    readonly aspectRatio: 0.85;
+  };
+  readonly comfortable: {
+    readonly gap: 16;
+    readonly padding: 20;
+    readonly minItemWidth: 200;
+    readonly maxItemWidth: 300;
+    readonly aspectRatio: 0.9;
+  };
+  readonly spacious: {
+    readonly gap: 24;
+    readonly padding: 32;
+    readonly minItemWidth: 280;
+    readonly maxItemWidth: 400;
+    readonly aspectRatio: 0.95;
+  };
+};
+
+//#endregion
+//#region src/list/utils/MasonryLayoutEngine.d.ts
+//# sourceMappingURL=GridLayoutCalculator.d.ts.map
+interface MasonryItemPosition {
+  id: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+//#endregion
+//#region src/list/models/ListItemsModel.d.ts
+declare class ListItemsModel implements ListItemsProviderListener {
+  provider: ListItemsProvider;
+  currentViewType: ListViewType;
+  _allItems: ListItemData[];
+  itemMap: mobx15.ObservableMap<string, ListItemData>;
+  totalItemCount: number;
+  searchQuery: string;
+  selectedItems: mobx16.ObservableMap<string, ListItemData>;
+  previousSelection: ListItemData[];
+  focusedItem: string | null;
+  selectionAnchor: string | null;
+  isLoading: boolean;
+  loadingRanges: mobx17.ObservableMap<string, boolean>;
+  errors: mobx18.ObservableMap<string, Error>;
+  viewportRange: {
+    start: number;
+    end: number;
+  };
+  scrollPosition: number;
+  containerSize: {
+    width: number;
+    height: number;
+  };
+  isDragging: boolean;
+  draggedItems: ListItemData[];
+  dragOverItem: string | null;
+  dragOverPosition: 'before' | 'after' | 'inside' | null;
+  itemSize: 'small' | 'medium' | 'large' | 'extra-large';
+  customItemWidth: number;
+  customItemHeight: number;
+  itemsPerRow: number | 'auto';
+  private gridCalculator;
+  private verticalMasonryEngine;
+  private horizontalMasonryEngine;
+  debugVisualization: boolean;
+  compactMode: boolean;
+  columnVisibility: {
+    type: boolean;
+    modified: boolean;
+    size: boolean;
+  };
+  showCheckboxes: boolean;
+  scrollToItemId: string | null;
+  pageSize: number;
+  currentPage: number;
+  constructor(provider: ListItemsProvider);
+  get items(): ListItemData[];
+  get hasSearchQuery(): boolean;
+  get allItemsCount(): number;
+  setSearchQuery(query: string): void;
+  clearSearch(): void;
+  clearItems(): void;
+  onItemsCountChanged(count: number): void;
+  onItemChanged(itemIndex: number): void;
+  get selectedItemsArray(): ListItemData[];
+  get hasSelection(): boolean;
+  get isItemSelected(): (itemId: string) => boolean;
+  get itemHeight(): number;
+  get isLoaded(): boolean;
+  get hasErrors(): boolean;
+  get selectedItemIds(): Set<string>;
+  get visibleItemsCount(): number;
+  get loadedItemsCount(): number;
+  get loadingProgress(): number;
+  get isFullyLoaded(): boolean;
+  get totalPages(): number;
+  get hasNextPage(): boolean;
+  get hasPreviousPage(): boolean;
+  goToPage: (page: number) => mobx_dist_internal19.CancellablePromise<void>;
+  nextPage: () => mobx_dist_internal20.CancellablePromise<void>;
+  prevPage: () => mobx_dist_internal21.CancellablePromise<void>;
+  setPageSize(size: number): void;
+  /**
+   * Load items from the provider
+   * Uses MobX flow for proper async action handling
+   */
+  loadItems: (options?: ListLoadOptions | undefined) => mobx_dist_internal22.CancellablePromise<void>;
+  /**
+   * Load a specific range of items for virtualization
+   */
+  loadItemRange: (start: number, end: number) => mobx_dist_internal23.CancellablePromise<void>;
+  /**
+   * Refresh items from provider
+   */
+  refresh: () => mobx_dist_internal24.CancellablePromise<void>;
+  /**
+   * Select a single item with proper single/multi-selection logic
+   */
+  selectItem(item: ListItemData, modifiers?: {
+    ctrl?: boolean;
+    shift?: boolean;
+  }): void;
+  /**
+   * Select a contiguous range of items between two item IDs
+   */
+  selectRange(fromId: string, toId: string): void;
+  /**
+   * Clear all selection
+   */
+  clearSelection(): void;
+  /**
+   * Select all items (if multi-select enabled)
+   */
+  selectAll(): void;
+  /**
+   * Set the current view type
+   */
+  setViewType(viewType: ListViewType): void;
+  /**
+   * Set item size for grid and masonry views
+   */
+  setItemSize(size: 'small' | 'medium' | 'large' | 'extra-large'): void;
+  /**
+   * Set custom item width and update calculators
+   */
+  setCustomItemWidth(width: number): void;
+  /**
+   * Set custom item height and update calculators
+   */
+  setCustomItemHeight(height: number): void;
+  /**
+   * Get current item dimensions
+   */
+  get itemDimensions(): {
+    width: number;
+    height: number;
+  };
+  /**
+   * Set items per row for grid and masonry views
+   */
+  setItemsPerRow(itemsPerRow: number | 'auto'): void;
+  /**
+   * Set debug visualization mode
+   */
+  setDebugVisualization(enabled: boolean): void;
+  setCompactMode(compact: boolean): void;
+  toggleCheckboxes(): void;
+  setShowCheckboxes(show: boolean): void;
+  setColumnVisibility(column: 'type' | 'modified' | 'size', visible: boolean): void;
+  get detailsGridTemplateColumns(): string;
+  /**
+   * Generate random aspect ratio for Pinterest-like variety
+   */
+  /**
+   * Deterministic aspect ratio based on item id (stable across re-renders).
+   * Uses a simple hash to pick from predefined ratios.
+   */
+  private generateDeterministicAspectRatio;
+  /**
+   * Get effective items per row based on view and container width
+   */
+  getEffectiveItemsPerRow(containerWidth?: number): number;
+  /**
+   * Set focused item
+   */
+  setFocusedItem(itemId: string | null): void;
+  /**
+   * Focus next item
+   */
+  focusNext(): boolean;
+  /**
+   * Focus previous item
+   */
+  focusPrevious(): boolean;
+  /**
+   * Focus the first item in the list
+   */
+  focusFirst(): boolean;
+  /**
+   * Focus the last item in the list
+   */
+  focusLast(): boolean;
+  /**
+   * Handle keyboard events for list navigation.
+   * Can be used directly via onKeyDown on a container element,
+   * or the useListKeyboard hook can be used for automatic attachment.
+   *
+   * - ArrowUp/ArrowDown: navigate between items
+   * - Home/End: jump to first/last item
+   * - Enter: open focused item (navigate into folder or open file)
+   * - Space: toggle selection of focused item
+   * - Escape: clear selection, or navigate up one directory level if nothing selected
+   * - Ctrl+A: select all items
+   */
+  handleKeyDown(event: KeyboardEvent): void;
+  /**
+   * Get the index of the currently focused item, defaulting to 0
+   */
+  private getFocusedIndex;
+  /**
+   * Navigate to a specific item index, updating focus, selection, and scroll
+   */
+  private navigateToIndex;
+  /**
+   * Check if an item can be dragged
+   */
+  canDragItem(item: ListItemData): boolean;
+  /**
+   * Check if items can be dropped on a target
+   */
+  canDropItems(draggedItems: ListItemData[], targetItem: ListItemData | null, position: 'before' | 'after' | 'inside'): boolean;
+  /**
+   * Start drag operation
+   */
+  startDrag(items: ListItemData[], event: DragEvent): void;
+  /**
+   * Handle drag over item
+   */
+  setDragOver(itemId: string | null, position: 'before' | 'after' | 'inside' | null): void;
+  /**
+   * Handle drop operation
+   */
+  handleDrop(targetItem: ListItemData | null, position: 'before' | 'after' | 'inside', event: DragEvent): boolean;
+  /**
+   * End drag operation
+   */
+  endDrag(success: boolean): void;
+  /**
+   * Update viewport range for virtualization and trigger dynamic loading
+   */
+  updateViewportRange(start: number, end: number): void;
+  /**
+   * Load items that are visible in the current viewport
+   */
+  private loadVisibleItems;
+  /**
+   * Update scroll position
+   */
+  updateScrollPosition(position: number): void;
+  /**
+   * Update container size
+   */
+  updateContainerSize(width: number, height: number): void;
+  /**
+   * Update layout calculators with current settings
+   */
+  private updateLayoutCalculators;
+  /**
+   * Get grid layout for current items
+   */
+  getGridLayout(): {
+    layout: GridItemLayout[];
+    totalHeight: number;
+  } | null;
+  /**
+   * Check whether an item is an actual image that should get variable height
+   * in masonry layout. Non-image items (folders, docs, code files) get uniform height.
+   */
+  private isImageItem;
+  /**
+   * Get vertical masonry layout for current items
+   */
+  getVerticalMasonryLayout(): {
+    layout: MasonryItemPosition[];
+    totalHeight: number;
+  } | null;
+  /**
+   * Get horizontal masonry layout for current items
+   */
+  getHorizontalMasonryLayout(): {
+    layout: MasonryItemPosition[];
+    totalHeight: number;
+  } | null;
+  /**
+   * Get visible items for virtualization
+   */
+  getVisibleGridItems(scrollTop: number, viewportHeight: number): GridItemLayout[];
+  /**
+   * Get visible vertical masonry items for virtualization
+   */
+  getVisibleVerticalMasonryItems(scrollTop: number, viewportHeight: number): MasonryItemPosition[];
+  /**
+   * Get visible horizontal masonry items for virtualization
+   */
+  getVisibleHorizontalMasonryItems(scrollTop: number, viewportHeight: number): MasonryItemPosition[];
+  /**
+   * Get visible masonry items for virtualization (unified method)
+   */
+  getVisibleMasonryItems(scrollTop: number, viewportHeight: number, isHorizontal?: boolean, overscan?: number): MasonryItemPosition[];
+  /**
+   * Ensure item is visible (scroll to item)
+   */
+  ensureItemVisible(itemId: string): boolean;
+  clearScrollToItem(): void;
+  /**
+   * Get item by ID
+   */
+  getItem(itemId: string): ListItemData | undefined;
+  /**
+   * Get item index
+   */
+  getItemIndex(itemId: string): number;
+  /**
+   * Resolve thumbnail URL for an item via provider cache.
+   * Returns blob URL when ready, undefined while loading.
+   * MobX observer components re-render when the URL becomes available.
+   */
+  resolveThumbnailUrl(item: ListItemData): string | undefined;
+} //#endregion
+//#region src/list/components/ListItem.d.ts
+
+//# sourceMappingURL=ListItemsModel.d.ts.map
+interface ListItemProps {
+  item: ListItemData;
+  index: number;
+  totalItems: number;
+  viewType: ListViewType$1;
+  provider?: ListItemsProvider;
+  model?: ListItemsModel;
+  itemWidth?: number;
+  itemHeight?: number;
+  thumbnailSize?: number;
+  isSelected?: boolean;
+  isFocused?: boolean;
+  isDraggedOver?: boolean;
+  dragOverPosition?: 'before' | 'after' | 'inside' | null;
+  canDrag?: boolean;
+  onClick?: (item: ListItemData, event: React$1.MouseEvent) => void;
+  onDoubleClick?: (item: ListItemData, event: React$1.MouseEvent) => void;
+  onContextMenu?: (item: ListItemData, event: React$1.MouseEvent) => void;
+  onDragStart?: (item: ListItemData, event: React$1.DragEvent) => void;
+  onDragOver?: (item: ListItemData, event: React$1.DragEvent) => void;
+  onDragLeave?: (item: ListItemData, event: React$1.DragEvent) => void;
+  onDrop?: (item: ListItemData, event: React$1.DragEvent) => void;
+}
+declare const ListItem: React$1.FunctionComponent<ListItemProps>;
+
+//#endregion
+//#region src/list/components/ListItems.d.ts
+//# sourceMappingURL=ListItem.d.ts.map
+interface ListItemsProps {
+  model: ListItemsModel;
+  className?: string;
+  style?: React$1.CSSProperties;
+  height?: number;
+  width?: number;
+  enableVirtualization?: boolean;
+  enableKeyboardNavigation?: boolean;
+}
+declare const ListItems: React$1.FunctionComponent<ListItemsProps>;
+
+//#endregion
+//#region src/list/components/ListContextMenu.d.ts
+//# sourceMappingURL=ListItems.d.ts.map
+interface ListContextMenuProps {
+  isOpen: boolean;
+  position: {
+    x: number;
+    y: number;
+  };
+  items: ListItemData[];
+  provider: ListItemsProvider;
+  onClose: () => void;
+  /** Extra menu items to prepend before provider items */
+  extraMenuItems?: ListContextMenuItem[];
+  /** Handler for extra menu item actions (called instead of provider.onContextMenuAction) */
+  onExtraMenuAction?: (actionId: string, items: ListItemData[]) => void;
+}
+declare const ListContextMenu: React$1.FunctionComponent<ListContextMenuProps>;
+
+//#endregion
+//#region src/list/components/ViewTypeSelector.d.ts
+//# sourceMappingURL=ListContextMenu.d.ts.map
+interface ViewTypeSelectorProps {
+  viewTypes: ListViewType$1[];
+  currentViewType: ListViewType$1;
+  onViewTypeChange: (viewType: ListViewType$1) => void;
+  variant?: 'buttons' | 'tabs' | 'dropdown';
+  size?: 'sm' | 'md' | 'lg';
+  className?: string;
+}
+declare const ViewTypeSelector: React$1.NamedExoticComponent<ViewTypeSelectorProps>;
+
+//#endregion
+//#region src/list/components/SearchFilter.d.ts
+//# sourceMappingURL=ViewTypeSelector.d.ts.map
+interface SearchFilterProps {
+  model: ListItemsModel;
+  placeholder?: string;
+  className?: string;
+}
+declare const SearchFilter: React$1.FunctionComponent<SearchFilterProps>;
+
+//#endregion
+//#region src/list/components/VirtualizedList.d.ts
+//# sourceMappingURL=SearchFilter.d.ts.map
+interface VirtualizedListProps {
+  model: ListItemsModel;
+  height: number;
+  width?: number;
+  className?: string;
+  overscanCount?: number;
+}
+declare const VirtualizedList: React$1.FunctionComponent<VirtualizedListProps>;
+
+//#endregion
+//#region src/list/components/VirtualizedGrid.d.ts
+//# sourceMappingURL=VirtualizedList.d.ts.map
+interface VirtualizedGridProps {
+  model: ListItemsModel;
+  height: number;
+  width: number;
+  className?: string;
+  overscanCount?: number;
+}
+declare const VirtualizedGrid: React$1.FunctionComponent<VirtualizedGridProps>;
+
+//#endregion
+//#region src/list/components/MasonryView.d.ts
+//# sourceMappingURL=VirtualizedGrid.d.ts.map
+interface MasonryViewProps {
+  model: ListItemsModel;
+  items: ListItemData[];
+  containerWidth: number;
+  containerHeight: number;
+  isHorizontal?: boolean;
+}
+declare const MasonryView: React$1.FC<MasonryViewProps>;
+
+//#endregion
+//#region src/list/components/ViewSizeControls.d.ts
+interface ViewSizeControlsProps {
+  model: ListItemsModel;
+  className?: string;
+  showSizePresets?: boolean;
+  showCustomSliders?: boolean;
+  showDebugToggle?: boolean;
+}
+declare const ViewSizeControls: React$1.FunctionComponent<ViewSizeControlsProps>;
+
+//#endregion
+//#region src/list/models/TreemapModel.d.ts
+//# sourceMappingURL=ViewSizeControls.d.ts.map
+type ColorScheme = 'extension' | 'size' | 'type';
+/**
+ * Get the RGBA color for a file extension (used by the cushion treemap renderer).
+ */
+
+/**
+ * Phase 1 TreemapModel — works with items already loaded in ListItemsModel.
+ *
+ * No worker scanning, no async. Computes layout from the flat items list,
+ * using file `size` for proportional rectangles (directories get size=1).
+ */
+declare class TreemapModel {
+  /** Current zoom path within the treemap */
+  zoomPath: string;
+  /** Path of the hovered tile (for tooltip) */
+  hoveredPath: string | null;
+  /** Active color scheme */
+  colorScheme: ColorScheme;
+  /** Whether to show file name labels on tiles */
+  showLabels: boolean;
+  /** Whether to show size labels on tiles */
+  showSizes: boolean;
+  /** Highlighted extension category label (e.g. 'JS/TS') for legend filtering */
+  highlightedExtension: string | null;
+  constructor();
+  zoomIn(path: string): void;
+  zoomOut(): void;
+  resetZoom(): void;
+  setHoveredPath(path: string | null): void;
+  setColorScheme(scheme: ColorScheme): void;
+  toggleLabels(): void;
+  toggleSizes(): void;
+  setHighlightedExtension(ext: string | null): void;
+  get breadcrumbs(): Array<{
+    name: string;
+    path: string;
+  }>;
+  /**
+   * Get the RGBA color for a node based on the current color scheme.
+   */
+  getNodeColor(item: ListItemData): [number, number, number, number];
+}
+
+//#endregion
+//#region src/list/components/TreemapView.d.ts
+//# sourceMappingURL=TreemapModel.d.ts.map
+/** Node metadata for overlay tiles */
+interface TileInfo {
+  path: string;
+  name: string;
+  size?: number;
+  isDirectory: boolean;
+}
+interface TreemapViewProps {
+  model: ListItemsModel;
+  treemapModel: TreemapModel;
+  width: number;
+  height: number;
+  className?: string;
+  onTileContextMenu?: (info: TileInfo, event: React$1.MouseEvent) => void;
+  onEmptyContextMenu?: (event: React$1.MouseEvent) => void;
+}
+/**
+ * TreemapView — renders items from ListItemsModel as a cushion-shaded treemap.
+ *
+ * Uses @cushiontreemap/core to render to a canvas, with transparent overlaid
+ * divs for click/hover interactivity.
+ *
+ * If the provider supports loadTreemapData(), shows recursive subdirectory content.
+ */
+declare const TreemapView: React$1.FunctionComponent<TreemapViewProps>;
+
+//#endregion
+//#region src/list/components/CalculatedGridView.d.ts
+//# sourceMappingURL=TreemapView.d.ts.map
+interface CalculatedGridViewProps {
+  model: ListItemsModel;
+  className?: string;
+  height?: number;
+  width?: number;
+  enableVirtualization?: boolean;
+  onItemClick?: (item: ListItemData, event: React$1.MouseEvent) => void;
+  onItemDoubleClick?: (item: ListItemData, event: React$1.MouseEvent) => void;
+  onItemContextMenu?: (item: ListItemData, event: React$1.MouseEvent) => void;
+  onItemDragStart?: (item: ListItemData, event: React$1.DragEvent) => void;
+  onItemDragOver?: (item: ListItemData, event: React$1.DragEvent) => void;
+  onItemDragLeave?: (item: ListItemData, event: React$1.DragEvent) => void;
+  onItemDrop?: (item: ListItemData, event: React$1.DragEvent) => void;
+}
+declare const CalculatedGridView: React$1.FunctionComponent<CalculatedGridViewProps>;
+
+//#endregion
+//#region src/list/components/shared/ListLoader.d.ts
+//# sourceMappingURL=CalculatedGridView.d.ts.map
+interface ListLoaderProps {
+  viewType: ListViewType;
+  itemCount?: number;
+  itemWidth?: number;
+  itemHeight?: number;
+  className?: string;
+}
+declare const ListLoader: React$1.FunctionComponent<ListLoaderProps>;
+
+//#endregion
+//#region src/list/components/shared/LoadingIndicator.d.ts
+//# sourceMappingURL=ListLoader.d.ts.map
+interface LoadingIndicatorProps {
+  size?: 'small' | 'medium' | 'large';
+  message?: string;
+  className?: string;
+  showSpinner?: boolean;
+}
+interface InlineLoadingProps {
+  className?: string;
+}
+interface LoadingProgressProps {
+  progress: number;
+  message?: string;
+  className?: string;
+}
+declare const LoadingIndicator: React$1.FunctionComponent<LoadingIndicatorProps>;
+declare const InlineLoading: React$1.FunctionComponent<InlineLoadingProps>;
+declare const LoadingProgress: React$1.FunctionComponent<LoadingProgressProps>;
+
+//#endregion
+//#region src/list/components/shared/ErrorBoundary.d.ts
+//# sourceMappingURL=LoadingIndicator.d.ts.map
+interface ErrorBoundaryProps {
+  children: ReactNode;
+  fallback?: (error: Error, errorInfo: ErrorInfo) => ReactNode;
+  onError?: (error: Error, errorInfo: ErrorInfo) => void;
+  className?: string;
+}
+interface ErrorBoundaryState {
+  hasError: boolean;
+  error: Error | null;
+  errorInfo: ErrorInfo | null;
+}
+declare class ListErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryProps);
+  static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+  componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+  handleRetry: () => void;
+  render(): string | number | bigint | boolean | react_jsx_runtime14.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
+}
+
+//#endregion
+//#region src/list/components/shared/ErrorDisplay.d.ts
+//# sourceMappingURL=ErrorBoundary.d.ts.map
+interface ErrorDisplayProps {
+  error: Error | string;
+  title?: string;
+  message?: string;
+  onRetry?: () => void;
+  onDismiss?: () => void;
+  className?: string;
+  size?: 'small' | 'medium' | 'large';
+  variant?: 'default' | 'destructive' | 'warning';
+}
+interface NetworkErrorProps {
+  onRetry?: () => void;
+  className?: string;
+}
+interface LoadErrorProps {
+  error: Error | string;
+  onRetry?: () => void;
+  className?: string;
+}
+declare const ErrorDisplay: React$1.FunctionComponent<ErrorDisplayProps>;
+declare const NetworkError: React$1.FunctionComponent<NetworkErrorProps>;
+declare const LoadError: React$1.FunctionComponent<LoadErrorProps>;
+
+//#endregion
+//#region src/list/components/shared/EmptyState.d.ts
+//# sourceMappingURL=ErrorDisplay.d.ts.map
+interface EmptyStateProps {
+  title?: string;
+  message?: string;
+  icon?: React$1.ReactNode;
+  actions?: React$1.ReactNode;
+  className?: string;
+  size?: 'small' | 'medium' | 'large';
+}
+interface NoItemsProps {
+  onRefresh?: () => void;
+  className?: string;
+}
+interface NoSearchResultsProps {
+  searchQuery?: string;
+  onClearSearch?: () => void;
+  className?: string;
+}
+interface NoSelectionProps {
+  message?: string;
+  className?: string;
+}
+declare const EmptyState: React$1.FunctionComponent<EmptyStateProps>;
+declare const NoItems: React$1.FunctionComponent<NoItemsProps>;
+declare const NoSearchResults: React$1.FunctionComponent<NoSearchResultsProps>;
+declare const NoSelection: React$1.FunctionComponent<NoSelectionProps>;
+
+//#endregion
+//#region src/list/providers/TestListProvider.d.ts
+//# sourceMappingURL=EmptyState.d.ts.map
+declare class TestListProvider implements ListItemsProvider {
+  readonly id = "test-list-provider";
+  readonly name = "Test List Provider";
+  readonly isMultiSelectEnabled = true;
+  readonly isVirtualizationEnabled = true;
+  readonly isDragDropEnabled = true;
+  readonly supportedViewTypes: ListViewType[];
+  private items;
+  private listener?;
+  constructor();
+  private generateLargeDataset;
+  private getIconForType;
+  /**
+   * Get custom icon for an item based on file type and extension
+   */
+  getItemIcon(item: ListItemData): string | React$1.ComponentType<any>;
+  loadItems(options?: ListLoadOptions): Promise<ListLoadResult>;
+  getItemCount(): Promise<number>;
+  loadItemRange(start: number, end: number): Promise<ListLoadResult>;
+  refresh(): Promise<ListLoadResult>;
+  getItemHeight(viewType: ListViewType): number;
+  getItemWidth(viewType: ListViewType): number;
+  getVirtualizationConfig(): VirtualizationConfig;
+  onSelectionChange(selectionInfo: ListSelectionInfo): void;
+  onViewTypeChange(viewType: ListViewType): void;
+  onItemDoubleClick(item: ListItemData): void;
+  getItemContextMenu(item: ListItemData): ListContextMenuItem[];
+  getMultiItemContextMenu(items: ListItemData[]): ListContextMenuItem[];
+  onContextMenuAction(menuItemId: string, items: ListItemData[]): void;
+  canDragItem(item: ListItemData): boolean;
+  canDropItems(draggedItems: ListItemData[], targetItem: ListItemData | null, position: 'before' | 'after' | 'inside'): boolean;
+  onDragStart(draggedItems: ListItemData[], event: DragEvent): void;
+  onDrop(dragDropInfo: ListDragDropInfo): void;
+  onDragEnd(draggedItems: ListItemData[], success: boolean): void;
+  addListener(listener: ListItemsProviderListener): void;
+  removeListener(listener: ListItemsProviderListener): void;
+  /**
+   * Add a new mock item (useful for testing dynamic updates)
+   */
+  addMockItem(item: Partial<ListItemData>): void;
+  /**
+   * Remove an item by ID (useful for testing dynamic updates)
+   */
+  removeMockItem(itemId: string): void;
+  /**
+   * Update an existing item (useful for testing dynamic updates)
+   */
+  updateMockItem(itemId: string, updates: Partial<ListItemData>): void;
+}
+
+//#endregion
+//#region src/list/utils/ListKeyboard.d.ts
+//# sourceMappingURL=TestListProvider.d.ts.map
+interface KeyboardNavigationOptions {
+  enableArrowKeys?: boolean;
+  enableHomeEnd?: boolean;
+  enableSpaceEnter?: boolean;
+  enableSelectAll?: boolean;
+  enableEscape?: boolean;
+  enablePageUpDown?: boolean;
+}
+declare class ListKeyboardHandler {
+  private model;
+  private options;
+  private isAttached;
+  constructor(model: ListItemsModel, options?: KeyboardNavigationOptions);
+  /**
+   * Attach keyboard event listeners
+   */
+  attach(element?: HTMLElement): void;
+  /**
+   * Detach keyboard event listeners
+   */
+  detach(element?: HTMLElement): void;
+  /**
+   * Main keyboard event handler
+   */
+  private handleKeyDown;
+  /**
+   * Handle arrow up navigation
+   */
+  private handleArrowUp;
+  /**
+   * Handle arrow down navigation
+   */
+  private handleArrowDown;
+  /**
+   * Handle arrow left navigation (grid view)
+   */
+  private handleArrowLeft;
+  /**
+   * Handle arrow right navigation (grid view)
+   */
+  private handleArrowRight;
+  /**
+   * Handle list view arrow up
+   */
+  private handleListArrowUp;
+  /**
+   * Handle list view arrow down
+   */
+  private handleListArrowDown;
+  /**
+   * Handle grid view arrow up (move up by grid columns)
+   */
+  private handleGridArrowUp;
+  /**
+   * Handle grid view arrow down (move down by grid columns)
+   */
+  private handleGridArrowDown;
+  /**
+   * Handle Home key - go to first item
+   */
+  private handleHome;
+  /**
+   * Handle End key - go to last item
+   */
+  private handleEnd;
+  /**
+   * Handle Page Up - move up by visible page size
+   */
+  private handlePageUp;
+  /**
+   * Handle Page Down - move down by visible page size
+   */
+  private handlePageDown;
+  /**
+   * Handle Space key - toggle selection of focused item
+   */
+  private handleSpace;
+  /**
+   * Handle Enter key - activate focused item
+   */
+  private handleEnter;
+  /**
+   * Handle Ctrl+A - select all items
+   */
+  private handleSelectAll;
+  /**
+   * Handle Escape - clear selection first, then navigate up one directory
+   */
+  private handleEscape;
+  /**
+   * Navigate to specific index with optional range selection
+   */
+  private navigateToIndex;
+  /**
+   * Get current focused item index
+   */
+  private getCurrentFocusedIndex;
+  /**
+   * Get currently focused item
+   */
+  private getFocusedItem;
+  /**
+   * Get number of columns per row in grid view
+   */
+  private getGridColumnsPerRow;
+  /**
+   * Get page size for page up/down navigation
+   */
+  private getPageSize;
+}
+/**
+ * Hook for using keyboard navigation in React components
+ */
+declare const useListKeyboard: (model: ListItemsModel, options?: KeyboardNavigationOptions, containerRef?: React$1.RefObject<HTMLElement | HTMLDivElement | null>) => ListKeyboardHandler;
+
+//#endregion
+//#region src/list/utils/ListAccessibility.d.ts
+//# sourceMappingURL=ListKeyboard.d.ts.map
+interface AccessibilityConfig {
+  role?: string;
+  ariaLabel?: string;
+  ariaLabelledBy?: string;
+  ariaDescribedBy?: string;
+  ariaMultiSelectable?: boolean;
+  ariaOrientation?: 'horizontal' | 'vertical';
+  tabIndex?: number;
+}
+interface ItemAccessibilityConfig {
+  role?: string;
+  ariaLabel?: string;
+  ariaSelected?: boolean;
+  ariaExpanded?: boolean;
+  ariaLevel?: number;
+  ariaSetSize?: number;
+  ariaPosInSet?: number;
+  tabIndex?: number;
+}
+declare function getListAccessibilityProps(config: {
+  viewType: string;
+  isMultiSelect: boolean;
+  totalItems: number;
+  selectedCount: number;
+  label?: string;
+  labelledBy?: string;
+  describedBy?: string;
+}): AccessibilityConfig;
+declare function getItemAccessibilityProps(config: {
+  item: any;
+  index: number;
+  totalItems: number;
+  isSelected: boolean;
+  isFocused: boolean;
+  viewType: string;
+  isExpandable?: boolean;
+  isExpanded?: boolean;
+  level?: number;
+}): ItemAccessibilityConfig;
+declare function createLiveRegionAnnouncement(config: {
+  action: 'select' | 'deselect' | 'focus' | 'activate' | 'load' | 'error';
+  itemName?: string;
+  itemCount?: number;
+  selectedCount?: number;
+  totalCount?: number;
+  errorMessage?: string;
+}): string;
+interface KeyboardNavigationConfig {
+  currentIndex: number;
+  totalItems: number;
+  itemsPerRow?: number;
+  viewType: string;
+}
+declare function getNextFocusIndex(key: string, config: KeyboardNavigationConfig): number | null;
+declare class FocusManager {
+  private focusedElement;
+  private focusHistory;
+  saveFocus(): void;
+  restoreFocus(): boolean;
+  focusFirst(container: HTMLElement): boolean;
+  focusLast(container: HTMLElement): boolean;
+  private getFocusableElements;
+}
+declare function announceToScreenReader(message: string, priority?: 'polite' | 'assertive'): void;
+
+//#endregion
+//#region src/list/utils/BenchmarkLogger.d.ts
+//# sourceMappingURL=ListAccessibility.d.ts.map
+interface BenchmarkResult {
+  operation: string;
+  duration: number;
+  timestamp: number;
+  metadata?: Record<string, any>;
+}
+interface BenchmarkReport {
+  totalOperations: number;
+  totalDuration: number;
+  averageDuration: number;
+  slowestOperation: BenchmarkResult | null;
+  fastestOperation: BenchmarkResult | null;
+  operations: BenchmarkResult[];
+}
+declare class BenchmarkLogger {
+  private results;
+  private activeTimers;
+  private enabled;
+  constructor(enabled?: boolean);
+  /**
+   * Start timing an operation
+   */
+  start(operation: string, metadata?: Record<string, any>): void;
+  /**
+   * End timing an operation and log the result
+   */
+  end(operation: string, metadata?: Record<string, any>): number;
+  /**
+   * Time a synchronous operation
+   */
+  time<T>(operation: string, fn: () => T, metadata?: Record<string, any>): T;
+  /**
+   * Time an asynchronous operation
+   */
+  timeAsync<T>(operation: string, fn: () => Promise<T>, metadata?: Record<string, any>): Promise<T>;
+  /**
+   * Get a performance report
+   */
+  getReport(): BenchmarkReport;
+  /**
+   * Log a performance report
+   */
+  logReport(): void;
+  /**
+   * Clear all benchmark results
+   */
+  clear(): void;
+  /**
+   * Enable or disable benchmarking
+   */
+  setEnabled(enabled: boolean): void;
+  /**
+   * Check if benchmarking is enabled
+   */
+  isEnabled(): boolean;
+  private getDurationColor;
+  private formatDuration;
+  private groupOperationsByName;
+}
+declare const benchmarkLogger: BenchmarkLogger;
+declare const benchmark: {
+  start: (operation: string, metadata?: Record<string, any>) => void;
+  end: (operation: string, metadata?: Record<string, any>) => number;
+  time: <T>(operation: string, fn: () => T, metadata?: Record<string, any>) => T;
+  timeAsync: <T>(operation: string, fn: () => Promise<T>, metadata?: Record<string, any>) => Promise<T>;
+  report: () => void;
+  clear: () => void;
+  setEnabled: (enabled: boolean) => void;
+};
+
+//#endregion
+//#region src/list/utils/MasonryLayoutCalculator.d.ts
+//# sourceMappingURL=BenchmarkLogger.d.ts.map
+interface MasonryLayoutConfig {
+  containerWidth: number;
+  containerHeight: number;
+  columnCount: number | 'auto';
+  gap: number;
+  padding: number;
+  minColumnWidth: number;
+  maxColumnWidth: number;
+}
+interface MasonryItemLayout {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  column: number;
+  thumbnailWidth: number;
+  thumbnailHeight: number;
+  textHeight: number;
+}
+interface MasonryLayoutResult {
+  columnCount: number;
+  columnWidth: number;
+  totalHeight: number;
+  items: MasonryItemLayout[];
+  columnHeights: number[];
+}
+interface MasonryItemData {
+  id: string;
+  aspectRatio?: number;
+  customHeight?: number;
+  textLength?: number;
+}
+declare class MasonryLayoutCalculator {
+  private config;
+  constructor(config: MasonryLayoutConfig);
+  updateConfig(updates: Partial<MasonryLayoutConfig>): void;
+  get currentConfig(): MasonryLayoutConfig;
+  calculateColumnCount(): number;
+  calculateColumnWidth(columnCount: number): number;
+  calculateItemHeight(item: MasonryItemData, columnWidth: number, baseHeight?: number): number;
+  private calculateTextHeight;
+  calculateThumbnailDimensions(item: MasonryItemData, columnWidth: number, itemHeight: number): {
+    width: number;
+    height: number;
+  };
+  calculateLayout(items: MasonryItemData[]): MasonryLayoutResult;
+  calculateVisibleItems(items: MasonryItemData[], scrollTop: number, viewportHeight: number, overscan?: number): {
+    startIndex: number;
+    endIndex: number;
+    visibleItems: MasonryItemLayout[];
+  };
+  getItemPosition(itemIndex: number, items: MasonryItemData[]): MasonryItemLayout | null;
+  getItemAtPosition(x: number, y: number, items: MasonryItemData[]): number | null;
+}
+declare function createMasonryCalculator(containerWidth: number, containerHeight: number, options?: Partial<MasonryLayoutConfig>): MasonryLayoutCalculator;
+declare const MASONRY_PRESETS: {
+  readonly compact: {
+    readonly gap: 4;
+    readonly padding: 4;
+    readonly minColumnWidth: 160;
+    readonly maxColumnWidth: 250;
+  };
+  readonly comfortable: {
+    readonly gap: 8;
+    readonly padding: 8;
+    readonly minColumnWidth: 200;
+    readonly maxColumnWidth: 300;
+  };
+  readonly spacious: {
+    readonly gap: 16;
+    readonly padding: 16;
+    readonly minColumnWidth: 250;
+    readonly maxColumnWidth: 400;
+  };
+};
+
+//#endregion
+//# sourceMappingURL=MasonryLayoutCalculator.d.ts.map
+
+export { AccessibilityConfig, BenchmarkReport, BenchmarkResult, CalculatedGridView as CalculatedGridView$1, DETAILS_VIEW_TYPE as DETAILS_VIEW_TYPE$1, EmptyState as EmptyState$1, ErrorDisplay as ErrorDisplay$1, FocusManager as FocusManager$1, GRID_PRESETS as GRID_PRESETS$1, GRID_VIEW_TYPE as GRID_VIEW_TYPE$1, GridItemLayout, GridLayoutCalculator as GridLayoutCalculator$1, GridLayoutConfig, GridLayoutResult, InlineLoading as InlineLoading$1, ItemAccessibilityConfig, KeyboardNavigationConfig, KeyboardNavigationOptions, LIST_VIEW_TYPE as LIST_VIEW_TYPE$1, ListContextMenu as ListContextMenu$1, ListContextMenuItem, ListDragDropInfo, ListError, ListErrorBoundary as ListErrorBoundary$1, ListItem as ListItem$1, ListItemData, ListItemProps, ListItemRenderer, ListItems as ListItems$1, ListItemsModel as ListItemsModel$1, ListItemsProps, ListItemsProvider, ListItemsProviderListener, ListKeyboardHandler as ListKeyboardHandler$1, ListLoadOptions, ListLoadResult, ListLoader as ListLoader$1, ListSelectionInfo, ListViewType, ListViewType$1, LoadError as LoadError$1, LoadingIndicator as LoadingIndicator$1, LoadingProgress as LoadingProgress$1, MASONRY_HORIZONTAL_VIEW_TYPE as MASONRY_HORIZONTAL_VIEW_TYPE$1, MASONRY_PRESETS as MASONRY_PRESETS$1, MASONRY_VERTICAL_VIEW_TYPE as MASONRY_VERTICAL_VIEW_TYPE$1, MasonryItemData, MasonryItemLayout, MasonryLayoutCalculator as MasonryLayoutCalculator$1, MasonryLayoutConfig, MasonryLayoutResult, MasonryView as MasonryView$1, NetworkError as NetworkError$1, NoItems as NoItems$1, NoSearchResults as NoSearchResults$1, NoSelection as NoSelection$1, SearchFilter as SearchFilter$1, TREEMAP_VIEW_TYPE as TREEMAP_VIEW_TYPE$1, TestListProvider as TestListProvider$1, ThumbnailSize, TreemapModel as TreemapModel$1, TreemapNodeData, TreemapScanProgress, TreemapView as TreemapView$1, ViewSizeControls as ViewSizeControls$1, ViewTypeSelector as ViewTypeSelector$1, ViewTypeSelectorProps, VirtualizationConfig, VirtualizedGrid as VirtualizedGrid$1, VirtualizedGridProps, VirtualizedList as VirtualizedList$1, VirtualizedListProps, announceToScreenReader as announceToScreenReader$1, benchmark as benchmark$1, benchmarkLogger as benchmarkLogger$1, createGridCalculator as createGridCalculator$1, createLiveRegionAnnouncement as createLiveRegionAnnouncement$1, createMasonryCalculator as createMasonryCalculator$1, getItemAccessibilityProps as getItemAccessibilityProps$1, getListAccessibilityProps as getListAccessibilityProps$1, getNextFocusIndex as getNextFocusIndex$1, useListKeyboard as useListKeyboard$1 };
+//# sourceMappingURL=index-Bryv_GCG.d.ts.map