FS UI API reference

fileSystem: IFileSystem

fileSystemBridge: FileSystemBridge

treeProvider: FileSystemTreeProvider

listProvider: FileSystemListProvider

treeModel: TreeModel

listModel: ListItemsModel

currentPath: string

selectedPath: string

isLoading: boolean

error: string

openFile: OpenFileState

renameState: { itemId: string; currentName: string; path: string; source: "list" | "tree"; }

deleteState: { targets: Array<{ path: string; isDirectory: boolean; name: string; }>; }

createState: { parentPath: string; type: "file" | "folder"; }

constructor(fileSystem: IFileSystem): FileBrowserModel

setInitialPath(path: string): Promise<void>

handleTreeSelection: (path: string) => Promise<void>

handleListNavigation: (path: string) => Promise<void>

handleListSelection: (selectedItems: ListItemData[]) => void

navigateUp(): Promise<void>

navigateToPath(path: string): Promise<void>

refresh(): Promise<void>

navigateToBreadcrumb(path: string): Promise<void>

refreshItems(): Promise<void>

clearError(): void

setCurrentPath(path: string): Promise<void>

openFileViewer(path: string, name: string, size?: number): Promise<void>

navigateToNextFile(): Promise<void>

navigateToPrevFile(): Promise<void>

closeFileViewer(): void

requestRename(itemId: string, currentName: string, path: string, source?: "list" | "tree"): void

confirmRename(newName: string): Promise<void>

cancelRename(): void

requestDelete(targets: Array<{ path: string; isDirectory: boolean; name: string; }>): void

confirmDelete(): Promise<void>

cancelDelete(): void

requestCreate(parentPath: string, type: "file" | "folder"): void

confirmCreate(name: string): Promise<void>

cancelCreate(): void

selectedItems: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, boolean>

lastSelectedIndex: number

focusedItem: FileBrowserItem

isUpdatingFromPanels: boolean

constructor(owner: SelectionOwner): SelectionManagerModel

isSelected: (itemId: string) => boolean

selectItem: (itemId: string, multiSelect?: boolean) => void

deselectItem: (itemId: string) => void

toggleSelection: (itemId: string, multiSelect?: boolean) => void

selectRange: (startItemId: string, endItemId: string, allItems: FileBrowserItem[]) => void

selectAll: (items: FileBrowserItem[]) => void

clearSelection: () => void

invertSelection: (allItems: FileBrowserItem[]) => void

getSelectedItems: (allItems: FileBrowserItem[]) => FileBrowserItem[]

setFocusedItem: (item: FileBrowserItem | null) => void

selectFromTreePanel: (item: FileBrowserItem) => void

selectFromRightPanel: (item: FileBrowserItem) => void

selectFromNavigation: (path: string, allItems: FileBrowserItem[]) => void

dispose: () => void

history: string[]

historyIndex: number

isUpdatingFromPanels: boolean

constructor(owner: NavigationOwner): NavigationManagerModel

addToHistory: (path: string) => void

goBack: () => string | null

goForward: () => string | null

goToParent: (currentPath: string) => string | null

clearHistory: () => void

setCurrentPath: (path: string) => void

navigateTo: (path: string) => void

normalizePath: (path: string) => string

getParentPath: (path: string) => string | null

getPathSegments: (path: string) => string[]

joinPaths: (...paths: string[]) => string

navigateFromTreePanel: (path: string) => void

navigateFromRightPanel: (path: string) => void

navigateFromBreadcrumb: (path: string) => void

navigateToWithCoordination: (path: string, source?: "tree" | "right" | "breadcrumb" | "history") => void

setSelectionManager: (selectionManager: any) => void

dispose: () => void

toolbarActions: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, ToolbarAction>

contextActions: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, ContextAction>

constructor(owner: ToolbarOwner): ToolbarManagerModel

addAction: (action: ToolbarAction) => void

removeAction: (actionId: string) => void

updateAction: (actionId: string, updates: Partial<ToolbarAction>) => void

addContextAction: (action: ContextAction) => void

removeContextAction: (actionId: string) => void

getAvailableActions: (context: ActionContext) => ToolbarAction[]

getContextActionsForItem: (context: ActionContext) => ContextAction[]

canExecuteAction: (actionId: string, context: ActionContext) => boolean

getActionById: (actionId: string) => ToolbarAction | undefined

getContextActionById: (actionId: string) => ContextAction | undefined

