@fde-desktop/fde-core 0.3.7 → 0.4.1

package/dist/index.d.ts

@@ -1,11 +1,2019 @@
-export * from './apps';
-export * from './components';
-export * from './stores';
-export * from './hooks';
-export * from './types';
-export * from './interfaces';
-export * from './utils';
-export * from './constants';
-export * from './domain';
-export * from './infrastructure';
-export { default as i18n } from './i18n/index';
+import * as react from 'react';
+import react__default, { ReactNode, FC, MouseEvent, ReactElement } from 'react';
+import { MantineThemeOverride } from '@mantine/core';
+import i18n from 'i18next';
+export { default as i18n } from 'i18next';
+import * as framer_motion from 'framer-motion';
+import { Transition, TargetAndTransition, Variants } from 'framer-motion';
+import { IconType, IconBaseProps } from 'react-icons';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+export { v4 as uuidv4 } from 'uuid';
+
+type SupportedLanguage$2 = 'en' | 'es';
+interface CustomThemeColors {
+    taskbar: string;
+    window: string;
+    accent: string;
+}
+interface ISettingsState {
+    wallpaper: string | null;
+    wallpaperModule: string;
+    launcherIcon: string;
+    font: string;
+    downloadedFonts: string[];
+    fontSize: number;
+    animationDuration: number;
+    theme: FdeTheme;
+    themeSetManually: boolean;
+    customThemeColors: CustomThemeColors | null;
+    language: SupportedLanguage$2;
+    setWallpaper: (url: string | null) => void;
+    setWallpaperModule: (module: string) => void;
+    setLauncherIcon: (icon: string) => void;
+    setFont: (font: string) => void;
+    markFontDownloaded: (fontName: string) => void;
+    setFontSize: (size: number) => void;
+    setAnimationDuration: (duration: number) => void;
+    setThemeMode: (mode: ThemeMode) => void;
+    toggleTheme: () => void;
+    setThemeAutomatic: () => void;
+    applySystemTheme: (mode: ThemeMode) => void;
+    setCustomThemeColors: (colors: CustomThemeColors | null) => void;
+    setLanguage: (lang: SupportedLanguage$2) => void;
+}
+
+type ThemeMode = 'light' | 'dark';
+interface Theme {
+    mode: ThemeMode;
+    desktop: string;
+    taskbar: string;
+    window: string;
+    accent: string;
+}
+interface WindowTheme {
+    borderRadius: string;
+    headerHeight: number;
+    minWidth: number;
+    minHeight: number;
+    defaultWidth: number;
+    defaultHeight: number;
+    shadow: string;
+}
+interface TaskbarTheme {
+    height: number;
+    position: 'bottom' | 'top';
+    background: string;
+    blur: boolean;
+}
+interface DesktopTheme {
+    background: string;
+    iconSize: number;
+    iconSpacing: number;
+}
+interface FdeTheme {
+    mode: ThemeMode;
+    colors: {
+        desktop: string;
+        taskbar: string;
+        window: string;
+        accent: string;
+    };
+    window: WindowTheme;
+    taskbar: TaskbarTheme;
+    desktop: DesktopTheme;
+}
+interface PartialFdeTheme {
+    mode?: ThemeMode;
+    colors?: Partial<FdeTheme['colors']>;
+    window?: Partial<WindowTheme>;
+    taskbar?: Partial<TaskbarTheme>;
+    desktop?: Partial<DesktopTheme>;
+}
+interface IThemeProvider {
+    getTheme(): FdeTheme;
+    setMode(mode: ThemeMode): void;
+    toggle(): void;
+    setCustomColors(colors: CustomThemeColors | null): void;
+}
+
+interface ThemeProviderProps {
+    children: react__default.ReactNode;
+    initialMode?: ThemeMode;
+    /** External mode override - when provided, syncs internal state with this value */
+    mode?: ThemeMode;
+    theme?: PartialFdeTheme;
+}
+declare function ThemeProvider({ children, initialMode, mode: externalMode, theme, }: ThemeProviderProps): react__default.ReactElement;
+
+declare function useTheme(): FdeTheme;
+declare function useThemeContext(): IThemeProvider;
+
+declare const DEFAULT_FDE_THEME: Record<ThemeMode, FdeTheme>;
+
+interface FileSystemNode {
+    id: string;
+    name: string;
+    type: FileSystemNodeType;
+    parentId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+interface FileNode extends FileSystemNode {
+    type: 'file';
+    content: string;
+    mimeType?: string;
+    url?: string;
+    iconName?: string;
+    iconColor?: string;
+}
+
+interface FolderNode extends FileSystemNode {
+    type: 'folder';
+    children: string[];
+    iconName?: string;
+    iconColor?: string;
+}
+
+type FileSystemNodeType = 'file' | 'folder';
+type FSNode = FileNode | FolderNode;
+
+interface FsManifestFile {
+    name: string;
+    folder: string;
+    mimeType: string;
+    url: string;
+}
+interface FsManifest {
+    folders: string[];
+    files: FsManifestFile[];
+}
+interface IFileSystem {
+    initialize(): Promise<void>;
+    reinitialize(): Promise<void>;
+    isReady(): boolean;
+    isEmpty(): boolean;
+    getNode(id: string): FSNode | undefined;
+    getChildren(folderId: string): FSNode[];
+    getRootNodes(): FSNode[];
+    getAllNodes(): FSNode[];
+    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
+    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
+    updateFile(id: string, content: string): Promise<FileNode>;
+    move(id: string, newParentId: string | null): Promise<FSNode>;
+    delete(id: string): Promise<void>;
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    saveBlob(blob: Blob): Promise<string>;
+    /** url: `idb://{hash}` for IndexedDB, `/api/fs?action=file&path=...` for Docker */
+    getBlob(url: string): Promise<Blob | null>;
+    toBlobUrl(url: string): Promise<string | null>;
+    seed(manifest: FsManifest): Promise<void>;
+    mergeSeed(manifest: FsManifest): Promise<void>;
+    getManifestSha(): Promise<string | null>;
+    saveManifestSha(sha: string): Promise<void>;
+    clearAll(): Promise<void>;
+}
+
+interface FdeProviderProps {
+    children: react__default.ReactNode;
+    fileSystem: IFileSystem;
+    initialMode?: ThemeMode;
+    theme?: PartialFdeTheme;
+    mantineTheme?: MantineThemeOverride;
+    fallback?: react__default.ReactNode;
+    onError?: (error: Error) => void;
+}
+declare function FdeProvider({ children, fileSystem, initialMode, theme, mantineTheme, fallback, onError, }: FdeProviderProps): react__default.ReactElement;
+
+interface FdeContextValue {
+    fs: IFileSystem | null;
+    isReady: boolean;
+    error: Error | null;
+    theme: FdeTheme;
+    setThemeMode: (mode: ThemeMode) => void;
+    toggleTheme: () => void;
+}
+
+declare function useFdeContext(): FdeContextValue;
+
+interface AppEntry {
+    id: string;
+    name: string;
+    icon: string;
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    minWidth?: number | false;
+    minHeight?: number | false;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
+    autoLoad?: {
+        url: string;
+        name?: string;
+    };
+    hasContextMenu?: boolean;
+    singleWindow?: boolean;
+}
+
+type WindowState = 'normal' | 'minimized' | 'maximized';
+type WindowInput<T = Record<string, unknown>> = {
+    title: string;
+    content: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    minWidth?: number;
+    minHeight?: number;
+    icon?: string;
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
+    contentData?: T;
+};
+
+interface WindowEntity {
+    id: string;
+    title: string;
+    content: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    minWidth?: number;
+    minHeight?: number;
+    isOpen: boolean;
+    state: WindowState;
+    zIndex: number;
+    icon?: string;
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
+    contentData?: Record<string, unknown>;
+    closeInterceptor?: () => boolean;
+}
+
+interface MenuItemAction {
+    type: 'item';
+    label: string;
+    icon?: string;
+    onClick: () => void;
+    disabled?: boolean;
+}
+interface MenuItemDivider {
+    type: 'divider';
+}
+interface MenuItemSlider {
+    type: 'slider';
+    label?: string;
+    min: number;
+    max: number;
+    value: number;
+    onChange: (value: number) => void;
+    labelFormat?: (value: number) => string;
+}
+type MenuItem = MenuItemAction | MenuItemDivider | MenuItemSlider;
+interface AppMenuDropdown {
+    type: 'menu';
+    label: string;
+    icon?: string;
+    items: MenuItem[];
+    rightSection?: ReactNode;
+}
+interface AppMenuCombobox {
+    type: 'combobox';
+    label?: string;
+    options: string[];
+    value: string;
+    onChange: (value: string) => void;
+}
+interface AppMenuSwitch {
+    type: 'switch';
+    label: string;
+    checked: boolean;
+    onChange: (value: boolean) => void;
+}
+interface AppMenuSlider {
+    type: 'slider';
+    label?: string;
+    min: number;
+    max: number;
+    value: number;
+    onChange: (value: number) => void;
+    marks?: {
+        value: number;
+        label?: string;
+    }[];
+    labelFormat?: (value: number) => string;
+}
+interface AppMenuTextInput {
+    type: 'text-input';
+    placeholder?: string;
+    value: string;
+    onChange: (value: string) => void;
+}
+interface AppMenuNumberInput {
+    type: 'number-input';
+    label?: string;
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+}
+interface AppMenuSelect {
+    type: 'select';
+    label?: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    value: string;
+    onChange: (value: string) => void;
+}
+interface AppMenuDirtyIndicator {
+    type: 'dirty-indicator';
+}
+type AppMenuElement = AppMenuDropdown | AppMenuCombobox | AppMenuSwitch | AppMenuSlider | AppMenuTextInput | AppMenuNumberInput | AppMenuSelect | AppMenuDirtyIndicator;
+
+interface WindowContentProps {
+    window?: WindowEntity;
+    notifyReady?: (contentData?: Record<string, unknown>) => void;
+}
+type AppComponent$1 = FC<WindowContentProps>;
+type MenuBarBuilder = (window: WindowEntity) => AppMenuElement[] | undefined;
+interface MenuBarComponentProps {
+    windowId: string;
+    onExit: () => void;
+    contentData?: Record<string, unknown>;
+}
+type MenuBarComponent = FC<MenuBarComponentProps>;
+interface AppRegistration {
+    component: AppComponent$1;
+    buildMenuBar?: MenuBarBuilder;
+    MenuBarComponent?: MenuBarComponent;
+}
+
+interface DesktopIconEntity {
+    id: string;
+    name: string;
+    icon: string;
+    iconName?: string;
+    iconColor?: string;
+    x: number;
+    y: number;
+    appId: string;
+    nodeId?: string;
+}
+
+interface MenuPosition {
+    x: number;
+    y: number;
+}
+
+interface CreateFolderOptions {
+    iconName?: string;
+    iconColor?: string;
+}
+
+type LoadingState = 'idle' | 'fetching' | 'compiling' | 'loading' | 'ready' | 'error';
+interface LoadingProgress {
+    state: LoadingState;
+    progress: number;
+    message?: string;
+    appName?: string;
+    error?: string;
+}
+interface WindowLoading extends LoadingProgress {
+    windowId: string;
+}
+
+type DesktopIconInput = Omit<DesktopIconEntity, 'id'>;
+
+interface OpenAppOptions {
+    title?: string;
+    icon?: string;
+    contentData?: Record<string, unknown>;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+    size?: {
+        width?: number;
+        height?: number;
+    };
+}
+interface FileDialogOptions {
+    acceptedMimeTypes?: string[];
+    multiple?: boolean;
+    defaultPath?: string;
+}
+interface SaveDialogOptions {
+    defaultName?: string;
+    defaultPath?: string;
+    acceptedMimeTypes?: string[];
+}
+interface NotificationOptions {
+    title: string;
+    message: string;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    duration?: number;
+}
+type FdeEventType = 'window-opened' | 'window-closed' | 'window-focused' | 'window-minimized' | 'window-maximized' | 'file-opened' | 'file-saved' | 'theme-changed' | 'notification-shown';
+interface FdeEventPayloads {
+    'window-opened': {
+        windowId: string;
+        content: string;
+    };
+    'window-closed': {
+        windowId: string;
+    };
+    'window-focused': {
+        windowId: string;
+    };
+    'window-minimized': {
+        windowId: string;
+    };
+    'window-maximized': {
+        windowId: string;
+    };
+    'file-opened': {
+        path: string;
+        appId?: string;
+    };
+    'file-saved': {
+        path: string;
+        success: boolean;
+    };
+    'theme-changed': {
+        theme: string;
+    };
+    'notification-shown': {
+        notificationId: string;
+    };
+}
+interface FdeDesktopAPI {
+    openApp: (appId: string, options?: OpenAppOptions) => void;
+    closeWindow: (windowId?: string) => void;
+    minimizeWindow: (windowId?: string) => void;
+    maximizeWindow: (windowId?: string) => void;
+    restoreWindow: (windowId?: string) => void;
+    focusWindow: (windowId?: string) => void;
+    openFile: (path: string, appId?: string) => void;
+    openFileDialog: (options?: FileDialogOptions) => Promise<string | null>;
+    saveFile: (content: string, options?: SaveDialogOptions) => Promise<boolean>;
+    saveFileDialog: (options?: SaveDialogOptions) => Promise<string | null>;
+    getTheme: () => Record<string, unknown>;
+    setTheme: (theme: Record<string, unknown>) => void;
+    showNotification: (options: NotificationOptions) => string;
+    hideNotification: (notificationId: string) => void;
+    getWindows: () => WindowEntity[];
+    getActiveWindow: () => WindowEntity | null;
+    getWindowById: (windowId: string) => WindowEntity | null;
+    fs: IFileSystem;
+    on: <T extends FdeEventType>(event: T, callback: (data: FdeEventPayloads[T]) => void) => () => void;
+    off: <T extends FdeEventType>(event: T, callback: (data: FdeEventPayloads[T]) => void) => void;
+    appReady: (appId: string) => void;
+    registerAppInstance: (appId: string, instance: unknown) => void;
+}
+declare global {
+    interface Window {
+        __FDE_API__?: FdeDesktopAPI;
+    }
+}
+
+declare const createWindow: (input: WindowInput) => WindowEntity;
+
+declare const createDesktopIcon: (input: DesktopIconInput) => DesktopIconEntity;
+
+interface LauncherFolder {
+    id: string;
+    name: string;
+    fcIcon: string;
+    appIds: string[];
+    isExpanded: boolean;
+    isPredefined: boolean;
+    order: number;
+}
+interface LauncherFolderInput {
+    name: string;
+    fcIcon: string;
+    appIds?: string[];
+    isExpanded?: boolean;
+    isPredefined?: boolean;
+    order?: number;
+}
+declare const createLauncherFolder: (input: LauncherFolderInput) => LauncherFolder;
+declare const createPredefinedLauncherFolder: (input: Omit<LauncherFolderInput, "isPredefined">) => LauncherFolder;
+declare const updateLauncherFolder: (folder: LauncherFolder, updates: Partial<Omit<LauncherFolder, "id" | "isPredefined">>) => LauncherFolder;
+
+declare const createFolder: (name: string, parentId?: string | null, options?: CreateFolderOptions) => FolderNode;
+declare const createFile: (name: string, content: string, parentId?: string | null, mimeType?: string, url?: string) => FileNode;
+
+interface CustomAppManifest {
+    id: string;
+    name: string;
+    version: string;
+    icon: string;
+    iconUrl?: string;
+    entry: string;
+    window: {
+        defaultWidth?: number;
+        defaultHeight?: number;
+        minWidth?: number | false;
+        minHeight?: number | false;
+        canMaximize?: boolean;
+        alwaysOnTop?: boolean;
+        singleWindow?: boolean;
+    };
+}
+interface AppsManifest {
+    version: string;
+    generated: string;
+    apps: CustomAppManifest[];
+}
+declare function fetchAppManifest(forceRefresh?: boolean): Promise<AppsManifest | null>;
+declare function getCachedManifest(): AppsManifest | null;
+declare function clearManifestCache(): void;
+declare function updateManifestCache(manifest: CustomAppManifest): void;
+declare function removeFromManifestCache(appId: string): void;
+declare function getCustomApps(): Promise<CustomAppManifest[]>;
+declare function getCustomAppById(appId: string): Promise<CustomAppManifest | undefined>;
+declare function isCustomApp(appId: string): boolean;
+declare function convertToAppEntry(manifest: CustomAppManifest): Partial<AppEntry>;
+declare function mergeAppsWithCustomApps(staticApps: AppEntry[], customApps: CustomAppManifest[]): AppEntry[];
+declare function syncWithServer(currentRegisteredApps: Record<string, CustomAppManifest>): Promise<{
+    added: CustomAppManifest[];
+    removed: string[];
+    manifest: AppsManifest | null;
+}>;
+
+type ClipboardAction = 'copy' | 'cut' | null;
+interface ClipboardState {
+    content: FSNode[];
+    action: ClipboardAction;
+}
+type DesktopSortMode$1 = 'default' | 'name-asc' | 'name-desc' | 'type';
+interface NotificationItem {
+    id: string;
+    title: string;
+    message: string;
+    onClose?: () => void;
+    fcIcon?: string;
+}
+interface DesktopState {
+    windows: WindowEntity[];
+    openWindow: (input: WindowInput) => void;
+    closeWindow: (id: string) => void;
+    minimizeWindow: (id: string) => void;
+    maximizeWindow: (id: string) => void;
+    restoreWindow: (id: string) => void;
+    focusWindow: (id: string) => void;
+    moveWindow: (id: string, x: number, y: number) => void;
+    resizeWindow: (id: string, width: number, height: number) => void;
+    icons: DesktopIconEntity[];
+    addIcon: (input: DesktopIconInput) => void;
+    removeIcon: (id: string) => void;
+    fsNodes: FSNode[];
+    desktopFolderId: string | null;
+    isFsReady: boolean;
+    createFile: (name: string, content: string, parentId: string | null, url?: string) => Promise<FileNode>;
+    createFolder: (name: string, parentId: string | null, iconName?: string, iconColor?: string) => Promise<FolderNode>;
+    initFs: () => Promise<void>;
+    updateFile: (id: string, content: string) => Promise<void>;
+    deleteNode: (id: string) => Promise<void>;
+    moveNode: (id: string, newParentId: string | null) => Promise<void>;
+    setFsNodes: (nodes: FSNode[]) => void;
+    syncIcons: () => void;
+    clipboard: ClipboardState;
+    copyToClipboard: (nodes: FSNode[]) => void;
+    cutToClipboard: (nodes: FSNode[]) => void;
+    clearClipboard: () => void;
+    contextMenu: {
+        x: number;
+        y: number;
+        owner: string | null;
+        targetNodeId?: string;
+    };
+    openContextMenu: (x: number, y: number, owner: string, targetNodeId?: string) => void;
+    closeContextMenu: () => void;
+    filesCurrentFolderId: string | null;
+    setFilesCurrentFolderId: (id: string | null) => void;
+    mergeSeed: (manifest: FsManifest) => Promise<void>;
+    mergeDesktopApps: (appIds: readonly string[]) => void;
+    reorderDesktopApps: (appIds: readonly string[]) => void;
+    notifications: NotificationItem[];
+    addNotification: (item: NotificationItem) => void;
+    removeNotification: (id: string) => void;
+    viewportWidth: number;
+    viewportHeight: number;
+    isViewportInitialized: boolean;
+    setViewportSize: (width: number, height: number) => void;
+    desktopSortMode: DesktopSortMode$1;
+    filesSortMode: DesktopSortMode$1;
+    setDesktopSortMode: (mode: DesktopSortMode$1) => void;
+    setFilesSortMode: (mode: DesktopSortMode$1) => void;
+    launcherFolders: LauncherFolder[];
+    setLauncherFolders: (folders: LauncherFolder[]) => void;
+    createLauncherFolder: (input: LauncherFolderInput) => LauncherFolder;
+    updateLauncherFolder: (id: string, updates: Partial<Omit<LauncherFolder, 'id' | 'isPredefined'>>) => void;
+    deleteLauncherFolder: (id: string) => void;
+    moveLauncherFolder: (id: string, newOrder: number) => void;
+    addAppToFolder: (appId: string, folderId: string) => void;
+    removeAppFromFolder: (appId: string, folderId: string) => void;
+    customApps: CustomAppManifest[];
+    setCustomApps: (apps: CustomAppManifest[]) => void;
+    handleCustomAppRegistered: (manifest: CustomAppManifest) => void;
+    handleCustomAppUnregistered: (appId: string) => void;
+}
+
+interface MountedAppState {
+    isLoaded: boolean;
+    isLoading: boolean;
+    isReady: boolean;
+    hasError: boolean;
+    error?: string;
+    mountedAt: number;
+    instance?: unknown;
+}
+interface CustomAppState {
+    mountedApps: Record<string, MountedAppState>;
+    registeredApps: Record<string, CustomAppManifest>;
+    hmrConnected: boolean;
+    hmrError: string | null;
+    devServerOffline: boolean;
+    hmrRetryCount: number;
+    setAppLoading: (appId: string) => void;
+    setAppLoaded: (appId: string) => void;
+    setAppReady: (appId: string, instance?: unknown) => void;
+    setAppError: (appId: string, error: string) => void;
+    clearApp: (appId: string) => void;
+    registerApp: (manifest: CustomAppManifest) => void;
+    unregisterApp: (appId: string) => void;
+    setHmrConnected: (connected: boolean) => void;
+    setHmrError: (error: string | null) => void;
+    setDevServerOffline: (offline: boolean) => void;
+    incrementHmrRetry: () => void;
+    resetHmrRetry: () => void;
+}
+
+interface IWindowManager {
+    getAll(): WindowEntity[];
+    getById(id: string): WindowEntity | undefined;
+    open(input: WindowInput): WindowEntity;
+    close(id: string): void;
+    minimize(id: string): void;
+    maximize(id: string): void;
+    restore(id: string): void;
+    focus(id: string): void;
+    move(id: string, x: number, y: number): void;
+    resize(id: string, width: number, height: number): void;
+    loadWindows(windows: WindowEntity[]): void;
+}
+
+interface WindowProps {
+    window: WindowEntity;
+    menuBar?: AppMenuElement[];
+    children?: ReactNode;
+    closeInterceptor?: () => boolean;
+}
+interface DesktopIconProps {
+    icon: DesktopIconEntity;
+    onDoubleClick: (appId: string, nodeId?: string) => void;
+    onContextMenu: (e: React.MouseEvent, nodeId: string) => void;
+}
+interface DesktopContextMenuProps {
+    opened: boolean;
+    position: MenuPosition;
+    onClose: () => void;
+    onOpenApp: (appId: string) => void;
+    onToggleTheme: () => void;
+}
+interface LauncherProps {
+    fcIcon?: string;
+    onContextMenu?: (e: React.MouseEvent) => void;
+}
+interface DesktopAreaProps {
+    children?: ReactNode;
+    onContextMenu?: (e: MouseEvent<HTMLDivElement>) => void;
+}
+interface TaskbarContextMenuProps {
+    windowMenuOpened: boolean;
+    panelMenuOpened: boolean;
+    launcherMenuOpened: boolean;
+    menuPosition: MenuPosition;
+    targetWindowId: string | null;
+    targetWindowState: string | null;
+    onCloseWindow: (id: string) => void;
+    onMinimizeWindow: (id: string) => void;
+    onMaximizeWindow: (id: string) => void;
+    onRestoreWindow: (id: string) => void;
+    onClose: () => void;
+}
+
+interface FileIconProps {
+    type: 'file' | 'folder';
+    name?: string;
+    folderNode?: FolderNode;
+    fileNode?: FileNode;
+    size?: number;
+    iconName?: string;
+}
+
+type AppComponent = FC<WindowContentProps>;
+interface AppRegistryEntry {
+    component?: AppComponent;
+    loader?: () => Promise<{
+        default: AppComponent;
+    }>;
+    menuBarLoader?: () => Promise<{
+        default: MenuBarComponent;
+    }>;
+    buildMenuBar?: MenuBarBuilder;
+    MenuBarComponent?: MenuBarComponent;
+    isLazy?: boolean;
+    appName?: string;
+    singleWindow?: boolean;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    minWidth?: number | false;
+    minHeight?: number | false;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
+    icon?: string;
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
+}
+declare function initRegistry(registry: Record<string, AppRegistryEntry>): void;
+declare function getAppComponent(content: string): AppComponent;
+declare function getMenuBarBuilder(content: string): MenuBarBuilder | undefined;
+declare function getMenuBarComponent(content: string): MenuBarComponent | undefined;
+declare function isLazyApp(content: string): boolean;
+declare function getAppName(content: string): string | undefined;
+declare function registerComponents(entries: Record<string, AppRegistryEntry>): void;
+declare const CORE_REGISTRY: Record<string, AppRegistryEntry>;
+
+interface FdeDesktopProps {
+    children?: react__default.ReactNode;
+    fallback?: react__default.ReactNode;
+    theme?: PartialFdeTheme;
+    mantineTheme?: MantineThemeOverride;
+    fileSystem?: IFileSystem;
+    initialMode?: ThemeMode;
+    customApps?: Record<string, AppRegistryEntry>;
+    onError?: (error: Error) => void;
+    /** URL or import of the default wallpaper image */
+    defaultWallpaper?: string;
+    /** App ID to open on startup */
+    initialApp?: string;
+    /** Loaders to prefetch in the background after startup */
+    prefetchLoaders?: Array<{
+        id: string;
+        loader: () => Promise<unknown>;
+    }>;
+}
+declare function FdeDesktop({ children, fallback, theme, mantineTheme, fileSystem, initialMode, customApps, onError, defaultWallpaper, initialApp, prefetchLoaders, }: FdeDesktopProps): react__default.ReactElement;
+
+declare const Window: FC<WindowProps>;
+
+declare const AppReadyProvider: FC<{
+    children: ReactNode;
+}>;
+
+interface AppReadyContextValue {
+    notifyReady: (contentData?: Record<string, unknown>) => void;
+    getContentData: () => Record<string, unknown> | undefined;
+}
+declare const useAppReady: () => AppReadyContextValue;
+
+declare const FilesAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const NotesAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const ImageViewerAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const PdfAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const MenuEditAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const UploaderAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const SettingsAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const DeviceInfoAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const CalendarAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const CreateItemAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const NotesMenuBarLazy: MenuBarComponent;
+declare const MenuEditMenuBarLazy: MenuBarComponent;
+declare const SettingsMenuBarLazy: MenuBarComponent;
+declare const PdfMenuBarLazy: MenuBarComponent;
+declare const ImageViewerMenuBarLazy: MenuBarComponent;
+
+interface AppMenuBarProps {
+    elements: AppMenuElement[];
+}
+declare const AppMenuBar: FC<AppMenuBarProps>;
+
+interface TaskbarProps {
+    calendarSlot?: ReactNode;
+}
+declare const Taskbar: FC<TaskbarProps>;
+
+declare const LanguageSelector: FC;
+
+declare const Launcher: FC<LauncherProps>;
+
+declare const TaskbarContextMenu: FC<TaskbarContextMenuProps>;
+
+interface DesktopProps extends DesktopAreaProps {
+    wallpaper?: string;
+    backgroundColor?: string;
+}
+declare const Desktop: FC<DesktopProps>;
+
+declare const DesktopIcon: FC<DesktopIconProps>;
+
+interface DynamicMenuBarRendererProps {
+    component?: MenuBarComponent;
+    windowId: string;
+    contentData: Record<string, unknown> | undefined;
+    onExit: () => void;
+}
+declare const DynamicMenuBarRenderer: FC<DynamicMenuBarRendererProps>;
+
+declare const ContextMenu: FC<DesktopContextMenuProps>;
+
+interface CreateItemContextMenuProps {
+    owner: string;
+    parentId: string | null;
+    currentPath: string;
+}
+declare const CreateItemContextMenu: FC<CreateItemContextMenuProps>;
+
+declare const CalendarApp: FC<WindowContentProps>;
+
+declare const FilesApp: FC<WindowContentProps>;
+
+declare const NotesApp: FC<WindowContentProps>;
+
+declare const ImageViewerApp: FC<WindowContentProps>;
+
+declare const PdfApp: FC<WindowContentProps>;
+
+declare const MenuEditApp: FC<WindowContentProps>;
+
+declare const UploaderApp: FC<WindowContentProps>;
+
+declare const StorybookApp: FC<WindowContentProps>;
+
+declare const SettingsApp: FC<WindowContentProps>;
+
+declare const DeviceInfoApp: FC<WindowContentProps>;
+
+interface SettingsSection$1 {
+    id: 'wallpaper' | 'appearance' | 'launcher' | 'font' | 'language' | 'reset';
+    label: string;
+    fcIcon: string;
+    description: string;
+}
+declare const SETTINGS_SECTIONS: SettingsSection$1[];
+
+declare const NotesMenuBar: FC<MenuBarComponentProps>;
+
+declare const MenuEditMenuBar: FC<MenuBarComponentProps>;
+
+declare const SettingsMenuBar: FC<MenuBarComponentProps>;
+
+declare const PdfMenuBar: FC<MenuBarComponentProps>;
+
+declare const ImageViewerMenuBar: FC<MenuBarComponentProps>;
+
+interface AppIconProps {
+    fcIcon?: string;
+    fallback?: string;
+    iconUrl?: string;
+    size?: number;
+    color?: string;
+}
+declare const AppIcon: FC<AppIconProps>;
+
+interface VscIconProps {
+    name: string;
+    size?: number;
+    color?: string;
+}
+declare const VscIcon: FC<VscIconProps>;
+
+interface AppLoadingProps {
+    message?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+declare const AppLoading: FC<AppLoadingProps>;
+
+interface DirtyIndicatorProps {
+    size?: number;
+}
+declare const DirtyIndicator: FC<DirtyIndicatorProps>;
+
+declare const ContextMenuAnchor: FC<MenuPosition>;
+
+declare const FileIcon: FC<FileIconProps>;
+
+interface AppEmptyStateProps {
+    label?: string;
+}
+declare const AppEmptyState: FC<AppEmptyStateProps>;
+
+interface ColorPickerProps {
+    value: string;
+    onChange: (color: string) => void;
+    error?: string;
+    disabled?: boolean;
+}
+declare const ColorPicker: FC<ColorPickerProps>;
+
+declare const CreateItemApp: FC<WindowContentProps>;
+
+type DownloadStatus = 'idle' | 'downloading' | 'done' | 'error';
+interface DownloadState {
+    status: DownloadStatus;
+    loaded: number;
+    total: number | null;
+    percent: number | null;
+    error: string | null;
+}
+interface UseDownloadReturn extends DownloadState {
+    download: (url: string) => Promise<string | null>;
+    reset: () => void;
+}
+declare const useDownload: () => UseDownloadReturn;
+
+interface DownloadProgressProps {
+    state: DownloadState;
+    ariaLabel?: string;
+    minDisplayTime?: number;
+}
+declare const DownloadProgress: FC<DownloadProgressProps>;
+
+interface FilePickerAppProps {
+    acceptedMimeTypes?: string[];
+    onConfirm: (node: FileNode) => void;
+    onCancel: () => void;
+}
+declare const FilePickerApp: FC<FilePickerAppProps>;
+interface FilePickerModalProps extends FilePickerAppProps {
+    opened: boolean;
+}
+declare const FilePickerModal: FC<FilePickerModalProps>;
+
+interface PickerModalProps {
+    opened: boolean;
+    children: ReactNode;
+    ariaLabelKey: string;
+    ariaLabelNs?: string;
+}
+declare const PickerModal: react.NamedExoticComponent<PickerModalProps>;
+
+interface IconColorPickerProps {
+    selectedIcon: string;
+    selectedColor: string;
+    onIconChange: (icon: string) => void;
+    onColorChange: (color: string) => void;
+    colorError?: string;
+}
+declare const IconColorPicker: FC<IconColorPickerProps>;
+
+interface SettingsSectionProps {
+    title: string;
+    description?: string;
+    children: ReactNode;
+}
+declare const SettingsSection: FC<SettingsSectionProps>;
+
+interface ExternalLinkAppConfig {
+    icon: string;
+    iconColor: string;
+    title: string;
+    url: string;
+    buttonLabel: string;
+    description?: string;
+}
+declare const ExternalLinkApp: FC<WindowContentProps & {
+    config: ExternalLinkAppConfig;
+}>;
+
+declare const SUPPORTED_LANGUAGES$1: readonly ["en", "es"];
+type SupportedLanguage$1 = (typeof SUPPORTED_LANGUAGES$1)[number];
+
+interface LanguageFlagProps {
+    lang: SupportedLanguage$1;
+    size?: number;
+}
+declare const LanguageFlag: FC<LanguageFlagProps>;
+
+interface CollapsibleSectionProps {
+    title: string;
+    fcIcon?: string;
+    expanded: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    className?: string;
+    'aria-label'?: string;
+}
+declare const CollapsibleSection: FC<CollapsibleSectionProps>;
+
+interface CustomAppLoaderProps {
+    appId: string;
+    windowIcon?: string;
+    notifyReady?: WindowContentProps['notifyReady'];
+}
+declare const CustomAppLoader: FC<CustomAppLoaderProps>;
+
+interface CustomAppLoadingScreenProps {
+    progress: LoadingProgress;
+    windowIcon?: string;
+}
+declare const CustomAppLoadingScreen: FC<CustomAppLoadingScreenProps>;
+
+interface CustomAppOfflineProps {
+    appId: string;
+}
+declare const CustomAppOffline: FC<CustomAppOfflineProps>;
+
+interface CustomAppNotSupportedProps {
+    appId: string;
+}
+declare const CustomAppNotSupported: FC<CustomAppNotSupportedProps>;
+
+declare const registerCloseInterceptor: (windowId: string, interceptor: () => boolean) => void;
+declare const unregisterCloseInterceptor: (windowId: string) => void;
+declare const getCloseInterceptor: (windowId: string) => (() => boolean) | undefined;
+interface UseCloseInterceptorOptions {
+    isDirtyGetter: () => boolean;
+    windowId?: string;
+    onDiscard?: () => void;
+    onSave?: () => void;
+}
+declare function useCloseInterceptor({ isDirtyGetter, windowId, onDiscard, onSave, }: UseCloseInterceptorOptions): void;
+
+declare function useAppName(appId: string | undefined): string;
+
+declare function useFolderName(folder: {
+    id: string;
+    name: string;
+    isPredefined: boolean;
+}): string;
+
+declare const useClock: () => string;
+
+declare const useAnimationDuration: () => {
+    duration: number;
+    windowVariants: framer_motion.Variants;
+    panelVariants: {
+        initial: {
+            opacity: number;
+            y: number;
+            scale: number;
+        };
+        animate: {
+            opacity: number;
+            y: number;
+            scale: number;
+            transition: framer_motion.Transition;
+        };
+        exit: {
+            opacity: number;
+            y: number;
+            scale: number;
+            transition: framer_motion.Transition;
+        };
+    };
+    minimizeVariant: (deltaX: number, deltaY: number) => framer_motion.TargetAndTransition;
+    restoreVariant: (deltaX: number, deltaY: number) => framer_motion.TargetAndTransition;
+    maximizeTransition: framer_motion.Transition;
+    easeIn: framer_motion.Transition;
+    easeOut: framer_motion.Transition;
+};
+
+type IconLibrary = 'fi' | 'fc' | 'vsc';
+declare const useDynamicIcon: (name: string, library: IconLibrary) => IconType | null;
+declare const useDynamicIconElement: (name: string, library: IconLibrary, props?: IconBaseProps) => ReactElement | null;
+declare const useFiIcon: (name: string) => IconType | null;
+declare const useFcIcon: (name: string) => IconType | null;
+declare const useVscIcon: (name: string) => IconType | null;
+declare const useFiIconElement: (name: string, props?: IconBaseProps) => ReactElement | null;
+declare const useFcIconElement: (name: string, props?: IconBaseProps) => ReactElement | null;
+declare const useVscIconElement: (name: string, props?: IconBaseProps) => ReactElement | null;
+
+declare const useTaskbarHeight: (opened: boolean) => {
+    menuRef: react.RefObject<HTMLDivElement | null>;
+    menuHeight: number;
+};
+
+type TaskbarMenuType = 'window' | 'panel' | 'launcher' | null;
+interface UseTaskbarContextMenuReturn {
+    activeMenu: TaskbarMenuType;
+    position: MenuPosition;
+    targetWindowId: string | null;
+    windowMenuOpened: boolean;
+    panelMenuOpened: boolean;
+    launcherMenuOpened: boolean;
+    openWindowMenu: (e: React.MouseEvent, windowId: string) => void;
+    openPanelMenu: (e: React.MouseEvent) => void;
+    openLauncherMenu: (e: React.MouseEvent) => void;
+    closeMenu: () => void;
+}
+declare const useTaskbarContextMenu: () => UseTaskbarContextMenuReturn;
+
+declare function useCollapsible(initialExpanded?: Set<string>): {
+    expanded: Set<string>;
+    toggle: (id: string) => void;
+    expand: (id: string) => void;
+    collapse: (id: string) => void;
+    expandAll: (ids: string[]) => void;
+    collapseAll: () => void;
+    reset: () => void;
+    isExpanded: (id: string) => boolean;
+};
+
+declare function useSearchFilter<T>(items: T[], searchQuery: string, getSearchableText: (item: T) => string | string[]): T[];
+
+interface RegistryContextValue {
+    register: (id: string, rect: DOMRect) => void;
+    unregister: (id: string) => void;
+    getRect: (id: string) => DOMRect | undefined;
+}
+declare const WindowButtonRegistryProvider: FC<{
+    children: ReactNode;
+}>;
+declare const useWindowButtonRegistry: () => RegistryContextValue;
+
+declare const AVAILABLE_FONTS: {
+    value: string;
+    label: string;
+    stack: string;
+}[];
+declare const FONT_STACKS: Record<string, string>;
+declare const GOOGLE_FONTS_HREF: Record<string, string>;
+
+/**
+ * Applies the currently selected font stack to the document root.
+ * Also re-injects <link> tags for all previously downloaded fonts on mount.
+ */
+declare const useApplyFont: () => void;
+
+declare const useAppUpdate: () => void;
+
+interface UseContextMenuReturn {
+    opened: boolean;
+    position: MenuPosition;
+    open: (e: MouseEvent, offsetY?: number) => void;
+    close: () => void;
+}
+declare const useContextMenu: (offsetY?: number, appId?: string) => UseContextMenuReturn;
+
+type DragItemType = 'app' | 'file' | 'folder';
+type DropTargetType = 'launcher-folder' | 'filesystem-folder' | 'desktop' | 'available-apps';
+interface DragItemData {
+    type: DragItemType;
+    id: string;
+    name: string;
+    sourceId: string;
+    sourceType: DropTargetType;
+    metadata?: {
+        fcIcon?: string;
+        iconUrl?: string;
+        icon?: string;
+        iconColor?: string;
+    };
+}
+interface DropTarget {
+    type: DropTargetType;
+    id: string;
+    name: string;
+    accepts: DragItemType[];
+}
+interface DragDropContextValue {
+    activeItem: DragItemData | null;
+    overTarget: DropTarget | null;
+}
+
+interface DragDropProviderProps {
+    children: ReactNode;
+    onDrop: (item: DragItemData, target: DropTarget) => void;
+    onCancel?: () => void;
+}
+declare const DragDropProvider: FC<DragDropProviderProps>;
+
+interface UseDraggableItemOptions {
+    item: DragItemData;
+    disabled?: boolean;
+}
+interface UseDraggableItemReturn {
+    attributes: React.HTMLAttributes<HTMLElement>;
+    listeners: Record<string, unknown> | undefined;
+    setNodeRef: (node: HTMLElement | null) => void;
+    isDragging: boolean;
+    transform: {
+        x: number;
+        y: number;
+    } | null;
+    style: React.CSSProperties;
+}
+declare function useDraggableItem(options: UseDraggableItemOptions): UseDraggableItemReturn;
+
+interface UseDroppableAreaOptions {
+    target: DropTarget;
+    disabled?: boolean;
+}
+interface UseDroppableAreaReturn {
+    setNodeRef: (node: HTMLElement | null) => void;
+    isOver: boolean;
+    active: DragItemData | null;
+}
+declare function useDroppableArea(options: UseDroppableAreaOptions): UseDroppableAreaReturn;
+
+declare function useDragDropState(): DragDropContextValue;
+
+interface FontDownloadProgress {
+    status: 'idle' | 'downloading' | 'done' | 'error';
+    loaded: number;
+    total: number | null;
+    percent: number | null;
+    error: string | null;
+}
+interface FontDownloadResult {
+    font: string;
+    success: boolean;
+}
+declare const useFontDownload: (font: string | null) => {
+    progress: FontDownloadProgress;
+    isDownloaded: boolean;
+    reset: () => void;
+    data: FontDownloadResult;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FontDownloadResult, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FontDownloadResult>;
+} | {
+    progress: FontDownloadProgress;
+    isDownloaded: boolean;
+    reset: () => void;
+    data: FontDownloadResult;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FontDownloadResult, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FontDownloadResult>;
+} | {
+    progress: FontDownloadProgress;
+    isDownloaded: boolean;
+    reset: () => void;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FontDownloadResult, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FontDownloadResult>;
+} | {
+    progress: FontDownloadProgress;
+    isDownloaded: boolean;
+    reset: () => void;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FontDownloadResult, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FontDownloadResult>;
+} | {
+    progress: FontDownloadProgress;
+    isDownloaded: boolean;
+    reset: () => void;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FontDownloadResult, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FontDownloadResult>;
+} | {
+    progress: FontDownloadProgress;
+    isDownloaded: boolean;
+    reset: () => void;
+    data: FontDownloadResult;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FontDownloadResult, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FontDownloadResult>;
+};
+
+interface UseIsDirtyOptions<T> {
+    /** Mutable ref that holds the snapshot (used internally). */
+    snapshotRef: React.MutableRefObject<T | null>;
+    /** Function that returns the current state of the app. */
+    getCurrentState: () => T;
+    /** Optional initial snapshot – used when no stored snapshot exists. */
+    initialSnapshot?: T;
+    /** Optional callback invoked when the dirty flag changes. */
+    onChange?: (isDirty: boolean) => void;
+    /** Unique identifier for the app – used to persist the snapshot in the global store. */
+    appId?: string;
+}
+declare function useIsDirty<T>({ snapshotRef, getCurrentState, initialSnapshot, onChange, appId, }: UseIsDirtyOptions<T>): {
+    isDirty: boolean;
+    takeSnapshot: () => void;
+    reset: () => void;
+};
+
+declare function useLanguageSync(): void;
+
+declare class IndexedDBFileSystem implements IFileSystem {
+    private db;
+    private nodes;
+    private ready;
+    private initPromise;
+    private persistQueue;
+    private persistScheduled;
+    initialize(): Promise<void>;
+    private doInitialize;
+    private openDatabase;
+    private loadNodes;
+    private migrateFromLocalStorage;
+    isReady(): boolean;
+    reinitialize(): Promise<void>;
+    private persistAllNodes;
+    private schedulePersist;
+    private flushPersistQueue;
+    private persistNode;
+    private deleteNodeFromPersist;
+    saveBlob(blob: Blob): Promise<string>;
+    getBlob(url: string): Promise<Blob | null>;
+    toBlobUrl(url: string): Promise<string | null>;
+    clearBlobs(): Promise<void>;
+    readFile(_path: string): Promise<string>;
+    writeFile(_path: string, _content: string): Promise<void>;
+    getNode(id: string): FSNode | undefined;
+    getChildren(folderId: string): FSNode[];
+    getRootNodes(): FSNode[];
+    getAllNodes(): FSNode[];
+    isEmpty(): boolean;
+    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
+    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
+    updateFile(id: string, content: string): Promise<FileNode>;
+    move(id: string, newParentId: string | null): Promise<FSNode>;
+    delete(id: string): Promise<void>;
+    getManifestSha(): Promise<string | null>;
+    saveManifestSha(sha: string): Promise<void>;
+    clearAll(): Promise<void>;
+    seed(manifest: FsManifest): Promise<void>;
+    mergeSeed(manifest: FsManifest): Promise<void>;
+    private buildFolderMapFromManifest;
+    private addChildToFolder;
+    private removeChildFromParent;
+    private deleteRecursive;
+}
+
+declare function setApiBaseUrl(url: string): void;
+declare class DockerFileSystemAdapter implements IFileSystem {
+    private nodes;
+    private pathToId;
+    private ready;
+    private rootFolderId;
+    private initPromise;
+    constructor();
+    initialize(): Promise<void>;
+    private doInitialize;
+    reinitialize(): Promise<void>;
+    isReady(): boolean;
+    isEmpty(): boolean;
+    getNode(id: string): FSNode | undefined;
+    getChildren(folderId: string): FSNode[];
+    getRootNodes(): FSNode[];
+    getAllNodes(): FSNode[];
+    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
+    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
+    updateFile(id: string, content: string): Promise<FileNode>;
+    move(id: string, newParentId: string | null): Promise<FSNode>;
+    delete(id: string): Promise<void>;
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    saveBlob(blob: Blob): Promise<string>;
+    getBlob(url: string): Promise<Blob | null>;
+    toBlobUrl(url: string): Promise<string | null>;
+    getManifestSha(): Promise<string | null>;
+    saveManifestSha(_sha: string): Promise<void>;
+    seed(_manifest: FsManifest): Promise<void>;
+    mergeSeed(_manifest: FsManifest): Promise<void>;
+    clearAll(): Promise<void>;
+    private getMimeType;
+    private getPathFromId;
+    private deleteRecursive;
+    private syncFromEntries;
+    private fetchReaddir;
+    private writeFileToServer;
+    private createDirOnServer;
+    private deleteFromServer;
+}
+
+declare const fileSystem: IndexedDBFileSystem | DockerFileSystemAdapter;
+declare const resetFileSystem: () => void;
+declare const resetWindowManager: () => void;
+declare function resolveFileUrl(url: string, signal?: AbortSignal): Promise<string>;
+declare const useDesktopStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DesktopState>, "setState" | "persist"> & {
+    setState(partial: DesktopState | Partial<DesktopState> | ((state: DesktopState) => DesktopState | Partial<DesktopState>), replace?: false | undefined): unknown;
+    setState(state: DesktopState | ((state: DesktopState) => DesktopState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DesktopState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DesktopState) => void) => () => void;
+        onFinishHydration: (fn: (state: DesktopState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DesktopState, unknown, unknown>>;
+    };
+}>;
+
+declare const getPersistedThemeMode: () => ThemeMode | null;
+declare const useSettingsStore: zustand.UseBoundStore<Omit<zustand.StoreApi<ISettingsState>, "setState" | "persist"> & {
+    setState(partial: ISettingsState | Partial<ISettingsState> | ((state: ISettingsState) => ISettingsState | Partial<ISettingsState>), replace?: false | undefined): unknown;
+    setState(state: ISettingsState | ((state: ISettingsState) => ISettingsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<ISettingsState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ISettingsState) => void) => () => void;
+        onFinishHydration: (fn: (state: ISettingsState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<ISettingsState, unknown, unknown>>;
+    };
+}>;
+
+declare const useCustomAppStore: zustand.UseBoundStore<zustand.StoreApi<CustomAppState>>;
+
+interface AppTempMemoryState {
+    snapshots: Record<string, unknown>;
+    setSnapshot: (appId: string, snapshot: unknown) => void;
+    getSnapshot: (appId: string) => unknown | null;
+    clearSnapshot: (appId: string) => void;
+}
+declare const useAppTempMemoryStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AppTempMemoryState>, "setState" | "persist"> & {
+    setState(partial: AppTempMemoryState | Partial<AppTempMemoryState> | ((state: AppTempMemoryState) => AppTempMemoryState | Partial<AppTempMemoryState>), replace?: false | undefined): unknown;
+    setState(state: AppTempMemoryState | ((state: AppTempMemoryState) => AppTempMemoryState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<AppTempMemoryState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AppTempMemoryState) => void) => () => void;
+        onFinishHydration: (fn: (state: AppTempMemoryState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<AppTempMemoryState, unknown, unknown>>;
+    };
+}>;
+
+interface CloseModalState {
+    isOpen: boolean;
+    windowId: string | null;
+    onSave: (() => void) | null;
+    onDiscard: (() => void) | null;
+}
+interface CloseModalActions {
+    openModal: (windowId: string, onSave: () => void, onDiscard: () => void) => void;
+    closeModal: () => void;
+}
+declare const useCloseModalStore: zustand.UseBoundStore<zustand.StoreApi<CloseModalState & CloseModalActions>>;
+
+interface AdaptiveDimensions {
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    minHeight: number;
+}
+declare function useAdaptiveDimensions(): AdaptiveDimensions;
+
+declare const useNotifications: () => {
+    notifications: NotificationItem[];
+    notify: (title: string, message: string, options?: {
+        fcIcon?: string;
+        onClose?: () => void;
+    }) => string;
+    dismiss: (id: string) => void;
+    addNotification: (item: NotificationItem) => void;
+    removeNotification: (id: string) => void;
+};
+
+declare const useSystemTheme: () => void;
+
+type OpenHookOptions = {
+    contentData?: Record<string, unknown>;
+    position?: {
+        x: number;
+        y: number;
+    };
+};
+declare const useOpenApp: () => (appId: string, { contentData, position }?: OpenHookOptions) => void;
+
+declare function useFdeApi(): FdeDesktopAPI | null;
+
+declare function useResolvedUrl(url: string | undefined): string | undefined;
+
+interface DeviceInfo {
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isPortrait: boolean;
+    shouldShowWarning: boolean;
+    screenWidth: number;
+    screenHeight: number;
+}
+declare function useDeviceDetection(): DeviceInfo;
+
+type AppReloadCallback = (appId: string) => void;
+type AppRegisteredCallback = (manifest: CustomAppManifest) => void;
+type AppUnregisteredCallback = (appId: string) => void;
+interface HMRCallbacks {
+    onReload: AppReloadCallback;
+    onRegistered?: AppRegisteredCallback;
+    onUnregistered?: AppUnregisteredCallback;
+}
+/**
+ * Reset connection state - useful for testing
+ * @internal
+ */
+declare function resetHMRState(): void;
+declare function checkHMREndpointExists(): Promise<boolean>;
+declare function useCustomAppHMR(callbacksArg: HMRCallbacks): void;
+declare function useCustomAppLifecycle(): void;
+
+/**
+ * Appends a dirty-indicator element to menu items if dirty.
+ * Returns a new array when dirty (immutable), or the original array when not dirty.
+ *
+ * @param items - The array of menu elements
+ * @param isDirty - Whether there are unsaved changes
+ * @returns The same array if not dirty, or a new array with dirty-indicator appended
+ *
+ * @example
+ * const items: AppMenuElement[] = [
+ *   { type: 'menu', label: 'File', items: [...] }
+ * ];
+ *
+ * return appendDirtyIndicator(items, isDirty);
+ */
+declare function appendDirtyIndicator(items: AppMenuElement[], isDirty: boolean): AppMenuElement[];
+
+declare const injectFontLink: (font: string) => void;
+
+type Runtime = 'browser' | 'docker' | 'electron';
+declare function getRuntime(): Runtime;
+declare function isDocker(): boolean;
+declare function isElectron(): boolean;
+declare function isBrowser(): boolean;
+declare function isDev(): boolean;
+
+declare function generateUUID(): string;
+
+declare function waitForContainer(containerId: string, timeout?: number): Promise<HTMLElement>;
+
+declare function setTestBaseUrl(url: string | null): void;
+declare function getBaseUrl(): string;
+declare function resetBaseUrlCache(): void;
+declare function resolveUrl(relativeUrl: string): string;
+
+declare const sortNodes: (nodes: FSNode[]) => FSNode[];
+declare const SortOptions: {
+    readonly BY_TYPE: "byType";
+    readonly BY_NAME: "byName";
+    readonly BY_DATE: "byDate";
+};
+type SortOption = (typeof SortOptions)[keyof typeof SortOptions];
+type DesktopSortMode = 'default' | 'name-asc' | 'name-desc' | 'type';
+declare function sortDesktopIcons(icons: DesktopIconEntity[], desktopAppsOrder?: readonly string[]): DesktopIconEntity[];
+declare const sortDesktopIconsByMode: (icons: DesktopIconEntity[], mode: DesktopSortMode) => DesktopIconEntity[];
+declare const sortNodesByMode: (nodes: FSNode[], mode: DesktopSortMode) => FSNode[];
+
+declare function formatBytes(bytes: number): string;
+
+declare function hashBlob(blob: Blob): Promise<string>;
+
+interface AppFileHandler {
+    appId: string;
+    mimeTypes: string[] | ((mimeType: string) => boolean);
+    transformContentData: (node: FileNode) => Record<string, unknown>;
+}
+declare const registerAppFileHandler: (handler: AppFileHandler) => void;
+declare const IMAGE_MIME_TYPES: Set<string>;
+declare const TEXT_MIME_TYPES: Set<string>;
+declare function getAppIdForMime(mimeType: string | undefined): string;
+declare function getAppIdForMime(node: FileNode): {
+    appId: string;
+    contentData: Record<string, unknown>;
+} | null;
+
+declare function getMimeTypeFromExtension(filename: string): string | undefined;
+
+declare const getFileExtension: (name: string) => string;
+
+declare function getFourRandomColors(count?: number): string[];
+
+type Breadcrumb = {
+    id: string | null;
+    name: string;
+};
+declare const buildBreadcrumbs: (currentFolderId: string | null, fsNodes: FSNode[]) => Breadcrumb[];
+
+declare const isNewerVersion: (latest: string, current: string) => boolean;
+
+interface ClearBrowserDataOptions {
+    keepIndexedDB?: boolean;
+    keepServiceWorker?: boolean;
+    keepLocalStorage?: boolean;
+    keepSessionStorage?: boolean;
+}
+declare function clearBrowserData(options?: ClearBrowserDataOptions): Promise<void>;
+
+declare const DEFAULT_WINDOW_DIMENSIONS: {
+    readonly defaultWidth: 800;
+    readonly defaultHeight: 600;
+    readonly minWidth: 640;
+    readonly minHeight: 480;
+};
+declare const CORE_APPS: AppEntry[];
+declare const CORE_APP_IDS: string[];
+
+declare const ANIMATION_DURATION = 0.3;
+declare const createEaseIn: (duration: number) => Transition;
+declare const createEaseOut: (duration: number) => Transition;
+declare const createWindowVariants: (duration: number) => Variants;
+declare const createPanelVariants: (duration: number) => {
+    initial: {
+        opacity: number;
+        y: number;
+        scale: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        scale: number;
+        transition: Transition;
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        scale: number;
+        transition: Transition;
+    };
+};
+declare const createMinimizeVariant: (duration: number) => (deltaX: number, deltaY: number) => TargetAndTransition;
+declare const createRestoreVariant: (duration: number) => (deltaX: number, deltaY: number) => TargetAndTransition;
+declare const createMaximizeTransition: (duration: number) => Transition;
+declare const EASE_IN: Transition;
+declare const EASE_OUT: Transition;
+declare const windowVariants: Variants;
+declare const panelVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+        scale: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        scale: number;
+        transition: Transition;
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        scale: number;
+        transition: Transition;
+    };
+};
+declare const minimizeVariant: (deltaX: number, deltaY: number) => TargetAndTransition;
+declare const restoreVariant: (deltaX: number, deltaY: number) => TargetAndTransition;
+declare const openVariants: {
+    readonly scale: {
+        readonly hidden: {
+            readonly opacity: 0;
+            readonly scale: 0.92;
+            readonly y: 12;
+        };
+        readonly visible: {
+            readonly opacity: 1;
+            readonly scale: 1;
+            readonly y: 0;
+            readonly transition: Transition;
+        };
+    };
+    readonly slide: {
+        readonly hidden: {
+            readonly opacity: 0;
+            readonly y: 40;
+        };
+        readonly visible: {
+            readonly opacity: 1;
+            readonly y: 0;
+            readonly transition: Transition;
+        };
+    };
+    readonly fade: {
+        readonly hidden: {
+            readonly opacity: 0;
+        };
+        readonly visible: {
+            readonly opacity: 1;
+            readonly transition: Transition;
+        };
+    };
+};
+declare const maximizeTransition: Transition;
+declare const randomWindowPosition: () => {
+    x: number;
+    y: number;
+};
+declare const centerWindowPosition: (viewportWidth: number, viewportHeight: number, windowWidth: number, windowHeight: number) => {
+    x: number;
+    y: number;
+};
+
+declare const BREAKPOINTS: {
+    readonly MOBILE: 768;
+    readonly TABLET: 1024;
+    readonly DESKTOP: 1280;
+};
+type Breakpoint = (typeof BREAKPOINTS)[keyof typeof BREAKPOINTS];
+
+declare const TASKBAR_HEIGHT = 48;
+declare const ICON_COLUMN_WIDTH = 80;
+declare const ICON_ROW_HEIGHT = 80;
+declare const ICON_MARGIN = 20;
+declare const DEFAULT_VIEWPORT_WIDTH: 1280;
+declare const DEFAULT_VIEWPORT_HEIGHT: 800;
+
+declare const APP_IDS: {
+    readonly WELCOME: "welcome";
+    readonly NOTEPAD: "notepad";
+    readonly UPLOADER: "uploader";
+    readonly FILES: "files";
+    readonly SETTINGS: "settings";
+    readonly PDF: "pdf";
+    readonly CALENDAR: "calendar";
+    readonly STORYBOOK: "storybook";
+    readonly LINKEDIN: "linkedin";
+    readonly GITHUB: "github";
+    readonly IMAGE_VIEWER: "image-viewer";
+    readonly DOS_EMULATOR: "dos-emulator";
+    readonly DOOM: "doom";
+    readonly TERMINAL: "terminal";
+    readonly CODE_SERVER: "code-server";
+    readonly DEVICE_INFO: "device-info";
+    readonly MENUEDIT: "menuedit";
+};
+declare const APP_ID_TO_TRANSLATION_KEY: Record<string, string>;
+type AppId = (typeof APP_IDS)[keyof typeof APP_IDS];
+declare const DESKTOP_APPS: AppId[];
+
+declare const EXTRA_APPS: AppEntry[];
+declare const EXTRA_APP_IDS: string[];
+
+declare const PRESET_COLORS: string[];
+
+declare const DEFAULT_THEME_COLORS: Record<ThemeMode, Theme>;
+
+declare const PRESET_ICONS: string[];
+
+declare const CUSTOM_APPS_FOLDER_ID = "launcher-folder-custom-apps";
+declare const PREDEFINED_LAUNCHER_FOLDERS: LauncherFolder[];
+declare const DEFAULT_LAUNCHER_FOLDERS: LauncherFolder[];
+
+declare const APPS: AppEntry[];
+declare const DESKTOP_APPS_ORDER: string[];
+declare function registerCustomApps(apps: AppEntry[]): void;
+declare function registerDesktopApps(appIds: string[]): void;
+
+declare const GITHUB_RELEASES_REPO = "frannunpal/frannunpal.github.io";
+declare const GITHUB_LATEST_RELEASE_URL = "https://api.github.com/repos/frannunpal/frannunpal.github.io/releases/latest";
+
+declare const PROFILE: {
+    name: string;
+    title: string;
+    email: string;
+    phone: string;
+    location: string;
+    linkedin: string;
+    github: string;
+    cvUrls: {
+        en: string;
+        es: string;
+    };
+};
+
+declare global {
+    interface Window {
+        __FDE_IN_DOCKER__?: boolean;
+    }
+}
+declare const APP_VERSION: string;
+
+declare const getVersionString: () => string;
+declare const getEnvironment: () => string;
+declare const getReleaseType: () => string;
+
+declare class WindowManagerAdapter implements IWindowManager {
+    private windows;
+    private nextZIndex;
+    private assignZIndex;
+    reset(): void;
+    loadWindows(windows: WindowEntity[]): void;
+    getAll(): WindowEntity[];
+    getById(id: string): WindowEntity | undefined;
+    open(input: WindowInput): WindowEntity;
+    close(id: string): void;
+    minimize(id: string): void;
+    maximize(id: string): void;
+    restore(id: string): void;
+    focus(id: string): void;
+    move(id: string, x: number, y: number): void;
+    resize(id: string, width: number, height: number): void;
+    private updateWindow;
+}
+
+declare class DefaultThemeProvider implements IThemeProvider {
+    private mode;
+    private customColors;
+    constructor(initialMode?: ThemeMode);
+    getTheme(): FdeTheme;
+    setMode(mode: ThemeMode): void;
+    setCustomColors(colors: CustomThemeColors | null): void;
+    toggle(): void;
+}
+
+declare const toMantineTheme: (theme: Theme) => MantineThemeOverride;
+
+declare function initializeFdeApi(): void;
+declare function getFdeApi(): FdeDesktopAPI;
+declare function isFdeApiInitialized(): boolean;
+
+type AppLoader = () => Promise<unknown>;
+declare function prefetchApps(apps: Array<{
+    id: string;
+    loader: AppLoader;
+}>): void;
+
+/**
+ * Storage Migration Utility
+ *
+ * Migrates legacy storage keys from 'fran-desktop' prefix to 'fde-desktop' prefix.
+ * This migration is idempotent and safe to run multiple times.
+ *
+ * Migration includes:
+ * - IndexedDB databases: fran-desktop-fs → fde-desktop-fs, fran-desktop-blobs → fde-desktop-blobs
+ * - localStorage keys: fran-desktop:* → fde-desktop:*
+ * - Zustand persist key: fran-desktop → fde-desktop
+ */
+interface MigrationResult {
+    indexedDB: {
+        fs: boolean;
+        blobs: boolean;
+    };
+    localStorage: {
+        keysMigrated: number;
+    };
+    version: number;
+}
+/**
+ * Runs the complete storage migration
+ *
+ * @returns MigrationResult with details about what was migrated
+ */
+declare function migrateStorage(): Promise<MigrationResult>;
+
+declare const SUPPORTED_LANGUAGES: readonly ["en", "es"];
+type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+declare const DEFAULT_LANGUAGE: SupportedLanguage;
+
+export { ANIMATION_DURATION, APPS, APP_IDS, APP_ID_TO_TRANSLATION_KEY, APP_VERSION, AVAILABLE_FONTS, type AdaptiveDimensions, type AppComponent, AppEmptyState, type AppEntry, type AppFileHandler, AppIcon, type AppId, AppLoading, type AppLoadingProps, AppMenuBar, type AppMenuElement, type AppReadyContextValue, AppReadyProvider, type AppRegistration, type AppRegistryEntry, type AppsManifest, BREAKPOINTS, type Breadcrumb, type Breakpoint, CORE_APPS, CORE_APP_IDS, CORE_REGISTRY, CUSTOM_APPS_FOLDER_ID, CalendarApp, CalendarAppLazy, type ClearBrowserDataOptions, type ClipboardAction, type ClipboardState, CollapsibleSection, ColorPicker, ContextMenu, ContextMenuAnchor, type CreateFolderOptions, CreateItemApp, CreateItemAppLazy, CreateItemContextMenu, CustomAppLoader, CustomAppLoadingScreen, type CustomAppManifest, CustomAppNotSupported, CustomAppOffline, type CustomAppState, type CustomThemeColors, DEFAULT_FDE_THEME, DEFAULT_LANGUAGE, DEFAULT_LAUNCHER_FOLDERS, DEFAULT_THEME_COLORS, DEFAULT_VIEWPORT_HEIGHT, DEFAULT_VIEWPORT_WIDTH, DEFAULT_WINDOW_DIMENSIONS, DESKTOP_APPS, DESKTOP_APPS_ORDER, DefaultThemeProvider, Desktop, type DesktopAreaProps, type DesktopContextMenuProps, DesktopIcon, type DesktopIconEntity, type DesktopIconInput, type DesktopIconProps, type DesktopProps, type DesktopSortMode$1 as DesktopSortMode, type DesktopState, type DesktopTheme, type DeviceInfo, DeviceInfoApp, DeviceInfoAppLazy, DirtyIndicator, DockerFileSystemAdapter, DownloadProgress, type DownloadState, type DownloadStatus, DragDropProvider, type DropTargetType, DynamicMenuBarRenderer, EASE_IN, EASE_OUT, EXTRA_APPS, EXTRA_APP_IDS, ExternalLinkApp, FONT_STACKS, type FSNode, type FdeContextValue, FdeDesktop, type FdeDesktopAPI, type FdeDesktopProps, type FdeEventPayloads, type FdeEventType, FdeProvider, type FdeProviderProps, type FdeTheme, type FileDialogOptions, FileIcon, type FileIconProps, type FileNode, FilePickerApp, FilePickerModal, type FileSystemNode, type FileSystemNodeType, FilesApp, FilesAppLazy, type FolderNode, PickerModal as FolderPicker, type FontDownloadProgress, type FsManifest, type FsManifestFile, GITHUB_LATEST_RELEASE_URL, GITHUB_RELEASES_REPO, GOOGLE_FONTS_HREF, ICON_COLUMN_WIDTH, ICON_MARGIN, ICON_ROW_HEIGHT, type IFileSystem, IMAGE_MIME_TYPES, type ISettingsState, type IThemeProvider, type IWindowManager, IconColorPicker, ImageViewerApp, ImageViewerAppLazy, ImageViewerMenuBar, ImageViewerMenuBarLazy, IndexedDBFileSystem, LanguageFlag, LanguageSelector, Launcher, type LauncherFolder, type LauncherFolderInput, type LauncherProps, type LoadingProgress, type LoadingState, type MenuBarBuilder, type MenuBarComponent, type MenuBarComponentProps, MenuEditApp, MenuEditAppLazy, MenuEditMenuBar, MenuEditMenuBarLazy, type MenuItem, type MenuPosition, type MountedAppState, NotesApp, NotesAppLazy, NotesMenuBar, NotesMenuBarLazy, type NotificationItem, type NotificationOptions, type OpenAppOptions, PREDEFINED_LAUNCHER_FOLDERS, PRESET_COLORS, PRESET_ICONS, PROFILE, type PartialFdeTheme, PdfApp, PdfAppLazy, PdfMenuBar, PdfMenuBarLazy, SETTINGS_SECTIONS, SUPPORTED_LANGUAGES, type SaveDialogOptions, SettingsApp, SettingsAppLazy, SettingsMenuBar, SettingsMenuBarLazy, type SettingsSection$1 as SettingsSection, SettingsSection as SettingsSectionComponent, type SortOption, SortOptions, StorybookApp, type SupportedLanguage$2 as SupportedLanguage, TASKBAR_HEIGHT, TEXT_MIME_TYPES, Taskbar, TaskbarContextMenu, type TaskbarContextMenuProps, type TaskbarMenuType, type TaskbarTheme, type Theme, type ThemeMode, ThemeProvider, type ThemeProviderProps, UploaderApp, UploaderAppLazy, type UseCloseInterceptorOptions, type UseDownloadReturn, type UseIsDirtyOptions, VscIcon, Window, WindowButtonRegistryProvider, type WindowContentProps, type WindowEntity, type WindowInput, type WindowLoading, WindowManagerAdapter, type WindowProps, type WindowState, type WindowTheme, appendDirtyIndicator, buildBreadcrumbs, centerWindowPosition, checkHMREndpointExists, clearBrowserData, clearManifestCache, convertToAppEntry, createDesktopIcon, createEaseIn, createEaseOut, createFile, createFolder, createLauncherFolder, createMaximizeTransition, createMinimizeVariant, createPanelVariants, createPredefinedLauncherFolder, createRestoreVariant, createWindow, createWindowVariants, fetchAppManifest, fileSystem, formatBytes, generateUUID, getAppComponent, getAppIdForMime, getAppName, getBaseUrl, getCachedManifest, getCloseInterceptor, getCustomAppById, getCustomApps, getEnvironment, getFdeApi, getFileExtension, getFourRandomColors, getMenuBarBuilder, getMenuBarComponent, getMimeTypeFromExtension, getPersistedThemeMode, getReleaseType, getRuntime, getVersionString, hashBlob, initRegistry, initializeFdeApi, injectFontLink, isBrowser, isCustomApp, isDev, isDocker, isElectron, isFdeApiInitialized, isLazyApp, isNewerVersion, maximizeTransition, mergeAppsWithCustomApps, migrateStorage, minimizeVariant, openVariants, panelVariants, prefetchApps, randomWindowPosition, registerAppFileHandler, registerCloseInterceptor, registerComponents, registerCustomApps, registerDesktopApps, removeFromManifestCache, resetBaseUrlCache, resetFileSystem, resetHMRState, resetWindowManager, resolveFileUrl, resolveUrl, restoreVariant, setApiBaseUrl, setTestBaseUrl, sortDesktopIcons, sortDesktopIconsByMode, sortNodes, sortNodesByMode, syncWithServer, toMantineTheme, unregisterCloseInterceptor, updateLauncherFolder, updateManifestCache, useAdaptiveDimensions, useAnimationDuration, useAppName, useAppReady, useAppTempMemoryStore, useAppUpdate, useApplyFont, useClock, useCloseInterceptor, useCloseModalStore, useCollapsible, useContextMenu, useCustomAppHMR, useCustomAppLifecycle, useCustomAppStore, useDesktopStore, useDeviceDetection, useDownload, useDragDropState, useDraggableItem, useDroppableArea, useDynamicIcon, useDynamicIconElement, useFcIcon, useFcIconElement, useFdeApi, useFdeContext, useFiIcon, useFiIconElement, useFolderName, useFontDownload, useIsDirty, useLanguageSync, useNotifications, useOpenApp, useResolvedUrl, useSearchFilter, useSettingsStore, useSystemTheme, useTaskbarContextMenu, useTaskbarHeight, useTheme, useThemeContext, useVscIcon, useVscIconElement, useWindowButtonRegistry, waitForContainer, windowVariants };