@haex-space/vault-sdk 2.5.42 → 2.5.45

package/dist/{client-CF0wJxT2.d.ts → client-Bgu2k1yJ.d.ts}

@@ -41,412 +41,6 @@ declare class DatabaseAPI {
     count(tableName: string, where?: string, whereParams?: unknown[]): Promise<number>;
 }
 
-/** File sync state constants */
-declare const FILE_SYNC_STATE: {
-    readonly SYNCED: "synced";
-    readonly SYNCING: "syncing";
-    readonly LOCAL_ONLY: "localOnly";
-    readonly REMOTE_ONLY: "remoteOnly";
-    readonly CONFLICT: "conflict";
-    readonly ERROR: "error";
-};
-/** Sync direction constants */
-declare const SYNC_DIRECTION: {
-    readonly UP: "up";
-    readonly DOWN: "down";
-    readonly BOTH: "both";
-};
-/** Storage backend type constants */
-declare const STORAGE_BACKEND_TYPE: {
-    readonly S3: "s3";
-    readonly R2: "r2";
-    readonly MINIO: "minio";
-    readonly GDRIVE: "gdrive";
-    readonly DROPBOX: "dropbox";
-};
-interface FileSpace {
-    id: string;
-    name: string;
-    isPersonal: boolean;
-    fileCount: number;
-    totalSize: number;
-    createdAt: string;
-    updatedAt: string;
-}
-interface FileInfo {
-    id: string;
-    spaceId: string;
-    name: string;
-    path: string;
-    mimeType: string | null;
-    size: number;
-    contentHash: string;
-    isDirectory: boolean;
-    syncState: FileSyncState;
-    backends: string[];
-    createdAt: string;
-    updatedAt: string;
-}
-/** Local file info (unencrypted, scanned from local filesystem) */
-interface LocalFileInfo {
-    /** Unique ID (hash of rule_id + relative path) */
-    id: string;
-    /** File name */
-    name: string;
-    /** Full local path */
-    path: string;
-    /** Relative path from sync root */
-    relativePath: string;
-    /** MIME type (null for directories) */
-    mimeType: string | null;
-    /** File size in bytes */
-    size: number;
-    /** Whether this is a directory */
-    isDirectory: boolean;
-    /** Last modified timestamp (ISO 8601) */
-    modifiedAt: string | null;
-}
-type FileSyncState = "synced" | "syncing" | "localOnly" | "remoteOnly" | "conflict" | "error";
-interface StorageBackendInfo$1 {
-    id: string;
-    type: StorageBackendType;
-    name: string;
-    enabled: boolean;
-    createdAt: string;
-}
-type StorageBackendType = "s3" | "r2" | "minio" | "gdrive" | "dropbox";
-interface S3BackendConfig {
-    type: "s3" | "r2" | "minio";
-    endpoint?: string;
-    region: string;
-    bucket: string;
-    accessKeyId: string;
-    secretAccessKey: string;
-}
-/** Backend configuration for S3-compatible storage */
-type BackendConfig = S3BackendConfig;
-interface SyncRule {
-    id: string;
-    /** Device ID this sync rule belongs to (local paths are device-specific) */
-    deviceId: string;
-    spaceId: string;
-    localPath: string;
-    backendIds: string[];
-    direction: SyncDirection;
-    enabled: boolean;
-    /** Gitignore-like patterns for files/folders to exclude from sync */
-    ignorePatterns: string[];
-    /** Default conflict resolution strategy for this sync rule */
-    conflictStrategy: ConflictStrategy;
-    createdAt: string;
-    updatedAt: string;
-}
-type SyncDirection = "up" | "down" | "both";
-/** Conflict resolution strategy for sync rules */
-type ConflictStrategy = "local" | "remote" | "newer" | "ask" | "keepBoth";
-/** Conflict strategy constants */
-declare const CONFLICT_STRATEGY: Record<string, ConflictStrategy>;
-interface SyncStatus {
-    isSyncing: boolean;
-    pendingUploads: number;
-    pendingDownloads: number;
-    lastSync: string | null;
-    errors: SyncError[];
-}
-interface SyncError {
-    fileId: string;
-    fileName: string;
-    error: string;
-    timestamp: string;
-}
-interface SyncProgress {
-    fileId: string;
-    fileName: string;
-    bytesTransferred: number;
-    totalBytes: number;
-    direction: "upload" | "download";
-}
-interface CreateSpaceOptions {
-    name: string;
-}
-interface AddBackendOptions {
-    name: string;
-    config: BackendConfig;
-}
-interface AddSyncRuleOptions {
-    spaceId: string;
-    localPath: string;
-    backendIds: string[];
-    direction?: SyncDirection;
-    /** Gitignore-like patterns for files/folders to exclude from sync */
-    ignorePatterns?: string[];
-    /** Default conflict resolution strategy (defaults to 'ask') */
-    conflictStrategy?: ConflictStrategy;
-}
-interface UpdateSyncRuleOptions {
-    ruleId: string;
-    backendIds?: string[];
-    direction?: SyncDirection;
-    enabled?: boolean;
-    /** Gitignore-like patterns for files/folders to exclude from sync */
-    ignorePatterns?: string[];
-    /** Default conflict resolution strategy */
-    conflictStrategy?: ConflictStrategy;
-}
-interface ListFilesOptions {
-    spaceId: string;
-    path?: string;
-    recursive?: boolean;
-}
-interface ScanLocalOptions {
-    /** Sync rule ID to scan */
-    ruleId: string;
-    /** Optional subpath within the sync root to scan */
-    subpath?: string;
-}
-interface UploadFileOptions {
-    spaceId: string;
-    localPath: string;
-    remotePath?: string;
-    backendIds?: string[];
-}
-interface DownloadFileOptions {
-    fileId: string;
-    localPath: string;
-}
-/** Queue operation type */
-type QueueOperation = 'upload' | 'download';
-/** Queue entry status */
-type QueueStatus = 'pending' | 'inProgress' | 'completed' | 'failed';
-/** Queue operation constants */
-declare const QUEUE_OPERATION: {
-    UPLOAD: "upload";
-    DOWNLOAD: "download";
-};
-/** Queue status constants */
-declare const QUEUE_STATUS: {
-    PENDING: "pending";
-    IN_PROGRESS: "inProgress";
-    COMPLETED: "completed";
-    FAILED: "failed";
-};
-/** A sync queue entry representing a pending or in-progress file operation */
-interface SyncQueueEntry {
-    id: string;
-    /** Device ID this entry belongs to */
-    deviceId: string;
-    /** Sync rule ID */
-    ruleId: string;
-    /** Full local path */
-    localPath: string;
-    /** Relative path from sync root (used as remote path) */
-    relativePath: string;
-    /** Operation type (upload/download) */
-    operation: QueueOperation;
-    /** Current status */
-    status: QueueStatus;
-    /** Priority (lower = higher priority) */
-    priority: number;
-    /** File size in bytes */
-    fileSize: number;
-    /** Error message if failed */
-    errorMessage: string | null;
-    /** Number of retry attempts */
-    retryCount: number;
-    /** When the entry was created */
-    createdAt: string;
-    /** When processing started */
-    startedAt: string | null;
-    /** When processing completed */
-    completedAt: string | null;
-}
-/** Request to add files to the sync queue */
-interface AddToQueueOptions {
-    /** Sync rule ID */
-    ruleId: string;
-    /** Files to add */
-    files: QueueFileEntry[];
-    /** Operation type */
-    operation: QueueOperation;
-    /** Priority (optional, default 100) */
-    priority?: number;
-}
-/** A file entry for adding to the queue */
-interface QueueFileEntry {
-    /** Full local path */
-    localPath: string;
-    /** Relative path from sync root */
-    relativePath: string;
-    /** File size in bytes */
-    fileSize: number;
-}
-/** Request to get queue entries */
-interface GetQueueOptions {
-    /** Filter by rule ID (optional) */
-    ruleId?: string;
-    /** Filter by status (optional) */
-    status?: QueueStatus;
-    /** Include completed entries (default: false) */
-    includeCompleted?: boolean;
-}
-/** Aggregated queue status */
-interface QueueSummary {
-    /** Number of pending items */
-    pendingCount: number;
-    /** Number of in-progress items */
-    inProgressCount: number;
-    /** Number of completed items */
-    completedCount: number;
-    /** Number of failed items */
-    failedCount: number;
-    /** Total bytes pending (sum of file_size for pending items) */
-    pendingBytes: number;
-    /** Currently processing entry (if any) */
-    currentEntry: SyncQueueEntry | null;
-}
-/**
- * File Sync API for E2E encrypted file synchronization
- *
- * Access via: client.filesystem.sync.*
- */
-declare class FileSyncAPI {
-    private client;
-    constructor(client: HaexVaultSdk);
-    /**
-     * List all file spaces
-     */
-    listSpacesAsync(): Promise<FileSpace[]>;
-    /**
-     * Create a new file space
-     */
-    createSpaceAsync(options: CreateSpaceOptions): Promise<FileSpace>;
-    /**
-     * Delete a file space
-     */
-    deleteSpaceAsync(spaceId: string): Promise<void>;
-    /**
-     * List files in a space
-     */
-    listFilesAsync(options: ListFilesOptions): Promise<FileInfo[]>;
-    /**
-     * Scan local files in a sync rule folder
-     * Returns unencrypted local files for display in the UI
-     */
-    scanLocalAsync(options: ScanLocalOptions): Promise<LocalFileInfo[]>;
-    /**
-     * Get file info by ID
-     */
-    getFileAsync(fileId: string): Promise<FileInfo | null>;
-    /**
-     * Upload a file to the sync system
-     */
-    uploadFileAsync(options: UploadFileOptions): Promise<FileInfo>;
-    /**
-     * Download a file to local storage
-     */
-    downloadFileAsync(options: DownloadFileOptions): Promise<void>;
-    /**
-     * Delete a file from the sync system
-     */
-    deleteFileAsync(fileId: string): Promise<void>;
-    /**
-     * List configured storage backends
-     */
-    listBackendsAsync(): Promise<StorageBackendInfo$1[]>;
-    /**
-     * Add a new storage backend
-     */
-    addBackendAsync(options: AddBackendOptions): Promise<StorageBackendInfo$1>;
-    /**
-     * Remove a storage backend
-     */
-    removeBackendAsync(backendId: string): Promise<void>;
-    /**
-     * Test backend connection
-     */
-    testBackendAsync(backendId: string): Promise<boolean>;
-    /**
-     * List sync rules
-     */
-    listSyncRulesAsync(): Promise<SyncRule[]>;
-    /**
-     * Add a sync rule
-     */
-    addSyncRuleAsync(options: AddSyncRuleOptions): Promise<SyncRule>;
-    /**
-     * Update a sync rule
-     */
-    updateSyncRuleAsync(options: UpdateSyncRuleOptions): Promise<SyncRule>;
-    /**
-     * Remove a sync rule
-     */
-    removeSyncRuleAsync(ruleId: string): Promise<void>;
-    /**
-     * Get current sync status
-     */
-    getSyncStatusAsync(): Promise<SyncStatus>;
-    /**
-     * Trigger a manual sync
-     */
-    triggerSyncAsync(): Promise<void>;
-    /**
-     * Pause syncing
-     */
-    pauseSyncAsync(): Promise<void>;
-    /**
-     * Resume syncing
-     */
-    resumeSyncAsync(): Promise<void>;
-    /**
-     * Resolve a file conflict
-     */
-    resolveConflictAsync(fileId: string, resolution: "local" | "remote" | "keepBoth"): Promise<void>;
-    /**
-     * Open a folder selection dialog
-     */
-    selectFolderAsync(): Promise<string | null>;
-    /**
-     * Add files to the sync queue
-     */
-    addToQueueAsync(options: AddToQueueOptions): Promise<SyncQueueEntry[]>;
-    /**
-     * Get queue entries for the current device
-     */
-    getQueueAsync(options?: GetQueueOptions): Promise<SyncQueueEntry[]>;
-    /**
-     * Get aggregated queue summary for the current device
-     */
-    getQueueSummaryAsync(): Promise<QueueSummary>;
-    /**
-     * Mark a queue entry as started (in_progress)
-     */
-    startQueueEntryAsync(entryId: string): Promise<void>;
-    /**
-     * Mark a queue entry as completed
-     */
-    completeQueueEntryAsync(entryId: string): Promise<void>;
-    /**
-     * Mark a queue entry as failed
-     */
-    failQueueEntryAsync(entryId: string, errorMessage: string): Promise<void>;
-    /**
-     * Retry all failed queue entries (reset to pending)
-     */
-    retryFailedQueueAsync(): Promise<void>;
-    /**
-     * Remove a queue entry
-     */
-    removeQueueEntryAsync(entryId: string): Promise<void>;
-    /**
-     * Clear all queue entries for a sync rule
-     */
-    clearQueueAsync(ruleId: string): Promise<void>;
-    /**
-     * Reset in_progress entries to pending (for recovery after crash)
-     */
-    recoverQueueAsync(): Promise<void>;
-}
-
 interface SaveFileOptions {
     /**
      * The default filename to suggest
@@ -502,9 +96,66 @@ interface ShowImageResult {
      */
     success: boolean;
 }