setActions: (actions: ToolbarAction[]) => void

setContextActions: (actions: ContextAction[]) => void

clearAllActions: () => void

availableViewModes: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, ViewModeDefinition>

currentViewMode: string

currentFilters: FilterCriteria

currentSortCriteria: SortCriteria

treeViewUI: TreeViewUIModel

listViewUI: ListViewUIModel

thumbnailViewUI: ThumbnailViewUIModel

treemapViewUI: TreemapViewUIModel

constructor(owner: any): ViewModeManagerModel

setCurrentViewMode: (viewModeId: string) => void

registerViewMode: (definition: ViewModeDefinition) => void

unregisterViewMode: (viewModeId: string) => void

setFilter: (key: keyof FilterCriteria, value: any) => void

clearFilters: () => void

setSortCriteria: (field: string, direction: "asc" | "desc") => void

clearSort: () => void

toggleSortDirection: () => void

supportsCapability: (capability: string) => boolean

dispose(): void

expandedFolders: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, boolean>

indentSize: number

showConnectors: boolean

expandOnSingleClick: boolean

collapseOnSecondClick: boolean

rememberExpansion: boolean

settings: TreeViewSettings

constructor(owner: any): TreeViewUIModel

expandFolder: (path: string) => void

collapseFolder: (path: string) => void

toggleFolder: (path: string) => void

isFolderExpanded: (path: string) => boolean

hasChildren: (item: FileBrowserItem) => boolean

sortTreeNodes: (nodes: FileBrowserItem[]) => FileBrowserItem[]

expandAll: () => void

collapseAll: () => void

updateSettings: (newSettings: Partial<TreeViewSettings>) => void

dispose(): void

columns: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, ColumnDefinition>

columnOrder: string[]

currentSort: SortCriteria

settings: ListViewSettings

showHeader: boolean

striped: boolean

compact: boolean

hoverable: boolean

constructor(owner: ListViewOwner): ListViewUIModel

addColumn: (column: ColumnDefinition) => void

removeColumn: (columnId: string) => void

updateColumn: (columnId: string, updates: Partial<ColumnDefinition>) => void

resizeColumn: (columnId: string, width: number) => void

reorderColumns: (fromIndex: number, toIndex: number) => void

showColumn: (columnId: string) => void

hideColumn: (columnId: string) => void

toggleColumnVisibility: (columnId: string) => void

setSortCriteria: (field: string, direction: "asc" | "desc") => void

toggleSort: (field: string) => void

clearSort: () => void

updateSettings: (newSettings: Partial<ListViewSettings>) => void

resetToDefaults: () => void

saveColumnLayout: (name: string) => void

loadColumnLayout: (name: string) => void

dispose(): void

thumbnailSize: number

gridSpacing: number

aspectRatio: number

showFilenames: boolean

showFileSize: boolean

showDate: boolean

loadThumbnails: boolean

thumbnailQuality: "low" | "medium" | "high"

columnsPerRow: number | "auto"

settings: ThumbnailViewSettings

loadingThumbnails: Set<string>

failedThumbnails: Set<string>

constructor(owner: ThumbnailOwner): ThumbnailViewUIModel

setThumbnailSize: (size: number) => void

setGridSpacing: (spacing: number) => void

setAspectRatio: (ratio: number) => void

setColumnsPerRow: (columns: number | "auto") => void

toggleShowFilenames: () => void

toggleShowFileSize: () => void

toggleShowDate: () => void

setThumbnailQuality: (quality: "low" | "medium" | "high") => void

setThumbnailLoading: (itemId: string, loading: boolean) => void

setThumbnailFailed: (itemId: string) => void

setThumbnailSuccess: (itemId: string) => void

isThumbnailLoading: (itemId: string) => boolean

isThumbnailFailed: (itemId: string) => boolean

clearThumbnailStates: () => void

calculateGridLayout: (containerWidth: number) => { columns: number; itemsPerRow: number; }

updateSettings: (newSettings: Partial<ThumbnailViewSettings>) => void

applyPreset: (preset: "compact" | "balanced" | "detailed") => void

resetToDefaults: () => void

dispose(): void

constructor(props: ErrorBoundaryProps): ErrorBoundary

getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>

componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void

handleReset: () => void

render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>> | import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/@types+react@19.2.14/node_modules/@types/react/jsx-runtime").JSX.Element

id: "filesystem"

