@anymux/ui-kit 0.1.0

package/dist/index-Ml_SgiKa.d.ts

@@ -0,0 +1,1847 @@
+import { TreeContextMenuItem, TreeLoadOptions, TreeLoadResult, TreeModel$1 as TreeModel, TreeNodeData, TreeProvider, TreeSelectionInfo } from "./index-kHr9udZD.js";
+import { ListContextMenuItem, ListDragDropInfo, ListItemData, ListItemsModel$1 as ListItemsModel, ListItemsProvider, ListItemsProviderListener, ListLoadOptions, ListLoadResult, ListSelectionInfo, ListViewType$1 as ListViewType, TreemapNodeData, TreemapScanProgress, VirtualizationConfig } from "./index-Bryv_GCG.js";
+import React$1, { Component, ReactNode } from "react";
+import { cn } from "@anymux/ui/lib/utils";
+import * as mobx35 from "mobx";
+import * as mobx36 from "mobx";
+import * as mobx31 from "mobx";
+import * as mobx32 from "mobx";
+import * as mobx29 from "mobx";
+import * as mobx27 from "mobx";
+import * as mobx28 from "mobx";
+import * as mobx30 from "mobx";
+import * as mobx37 from "mobx";
+import * as react_jsx_runtime25 from "react/jsx-runtime";
+import * as mobx_dist_internal26 from "mobx/dist/internal";
+import { IFileSystem, IGitRepo } from "@anymux/file-system";
+
+//#region src/file-browser/components/FileBrowser.d.ts
+interface FileBrowserProps$1 {
+  fileSystem: IFileSystem;
+  initialPath?: string;
+  className?: string;
+  showBreadcrumbs?: boolean;
+  showNavigation?: boolean;
+  onError?: (error: {
+    message: string;
+  }) => void;
+  onPathChange?: (path: string) => void;
+  onNotify?: (type: 'success' | 'error' | 'warning', message: string) => void;
+  /** Structured action callback with undo support (preferred over onNotify for success actions) */
+  onAction?: (action: {
+    type: 'create' | 'rename' | 'delete' | 'upload';
+    message: string;
+    undo?: () => Promise<void>;
+  }) => void;
+}
+declare const FileBrowser: React$1.FC<FileBrowserProps$1>;
+
+//#endregion
+//#region src/file-browser/types/FileBrowserTypes.d.ts
+//# sourceMappingURL=FileBrowser.d.ts.map
+interface FileBrowserItem {
+  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;
+}
+interface FileBrowserItemDetails extends FileBrowserItem {
+  content?: string | Uint8Array;
+  preview?: PreviewData;
+  properties?: Record<string, any>;
+}
+interface PreviewData {
+  type: 'image' | 'text' | 'video' | 'audio' | 'document';
+  url?: string;
+  content?: string;
+  thumbnail?: string;
+  metadata?: Record<string, any>;
+}
+interface IconDefinition {
+  type: 'lucide' | 'custom';
+  name?: string;
+  component?: React$1.ComponentType<any>;
+  color?: string;
+  size?: number;
+}
+interface ItemChange {
+  type: 'added' | 'removed' | 'modified' | 'moved';
+  item: FileBrowserItem;
+  oldPath?: string;
+  newPath?: string;
+}
+interface FilterCriteria {
+  searchText?: string;
+  fileTypes?: string[];
+  dateRange?: {
+    start: Date;
+    end: Date;
+  };
+  sizeRange?: {
+    min: number;
+    max: number;
+  };
+  customFilters?: Record<string, any>;
+}
+interface SortCriteria$1 {
+  field: string;
+  direction: 'asc' | 'desc';
+}
+interface NavigationState {
+  currentPath: string;
+  history: string[];
+  historyIndex: number;
+  canGoBack: boolean;
+  canGoForward: boolean;
+}
+interface SelectionState {
+  selectedItems: Set<string>;
+  lastSelectedIndex: number;
+  focusedItemId: string | null;
+  selectionMode: 'single' | 'multiple';
+}
+type LoadingState = 'idle' | 'loading' | 'success' | 'error';
+interface ErrorState {
+  message: string;
+  code?: string;
+  details?: any;
+  timestamp: Date;
+}
+interface FileBrowserEventHandlers {
+  onPathChange?: (path: string) => void;
+  onItemSelect?: (item: FileBrowserItem) => void;
+  onItemActivate?: (item: FileBrowserItem) => void;
+  onSelectionChange?: (selectedItems: FileBrowserItem[]) => void;
+  onError?: (error: ErrorState) => void;
+  onLoadingChange?: (isLoading: boolean) => void;
+}
+interface FileBrowserProps {
+  provider: any;
+  initialPath?: string;
+  initialViewMode?: string;
+  eventHandlers?: FileBrowserEventHandlers;
+  className?: string;
+  style?: React$1.CSSProperties;
+  showToolbar?: boolean;
+  showBreadcrumb?: boolean;
+  showStatusBar?: boolean;
+  allowMultiSelect?: boolean;
+  availableViewModes?: string[];
+  defaultViewMode?: string;
+  theme?: 'light' | 'dark' | 'auto';
+  density?: 'compact' | 'normal' | 'comfortable';
+} //#endregion
+//#region src/file-browser/components/shared/FileBrowserItem.d.ts
+
+//# sourceMappingURL=FileBrowserTypes.d.ts.map
+interface FileBrowserItemProps {
+  item: FileBrowserItem;
+  isSelected?: boolean;
+  isHovered?: boolean;
+  showDetails?: boolean;
+  showIcon?: boolean;
+  showSize?: boolean;
+  showDate?: boolean;
+  iconSize?: 'sm' | 'md' | 'lg';
+  layout?: 'horizontal' | 'vertical';
+  onClick?: (item: FileBrowserItem, event: React$1.MouseEvent) => void;
+  onDoubleClick?: (item: FileBrowserItem, event: React$1.MouseEvent) => void;
+  onContextMenu?: (item: FileBrowserItem, event: React$1.MouseEvent) => void;
+  onKeyDown?: (item: FileBrowserItem, event: React$1.KeyboardEvent) => void;
+  className?: string;
+  style?: React$1.CSSProperties;
+  children?: React$1.ReactNode;
+}
+declare const FileBrowserItemComponent: React$1.FC<FileBrowserItemProps>;
+
+//#endregion
+//#region src/file-browser/components/shared/ErrorBoundary.d.ts
+interface ErrorBoundaryProps {
+  children: ReactNode;
+  fallback?: (error: Error, errorInfo: string, onReset: () => void) => ReactNode;
+  onError?: (error: Error, errorInfo: string) => void;
+  className?: string;
+}
+interface ErrorBoundaryState {
+  hasError: boolean;
+  error: Error | null;
+  errorInfo: string | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryProps);
+  static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+  componentDidCatch(error: Error, errorInfo: React$1.ErrorInfo): void;
+  handleReset: () => void;
+  render(): string | number | bigint | boolean | react_jsx_runtime25.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/file-browser/components/shared/FileIcon.d.ts
+interface FileIconProps$1 {
+  item: FileBrowserItem;
+  getItemIcon?: (item: FileBrowserItem) => IconDefinition;
+  size?: 'sm' | 'md' | 'lg' | 'xl';
+  className?: string;
+  isExpanded?: boolean;
+}
+declare const FileIcon: React$1.FC<FileIconProps$1>;
+
+//#endregion
+//#region src/file-browser/types/ViewModeTypes.d.ts
+interface ViewModeDefinition$1 {
+  id: string;
+  name: string;
+  description?: string;
+  icon: IconDefinition;
+  component: React$1.ComponentType<ViewModeComponentProps>;
+  capabilities: ViewModeCapabilities;
+  settings?: ViewModeSettings;
+  isDefault?: boolean;
+  priority?: number;
+}
+interface ViewModeComponentProps {
+  model: any;
+  className?: string;
+  style?: React$1.CSSProperties;
+}
+interface ViewModeCapabilities {
+  supportsSelection: boolean;
+  supportsMultiSelection: boolean;
+  supportsNavigation: boolean;
+  supportsSorting: boolean;
+  supportsFiltering: boolean;
+  supportsDragDrop: boolean;
+  supportsKeyboardNavigation: boolean;
+  supportsVirtualization: boolean;
+  supportsGrouping?: boolean;
+  supportsInlinePreview?: boolean;
+  supportsCustomColumns?: boolean;
+  supportsZoom?: boolean;
+}
+interface ViewModeSettings {
+  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>;
+}
+interface TreeViewSettings extends ViewModeSettings {
+  indentSize?: number;
+  showConnectors?: boolean;
+  expandOnSingleClick?: boolean;
+  collapseOnSecondClick?: boolean;
+  rememberExpansion?: boolean;
+  autoExpand?: boolean;
+  maxDepth?: number;
+}
+interface ListViewSettings extends ViewModeSettings {
+  columns?: ColumnDefinition$1[];
+  headerHeight?: number;
+  rowHeight?: number;
+  alternatingRows?: boolean;
+  gridLines?: boolean;
+  resizableColumns?: boolean;
+  sortableColumns?: boolean;
+}
+interface ThumbnailViewSettings extends ViewModeSettings {
+  thumbnailSize?: number;
+  aspectRatio?: number;
+  showFilenames?: boolean;
+  showFileSize?: boolean;
+  showDate?: boolean;
+  gridSpacing?: number;
+  loadThumbnails?: boolean;
+  thumbnailQuality?: 'low' | 'medium' | 'high';
+}
+interface TreemapViewSettings extends ViewModeSettings {
+  algorithm?: 'squarified' | 'slice-dice' | 'strip';
+  colorScheme?: 'size' | 'type' | 'date' | 'custom';
+  paddingInner?: number;
+  paddingOuter?: number;
+  showLabels?: boolean;
+  labelThreshold?: number;
+  animation?: boolean;
+  zoomable?: boolean;
+}
+interface ColumnDefinition$1 {
+  id: string;
+  label: string;
+  width?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  sortable?: boolean;
+  resizable?: boolean;
+  visible?: boolean;
+  align?: 'left' | 'center' | 'right';
+  format?: (value: any) => string;
+  renderer?: React$1.ComponentType<{
+    value: any;
+    item: any;
+  }>;
+  priority?: number;
+}
+type ViewModeType = 'tree' | 'list' | 'thumbnail' | 'treemap' | 'custom';
+
+//#endregion
+//#region src/file-browser/models/ui/TreeViewUIModel.d.ts
+declare class TreeViewUIModel {
+  expandedFolders: mobx35.ObservableMap<string, boolean>;
+  indentSize: number;
+  showConnectors: boolean;
+  expandOnSingleClick: boolean;
+  collapseOnSecondClick: boolean;
+  rememberExpansion: boolean;
+  settings: TreeViewSettings;
+  private owner;
+  constructor(owner: any);
+  get logger(): any;
+  get expandedFoldersArray(): string[];
+  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;
+  private initializeSettings;
+  dispose(): void;
+}
+
+//#endregion
+//#region src/file-browser/models/LeftPanelManagerModel.d.ts
+//# sourceMappingURL=TreeViewUIModel.d.ts.map
+interface LeftPanelMode {
+  id: string;
+  name: string;
+  icon?: string;
+  component: React.ComponentType<any>;
+  isAvailable?: () => boolean;
+}
+
+//#endregion
+//#region src/file-browser/models/ui/ListViewUIModel.d.ts
+interface SortCriteria {
+  field: string;
+  direction: 'asc' | 'desc';
+}
+interface ColumnDefinition {
+  id: string;
+  label: string;
+  field: string;
+  width: number;
+  minWidth: number;
+  maxWidth?: number;
+  resizable: boolean;
+  sortable: boolean;
+  visible: boolean;
+  align?: 'left' | 'center' | 'right';
+  format?: (value: any) => string;
+}
+interface ListViewOwner {
+  logger?: {
+    info: (message: string) => void;
+  } | null;
+}
+declare class ListViewUIModel {
+  columns: mobx36.ObservableMap<string, ColumnDefinition>;
+  columnOrder: string[];
+  currentSort: SortCriteria | null;
+  settings: ListViewSettings;
+  showHeader: boolean;
+  striped: boolean;
+  compact: boolean;
+  hoverable: boolean;
+  private owner;
+  constructor(owner: ListViewOwner);
+  get logger(): {
+    info: (message: string) => void;
+  } | null | undefined;
+  get visibleColumns(): ColumnDefinition[];
+  get sortableColumns(): ColumnDefinition[];
+  get allColumns(): ColumnDefinition[];
+  get totalWidth(): number;
+  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;
+  private initializeDefaultColumns;
+  dispose(): void;
+}
+
+//#endregion
+//#region src/file-browser/models/ui/ThumbnailViewUIModel.d.ts
+interface ThumbnailOwner {
+  logger?: {
+    info: (message: string) => void;
+  } | null;
+}
+declare class ThumbnailViewUIModel {
+  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>;
+  private owner;
+  constructor(owner: ThumbnailOwner);
+  get logger(): {
+    info: (message: string) => void;
+  } | null | undefined;
+  get itemWidth(): number;
+  get itemHeight(): number;
+  get isLoadingAnyThumbnails(): boolean;
+  get thumbnailSizePresets(): {
+    label: string;
+    value: number;
+  }[];
+  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;
+  private initializeSettings;
+  dispose(): void;
+}
+
+//#endregion
+//#region src/file-browser/models/ui/TreemapViewUIModel.d.ts
+interface TreemapOwner {
+  logger?: {
+    info: (message: string) => void;
+  } | null;
+}
+interface TreemapNode {
+  id: string;
+  name: string;
+  size: number;
+  type: 'file' | 'directory';
+  children?: TreemapNode[];
+  depth: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  color?: string;
+}
+declare class TreemapViewUIModel {
+  minTileSize: number;
+  maxDepth: number;
+  showLabels: boolean;
+  showSizes: boolean;
+  colorScheme: 'type' | 'size' | 'date' | 'custom';
+  animationDuration: number;
+  padding: number;
+  borderWidth: number;
+  aspectRatio: number;
+  enableZoom: boolean;
+  enableDrillDown: boolean;
+  showTooltips: boolean;
+  settings: TreemapViewSettings;
+  currentRoot: string | null;
+  zoomLevel: number;
+  private owner;
+  constructor(owner: TreemapOwner);
+  get logger(): {
+    info: (message: string) => void;
+  } | null | undefined;
+  get effectiveMinTileSize(): number;
+  get colorSchemes(): {
+    id: string;
+    label: string;
+    description: string;
+  }[];
+  setMinTileSize: (size: number) => void;
+  setMaxDepth: (depth: number) => void;
+  setColorScheme: (scheme: "type" | "size" | "date" | "custom") => void;
+  setPadding: (padding: number) => void;
+  setZoomLevel: (level: number) => void;
+  toggleShowLabels: () => void;
+  toggleShowSizes: () => void;
+  toggleEnableZoom: () => void;
+  toggleEnableDrillDown: () => void;
+  drillDown: (nodeId: string) => void;
+  drillUp: () => void;
+  resetView: () => void;
+  calculateTreemapLayout: (items: FileBrowserItem[], width: number, height: number) => TreemapNode[];
+  private itemsToTreemapNodes;
+  private calculateItemSize;
+  private getItemColor;
+  private getExtensionColor;
+  private squarify;
+  updateSettings: (newSettings: Partial<TreemapViewSettings>) => void;
+  applyPreset: (preset: "overview" | "detailed" | "interactive") => void;
+  resetToDefaults: () => void;
+  private initializeSettings;
+  dispose(): void;
+}
+
+//#endregion
+//#region src/file-browser/models/RightPanelManagerModel.d.ts
+interface ViewModeDefinition {
+  id: string;
+  name: string;
+  icon: string;
+  component?: React.ComponentType<any>;
+  applicableFor?: (contentType: 'file' | 'folder' | 'empty') => boolean;
+}
+
+//#endregion
+//#region src/file-browser/providers/IFileBrowserProvider.d.ts
+interface IFileBrowserProvider$1 {
+  readonly id: string;
+  readonly name: string;
+  readonly version: string;
+  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;
+  getItemPreview?(item: FileBrowserItem): Promise<PreviewData | null>;
+  getItemDisplayName?(item: FileBrowserItem): string;
+  canPreviewFile?(item: FileBrowserItem): boolean;
+  getFilePreview?(item: FileBrowserItem): Promise<PreviewData>;
+  canPerformAction?(action: string, items: FileBrowserItem[]): boolean;
+  performAction?(action: string, items: FileBrowserItem[]): Promise<any>;
+  initialize?(): Promise<void>;
+  dispose?(): void;
+}
+interface ProviderCapabilities {
+  canCreate: boolean;
+  canRead: boolean;
+  canUpdate: boolean;
+  canDelete: boolean;
+  canMove: boolean;
+  canCopy: boolean;
+  canRename: boolean;
+  supportsNavigation: boolean;
+  supportsSelection: boolean;
+  supportsHierarchy: boolean;
+  supportsLeftPanelModes: boolean;
+  supportsRightPanelViewModes: boolean;
+  supportsFilePreview: boolean;
+}
+
+//#endregion
+//#region src/file-browser/providers/FileSystemProvider.d.ts
+//# sourceMappingURL=IFileBrowserProvider.d.ts.map
+interface CacheOptions {
+  maxSize: number;
+  ttlMs: number;
+  enableLogging: boolean;
+}
+declare class FileSystemProvider implements IFileBrowserProvider$1 {
+  readonly id = "filesystem";
+  readonly name = "File System Provider";
+  readonly version = "1.0.0";
+  private fileSystem;
+  private cache;
+  private cacheOptions;
+  constructor(fileSystem: IFileSystem, cacheOptions?: Partial<CacheOptions>);
+  loadItems(path: string): Promise<FileBrowserItem[]>;
+  normalizePath(path: string): string;
+  private formatPermissions;
+  private enhanceError;
+  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;
+  private getFromCache;
+  private setInCache;
+  private invalidateCache;
+  private evictLeastRecentlyUsed;
+  private logCache;
+  clearCache(): void;
+  getCacheStats(): {
+    size: number;
+    maxSize: number;
+    hitRate?: number;
+  };
+  getLeftPanelModes(): LeftPanelMode[];
+  getRightPanelViewModes(): ViewModeDefinition[];
+}
+
+//#endregion
+//#region src/file-browser/providers/GitRepositoryProvider.d.ts
+interface GitRepositoryOptions {
+  repositoryPath: string;
+  branch?: string;
+  enableLogging?: boolean;
+  fileSystem?: IFileSystem;
+  gitRepo?: IGitRepo;
+}
+declare class GitRepositoryProvider implements IFileBrowserProvider$1 {
+  readonly id = "git-repository";
+  readonly name = "Git Repository Provider";
+  readonly version = "1.0.0";
+  private options;
+  private fileSystem;
+  private gitRepo;
+  constructor(options: GitRepositoryOptions);
+  loadItems(path: string): Promise<FileBrowserItem[]>;
+  private loadItemsFromFileSystem;
+  normalizePath(path: string): string;
+  getParentPath(path: string): string | null;
+  resolvePath(basePath: string, relativePath: string): string;
+  getItemIcon(item: FileBrowserItem): IconDefinition;
+  private getBaseFileIcon;
+  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[]>;
+  private getMockGitFiles;
+  private getFileName;
+  private getGitStatus;
+  private log;
+}
+
+//#endregion
+//#region src/file-browser/providers/GitProvider.d.ts
+interface GitRepositoryModel {
+  path: string;
+  fileTree: any[];
+  isLoadingFiles: boolean;
+  getFileContent(path: string): Promise<string>;
+}
+interface GitWrapperIntegration {
+  path: string;
+  fileTree: any[];
+  isLoadingFiles: boolean;
+  getFileContent(path: string): Promise<string>;
+}
+declare class GitProvider implements IFileBrowserProvider$1 {
+  readonly id = "git";
+  readonly name = "Git Provider";
+  readonly version = "1.0.0";
+  private repository;
+  constructor(repository: GitRepositoryModel | GitWrapperIntegration);
+  loadItems(path: string): Promise<FileBrowserItem[]>;
+  private getItemsForPath;
+  private convertGitNodeToFileBrowserItem;
+  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;
+}
+
+//#endregion
+//#region src/file-browser/adapters/FileSystemBridge.d.ts
+interface ScanProgress {
+  directoriesScanned: number;
+  filesFound: number;
+  totalSize: number;
+}
+interface FileSystemItem {
+  id: string;
+  path: string;
+  name: string;
+  type: 'file' | 'directory';
+  size?: number;
+  modified?: Date;
+  isDirectory: boolean;
+  children?: FileSystemItem[];
+}
+declare class FileSystemBridge {
+  private fileSystem;
+  constructor(fileSystem: IFileSystem);
+  loadDirectoryTree(path: string): Promise<FileSystemItem[]>;
+  loadDirectoryContents(path: string): Promise<FileSystemItem[]>;
+  loadDirectoryRecursive(path: string, maxDepth?: number, onProgress?: (progress: ScanProgress) => void, _progress?: ScanProgress): Promise<FileSystemItem[]>;
+  readFile(path: string): Promise<Buffer | string>;
+  writeFile(path: string, content: Buffer | string): Promise<void>;
+  deleteItem(path: string, isDirectory: boolean): Promise<void>;
+  createDirectory(path: string): Promise<void>;
+  renameItem(oldPath: string, newPath: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+}
+
+//#endregion
+//#region src/file-browser/providers/FileSystemTreeProvider.d.ts
+//# sourceMappingURL=FileSystemBridge.d.ts.map
+interface FileSystemTreeProviderOptions {
+  showFilesInTree: boolean;
+  onSelectionChange: (path: string) => void;
+  onRefresh?: () => Promise<void>;
+  onRenameRequest?: (itemId: string, currentName: string, path: string, source: 'list' | 'tree') => void;
+  onDeleteRequest?: (targets: Array<{
+    path: string;
+    isDirectory: boolean;
+    name: string;
+  }>) => void;
+  onNewItemRequest?: (parentPath: string, type: 'file' | 'folder') => void;
+}
+declare class FileSystemTreeProvider implements TreeProvider {
+  private bridge;
+  private options;
+  readonly id = "filesystem-tree";
+  readonly name = "File System Tree";
+  readonly version = "1.0.0";
+  isMultiSelectEnabled: boolean;
+  readonly isDragDropEnabled = true;
+  readonly isVirtualizationEnabled = false;
+  readonly useCheckboxSelection = false;
+  readonly allowPartialSelection = false;
+  readonly isTableViewEnabled = false;
+  constructor(bridge: FileSystemBridge, options: FileSystemTreeProviderOptions);
+  loadNodes(options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  loadChildren(node: TreeNodeData, options?: TreeLoadOptions): Promise<TreeLoadResult>;
+  refresh(path?: string): Promise<TreeLoadResult>;
+  getNodeContextMenu(node: TreeNodeData): TreeContextMenuItem[];
+  getMultiNodeContextMenu(nodes: TreeNodeData[]): TreeContextMenuItem[];
+  getEmptySpaceContextMenu(parentNode?: TreeNodeData): TreeContextMenuItem[];
+  canExpand(node: TreeNodeData): boolean;
+  canSelect(node: TreeNodeData): boolean;
+  onSelectionChange: (selectionInfo: TreeSelectionInfo) => void;
+  onNodeExpansion?(node: TreeNodeData, expanded: boolean): void;
+  onNodeDoubleClick?(node: TreeNodeData): void;
+  onNodeFocus?(node: TreeNodeData | null): void;
+  onContextMenuAction?(menuItemId: string, nodes: TreeNodeData[]): void;
+  private requestRename;
+  private requestDelete;
+  private requestNewItem;
+  executeRename(path: string, newName: string): Promise<void>;
+  executeDelete(targets: Array<{
+    path: string;
+    isDirectory: boolean;
+  }>): Promise<void>;
+  executeCreate(parentPath: string, name: string, type: 'file' | 'folder'): Promise<void>;
+  initialize?(): Promise<void>;
+  dispose?(): void;
+}
+
+//#endregion
+//#region src/file-browser/providers/FileSystemListProvider.d.ts
+interface FileSystemListProviderOptions {
+  showAllItems: boolean;
+  /** Service identifier for IndexedDB thumbnail cache key scoping */
+  serviceId?: string;
+  onSelectionChange: (items: ListItemData[]) => void;
+  onNavigation: (path: string) => void;
+  onNavigateUp?: () => void;
+  onOpenFile?: (path: string, name: string, size?: number) => void;
+  onPreviewFile?: (path: string, name: string, size?: number) => void;
+  onRefresh?: () => Promise<void>;
+  onRenameRequest?: (itemId: string, currentName: string, path: string, source: 'list' | 'tree') => void;
+  onDeleteRequest?: (targets: Array<{
+    path: string;
+    isDirectory: boolean;
+    name: string;
+  }>) => void;
+  onNewItemRequest?: (parentPath: string, type: 'file' | 'folder') => void;
+}
+declare class FileSystemListProvider implements ListItemsProvider {
+  private bridge;
+  private options;
+  readonly id = "filesystem-list";
+  readonly name = "File System List";
+  readonly supportedViewTypes: ListViewType[];
+  readonly isMultiSelectEnabled = true;
+  readonly isVirtualizationEnabled = false;
+  readonly isDragDropEnabled = true;
+  currentPath: string;
+  private listeners;
+  thumbnailCache: mobx31.ObservableMap<string, string>;
+  aspectRatioCache: mobx32.ObservableMap<string, number>;
+  private thumbnailLoading;
+  constructor(bridge: FileSystemBridge, options: FileSystemListProviderOptions);
+  /**
+   * Get a cached thumbnail blob URL, or trigger async load if not cached.
+   * Returns undefined while loading (MobX will re-render when cache updates).
+   */
+  getThumbnailBlobUrl(path: string): string | undefined;
+  private loadThumbnail;
+  /**
+   * Get cached aspect ratio for an image path.
+   * Returns undefined if not yet measured.
+   */
+  getAspectRatio(path: string): number | undefined;
+  /**
+   * Revoke all cached blob URLs (call on path change / unmount)
+   */
+  clearThumbnailCache(): void;
+  setPath(path: string): void;
+  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;
+  loadTreemapData(onProgress?: (progress: TreemapScanProgress) => void): Promise<TreemapNodeData[]>;
+  onItemDoubleClick: (item: ListItemData) => void;
+  addListener(listener: ListItemsProviderListener): void;
+  removeListener(listener: ListItemsProviderListener): void;
+  getItemIcon(item: ListItemData): string;
+  getItemContextMenu(item: ListItemData): ListContextMenuItem[];
+  getEmptySpaceContextMenu(): 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;
+  resolveThumbnailUrl(item: ListItemData): string | undefined;
+  private getThumbnailUrl;
+  private getFileIconString;
+  private isImageFile;
+  private openFileWithViewer;
+  private copyPaths;
+  private downloadFile;
+  private requestRename;
+  private requestDelete;
+  private requestNewItem;
+  executeRename(path: string, newName: string): Promise<void>;
+  executeDelete(targets: Array<{
+    path: string;
+    isDirectory: boolean;
+  }>): Promise<void>;
+  executeCreate(parentPath: string, name: string, type: 'file' | 'folder'): Promise<void>;
+}
+
+//#endregion
+//#region src/file-browser/registry/types.d.ts
+/**
+ * Plugin interface for file viewers.
+ * Extends the simple ViewerConfig with richer matching, lazy loading, and toolbar support.
+ */
+interface FileViewerPlugin {
+  /** Unique plugin ID, e.g., 'pdf-viewer', 'monaco-editor' */
+  id: string;
+  /** Human-readable name shown in "Open with..." menu */
+  name: string;
+  /** Optional description for UI tooltips */
+  description?: string;
+  /** Plugin capabilities */
+  capabilities: {
+    /** Can this plugin edit files (enables save flow)? */
+    canEdit?: boolean;
+    /** Can this plugin render in the inline preview pane (smaller viewport)? */
+    canPreview?: boolean;
+    /** Can this plugin render full-screen (the main viewer mode)? */
+    canFullscreen?: boolean;
+  };
+  /** File extensions this plugin handles (without dots), e.g., ['pdf', 'epub'] */
+  extensions?: string[];
+  /** MIME types this plugin handles, e.g., ['application/pdf'] */
+  mimeTypes?: string[];
+  /** Glob patterns for filenames, e.g., ['Dockerfile', 'Makefile', '.env*'] */
+  filePatterns?: string[];
+  /**
+   * Advanced match function for content-sniffing or complex logic.
+   * Called only if extension/MIME/pattern matching passes or if no
+   * static matchers are defined.
+   * Return a confidence score 0-100 (0 = cannot handle, 100 = perfect match).
+   */
+  canHandle?: (file: FileMatchContext) => number;
+  /**
+   * Priority (higher = preferred). Default: 0.
+   * Built-in viewers use 10-20. Third-party plugins should use 50+
+   * to override built-in viewers, or negative to serve as fallbacks.
+   */
+  priority?: number;
+  /**
+   * The viewer React component. Can be a concrete component or a lazy loader.
+   * When undefined, `load()` must be provided.
+   */
+  component?: React$1.ComponentType<ViewerProps>;
+  /**
+   * Dynamic loader that returns the viewer component.
+   * Used for code-splitting. The registry wraps this in React.lazy().
+   */
+  load?: () => Promise<{
+    default: React$1.ComponentType<ViewerProps>;
+  }>;
+  /** If true, this plugin is used as the fallback for unrecognized file types */
+  isDefault?: boolean;
+  /**
+   * Declarative toolbar actions rendered by the ViewerHost.
+   * For dynamic toolbar items, plugins should use the `onToolbarExtras`
+   * callback on ViewerProps (already supported).
+   */
+  toolbarActions?: ToolbarAction$1[];
+  /**
+   * Keyboard shortcuts the plugin handles.
+   * The ViewerHost binds these when the plugin is active.
+   */
+  keyboardShortcuts?: KeyboardShortcut[];
+}
+/** Context passed to canHandle() and resolveViewer() for file matching */
+interface FileMatchContext {
+  /** Filename including extension */
+  name: string;
+  /** Full path */
+  path: string;
+  /** File extension without dot, lowercase */
+  extension: string;
+  /** MIME type if known */
+  mimeType?: string;
+  /** File size in bytes */
+  size?: number;
+  /**
+   * First bytes of content (for magic-number sniffing).
+   * Only available if the registry is configured to pre-read headers.
+   * Typically 512 bytes.
+   */
+  headerBytes?: ArrayBuffer;
+}
+/** Declarative toolbar action for ViewerHost */
+interface ToolbarAction$1 {
+  id: string;
+  label: string;
+  icon?: React$1.ComponentType<{
+    className?: string;
+  }>;
+  /** Called when the action is triggered */
+  onClick: () => void;
+  /** Whether the action is currently enabled */
+  enabled?: boolean | (() => boolean);
+  /** Keyboard shortcut label for tooltip, e.g., "Ctrl+S" */
+  shortcutLabel?: string;
+  /** Position: 'left' | 'right'. Default: 'right' */
+  position?: 'left' | 'right';
+}
+/** Keyboard shortcut binding for ViewerHost */
+interface KeyboardShortcut {
+  /** Key combination, e.g., 'ctrl+s', 'escape', 'ctrl+shift+p' */
+  key: string;
+  /** Handler */
+  handler: () => void;
+  /** Only active when the viewer has focus? Default: true */
+  requireFocus?: boolean;
+}
+/** Result of resolving a viewer for a file */
+interface ResolvedViewer {
+  /** The matched plugin */
+  plugin: FileViewerPlugin;
+  /** The React component to render (resolved from component or load via React.lazy) */
+  Component: React$1.ComponentType<ViewerProps>;
+  /** Match confidence score. Extension match = 80, MIME = 70, pattern = 60, canHandle = dynamic */
+  confidence: number;
+}
+
+//#endregion
+//#region src/file-browser/registry/ViewerRegistry.d.ts
+//# sourceMappingURL=types.d.ts.map
+interface ViewerConfig {
+  id: string;
+  name: string;
+  description?: string;
+  extensions: string[];
+  component: React$1.ComponentType<ViewerProps>;
+  priority?: number;
+  canEdit?: boolean;
+  isDefault?: boolean;
+}
+interface ViewerProps {
+  file: {
+    path: string;
+    name: string;
+    content?: string | ArrayBuffer;
+    size?: number;
+    mimeType?: string;
+  };
+  onClose?: () => void;
+  onSave?: (content: string | ArrayBuffer) => Promise<void>;
+  className?: string;
+  readOnly?: boolean;
+  /** Callback for viewer to register toolbar controls rendered in parent toolbar */
+  onToolbarExtras?: (extras: React$1.ReactNode) => void;
+  /**
+   * Called by the plugin when the content becomes dirty (modified).
+   * The host uses this to show unsaved-changes indicators and
+   * to prompt before closing.
+   */
+  onDirtyChange?: (isDirty: boolean) => void;
+  /**
+   * Whether to render in compact/preview mode (inside the preview pane)
+   * vs full mode (inside the main viewer area).
+   * Plugins can adjust their layout based on this.
+   */
+  mode?: 'preview' | 'full';
+  /**
+   * Content fetcher for streaming/on-demand loading.
+   * Plugins that handle large files (PDF, video) can use this
+   * instead of receiving the full content upfront.
+   */
+  fetchContent?: () => Promise<string | ArrayBuffer>;
+  /**
+   * URL for the file if it can be accessed directly (e.g., S3 presigned URL).
+   * Useful for media players that need a URL, not a buffer.
+   */
+  contentUrl?: string;
+}
+declare function viewerConfigToPlugin(config: ViewerConfig): FileViewerPlugin;
+declare class ViewerRegistry {
+  private viewers;
+  private extensionMap;
+  private plugins;
+  private extensionIndex;
+  private mimeTypeIndex;
+  private patternPlugins;
+  /**
+   * Register a plugin. Replaces any existing plugin with the same ID.
+   */
+  registerPlugin(plugin: FileViewerPlugin): void;
+  /**
+   * Unregister a plugin by ID.
+   */
+  unregisterPlugin(pluginId: string): void;
+  /**
+   * Find the best viewer for a given file.
+   *
+   * Matching order with scoring:
+   * 1. Extension match (bonus: 80)
+   * 2. MIME type match (bonus: 70)
+   * 3. Filename pattern match (bonus: 60)
+   * 4. canHandle() callback (bonus: canHandle return value 0-100)
+   * 5. Default plugin (isDefault: true, bonus: 0)
+   *
+   * Final score = matchTypeBonus + plugin.priority + canHandle score (if applicable)
+   */
+  resolveViewer(file: FileMatchContext, options?: {
+    preferEditable?: boolean;
+  }): ResolvedViewer | null;
+  /**
+   * Find ALL viewers that can handle a file, sorted by score (descending).
+   * Used for "Open with..." menu.
+   */
+  resolveAllViewers(file: FileMatchContext): ResolvedViewer[];
+  /**
+   * Get a plugin by ID.
+   */
+  getPluginById(pluginId: string): FileViewerPlugin | null;
+  /**
+   * Get all registered plugins.
+   */
+  getAllPlugins(): FileViewerPlugin[];
+  /**
+   * Build a FileMatchContext from a filename (convenience helper).
+   */
+  buildFileMatchContext(filename: string, opts?: {
+    path?: string;
+    mimeType?: string;
+    size?: number;
+  }): FileMatchContext;
+  registerViewer(config: ViewerConfig): void;
+  unregisterViewer(viewerId: string): void;
+  getViewer(filename: string, preferEditable?: boolean): ViewerConfig | null;
+  getViewers(filename: string): ViewerConfig[];
+  canHandle(filename: string): boolean;
+  getAllViewers(): ViewerConfig[];
+  getViewerById(id: string): ViewerConfig | null;
+  getFileCategory(filename: string): string;
+  private extractExtension;
+  private getDefaultViewer;
+  /**
+   * Find all candidate viewers for a file, scored and sorted descending.
+   */
+  private findCandidates;
+  /**
+   * Rebuild plugin indexes from the plugin map.
+   */
+  private rebuildIndexes;
+  /**
+   * Sync a plugin into the legacy viewers/extensionMap storage.
+   */
+  private syncPluginToLegacy;
+  /**
+   * Remove a plugin from legacy storage.
+   */
+  private removeLegacy;
+}
+declare const globalViewerRegistry: ViewerRegistry;
+
+//#endregion
+//#region src/file-browser/models/UploadModel.d.ts
+//# sourceMappingURL=ViewerRegistry.d.ts.map
+interface UploadFileEntry {
+  /** Original File object from the browser */
+  file: File;
+  /** Target path on the file system */
+  targetPath: string;
+  /** Upload progress 0-100 */
+  progress: number;
+  /** Status of this individual file */
+  status: 'pending' | 'uploading' | 'done' | 'error';
+  /** Error message if status is 'error' */
+  error?: string;
+}
+declare class UploadModel {
+  private bridge;
+  /** Files currently being uploaded or queued */
+  files: UploadFileEntry[];
+  /** Overall upload state */
+  isUploading: boolean;
+  /** Number of completed uploads in the current batch */
+  completedCount: number;
+  /** Whether the upload summary toast is visible */
+  showSummary: boolean;
+  /** Last batch summary */
+  lastSummary: {
+    total: number;
+    succeeded: number;
+    failed: number;
+  } | null;
+  private notify;
+  constructor(bridge: FileSystemBridge, notify?: (type: 'success' | 'error' | 'warning', message: string) => void);
+  /** Total number of files in the current batch */
+  get totalCount(): number;
+  /** Overall progress across all files (0-100) */
+  get overallProgress(): number;
+  /** Number of files that failed */
+  get failedCount(): number;
+  /** Whether there are any active uploads */
+  get hasActiveUploads(): boolean;
+  /**
+   * Upload multiple files to a target directory.
+   * Uses MobX flow for proper async tracking.
+   */
+  uploadFiles: (fileList: FileList | File[], targetDirectory: string) => mobx_dist_internal26.CancellablePromise<void>;
+  /** Clear the file list and summary */
+  clear(): void;
+  /** Dismiss the summary toast */
+  dismissSummary(): void;
+}
+
+//#endregion
+//#region src/file-browser/models/FileBrowserModel.d.ts
+//# sourceMappingURL=UploadModel.d.ts.map
+interface OpenFileState {
+  path: string;
+  name: string;
+  content?: string | ArrayBuffer;
+  size?: number;
+  mimeType?: string;
+  viewer: ViewerConfig;
+}
+interface PreviewFileState {
+  path: string;
+  name: string;
+  content?: string | ArrayBuffer;
+  size?: number;
+  mimeType?: string;
+  viewer: ViewerConfig;
+  isLoading: boolean;
+}
+declare class FileBrowserModel {
+  fileSystem: IFileSystem;
+  fileSystemBridge: FileSystemBridge;
+  treeProvider: FileSystemTreeProvider;
+  listProvider: FileSystemListProvider;
+  treeModel: TreeModel;
+  listModel: ListItemsModel;
+  uploadModel: UploadModel;
+  currentPath: string;
+  selectedPath: string | null;
+  isLoading: boolean;
+  error: string | null;
+  onPathChange?: (path: string) => void;
+  onNotify?: (type: 'success' | 'error' | 'warning', message: string) => void;
+  /** Structured action callback with undo support */
+  onAction?: (action: {
+    type: 'create' | 'rename' | 'delete' | 'upload';
+    message: string;
+    undo?: () => Promise<void>;
+  }) => void;
+  openFile: OpenFileState | null;
+  isLoadingFile: boolean;
+  previewEnabled: boolean;
+  previewFile: PreviewFileState | null;
+  renameState: {
+    itemId: string;
+    currentName: string;
+    path: string;
+    source: 'list' | 'tree';
+  } | null;
+  deleteState: {
+    targets: Array<{
+      path: string;
+      isDirectory: boolean;
+      name: string;
+    }>;
+  } | null;
+  createState: {
+    parentPath: string;
+    type: 'file' | 'folder';
+  } | null;
+  constructor(fileSystem: IFileSystem);
+  private notify;
+  setInitialPath(path: string): Promise<void>;
+  handleTreeSelection: (path: string) => Promise<void>;
+  handleListNavigation: (path: string) => Promise<void>;
+  handleListSelection: (selectedItems: ListItemData[]) => void;
+  private selectPathInTree;
+  private findNodeByPath;
+  navigateUp(): Promise<void>;
+  navigateToPath(path: string): Promise<void>;
+  refresh(): Promise<void>;
+  navigateToBreadcrumb(path: string): Promise<void>;
+  get canNavigateUp(): boolean;
+  get pathSegments(): Array<{
+    name: string;
+    path: string;
+  }>;
+  get isTreeLoading(): boolean;
+  get isListLoading(): boolean;
+  get hasTreeNodes(): boolean;
+  get hasListItems(): boolean;
+  get hasError(): boolean;
+  get hasItems(): boolean;
+  get itemsArray(): ListItemData[];
+  refreshItems(): Promise<void>;
+  clearError(): void;
+  setCurrentPath(path: string): Promise<void>;
+  private static readonly BINARY_EXTENSIONS;
+  private static readonly MIME_TYPES;
+  openFileViewer(path: string, name: string, size?: number): Promise<void>;
+  get viewableFiles(): Array<{
+    path: string;
+    name: string;
+    size?: number;
+  }>;
+  get currentFileIndex(): number;
+  get canNavigateNext(): boolean;
+  get canNavigatePrev(): boolean;
+  navigateToNextFile(): Promise<void>;
+  navigateToPrevFile(): Promise<void>;
+  closeFileViewer(): void;
+  togglePreview(): void;
+  loadPreviewFile(path: string, name: string, size?: number): Promise<void>;
+  clearPreview(): void;
+  uploadFiles(files: FileList | File[]): Promise<void>;
+  triggerFileUpload(): 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;
+}
+
+//#endregion
+//#region src/file-browser/models/ViewerHostModel.d.ts
+//# sourceMappingURL=FileBrowserModel.d.ts.map
+/**
+ * MobX model for ViewerHost component state.
+ * Manages the transient UI state for a specific viewer session:
+ * dirty tracking, toolbar extras from the plugin, and loading state.
+ */
+declare class ViewerHostModel {
+  isDirty: boolean;
+  isLoading: boolean;
+  error: string | null;
+  toolbarExtras: React$1.ReactNode;
+  constructor();
+  setDirty(dirty: boolean): void;
+  setToolbarExtras(extras: React$1.ReactNode): void;
+  setLoading(loading: boolean): void;
+  setError(error: string | null): void;
+  reset(): void;
+}
+
+//#endregion
+//#region src/file-browser/models/SelectionManagerModel.d.ts
+//# sourceMappingURL=ViewerHostModel.d.ts.map
+interface SelectionOwner {
+  logger?: {
+    info: (message: string) => void;
+  } | null;
+  leftPanel?: any;
+  rightPanel?: any;
+  navigationManager?: any;
+}
+declare class SelectionManagerModel {
+  selectedItems: mobx29.ObservableMap<string, boolean>;
+  lastSelectedIndex: number;
+  focusedItem: FileBrowserItem | null;
+  isUpdatingFromPanels: boolean;
+  private owner;
+  private disposers;
+  constructor(owner: SelectionOwner);
+  get selectedItemsArray(): string[];
+  get hasSelection(): boolean;
+  get selectionCount(): number;
+  get isMultipleSelection(): boolean;
+  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;
+  private coordinateSelection;
+  private setupCoordinationReactions;
+  selectFromTreePanel: (item: FileBrowserItem) => void;
+  selectFromRightPanel: (item: FileBrowserItem) => void;
+  selectFromNavigation: (path: string, allItems: FileBrowserItem[]) => void;
+  dispose: () => void;
+}
+
+//#endregion
+//#region src/file-browser/models/NavigationManagerModel.d.ts
+interface NavigationOwner {
+  logger?: {
+    info: (message: string) => void;
+  } | null;
+  leftPanel?: any;
+  rightPanel?: any;
+  selectionManager?: any;
+}
+declare class NavigationManagerModel {
+  history: string[];
+  historyIndex: number;
+  isUpdatingFromPanels: boolean;
+  private owner;
+  private disposers;
+  constructor(owner: NavigationOwner);
+  get canGoBack(): boolean;
+  get canGoForward(): boolean;
+  get currentPath(): string;
+  get previousPath(): string | null;
+  get nextPath(): string | null;
+  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;
+  private setupCoordinationReactions;
+  private coordinateNavigation;
+  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;
+}
+
+//#endregion
+//#region src/file-browser/types/ProviderTypes.d.ts
+interface IFileBrowserProvider {
+  readonly id: string;
+  readonly name: string;
+  readonly 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$1[];
+  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;
+}
+interface ToolbarAction {
+  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;
+}
+interface ContextAction {
+  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[];
+}
+interface ActionContext {
+  selectedItems: FileBrowserItem[];
+  currentPath: string;
+  provider: IFileBrowserProvider;
+  viewMode: string;
+  allItems: FileBrowserItem[];
+}
+interface ActionResult {
+  success: boolean;
+  message?: string;
+  data?: any;
+  error?: Error;
+}
+interface FilterDefinition {
+  id: string;
+  label: string;
+  type: 'text' | 'select' | 'multiselect' | 'date' | 'range' | 'boolean';
+  defaultValue?: any;
+  options?: {
+    value: any;
+    label: string;
+  }[];
+  placeholder?: string;
+}
+interface SortFieldDefinition {
+  id: string;
+  label: string;
+  defaultDirection?: 'asc' | 'desc';
+  customSort?: (a: FileBrowserItem, b: FileBrowserItem, direction: 'asc' | 'desc') => number;
+}
+interface ProviderConfiguration {
+  enableLogging?: boolean;
+  cacheSize?: number;
+  cacheTTL?: number;
+  batchSize?: number;
+  timeout?: number;
+  retryAttempts?: number;
+  customOptions?: Record<string, any>;
+}
+
+//#endregion
+//#region src/file-browser/models/ToolbarManagerModel.d.ts
+//# sourceMappingURL=ProviderTypes.d.ts.map
+interface ToolbarOwner {
+  logger?: {
+    info: (message: string) => void;
+  } | null;
+}
+declare class ToolbarManagerModel {
+  toolbarActions: mobx27.ObservableMap<string, ToolbarAction>;
+  contextActions: mobx28.ObservableMap<string, ContextAction>;
+  private owner;
+  constructor(owner: ToolbarOwner);
+  get globalActions(): ToolbarAction[];
+  get selectionActions(): ToolbarAction[];
+  get allToolbarActions(): ToolbarAction[];
+  get allContextActions(): ContextAction[];
+  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;
+}
+
+//#endregion
+//#region src/file-browser/models/ViewModeManagerModel.d.ts
+declare class ViewModeManagerModel {
+  availableViewModes: mobx30.ObservableMap<string, ViewModeDefinition$1>;
+  currentViewMode: string;
+  currentFilters: FilterCriteria;
+  currentSortCriteria: SortCriteria | null;
+  treeViewUI: TreeViewUIModel;
+  listViewUI: ListViewUIModel;
+  thumbnailViewUI: ThumbnailViewUIModel;
+  treemapViewUI: TreemapViewUIModel;
+  private owner;
+  constructor(owner: any);
+  get logger(): any;
+  get currentViewModeDefinition(): ViewModeDefinition$1 | undefined;
+  get availableViewModesArray(): ViewModeDefinition$1[];
+  get currentViewUI(): TreeViewUIModel | ListViewUIModel | ThumbnailViewUIModel | TreemapViewUIModel;
+  get hasFilters(): boolean;
+  get hasSorting(): boolean;
+  setCurrentViewMode: (viewModeId: string) => void;
+  registerViewMode: (definition: ViewModeDefinition$1) => 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;
+  private initializeDefaultViewModes;
+  dispose(): void;
+}
+
+//#endregion
+//#region src/file-browser/components/ViewerHost.d.ts
+//# sourceMappingURL=ViewModeManagerModel.d.ts.map
+interface ViewerHostProps {
+  /** The resolved viewer from the registry */
+  viewer: ResolvedViewer;
+  /** File metadata and content */
+  file: ViewerProps['file'];
+  /** 'full' for main viewer, 'preview' for inline pane */
+  mode: 'full' | 'preview';
+  /** Called when the viewer wants to close */
+  onClose?: () => void;
+  /** Called to save edits */
+  onSave?: (content: string | ArrayBuffer) => Promise<void>;
+  /** Whether the file is read-only */
+  readOnly?: boolean;
+  /** Optional URL for direct content access */
+  contentUrl?: string;
+  /** Optional lazy content fetcher */
+  fetchContent?: () => Promise<string | ArrayBuffer>;
+  /** Additional toolbar elements from the host (e.g., prev/next nav) */
+  hostToolbar?: React$1.ReactNode;
+  className?: string;
+}
+/**
+ * ViewerHost: shared viewer surface component.
+ *
+ * Renders a resolved viewer plugin wrapped in Suspense, with:
+ * - Plugin's declarative toolbarActions (left + right positions)
+ * - Host toolbar slot (e.g., prev/next navigation)
+ * - Dynamic toolbar extras injected by the plugin via onToolbarExtras
+ * - Keyboard shortcut bindings from the plugin
+ * - Dirty state tracking via onDirtyChange
+ *
+ * Used by FileBrowser (full viewer mode), PreviewPane, and
+ * future ObjectStorageBrowser/GitBrowser integration.
+ */
+declare const ViewerHost: React$1.FC<ViewerHostProps>;
+
+//#endregion
+//#region src/file-browser/components/FileBrowserHeader.d.ts
+//# sourceMappingURL=ViewerHost.d.ts.map
+interface FileBrowserHeaderProps {
+  model: FileBrowserModel;
+  toolbarManager?: ToolbarManagerModel;
+  className?: string;
+  showBreadcrumb?: boolean;
+  showToolbar?: boolean;
+}
+declare const FileBrowserHeader: React$1.FC<FileBrowserHeaderProps>;
+
+//#endregion
+//#region src/file-browser/components/FileBrowserContent.d.ts
+interface FileBrowserContentProps {
+  model: FileBrowserModel;
+  className?: string;
+  currentViewMode?: string;
+}
+declare const FileBrowserContent: React$1.FC<FileBrowserContentProps>;
+
+//#endregion
+//#region src/file-browser/components/views/TreeView/TreeView.d.ts
+interface TreeViewProps {
+  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;
+}
+declare const TreeView: React$1.FC<TreeViewProps>;
+
+//#endregion
+//#region src/file-browser/models/ResponsiveLayoutManagerModel.d.ts
+interface ResponsiveOwner {
+  logger?: {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+  } | null;
+}
+type ScreenSize = 'mobile' | 'tablet' | 'desktop';
+type PanelLayout = 'single' | 'dual' | 'overlay';
+interface ResponsiveBreakpoints {
+  mobile: number;
+  tablet: number;
+  desktop: number;
+}
+interface LayoutConfiguration {
+  screenSize: ScreenSize;
+  panelLayout: PanelLayout;
+  showLeftPanel: boolean;
+  showRightPanel: boolean;
+  leftPanelWidth: string;
+  rightPanelWidth: string;
+  isLeftPanelCollapsed: boolean;
+  isRightPanelCollapsed: boolean;
+}
+declare class ResponsiveLayoutManagerModel {
+  screenWidth: number;
+  screenHeight: number;
+  breakpoints: ResponsiveBreakpoints;
+  isLeftPanelVisible: boolean;
+  isRightPanelVisible: boolean;
+  isLeftPanelCollapsed: boolean;
+  isRightPanelCollapsed: boolean;
+  isMobileMenuOpen: boolean;
+  activePanel: 'left' | 'right' | null;
+  isAnimating: boolean;
+  animationDuration: number;
+  previousFocusElement: HTMLElement | null;
+  trapFocus: boolean;
+  leftPanelWidth: string;
+  rightPanelWidth: string;
+  minPanelWidth: number;
+  maxPanelWidth: number;
+  adaptiveViewModes: mobx37.ObservableMap<ScreenSize, string[]>;
+  private owner;
+  private resizeObserver;
+  private mediaQueryListeners;
+  constructor(owner: ResponsiveOwner);
+  private setupAdaptiveViewModes;
+  private setupMediaQueryListeners;
+  private handleMediaQueryChange;
+  private updateLayoutForScreenSize;
+  get currentScreenSize(): ScreenSize;
+  get currentPanelLayout(): PanelLayout;
+  get currentLayoutConfiguration(): LayoutConfiguration;
+  get shouldShowLeftPanel(): boolean;
+  get shouldShowRightPanel(): boolean;
+  get availableViewModes(): string[];
+  get isMobile(): boolean;
+  get isTablet(): boolean;
+  get isDesktop(): boolean;
+  get canShowDualPanels(): boolean;
+  get shouldShowHamburgerMenu(): boolean;
+  setScreenDimensions: (width: number, height: number) => void;
+  setBreakpoints: (breakpoints: Partial<ResponsiveBreakpoints>) => void;
+  toggleLeftPanel: () => void;
+  toggleRightPanel: () => void;
+  setLeftPanelVisibility: (visible: boolean) => void;
+  setRightPanelVisibility: (visible: boolean) => void;
+  toggleMobileMenu: () => void;
+  showMobilePanel: (panel: "left" | "right") => void;
+  hideMobilePanel: () => void;
+  toggleMobilePanel: (panel: "left" | "right") => void;
+  setLeftPanelWidth: (width: string) => void;
+  setRightPanelWidth: (width: string) => void;
+  setAdaptiveViewModes: (screenSize: ScreenSize, viewModes: string[]) => void;
+  isViewModeAvailable: (viewMode: string) => boolean;
+  private animatePanel;
+  private storeFocus;
+  private restoreFocus;
+  isTouchFriendlySize: (element: HTMLElement) => boolean;
+  enableGestureNavigation: (element: HTMLElement) => {
+    onSwipeLeft: () => void;
+    onSwipeRight: () => void;
+    onSwipeDown: () => void;
+  };
+  observeElementResize: (element: HTMLElement) => void;
+  dispose: () => void;
+}
+
+//#endregion
+//#region src/file-browser/components/views/ListView/ListView.d.ts
+interface ListViewProps {
+  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;
+}
+declare const ListView: React$1.FC<ListViewProps>;
+
+//#endregion
+//#region src/file-browser/components/navigation/NavigationButtons.d.ts
+interface NavigationButtonsProps {
+  canGoBack?: boolean;
+  canGoForward?: boolean;
+  canGoUp?: boolean;
+  onGoBack?: () => void;
+  onGoForward?: () => void;
+  onGoUp?: () => void;
+  className?: string;
+  variant?: 'default' | 'compact';
+  showLabels?: boolean;
+  disabled?: boolean;
+}
+declare const NavigationButtons: React$1.FC<NavigationButtonsProps>;
+
+//#endregion
+//#region src/file-browser/components/toolbar/ViewModeToggle.d.ts
+interface ViewModeToggleProps {
+  currentMode: ViewModeType;
+  availableModes: ViewModeType[];
+  onModeChange?: (mode: ViewModeType) => void;
+  className?: string;
+  variant?: 'tabs' | 'buttons';
+  showLabels?: boolean;
+  disabled?: boolean;
+}
+declare const ViewModeToggle: React$1.FC<ViewModeToggleProps>;
+
+//#endregion
+//#region src/file-browser/types/UITypes.d.ts
+interface UIComponentProps {
+  className?: string;
+  style?: React$1.CSSProperties;
+  children?: React$1.ReactNode;
+}
+interface FileIconProps extends UIComponentProps {
+  item: FileBrowserItem;
+  size?: number | 'sm' | 'md' | 'lg';
+  variant?: 'outline' | 'filled';
+}
+interface BreadcrumbProps extends UIComponentProps {
+  path: string;
+  onNavigate: (path: string) => void;
+  maxItems?: number;
+  separator?: React$1.ReactNode;
+}
+interface ToolbarActionConfig {
+  id: string;
+  label: string;
+  icon: IconDefinition;
+  tooltip?: string;
+  shortcut?: string;
+  variant?: 'default' | 'primary' | 'secondary' | 'destructive';
+  size?: 'sm' | 'md' | 'lg';
+  showLabel?: boolean;
+  isVisible?: boolean;
+  isEnabled?: boolean;
+  isActive?: boolean;
+  action: () => void;
+}
+
+//#endregion
+export { ActionContext, ActionResult, BreadcrumbProps, ColumnDefinition, ContextAction, ErrorBoundary as ErrorBoundary$1, ErrorBoundaryProps, ErrorState, FileBrowser as FileBrowser$1, FileBrowserContent, FileBrowserContentProps, FileBrowserEventHandlers, FileBrowserHeader, FileBrowserHeaderProps, FileBrowserItem, FileBrowserItemComponent, FileBrowserItemDetails, FileBrowserModel as FileBrowserModel$1, FileBrowserProps, FileIcon, FileIconProps, FileMatchContext, FileSystemBridge as FileSystemBridge$1, FileSystemListProvider as FileSystemListProvider$1, FileSystemProvider as FileSystemProvider$1, FileSystemTreeProvider as FileSystemTreeProvider$1, FileViewerPlugin, FilterCriteria, FilterDefinition, GitProvider as GitProvider$1, GitRepositoryProvider as GitRepositoryProvider$1, IFileBrowserProvider$1 as IFileBrowserProvider, IconDefinition, ItemChange, KeyboardShortcut, ListView, ListViewProps, ListViewSettings, ListViewUIModel as ListViewUIModel$1, LoadingState, NavigationButtons, NavigationButtonsProps, NavigationManagerModel as NavigationManagerModel$1, NavigationState, PreviewData, ProviderCapabilities, ProviderConfiguration, ResolvedViewer, SelectionManagerModel as SelectionManagerModel$1, SelectionState, SortCriteria$1 as SortCriteria, SortFieldDefinition, ThumbnailViewSettings, ThumbnailViewUIModel as ThumbnailViewUIModel$1, ToolbarAction$1 as ToolbarAction, ToolbarActionConfig, ToolbarManagerModel as ToolbarManagerModel$1, TreeView, TreeViewProps, TreeViewSettings, TreeViewUIModel as TreeViewUIModel$1, UIComponentProps, UploadFileEntry, UploadModel as UploadModel$1, ViewModeCapabilities, ViewModeDefinition$1 as ViewModeDefinition, ViewModeManagerModel as ViewModeManagerModel$1, ViewModeSettings, ViewModeToggle, ViewModeToggleProps, ViewerConfig, ViewerHost as ViewerHost$1, ViewerHostModel as ViewerHostModel$1, ViewerHostProps, ViewerProps, ViewerRegistry as ViewerRegistry$1, cn, globalViewerRegistry as globalViewerRegistry$1, viewerConfigToPlugin as viewerConfigToPlugin$1 };
+//# sourceMappingURL=index-Ml_SgiKa.d.ts.map