+/**
+ * File/directory metadata
+ */
+interface FileStat {
+    /** File size in bytes */
+    size: number;
+    /** True if this is a file */
+    isFile: boolean;
+    /** True if this is a directory */
+    isDirectory: boolean;
+    /** True if this is a symbolic link */
+    isSymlink: boolean;
+    /** Last modified time (Unix timestamp in milliseconds) */
+    modified?: number;
+    /** Created time (Unix timestamp in milliseconds) */
+    created?: number;
+    /** Whether the file is read-only */
+    readonly: boolean;
+}
+/**
+ * Directory entry
+ */
+interface DirEntry {
+    /** Entry name (not full path) */
+    name: string;
+    /** Full path */
+    path: string;
+    /** True if this is a file */
+    isFile: boolean;
+    /** True if this is a directory */
+    isDirectory: boolean;
+    /** File size in bytes (0 for directories) */
+    size: number;
+    /** Last modified time (Unix timestamp in milliseconds) */
+    modified?: number;
+}
+/**
+ * Options for selecting a folder
+ */
+interface SelectFolderOptions {
+    /** Dialog title */
+    title?: string;
+    /** Default path to open */
+    defaultPath?: string;
+}
+/**
+ * Options for selecting files
+ */
+interface SelectFileOptions {
+    /** Dialog title */
+    title?: string;
+    /** Default path to open */
+    defaultPath?: string;
+    /** File filters (name -> extensions) */
+    filters?: Array<[string, string[]]>;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+}
 declare class FilesystemAPI {
     private client;
-    readonly sync: FileSyncAPI;
     constructor(client: HaexVaultSdk);
     /**
      * Opens a save file dialog and saves the provided data to the selected location
@@ -528,6 +179,71 @@ declare class FilesystemAPI {
      * @returns The result of the operation
      */
     showImageAsync(options: ShowImageOptions): Promise<ShowImageResult>;
+    /**
+     * Read file contents
+     * @param path Absolute path to the file
+     * @returns File contents as Uint8Array
+     */
+    readFile(path: string): Promise<Uint8Array>;
+    /**
+     * Write file contents
+     * @param path Absolute path to the file
+     * @param data File contents as Uint8Array
+     */
+    writeFile(path: string, data: Uint8Array): Promise<void>;
+    /**
+     * Read directory contents
+     * @param path Absolute path to the directory
+     * @returns Array of directory entries
+     */
+    readDir(path: string): Promise<DirEntry[]>;
+    /**
+     * Create a directory (and parent directories if needed)
+     * @param path Absolute path to create
+     */
+    mkdir(path: string): Promise<void>;
+    /**
+     * Remove a file or directory
+     * @param path Absolute path to remove
+     * @param recursive If true, remove directories recursively
+     */
+    remove(path: string, recursive?: boolean): Promise<void>;
+    /**
+     * Check if a path exists
+     * @param path Absolute path to check
+     * @returns True if the path exists
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Get file/directory metadata
+     * @param path Absolute path
+     * @returns File metadata
+     */
+    stat(path: string): Promise<FileStat>;
+    /**
+     * Open a folder selection dialog
+     * @param options Dialog options
+     * @returns Selected folder path, or null if cancelled
+     */
+    selectFolder(options?: SelectFolderOptions): Promise<string | null>;
+    /**
+     * Open a file selection dialog
+     * @param options Dialog options
+     * @returns Selected file paths, or null if cancelled
+     */
+    selectFile(options?: SelectFileOptions): Promise<string[] | null>;
+    /**
+     * Rename/move a file or directory
+     * @param from Source path
+     * @param to Destination path
+     */
+    rename(from: string, to: string): Promise<void>;
+    /**
+     * Copy a file
+     * @param from Source path
+     * @param to Destination path
+     */
+    copy(from: string, to: string): Promise<void>;
 }
 
 declare class WebAPI {
@@ -791,4 +507,4 @@ declare class HaexVaultSdk {
     private log;
 }
 
-export { type AddBackendRequest as A, type BackendConfig as B, type ConflictStrategy as C, DatabaseAPI as D, type QueueSummary as E, FilesystemAPI as F, type GetQueueOptions as G, HaexVaultSdk as H, FILE_SYNC_STATE as I, SYNC_DIRECTION as J, STORAGE_BACKEND_TYPE as K, type ListFilesOptions as L, CONFLICT_STRATEGY as M, QUEUE_OPERATION as N, QUEUE_STATUS as O, PermissionsAPI as P, type QueueOperation as Q, RemoteStorageAPI as R, StorageAPI as S, type UpdateSyncRuleOptions as U, WebAPI as W, FileSyncAPI as a, type StorageBackendInfo as b, type S3Config as c, type StorageObjectInfo as d, type FileSpace as e, type FileInfo as f, type FileSyncState as g, type StorageBackendInfo$1 as h, type StorageBackendType as i, type S3BackendConfig as j, type SyncRule as k, type SyncDirection as l, type SyncStatus as m, type SyncError as n, type SyncProgress as o, type CreateSpaceOptions as p, type AddBackendOptions as q, type AddSyncRuleOptions as r, type ScanLocalOptions as s, type UploadFileOptions as t, type DownloadFileOptions as u, type LocalFileInfo as v, type QueueStatus as w, type SyncQueueEntry as x, type AddToQueueOptions as y, type QueueFileEntry as z };
+export { type AddBackendRequest as A, DatabaseAPI as D, FilesystemAPI as F, HaexVaultSdk as H, PermissionsAPI as P, RemoteStorageAPI as R, StorageAPI as S, WebAPI as W, type FileStat as a, type DirEntry as b, type SelectFolderOptions as c, type SelectFileOptions as d, type StorageBackendInfo as e, type S3Config as f, type StorageObjectInfo as g };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { H as HaexVaultSdk } from './client-BAu3VPE3.mjs';
-export { q as AddBackendOptions, r as AddSyncRuleOptions, y as AddToQueueOptions, B as BackendConfig, M as CONFLICT_STRATEGY, C as ConflictStrategy, p as CreateSpaceOptions, D as DatabaseAPI, u as DownloadFileOptions, I as FILE_SYNC_STATE, f as FileInfo, e as FileSpace, a as FileSyncAPI, g as FileSyncState, F as FilesystemAPI, G as GetQueueOptions, L as ListFilesOptions, v as LocalFileInfo, P as PermissionsAPI, N as QUEUE_OPERATION, O as QUEUE_STATUS, z as QueueFileEntry, Q as QueueOperation, w as QueueStatus, E as QueueSummary, A as RemoteAddBackendRequest, c as RemoteS3Config, R as RemoteStorageAPI, b as RemoteStorageBackendInfo, d as RemoteStorageObjectInfo, j as S3BackendConfig, K as STORAGE_BACKEND_TYPE, J as SYNC_DIRECTION, s as ScanLocalOptions, h as StorageBackendInfo, i as StorageBackendType, l as SyncDirection, n as SyncError, o as SyncProgress, x as SyncQueueEntry, k as SyncRule, m as SyncStatus, U as UpdateSyncRuleOptions, t as UploadFileOptions, W as WebAPI } from './client-BAu3VPE3.mjs';
+import { H as HaexVaultSdk } from './client-BDxVgihp.mjs';
+export { D as DatabaseAPI, b as DirEntry, a as FileStat, F as FilesystemAPI, P as PermissionsAPI, A as RemoteAddBackendRequest, f as RemoteS3Config, R as RemoteStorageAPI, e as RemoteStorageBackendInfo, g as RemoteStorageObjectInfo, d as SelectFileOptions, c as SelectFolderOptions, W as WebAPI } from './client-BDxVgihp.mjs';
 import { E as ExtensionManifest, H as HaexHubConfig } from './types-DiXJ5SF6.mjs';
 export { A as ApplicationContext, t as AuthorizedClient, B as BlockedClient, C as ContextChangedEvent, F as DEFAULT_TIMEOUT, o as DatabaseColumnInfo, m as DatabaseExecuteParams, k as DatabasePermission, d as DatabasePermissionRequest, l as DatabaseQueryParams, D as DatabaseQueryResult, n as DatabaseTableInfo, U as EXTERNAL_EVENTS, z as ErrorCode, g as EventCallback, a as ExtensionInfo, v as ExternalAuthDecision, x as ExternalConnection, J as ExternalConnectionErrorCode, I as ExternalConnectionState, V as ExternalEvent, s as ExternalRequest, r as ExternalRequestEvent, e as ExternalRequestHandler, f as ExternalResponse, O as HAEXTENSION_EVENTS, j as HaexHubEvent, h as HaexHubRequest, i as HaexHubResponse, N as HaexVaultSdkError, Q as HaextensionEvent, u as PendingAuthorization, P as PermissionResponse, y as PermissionStatus, R as RequestedExtension, p as SearchQuery, q as SearchRequestEvent, S as SearchResult, w as SessionAuthorization, T as TABLE_SEPARATOR, W as WebRequestOptions, c as WebResponse, L as canExternalClientSendRequests, G as getTableName, K as isExternalClientConnected } from './types-DiXJ5SF6.mjs';
 export { H as HaextensionConfig } from './config-D_HXjsEV.mjs';
@@ -103,41 +103,17 @@ declare const HAEXTENSION_METHODS: {
         readonly saveFile: "haextension:filesystem:save-file";
         readonly openFile: "haextension:filesystem:open-file";
         readonly showImage: "haextension:filesystem:show-image";
-    };
-    readonly filesync: {
-        readonly listSpaces: "haextension:filesync:list-spaces";
-        readonly createSpace: "haextension:filesync:create-space";
-        readonly deleteSpace: "haextension:filesync:delete-space";
-        readonly listFiles: "haextension:filesync:list-files";
-        readonly getFile: "haextension:filesync:get-file";
-        readonly uploadFile: "haextension:filesync:upload-file";
-        readonly downloadFile: "haextension:filesync:download-file";
-        readonly deleteFile: "haextension:filesync:delete-file";
-        readonly listBackends: "haextension:filesync:list-backends";
-        readonly addBackend: "haextension:filesync:add-backend";
-        readonly removeBackend: "haextension:filesync:remove-backend";
-        readonly testBackend: "haextension:filesync:test-backend";
-        readonly listSyncRules: "haextension:filesync:list-sync-rules";
-        readonly addSyncRule: "haextension:filesync:add-sync-rule";
-        readonly updateSyncRule: "haextension:filesync:update-sync-rule";
-        readonly removeSyncRule: "haextension:filesync:remove-sync-rule";
-        readonly getSyncStatus: "haextension:filesync:get-sync-status";
-        readonly triggerSync: "haextension:filesync:trigger-sync";
-        readonly pauseSync: "haextension:filesync:pause-sync";
-        readonly resumeSync: "haextension:filesync:resume-sync";
-        readonly resolveConflict: "haextension:filesync:resolve-conflict";
-        readonly selectFolder: "haextension:filesync:select-folder";
-        readonly scanLocal: "haextension:filesync:scan-local";
-        readonly addToQueue: "haextension:filesync:add-to-queue";
-        readonly getQueue: "haextension:filesync:get-queue";
-        readonly getQueueSummary: "haextension:filesync:get-queue-summary";
-        readonly startQueueEntry: "haextension:filesync:start-queue-entry";
-        readonly completeQueueEntry: "haextension:filesync:complete-queue-entry";
-        readonly failQueueEntry: "haextension:filesync:fail-queue-entry";
-        readonly retryFailedQueue: "haextension:filesync:retry-failed-queue";
-        readonly removeQueueEntry: "haextension:filesync:remove-queue-entry";
-        readonly clearQueue: "haextension:filesync:clear-queue";
-        readonly recoverQueue: "haextension:filesync:recover-queue";
+        readonly readFile: "haextension:filesystem:read-file";
+        readonly writeFile: "haextension:filesystem:write-file";
+        readonly readDir: "haextension:filesystem:read-dir";
+        readonly mkdir: "haextension:filesystem:mkdir";
+        readonly remove: "haextension:filesystem:remove";
+        readonly exists: "haextension:filesystem:exists";
+        readonly stat: "haextension:filesystem:stat";
+        readonly selectFolder: "haextension:filesystem:select-folder";
+        readonly selectFile: "haextension:filesystem:select-file";
+        readonly rename: "haextension:filesystem:rename";
+        readonly copy: "haextension:filesystem:copy";
     };
     readonly storage: {
         readonly getItem: "haextension:storage:get-item";
@@ -206,6 +182,17 @@ declare const TAURI_COMMANDS: {
         readonly saveFile: "webview_extension_fs_save_file";
         readonly openFile: "webview_extension_fs_open_file";
         readonly showImage: "webview_extension_fs_show_image";
+        readonly readFile: "filesystem_read_file";
+        readonly writeFile: "filesystem_write_file";
+        readonly readDir: "filesystem_read_dir";
+        readonly mkdir: "filesystem_mkdir";
+        readonly remove: "filesystem_remove";
+        readonly exists: "filesystem_exists";
+        readonly stat: "filesystem_stat";
+        readonly selectFolder: "filesystem_select_folder";
+        readonly selectFile: "filesystem_select_file";
+        readonly rename: "filesystem_rename";
+        readonly copy: "filesystem_copy";
     };
     readonly external: {
         readonly respond: "webview_extension_external_respond";