name: "File System Provider"

version: "1.0.0"

constructor(fileSystem: IFileSystem, cacheOptions?: Partial<CacheOptions>): FileSystemProvider

loadItems(path: string): Promise<FileBrowserItem[]>

normalizePath(path: string): string

getParentPath(path: string): string | null

resolvePath(basePath: string, relativePath: string): string

getItemIcon(item: FileBrowserItem): IconDefinition

getItemDisplayName(item: FileBrowserItem): string

getItemPreview(item: FileBrowserItem): Promise<PreviewData | null>

canPerformAction(action: string, items: FileBrowserItem[]): boolean

performAction(action: string, items: FileBrowserItem[]): Promise<any>

initialize(): Promise<void>

dispose(): void

clearCache(): void

getCacheStats(): { size: number; maxSize: number; hitRate?: number; }

getLeftPanelModes(): LeftPanelMode[]

getRightPanelViewModes(): ViewModeDefinition[]

id: "git-repository"

name: "Git Repository Provider"

version: "1.0.0"

constructor(options: GitRepositoryOptions): GitRepositoryProvider

loadItems(path: string): Promise<FileBrowserItem[]>

normalizePath(path: string): string

getParentPath(path: string): string | null

resolvePath(basePath: string, relativePath: string): string

getItemIcon(item: FileBrowserItem): IconDefinition

getItemDisplayName(item: FileBrowserItem): string

getItemPreview(item: FileBrowserItem): Promise<PreviewData | null>

canPerformAction(action: string, items: FileBrowserItem[]): boolean

performAction(action: string, items: FileBrowserItem[]): Promise<any>

initialize(): Promise<void>

dispose(): void

getCurrentBranch(): Promise<string>

getBranches(): Promise<string[]>

switchBranch(branch: string): Promise<void>

getCommitHistory(path?: string, limit?: number): Promise<any[]>

id: "git"

name: "Git Provider"

version: "1.0.0"

constructor(repository: GitRepositoryModel | GitWrapperIntegration): GitProvider

loadItems(path: string): Promise<FileBrowserItem[]>

getLeftPanelModes(): LeftPanelMode[]

getRightPanelViewModes(): ViewModeDefinition[]

normalizePath(path: string): string

getParentPath(path: string): string | null

resolvePath(basePath: string, relativePath: string): string

getItemIcon(item: FileBrowserItem): IconDefinition

getItemDisplayName(item: FileBrowserItem): string

canPreviewFile(item: FileBrowserItem): boolean

getFilePreview(item: FileBrowserItem): Promise<PreviewData>

getItemPreview(item: FileBrowserItem): Promise<PreviewData | null>

canPerformAction(action: string, items: FileBrowserItem[]): boolean

performAction(action: string, items: FileBrowserItem[]): Promise<any>

initialize(): Promise<void>

dispose(): void

nodes: TreeNodeData[]

nodeMap: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, TreeNodeData>

isLoading: boolean

errors: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, Error>

selectedNodes: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, TreeNodeData>

focusedNode: string

checkboxStates: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, CheckboxState>

expandedNodes: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, boolean>

loadingNodes: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, boolean>

contextMenuVisible: boolean

contextMenuPosition: { x: number; y: number; }

contextMenuItems: TreeContextMenuItem[]

contextMenuNodes: TreeNodeData[]

constructor(provider: TreeProvider): TreeModel

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) => import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").CancellablePromise<void>

Select a specific node

selectNode(node: TreeNodeData): void

Deselect a specific node

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

Set focus to a specific node

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

Expand a specific node

expandNode: (node: TreeNodeData) => import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").CancellablePromise<void>

Collapse a specific node

collapseNode(node: TreeNodeData): void

Toggle expansion state of a specific node

toggleExpansion(node: TreeNodeData): void

Show context menu for a specific node

showContextMenu(node: TreeNodeData, event: MouseEvent): void

Show context menu for multiple selected nodes

showMultiNodeContextMenu(nodes: TreeNodeData[], event: MouseEvent): void

Hide context menu

hideContextMenu(): void

Handle context menu item click

handleContextMenuAction(menuItem: TreeContextMenuItem): void

id: "test-tree-provider"

name: "Test Tree Provider"

version: "1.0.0"

isMultiSelectEnabled: boolean

isDragDropEnabled: false

isVirtualizationEnabled: false

isTableViewEnabled: true

useCheckboxSelection: boolean

