@fde-desktop/fde-core 0.3.7 → 0.3.8

package/dist/index.d.cts

@@ -0,0 +1,1457 @@
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import * as framer_motion from 'framer-motion';
+import { Transition, TargetAndTransition, Variants } from 'framer-motion';
+import * as react from 'react';
+import { MouseEvent, RefObject, ReactNode, FC } from 'react';
+import { IconType } from 'react-icons';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { MantineThemeOverride } from '@mantine/core';
+export { default as i18n } from 'i18next';
+export { v4 as uuidv4 } from 'uuid';
+
+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;
+    multipleWindow?: boolean;
+}
+
+declare const DEFAULT_WINDOW_DIMENSIONS: {
+    readonly defaultWidth: 800;
+    readonly defaultHeight: 600;
+    readonly minWidth: 640;
+    readonly minHeight: 480;
+};
+declare const FilesApp: AppEntry;
+declare const SettingsApp: AppEntry;
+declare const NotepadApp: AppEntry;
+declare const ImageViewerApp: AppEntry;
+declare const PdfApp: AppEntry;
+declare const UploaderApp: AppEntry;
+declare const MenuEditApp: AppEntry;
+declare const DeviceInfoApp: AppEntry;
+declare const CalendarApp: AppEntry;
+declare const CORE_APPS: AppEntry[];
+declare const CORE_APP_IDS: string[];
+
+interface CreateFolderOptions {
+    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 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 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>;
+}
+
+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>;
+    /** Accepts the full URL returned by saveBlob (e.g. `idb://{hash}`) */
+    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>;
+    /**
+     * Builds a folderPath → FolderNode map from a manifest, creating all intermediate
+     * subfolders (e.g. "Documents/docker") as children of their parent folders.
+     * @param mergeMode - when true, reuse existing nodes from this.nodes instead of creating new ones
+     */
+    private buildFolderMapFromManifest;
+    private addChildToFolder;
+    private removeChildFromParent;
+    private deleteRecursive;
+}
+
+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;
+}
+
+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;
+}
+
+type WindowState = 'normal' | 'minimized' | 'maximized';
+type WindowInput = Omit<WindowEntity, 'id' | 'isOpen' | 'state' | 'zIndex'>;
+
+interface DesktopIconEntity {
+    id: string;
+    name: string;
+    icon: string;
+    iconName?: string;
+    iconColor?: string;
+    x: number;
+    y: number;
+    appId: string;
+    nodeId?: string;
+}
+
+type DesktopIconInput = Omit<DesktopIconEntity, 'id'>;
+
+/**
+ * Sorts an array of filesystem nodes: folders first, then files, each group
+ * sorted alphabetically by name (locale-aware, case-insensitive).
+ */
+declare const sortNodes: (nodes: FSNode[]) => FSNode[];
+type DesktopSortMode = 'default' | 'name-asc' | 'name-desc' | 'type';
+/**
+ * Sorts desktop icons by DESKTOP_APPS_ORDER (apps first, then folders, then files).
+ */
+declare const sortDesktopIcons: (icons: DesktopIconEntity[]) => DesktopIconEntity[];
+/**
+ * Sorts desktop icons by the specified mode.
+ */
+declare const sortDesktopIconsByMode: (icons: DesktopIconEntity[], mode: DesktopSortMode) => 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 updateLauncherFolder: (folder: LauncherFolder, updates: Partial<Omit<LauncherFolder, "id" | "isPredefined">>) => LauncherFolder;
+
+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;
+    };
+}
+
+type ClipboardAction = 'copy' | 'cut' | null;
+interface ClipboardState {
+    content: FSNode[];
+    action: ClipboardAction;
+}
+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;
+    filesSortMode: DesktopSortMode;
+    setDesktopSortMode: (mode: DesktopSortMode) => void;
+    setFilesSortMode: (mode: DesktopSortMode) => 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 NotificationItem {
+    id: string;
+    title: string;
+    message: string;
+    onClose?: () => void;
+    fcIcon?: string;
+}
+
+declare const fileSystem: IndexedDBFileSystem | DockerFileSystemAdapter;
+/** Sync reset for tests — clears in-memory state immediately, async DB flush follows. */
+declare const resetFileSystem: () => void;
+declare const resetWindowManager: () => void;
+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>>;
+    };
+}>;
+
+type ThemeMode = 'light' | 'dark';
+interface Theme {
+    mode: ThemeMode;
+    desktop: string;
+    taskbar: string;
+    window: string;
+    accent: string;
+}
+
+declare const SUPPORTED_LANGUAGES: readonly ["en", "es"];
+type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+
+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: Theme;
+    themeSetManually: boolean;
+    customThemeColors: CustomThemeColors | null;
+    language: SupportedLanguage;
+    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) => void;
+}
+
+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>>;
+    };
+}>;
+
+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;
+}
+
+declare const useCustomAppStore: zustand.UseBoundStore<zustand.StoreApi<CustomAppState>>;
+
+/**
+ * Store for temporary snapshots used by the `useIsDirty` hook.
+ * Each app (identified by a unique string id) can store its own snapshot.
+ * Snapshots are persisted to `localStorage` so they survive page reloads.
+ */
+interface AppTempMemoryState {
+    /** Mapping of appId → snapshot (any serializable value) */
+    snapshots: Record<string, unknown>;
+    /** Set a snapshot for a given appId */
+    setSnapshot: (appId: string, snapshot: unknown) => void;
+    /** Retrieve a snapshot for a given appId */
+    getSnapshot: (appId: string) => unknown | null;
+    /** Clear the snapshot for a given appId */
+    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>>;
+    };
+}>;
+
+type OpenAppOptions$1 = {
+    /** Extra data passed to the window's content component. */
+    contentData?: Record<string, unknown>;
+    /** Override position (e.g. for the initial seed window). */
+    position?: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Returns a stable `openApp(appId, options?)` callback that looks up app
+ * metadata from static or custom apps, picks a random desktop position
+ * (unless overridden) and calls `openWindow` on the desktop store.
+ *
+ * If `multipleWindow: true` on the app, always opens a new window.
+ * Otherwise, focuses existing window if one is already open.
+ */
+declare const useOpenApp: () => (appId: string, { contentData, position }?: OpenAppOptions$1) => void;
+
+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 function useFdeApi(): FdeDesktopAPI | null;
+
+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;
+
+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;
+};
+
+declare function useAppName(appId: string | undefined): string;
+
+declare const useClock: () => string;
+
+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;
+};
+
+interface MenuPosition {
+    x: number;
+    y: number;
+}
+
+interface UseContextMenuReturn {
+    opened: boolean;
+    position: MenuPosition;
+    open: (e: MouseEvent, offsetY?: number) => void;
+    close: () => void;
+}
+declare const useContextMenu: (offsetY?: number, appId?: string) => UseContextMenuReturn;
+
+interface DeviceInfo {
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isPortrait: boolean;
+    shouldShowWarning: boolean;
+    screenWidth: number;
+    screenHeight: number;
+}
+declare function useDeviceDetection(): DeviceInfo;
+
+type DownloadStatus = 'idle' | 'downloading' | 'done' | 'error';
+interface DownloadState {
+    status: DownloadStatus;
+    /** Bytes received so far */
+    loaded: number;
+    /** Total bytes, or null if Content-Length is not available */
+    total: number | null;
+    /** 0–100, or null when total is unknown */
+    percent: number | null;
+    error: string | null;
+}
+interface UseDownloadReturn extends DownloadState {
+    download: (url: string) => Promise<string | null>;
+    reset: () => void;
+}
+/**
+ * Hook for tracking streamed HTTP downloads with real-time progress.
+ * Returns a `download(url)` function that resolves with the response text
+ * (or null on error) and updates progress state as data arrives.
+ */
+declare const useDownload: () => UseDownloadReturn;
+
+type IconLibrary = 'fi' | 'fc' | 'vsc';
+declare const useDynamicIcon: (name: string, library: IconLibrary) => IconType | null;
+declare const useFiIcon: (name: string) => IconType | null;
+declare const useFcIcon: (name: string) => IconType | null;
+declare const useVscIcon: (name: string) => IconType | null;
+
+declare function useFolderName(folder: {
+    id: string;
+    name: string;
+    isPredefined: boolean;
+}): string;
+
+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;
+};
+
+interface UseJsDosOptions {
+    autoLoad?: {
+        url: string;
+        name?: string;
+    };
+}
+interface UseJsDosReturn {
+    containerRef: RefObject<HTMLDivElement | null>;
+    isRunning: boolean;
+    isPaused: boolean;
+    isMuted: boolean;
+    volume: number;
+    isLoading: boolean;
+    error: string | null;
+    bundleName: string | null;
+    loadBundle: (url: string, name?: string) => Promise<void>;
+    exit: () => Promise<void>;
+    restart: () => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    mute: () => void;
+    unmute: () => void;
+    setVolume: (level: number) => void;
+}
+declare function useJsDos(options?: UseJsDosOptions): UseJsDosReturn;
+
+declare function useLanguageSync(): void;
+
+declare function useResolvedUrl(url: string | undefined): string | undefined;
+
+declare function useSearchFilter<T>(items: T[], searchQuery: string, getSearchableText: (item: T) => string | string[]): T[];
+
+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;
+
+interface RegistryContextValue {
+    register: (id: string, rect: DOMRect) => void;
+    unregister: (id: string) => void;
+    getRect: (id: string) => DOMRect | undefined;
+}
+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;
+
+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 AdaptiveDimensions {
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    minHeight: number;
+}
+declare function useAdaptiveDimensions(): AdaptiveDimensions;
+
+type AppReloadCallback = (appId: string) => void;
+type AppRegisteredCallback = (manifest: CustomAppManifest) => void;
+type AppUnregisteredCallback = (appId: string) => void;
+interface HMRCallbacks {
+    onReload: AppReloadCallback;
+    onRegistered?: AppRegisteredCallback;
+    onUnregistered?: AppUnregisteredCallback;
+}
+declare function useCustomAppHMR(callbacksArg: HMRCallbacks): void;
+
+type LoadingState = 'idle' | 'fetching' | 'compiling' | 'loading' | 'ready' | 'error';
+
+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 = 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;
+    buildMenuBar?: MenuBarBuilder;
+    MenuBarComponent?: MenuBarComponent;
+}
+
+type Runtime = 'browser' | 'docker' | 'electron';
+/**
+ * Detects the current runtime environment.
+ * - browser: Standard web browser
+ * - docker: Running inside Docker container (detected via injected flag)
+ * - electron: Electron desktop app
+ */
+declare function getRuntime(): Runtime;
+declare function isDocker(): boolean;
+declare function isElectron(): boolean;
+declare function isBrowser(): boolean;
+/**
+ * Detects if running in development mode.
+ * - Checks window.__IS_DEV__ flag (injected by Docker entrypoint)
+ * - Falls back to hostname detection for local development
+ */
+declare function isDev(): boolean;
+
+declare function generateUUID(): string;
+
+/**
+ * Waits for a DOM element with the given ID to appear in the document.
+ * Uses polling with 1 second intervals.
+ *
+ * @param containerId - The ID of the container element to wait for (without #)
+ * @param timeout - Maximum time to wait in milliseconds (default: 5000)
+ * @returns Promise that resolves with the container element
+ * @throws Error if container is not found within timeout
+ */
+declare function waitForContainer(containerId: string, timeout?: number): Promise<HTMLElement>;
+
+declare function getBaseUrl(): string;
+declare function resolveUrl(relativeUrl: string): string;
+
+declare function formatBytes(bytes: number): string;
+
+declare function hashBlob(blob: Blob): Promise<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;
+};
+/**
+ * Builds a breadcrumb trail from the root to the given folder.
+ * Always starts with `{ id: null, name: 'Home' }`.
+ */
+declare const buildBreadcrumbs: (currentFolderId: string | null, fsNodes: FSNode[]) => Breadcrumb[];
+
+declare const isNewerVersion: (latest: string, current: string) => boolean;
+
+/**
+ * Clears all browser data: Service Workers, Cache API, IndexedDB, localStorage, sessionStorage.
+ * Useful for tests and for the reset settings feature.
+ */
+interface ClearBrowserDataOptions {
+    /** If true, keep IndexedDB databases (user files) */
+    keepIndexedDB?: boolean;
+    /** If true, keep Service Workers registered */
+    keepServiceWorker?: boolean;
+    /** If true, keep localStorage */
+    keepLocalStorage?: boolean;
+    /** If true, keep sessionStorage */
+    keepSessionStorage?: boolean;
+}
+/**
+ * Clears all browser data with configurable options.
+ *
+ * @param options - Configuration options for what to keep
+ *
+ * @example
+ * // Clear everything (full reset)
+ * await clearBrowserData();
+ *
+ * @example
+ * // Keep user files (IndexedDB)
+ * await clearBrowserData({ keepIndexedDB: true });
+ *
+ * @example
+ * // Keep everything except cache
+ * await clearBrowserData({ keepIndexedDB: true, keepServiceWorker: true, keepLocalStorage: true });
+ */
+declare function clearBrowserData(options?: ClearBrowserDataOptions): Promise<void>;
+
+declare const WelcomeApp: AppEntry;
+declare const StorybookApp: AppEntry;
+declare const LinkedinApp: AppEntry;
+declare const GithubApp: AppEntry;
+declare const TerminalApp: AppEntry;
+declare const CodeServerApp: AppEntry;
+declare const DosEmulatorApp: AppEntry;
+declare const DoomApp: AppEntry;
+declare const EXTRA_APPS: AppEntry[];
+declare const EXTRA_APP_IDS: string[];
+
+declare const APPS: AppEntry[];
+declare const DESKTOP_APPS_ORDER: string[];
+declare function registerCustomApps(apps: AppEntry[]): void;
+declare function registerDesktopApps(appIds: string[]): void;
+
+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 CUSTOM_APPS_FOLDER_ID = "launcher-folder-custom-apps";
+declare const DEFAULT_LAUNCHER_FOLDERS: LauncherFolder[];
+
+declare const BREAKPOINTS: {
+    readonly MOBILE: 768;
+    readonly TABLET: 1024;
+    readonly DESKTOP: 1280;
+};
+
+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 DEFAULT_THEME_COLORS: Record<ThemeMode, Theme>;
+
+declare const PRESET_COLORS: string[];
+
+declare const PRESET_ICONS: 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 createWindow: (input: WindowInput) => WindowEntity;
+
+declare const createDesktopIcon: (input: DesktopIconInput) => DesktopIconEntity;
+
+declare function initializeFdeApi(): void;
+declare function isFdeApiInitialized(): boolean;
+
+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;
+}
+
+declare class WindowManagerAdapter implements IWindowManager {
+    private windows;
+    private nextZIndex;
+    private assignZIndex;
+    reset(): void;
+    /**
+     * Restores persisted windows into the adapter and synchronizes the
+     * nextZIndex counter so that subsequent focus/open calls always produce
+     * a value strictly higher than any already-persisted zIndex.
+     */
+    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 const toMantineTheme: (theme: Theme) => MantineThemeOverride;
+
+type AppLoader = () => Promise<unknown>;
+declare function prefetchApps(apps: Array<{
+    id: string;
+    loader: AppLoader;
+}>): void;
+
+export { ANIMATION_DURATION, APPS, APP_IDS, AVAILABLE_FONTS, type AppComponent, type AppEntry, type AppMenuElement, type AppRegistration, BREAKPOINTS, CORE_APPS, CORE_APP_IDS, CUSTOM_APPS_FOLDER_ID, CalendarApp, type ClipboardAction, type ClipboardState, CodeServerApp, type CreateFolderOptions, type CustomAppState, type CustomThemeColors, DEFAULT_LAUNCHER_FOLDERS, DEFAULT_THEME_COLORS, DEFAULT_VIEWPORT_HEIGHT, DEFAULT_VIEWPORT_WIDTH, DEFAULT_WINDOW_DIMENSIONS, DESKTOP_APPS_ORDER, type DesktopIconInput, type DesktopState, DeviceInfoApp, DockerFileSystemAdapter, DoomApp, DosEmulatorApp, EASE_IN, EASE_OUT, EXTRA_APPS, EXTRA_APP_IDS, FONT_STACKS, type FSNode, type FileNode, FilesApp, type FolderNode, type FsManifest, type FsManifestFile, GOOGLE_FONTS_HREF, GithubApp, ICON_COLUMN_WIDTH, ICON_MARGIN, ICON_ROW_HEIGHT, type IFileSystem, type ISettingsState, ImageViewerApp, IndexedDBFileSystem, LinkedinApp, type LoadingState, type MenuBarBuilder, type MenuBarComponent, type MenuBarComponentProps, MenuEditApp, type MenuPosition, type MountedAppState, NotepadApp, type NotificationItem, PRESET_COLORS, PRESET_ICONS, PdfApp, SettingsApp, StorybookApp, TASKBAR_HEIGHT, TerminalApp, UploaderApp, WelcomeApp, type WindowContentProps, type WindowEntity, type WindowInput, WindowManagerAdapter, type WindowState, buildBreadcrumbs, centerWindowPosition, clearBrowserData, createDesktopIcon, createEaseIn, createEaseOut, createLauncherFolder, createMaximizeTransition, createMinimizeVariant, createPanelVariants, createRestoreVariant, createWindow, createWindowVariants, fileSystem, formatBytes, generateUUID, getAppIdForMime, getBaseUrl, getFileExtension, getFourRandomColors, getMimeTypeFromExtension, getRuntime, hashBlob, initializeFdeApi, isBrowser, isDev, isDocker, isElectron, isFdeApiInitialized, isNewerVersion, maximizeTransition, minimizeVariant, openVariants, panelVariants, prefetchApps, randomWindowPosition, registerCustomApps, registerDesktopApps, resetFileSystem, resetWindowManager, resolveUrl, restoreVariant, sortDesktopIcons, sortDesktopIconsByMode, sortNodes, toMantineTheme, updateLauncherFolder, useAdaptiveDimensions, useAnimationDuration, useAppName, useAppTempMemoryStore, useApplyFont, useClock, useCollapsible, useContextMenu, useCustomAppHMR, useCustomAppStore, useDesktopStore, useDeviceDetection, useDownload, useDynamicIcon, useFcIcon, useFdeApi, useFiIcon, useFolderName, useFontDownload, useIsDirty, useJsDos, useLanguageSync, useNotifications, useOpenApp, useResolvedUrl, useSearchFilter, useSettingsStore, useSystemTheme, useTaskbarContextMenu, useTaskbarHeight, useVscIcon, useWindowButtonRegistry, waitForContainer, windowVariants };