allowPartialSelection: true

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(): TestTreeProvider

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>

Get custom icon for a node based on file type and category

getNodeIcon(node: TreeNodeData): string | React.ComponentType<any>

id: "simple-tree-provider"

name: "Simple Tree Provider"

version: "1.0.0"

isMultiSelectEnabled: boolean

isDragDropEnabled: false

isVirtualizationEnabled: false

isTableViewEnabled: false

useCheckboxSelection: boolean

allowPartialSelection: true

config: {}

selectionTheme: TreeSelectionTheme

onSelectionChange: (selectionInfo: TreeSelectionInfo) => void

onNodeExpansion: (node: TreeNodeData, isExpanded: boolean) => void

onNodeFocus: (node: TreeNodeData | null) => void

onContextMenuAction: (actionId: string, nodes: TreeNodeData[]) => void

constructor(options?: SimpleTreeProviderOptions): SimpleTreeProvider

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

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

constructor(props: ErrorBoundaryProps): ListErrorBoundary

getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>

componentDidCatch(error: Error, errorInfo: ErrorInfo): void

handleRetry: () => void

render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>> | import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/@types+react@19.2.14/node_modules/@types/react/jsx-runtime").JSX.Element

saveFocus(): void

restoreFocus(): boolean

focusFirst(container: HTMLElement): boolean

focusLast(container: HTMLElement): boolean

currentViewType: ListViewType

items: ListItemData[]

itemMap: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, ListItemData>

totalItemCount: number

selectedItems: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, ListItemData>

previousSelection: ListItemData[]

focusedItem: string

selectionAnchor: string

isLoading: boolean

loadingRanges: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, boolean>

errors: import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").ObservableMap<string, Error>

viewportRange: { start: number; end: number; }

scrollPosition: number

containerSize: { width: number; height: number; }

isDragging: boolean

draggedItems: ListItemData[]

dragOverItem: string

dragOverPosition: "before" | "after" | "inside"

itemSize: "medium" | "small" | "large" | "extra-large"

customItemWidth: number

customItemHeight: number

itemsPerRow: number | "auto"

debugVisualization: boolean

constructor(provider: ListItemsProvider): ListItemsModel

onItemsCountChanged(count: number): void

onItemChanged(itemIndex: number): void

Load items from the provider Uses MobX flow for proper async action handling

loadItems: (options?: ListLoadOptions) => import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").CancellablePromise<void>

Load a specific range of items for virtualization

loadItemRange: (start: number, end: number) => import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").CancellablePromise<void>

Refresh items from provider

refresh: () => import("/home/andrew/gits/github/AnyFileSystem/AnyFsMnoorepo-sf-phase3-npmf/node_modules/.pnpm/mobx@6.15.0/node_modules/mobx/dist/internal").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

Set items per row for grid and masonry views

setItemsPerRow(itemsPerRow: number | "auto"): void

Set debug visualization mode

setDebugVisualization(enabled: boolean): void

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

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

Update scroll position

updateScrollPosition(position: number): void

Update container size

updateContainerSize(width: number, height: number): void

Get grid layout for current items

getGridLayout(): { layout: GridItemLayout[]; totalHeight: number; } | null

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

Get item by ID

getItem(itemId: string): ListItemData | undefined

Get item index

getItemIndex(itemId: string): number

id: "test-list-provider"

name: "Test List Provider"

isMultiSelectEnabled: true

isVirtualizationEnabled: true

isDragDropEnabled: true

supportedViewTypes: ListViewType[]

constructor(): TestListProvider

Get custom icon for an item based on file type and extension

getItemIcon(item: ListItemData): string | React.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

constructor(config: GridLayoutConfig): GridLayoutCalculator

updateConfig(updates: Partial<GridLayoutConfig>): void

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

constructor(config: MasonryLayoutConfig): MasonryLayoutCalculator

updateConfig(updates: Partial<MasonryLayoutConfig>): void

calculateColumnCount(): number

calculateColumnWidth(columnCount: number): number

calculateItemHeight(item: MasonryItemData, columnWidth: number, baseHeight?: number): number

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

provider: any

initialPath: string

initialViewMode: string

eventHandlers: FileBrowserEventHandlers

className: string

style: React.CSSProperties

showToolbar: boolean

showBreadcrumb: boolean

showStatusBar: boolean

allowMultiSelect: boolean

availableViewModes: string[]

defaultViewMode: string

theme: "light" | "dark" | "auto"

density: "compact" | "normal" | "comfortable"

id: string

name: string

path: string

type: "file" | "directory"

size: number

lastModified: Date

permissions: string

metadata: Record<string, any>

children: FileBrowserItem[]

isLoading: boolean

hasChildren: boolean

content: string | Uint8Array<ArrayBufferLike>

preview: PreviewData

properties: Record<string, any>

onPathChange: (path: string) => void

onItemSelect: (item: FileBrowserItem) => void

onItemActivate: (item: FileBrowserItem) => void

onSelectionChange: (selectedItems: FileBrowserItem[]) => void

onError: (error: ErrorState) => void

onLoadingChange: (isLoading: boolean) => void

message: string

code: string

details: any

timestamp: Date

searchText: string

fileTypes: string[]

dateRange: { start: Date; end: Date; }

sizeRange: { min: number; max: number; }

customFilters: Record<string, any>

field: string

direction: "asc" | "desc"

currentPath: string

history: string[]

historyIndex: number

canGoBack: boolean

canGoForward: boolean

selectedItems: Set<string>

lastSelectedIndex: number

focusedItemId: string

selectionMode: "single" | "multiple"

type: "lucide" | "custom"

name: string

component: React.ComponentType<any>

color: string

size: number

type: "image" | "text" | "video" | "audio" | "document"

url: string

content: string

thumbnail: string

metadata: Record<string, any>

type: "added" | "removed" | "modified" | "moved"

item: FileBrowserItem

oldPath: string

newPath: string

id: string

label: string

field: string

width: number

minWidth: number

maxWidth: number

resizable: boolean

sortable: boolean

visible: boolean

align: "right" | "left" | "center"

format: (value: any) => string

size: "sm" | "md" | "lg"

overlay: boolean

className: string

'aria-label': string

children: React.ReactNode

fallback: (error: Error, errorInfo: string, onReset: () => void) => ReactNode

onError: (error: Error, errorInfo: string) => void

className: string

item: FileBrowserItem

getItemIcon: (item: FileBrowserItem) => IconDefinition

size: "sm" | "md" | "lg" | "xl"

className: string

isExpanded: boolean

model: FileBrowserModel

toolbarManager: ToolbarManagerModel

className: string

showBreadcrumb: boolean

showToolbar: boolean

model: FileBrowserModel

className: string

currentViewMode: string

items: FileBrowserItem[]

treeModel: TreeViewUIModel

onItemClick: (item: FileBrowserItem) => void

onItemDoubleClick: (item: FileBrowserItem) => void

onItemActivate: (item: FileBrowserItem) => void

onSelectionChange: (selectedItems: FileBrowserItem[]) => void

onPathChange: (path: string) => void

selectedItemIds: Set<string>

focusedItemId: string

className: string

getItemIcon: (item: FileBrowserItem) => any

loadFolder: (path: string) => Promise<FileBrowserItem[]>

virtualization: boolean

maxHeight: number

item: FileBrowserItem

treeModel: TreeViewUIModel

level: number

onItemClick: (item: FileBrowserItem) => void

onItemDoubleClick: (item: FileBrowserItem) => void

isSelected: boolean

isFocused: boolean

getItemIcon: (item: FileBrowserItem) => any

items: FileBrowserItem[]

treeModel: TreeViewUIModel

onItemClick: (item: FileBrowserItem) => void

onItemDoubleClick: (item: FileBrowserItem) => void

onSelectionChange: (selectedItems: FileBrowserItem[]) => void

selectedItemIds: Set<string>

focusedItemId: string

className: string

getItemIcon: (item: FileBrowserItem) => any

virtualization: boolean

maxHeight: number

items: FileBrowserItem[]

listModel: ListViewUIModel

responsiveManager: ResponsiveLayoutManagerModel

onItemClick: (item: FileBrowserItem) => void

onItemDoubleClick: (item: FileBrowserItem) => void

onItemActivate: (item: FileBrowserItem) => void

onSelectionChange: (selectedItems: FileBrowserItem[]) => void

selectedItemIds: Set<string>

focusedItemId: string

className: string

getItemIcon: (item: FileBrowserItem) => any

path: string

onPathChange: (path: string) => void

className: string

maxSegments: number

separator: React.ReactNode

showRoot: boolean

rootLabel: string

canGoBack: boolean

canGoForward: boolean

canGoUp: boolean

onGoBack: () => void

onGoForward: () => void

onGoUp: () => void

className: string

variant: "compact" | "default"

showLabels: boolean

disabled: boolean

currentMode: ViewModeType

availableModes: ViewModeType[]

onModeChange: (mode: ViewModeType) => void

className: string

variant: "tabs" | "buttons"

showLabels: boolean

disabled: boolean

Provider identifier

id: string

Human-readable name

name: string

Provider version

version: string

Whether multi-selection is enabled

isMultiSelectEnabled: boolean

Whether drag and drop is enabled

isDragDropEnabled: boolean

Whether virtualization is enabled for large trees

isVirtualizationEnabled: boolean

Whether to use checkbox-based selection instead of highlight selection

useCheckboxSelection: boolean

Whether to allow partial (indeterminate) checkbox selection for parent nodes

allowPartialSelection: boolean

Whether table view is enabled for this provider

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

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>

Search nodes

search(query: string, options?: TreeLoadOptions): Promise<TreeLoadResult>

Get context menu items for a specific node

getNodeContextMenu(node: TreeNodeData): TreeContextMenuItem[]

Get context menu items for multiple selected nodes

getMultiNodeContextMenu(nodes: TreeNodeData[]): TreeContextMenuItem[]

Get context menu items for empty space (no node)

getEmptySpaceContextMenu(parentNode?: TreeNodeData): TreeContextMenuItem[]

Get custom renderer for a specific node

getNodeRenderer(node: TreeNodeData): TreeNodeRenderer | null

Get default renderer for all nodes of this provider

getDefaultRenderer(): TreeNodeRenderer

Get custom icon for a node

getNodeIcon(node: TreeNodeData): string | React.ComponentType<any>

Check if a node can be expanded

canExpand(node: TreeNodeData): boolean

Check if a node can be selected

canSelect(node: TreeNodeData): boolean

Check if nodes can be dragged

canDrag(nodes: TreeNodeData[]): boolean

Check if a drop operation is allowed

canDrop(dragInfo: TreeDragDropInfo): boolean

Called when node selection changes

onSelectionChange(selectionInfo: TreeSelectionInfo): void

Called when a node is expanded or collapsed

onNodeExpansion(node: TreeNodeData, expanded: boolean): void

Called when a node is double-clicked

onNodeDoubleClick(node: TreeNodeData): void

Called when a drag and drop operation completes

onDragDrop(dragInfo: TreeDragDropInfo): Promise<void>

Called when a context menu item is selected

onContextMenuAction(menuItemId: string, nodes: TreeNodeData[]): void

Called when a node is focused

onNodeFocus(node: TreeNodeData | null): void

Called when table sort changes

onTableSort(sort: TreeTableSort | null): void

Called when table data export is requested

onTableExport(options: TreeTableExportOptions): Promise<string | void>

Initialize the provider

initialize(): Promise<void>

Cleanup provider resources

dispose(): void

Provider-specific configuration

config: Record<string, any>

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: 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>

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

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

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: "right" | "left" | "center"

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

Column ID to sort by

columnId: string

Sort direction

direction: "asc" | "desc"

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

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: string; foreground: string; accent: string; }

Whether to animate selection changes

animated: boolean

Whether to show selection even when component loses focus

persistSelection: boolean

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

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

role: string

ariaLabel: string

ariaLabelledBy: string

ariaDescribedBy: string

ariaMultiSelectable: boolean

ariaOrientation: "horizontal" | "vertical"

tabIndex: number

role: string

ariaLabel: string

ariaSelected: boolean

ariaExpanded: boolean

ariaLevel: number

ariaSetSize: number

ariaPosInSet: number

tabIndex: number

currentIndex: number

totalItems: number

itemsPerRow: number

viewType: string

Provider identifier

id: string

Human-readable name

name: string

Supported view types for this provider

supportedViewTypes: ListViewType[]

Whether multi-selection is enabled

isMultiSelectEnabled: boolean

Whether virtualization is enabled

isVirtualizationEnabled: boolean

Load items from the data source

loadItems(options?: ListLoadOptions): Promise<ListLoadResult>

Get total count of items (for virtualization)

getItemCount(): Promise<number>

Load a specific range of items (for virtualization)

loadItemRange(start: number, end: number): Promise<ListLoadResult>

Refresh/reload items

refresh(): Promise<ListLoadResult>

Get item height for a specific view type (for virtualization)

getItemHeight(viewType: ListViewType): number

Get item width for grid-based view types

getItemWidth(viewType: ListViewType): number

Get virtualization configuration

getVirtualizationConfig(): VirtualizationConfig

Called when selection changes

onSelectionChange(selectionInfo: ListSelectionInfo): void

Called when view type changes

onViewTypeChange(viewType: ListViewType): void

Called when an item is double-clicked

onItemDoubleClick(item: ListItemData): void

addListener(listener: ListItemsProviderListener): void

removeListener(listener: ListItemsProviderListener): void

Get custom icon for an item

getItemIcon(item: ListItemData): string | React.ComponentType<any>

Get context menu items for a specific item

getItemContextMenu(item: ListItemData): ListContextMenuItem[]

Get context menu items for multiple selected items

getMultiItemContextMenu(items: ListItemData[]): ListContextMenuItem[]

Called when a context menu action is selected

onContextMenuAction(menuItemId: string, items: ListItemData[]): void

Whether drag and drop is enabled

isDragDropEnabled: boolean

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

Called when drag operation starts

onDragStart(draggedItems: ListItemData[], event: DragEvent): void

Called when items are dropped

onDrop(dragDropInfo: ListDragDropInfo): void

Called when drag operation ends (whether successful or not)

onDragEnd(draggedItems: ListItemData[], success: boolean): void

operation: string

duration: number

timestamp: number

metadata: Record<string, any>

totalOperations: number

totalDuration: number

averageDuration: number

slowestOperation: BenchmarkResult

fastestOperation: BenchmarkResult

operations: BenchmarkResult[]

containerWidth: number

containerHeight: number

itemsPerRow: number | "auto"

gap: number

padding: number

minItemWidth: number

maxItemWidth: number

aspectRatio: number

x: number

y: number

width: number

height: number

thumbnailSize: number

textHeight: number

itemsPerRow: number

itemWidth: number

itemHeight: number

totalRows: number

totalHeight: number

items: GridItemLayout[]

containerWidth: number

containerHeight: number

columnCount: number | "auto"

gap: number

padding: number

minColumnWidth: number

maxColumnWidth: number

x: number

y: number

width: number

height: number

column: number

thumbnailWidth: number

thumbnailHeight: number

textHeight: number

columnCount: number

columnWidth: number

totalHeight: number

items: MasonryItemLayout[]

columnHeights: number[]

id: string

aspectRatio: number

customHeight: number

textLength: number

sections: ExplorerSections

className: string

isSidebarCollapsed: boolean

setSidebarCollapsed: (collapsed: boolean) => void

header: React.ReactNode

footer: React.ReactNode

sidebar: { content: ReactNode; toolbar?: ReactNode; width?: number; }

main: { content: ReactNode; toolbar?: ReactNode; }

id: string

name: string

description: string

icon: IconDefinition

component: React.ComponentType<ViewModeComponentProps>

capabilities: ViewModeCapabilities

settings: ViewModeSettings

isDefault: boolean

priority: number

model: any

className: string

style: React.CSSProperties

supportsSelection: boolean

supportsMultiSelection: boolean

supportsNavigation: boolean

supportsSorting: boolean

supportsFiltering: boolean

supportsDragDrop: boolean

supportsKeyboardNavigation: boolean

supportsVirtualization: boolean

supportsGrouping: boolean

supportsInlinePreview: boolean

supportsCustomColumns: boolean

supportsZoom: boolean

defaultSortField: string

defaultSortDirection: "asc" | "desc"

itemSize: { width?: number; height?: number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number; }

layout: { padding?: number; gap?: number; columns?: number | "auto"; rows?: number | "auto"; }

display: { showIcons?: boolean; showLabels?: boolean; showDetails?: boolean; showPreview?: boolean; iconSize?: "small" | "medium" | "large"; labelPosition?: "bottom" | "right" | "overlay"; }

interaction: { singleClickOpen?: boolean; doubleClickOpen?: boolean; hoverPreview?: boolean; contextMenu?: boolean; }

performance: { virtualization?: boolean; bufferSize?: number; preloadCount?: number; debounceMs?: number; }

customSettings: Record<string, any>

isActive: boolean

isInitialized: boolean

settings: ViewModeSettings

lastUsed: Date

userPreferences: Record<string, any>

indentSize: number

showConnectors: boolean

expandOnSingleClick: boolean

collapseOnSecondClick: boolean

rememberExpansion: boolean

autoExpand: boolean

maxDepth: number

columns: ColumnDefinition[]

headerHeight: number

rowHeight: number

alternatingRows: boolean

gridLines: boolean

resizableColumns: boolean

sortableColumns: boolean

thumbnailSize: number

aspectRatio: number

showFilenames: boolean

showFileSize: boolean

showDate: boolean

gridSpacing: number

loadThumbnails: boolean

thumbnailQuality: "low" | "medium" | "high"

algorithm: "squarified" | "slice-dice" | "strip"

colorScheme: "custom" | "size" | "type" | "date"

paddingInner: number

paddingOuter: number

showLabels: boolean

labelThreshold: number

animation: boolean

zoomable: boolean

registerViewMode(definition: ViewModeDefinition): void

unregisterViewMode(id: string): void

getViewMode(id: string): ViewModeDefinition | undefined

getAllViewModes(): ViewModeDefinition[]

getViewModesByCapability(capability: keyof ViewModeCapabilities): ViewModeDefinition[]

id: string

name: string

version: string

loadItems(path: string): Promise<FileBrowserItem[]>

loadItemDetails(item: FileBrowserItem): Promise<FileBrowserItemDetails>

refreshItems(path: string): Promise<FileBrowserItem[]>

normalizePath(path: string): string

getParentPath(path: string): string | null

resolvePath(basePath: string, relativePath: string): string

getSupportedViewModes(): ViewModeDefinition[]

getToolbarActions(): ToolbarAction[]

getContextMenuActions(item: FileBrowserItem): ContextAction[]

getDefaultViewMode(): string

canPerformAction(action: string, items: FileBrowserItem[]): boolean

performAction(action: string, items: FileBrowserItem[]): Promise<ActionResult>

getItemIcon(item: FileBrowserItem): IconDefinition

getItemPreview(item: FileBrowserItem): Promise<PreviewData | null>

getItemDisplayName(item: FileBrowserItem): string

getItemTooltip(item: FileBrowserItem): string

getAvailableFilters(): FilterDefinition[]

getAvailableSortFields(): SortFieldDefinition[]

applyFilter(items: FileBrowserItem[], criteria: any): FileBrowserItem[]

applySort(items: FileBrowserItem[], field: string, direction: "asc" | "desc"): FileBrowserItem[]

onItemsChanged(callback: (changes: ItemChange[]) => void): () => void

onError(callback: (error: Error) => void): () => void

initialize(): Promise<void>

dispose(): void

id: string

label: string

icon: IconDefinition

tooltip: string

category: string

priority: number

shortcut: string

isVisible: (context: ActionContext) => boolean

isEnabled: (context: ActionContext) => boolean

isActive: (context: ActionContext) => boolean

action: (context: ActionContext) => Promise<void> | void

variant: "default" | "primary" | "secondary" | "destructive"

size: "sm" | "md" | "lg"

showLabel: boolean

id: string

label: string

icon: IconDefinition

shortcut: string

group: string

separator: boolean

isEnabled: (context: ActionContext) => boolean

isVisible: (context: ActionContext) => boolean

action: (context: ActionContext) => Promise<void> | void

submenu: ContextAction[]

selectedItems: FileBrowserItem[]

currentPath: string

provider: IFileBrowserProvider

viewMode: string

allItems: FileBrowserItem[]

success: boolean

message: string

data: any

error: Error

id: string

label: string

type: "boolean" | "text" | "date" | "select" | "multiselect" | "range"

defaultValue: any

options: { value: any; label: string; }[]

placeholder: string

id: string

label: string

defaultDirection: "asc" | "desc"

customSort: (a: FileBrowserItem, b: FileBrowserItem, direction: "asc" | "desc") => number

canCreate: boolean

canRead: boolean

canUpdate: boolean

canDelete: boolean

canMove: boolean

canCopy: boolean

canRename: boolean

canUpload: boolean

canDownload: boolean

canPreview: boolean

canSearch: boolean

canFilter: boolean

canSort: boolean

supportsNavigation: boolean

supportsSelection: boolean

supportsHierarchy: boolean

maxFileSize: number

supportedFileTypes: string[]

enableLogging: boolean

cacheSize: number

cacheTTL: number

batchSize: number

timeout: number

retryAttempts: number

customOptions: Record<string, any>