@emailmaker/emailmaker 1.0.93-alpha.6 → 1.0.94-alpha.1

package/emailmaker.d.ts

@@ -39,17 +39,9 @@ type RemoveEventPayload<T> = {
   value: T;
 };
 
-type MergeTagGroup = {
-  type?: 'group';
-  label: string;
-  value: string;
-  children?: MergeTag[];
-};
+type MergeTagGroup = { type?: 'group'; label: string; value: string; children?: MergeTag[] };
 
-type MergeTagItem = {
-  label: string;
-  value: string;
-};
+type MergeTagItem = { label: string; value: string };
 type MergeTag = MergeTagGroup | MergeTagItem;
 
 type SaveListener<T> = AppListener<SaveEventPayload<T>, T | undefined | void>;
@@ -81,19 +73,9 @@ type Notify = {
   role?: 'alert' | 'status';
 };
 
-type EmailDesc = {
-  id?: string;
-  title?: string;
-  code?: string;
-  subject?: string;
-  preheader?: string;
-};
+type EmailDesc = { id?: string; title?: string; code?: string; subject?: string; preheader?: string };
 
-type BlockDesc = {
-  id?: string;
-  title?: string;
-  code?: string;
-};
+type BlockDesc = { id?: string; title?: string; code?: string };
 
 interface ISelection {
   selectionStartLineNumber: number;
@@ -106,12 +88,7 @@ interface ISingleModelEditStackData {
   afterVersionId: number;
   beforeCursorState: ISelection[];
   beforeVersionId: number;
-  changes: {
-    oldPosition: number;
-    oldText: string;
-    newPosition: number;
-    newText: string;
-  }[];
+  changes: { oldPosition: number; oldText: string; newPosition: number; newText: string }[];
 }
 
 interface IFrameErrorInfo {
@@ -156,9 +133,7 @@ declare namespace Notify {
     | { id: 'GET_LOCALE_ERROR'; data: any }
     | { id: 'GET_LOCALES_ERROR'; data: any }
   );
-  type ErrorEvent = {
-    type: 'error';
-  } & Error;
+  type ErrorEvent = { type: 'error' } & Error;
 
   type Success =
     | { id?: ''; data?: any }
@@ -174,9 +149,7 @@ declare namespace Notify {
     | { id: 'BLOCK_CLONING_SUCCESS'; data: BlockDesc }
     | { id: 'BLOCK_REMOVING_SUCCESS'; data: BlockDesc };
 
-  type SuccessEvent = {
-    type: 'success';
-  } & Success;
+  type SuccessEvent = { type: 'success' } & Success;
 
   type Warning =
     | { id?: ''; data?: any }
@@ -425,11 +398,7 @@ declare namespace ExportedApi {
   }
 
   interface CompiledEmail extends Email {
-    readonly compiled: {
-      html: string;
-      ampHtml: string;
-      text: string;
-    };
+    readonly compiled: { html: string; ampHtml: string; text: string };
   }
 }
 declare namespace ExportedApi {
@@ -475,10 +444,7 @@ declare namespace ExportedApi {
   }
 
   interface CompiledEmailRevision extends EmailRevision {
-    readonly compiled: {
-      html: string;
-      ampHtml: string;
-    };
+    readonly compiled: { html: string; ampHtml: string };
   }
 }
 declare namespace ExportedApi {
@@ -792,6 +758,8 @@ declare namespace ExportedApi {
     disableDoubleClickNextButton?: boolean;
     /** manually change state of next button  */
     activeNextButton?: boolean;
+    /** icons stroke width  */
+    iconStrokeWidth: number
   }
 
   export interface User {
@@ -848,11 +816,7 @@ declare namespace ExportedApi {
 }
 
 declare namespace ExportedApi {
-  export type JWTAuthOptions = {
-    email: string;
-    password: string;
-    remember?: boolean;
-  };
+  export type JWTAuthOptions = { email: string; password: string; remember?: boolean };
 
   type JWTOptions = {
     /** JWT authorization credentials */
@@ -935,7 +899,7 @@ declare namespace ExportedApi {
     type ReadEmailHandler = (id: string) => MayBePromise<Email>;
     type ReadEmailAutosavesHandler = (emailId: string) => MayBePromise<EmailRevision[]>;
     type ReadBlocksHandler = (project: string) => MayBePromise<Block[]>;
-    type ReadTemplateBlocksHandler = ({ emailId: string, project: string }) => MayBePromise<Block[]>;
+    type ReadTemplateBlocksHandler = (block: { emailId: string; project: string }) => MayBePromise<Block[]>;
     type ReadCommentsHandler = (emailId: string) => MayBePromise<Comment[]>;
 
     type EmailHandler = AppListener<Email>;
@@ -954,22 +918,11 @@ declare namespace ExportedApi {
 
     type TestEmailModalSendHandler = AppListener<Email, false | void>;
 
-    type LivePreviewHandler = AppListener<{
-      project?: string;
-      id: string;
-      subject?: string;
-      html: string;
-    }>;
+    type LivePreviewHandler = AppListener<{ project?: string; id: string; subject?: string; html: string }>;
 
-    type ShareHandler = AppListener<{
-      project?: string;
-      id: string;
-    }>;
+    type ShareHandler = AppListener<{ project?: string; id: string }>;
 
-    type PreviewHandler = AppListener<{
-      project?: string;
-      id: string;
-    }>;
+    type PreviewHandler = AppListener<{ project?: string; id: string }>;
 
     type ValidateEvent = AppListener<CodeError[]>;
 
@@ -1254,36 +1207,70 @@ interface IUndoRedoService {
 }
 
 /**
- * Folder information.
+ * Represents the result of a single operation within a batch request.
+ *
+ * @template T - The type of data returned by successful operations. Use `void` for operations
+ *               that don't return data (e.g., delete operations).
+ *
+ * @example
+ * // For a successful file copy operation
+ * const result: OperationResult<FileInfo> = {
+ *   id: 'file123',
+ *   success: true,
+ *   data: { id: 'file123-copy', name: 'file.txt', ... }
+ * };
+ *
+ * @example
+ * // For a failed operation
+ * const result: OperationResult<void> = {
+ *   id: 'file456',
+ *   success: false,
+ *   error: 'Permission denied'
+ * };
  */
-export interface FolderInfo {
-  /** Unique folder identifier */
-  id: string;
-  /** Folder name */
-  name: string;
-  /** Parent folder identifier (null or undefined if it's a root folder) */
-  parentId?: string | null;
+export interface OperationResult<T = void> {
+  /**
+   * Unique identifier of the item that was processed.
+   * This should match the ID of the original item from the request.
+   */
+  id?: string;
 
-  childCount?: number;
-}
+  /**
+   * Indicates whether the operation completed successfully.
+   */
+  success?: boolean;
 
-export type FolderOperationResult = Partial<FolderInfo> & { id: string };
+  /**
+   * The result data returned by successful operations.
+   * Present only when `success` is `true` and the operation returns data.
+   */
+  data?: T;
 
+  /**
+   * Error message describing why the operation failed.
+   * Present only when `success` is `false`.
+   */
+  error?: string;
+}
+
+export type BatchResult<T> = { success: boolean; error?: string; detailed?: OperationResult<T>[] };
 
 /**
  * File information.
  */
-export interface FileInfo {
+export interface FileSystemItem {
   /** Unique file identifier */
   id: string;
   /** File name */
   name: string;
+  /** Identifier of the folder the file belongs to */
+  folderId: string;
+  /** Item type - file or folder */
+  isFolder?: boolean;
   /** File size */
   size?: number;
   /** File creation or upload date */
   date?: string;
-  /** Identifier of the folder the file belongs to */
-  folderId: string;
   /** File MIME type */
   type?: string;
   /** File download URL (used if `getFile` method is not implemented) */
@@ -1300,15 +1287,17 @@ export interface FileInfo {
   extension?: string;
   /** Whether the file is selected in the UI */
   selected?: boolean;
-  /** Whether the item is a folder */
-  isFolder?: boolean;
   /** Date when the file was last edited */
   lastEdited?: string;
-
-  childCount?: number;
+  /** Number of children items (for folders) */
+  childrenCount?: number;
 }
 
-export type FileOperationResult = Partial<FileInfo> & { id: string };
+/**
+ * Represents partial updates to a file system item after an operation.
+ * Contains only the fields that were changed during the operation.
+ */
+export type FileSystemItemUpdate = Partial<FileSystemItem> & { id: string };
 
 /**
  * API response with pagination details.
@@ -1338,106 +1327,199 @@ export interface SortState {
   sortOrder: 'asc' | 'desc';
 }
 
+export interface StorageProviderController {
+  /**
+   * Invalidates the cache for a specific file system item.
+   *
+   * This method should be called when an item's data has changed externally
+   * and the cached version is no longer valid. After invalidation, the next
+   * access to this item will trigger a fresh fetch from the storage backend.
+   *
+   * @param itemId - The unique identifier of the file or folder to invalidate
+   * @example
+   * // After renaming a file, invalidate its cache
+   * controller.invalidateItemCache(fileId);
+   */
+  invalidateItemCache(itemId: string): void;
+
+  /**
+   * Retrieves a cached file system item.
+   *
+   * @param itemId - The unique identifier of the file or folder
+   * @returns The cached item or undefined if not found in cache
+   */
+  getCachedItem(itemId: string): FileSystemItem | undefined;
+}
+
 /**
  * Interface for storage providers.
  * Defines the contract for different storage backends (e.g., cloud APIs).
  */
 export interface StorageProvider {
   /**
-   * Use the path as an identifier
+   * Use the path as an identifier for folders
    */
   pathMode?: boolean;
+
+  /**
+   * Custom identifier for the root folder.
+   * - This ID will be used internally for the root of the file tree.
+   * - Defaults to an empty string `''` if not provided.
+   */
+  rootId?: string;
+
+  /**
+   * Path to the trash/recycle bin folder.
+   * - Used when `useSoftDelete` is enabled or for trash operations.
+   * - The provider will resolve this path to an actual folder ID.
+   */
+  trashPath?: string;
+
+  /**
+   * Path to the temporary folder for uploads and transient files.
+   * - Used for operations where temporary storage is needed.
+   * - The provider will resolve this path to an actual folder ID.
+   */
+  tempPath?: string;
+  /**
+   * @default true
+   */
+  ensureFolderTrailingSlash?: boolean;
+
+  /**
+   * Utility method for finding system files/folders by path.
+   * By default, searches for folders through getFiles method.
+   *
+   * @param path - Path to the file or folder
+   * @returns The found item or undefined if not found
+   */
+  findItemByPath?(path: string): MayBePromise<FileSystemItem | undefined>;
+
+  /**
+   * Sets the controller for cache management.
+   *
+   * This method provides the storage provider with a controller interface
+   * that allows it to communicate cache invalidation requests back to the file manager.
+   *
+   * @param controller - The controller instance for cache management
+   * @example
+   * // Store the controller for later use
+   * setController(controller) {
+   *   this.controller = controller;
+   * }
+   */
+  setController?(controller: StorageProviderController): MayBePromise<void>;
+
+  /**
+   * Enables client-side soft delete implementation.
+   * When enabled, delete operations will move items to trashPath instead of permanent deletion.
+   *
+   * @note If your backend already implements soft delete, keep this disabled
+   * to avoid double soft-delete logic.
+   *
+   * @default false
+   */
+  useSoftDelete?: boolean;
   /**
    * Retrieve the file content as a binary blob.
    *
    * ⚠️ If this method is not implemented, the file will be downloaded
    * using the `url` property from the `FileInfo` object.
    *
-   * @param file File
+   * @param file - File object
    * @returns File contents as a Blob
    */
-  getFileData?: (file: FileInfo) => Promise<Blob>;
+  getFileData?: (file: FileSystemItem) => MayBePromise<Blob>;
 
-  getUrl?: (file: FileInfo) => MayBePromise<string>;
+  /**
+   * Get URL for file access
+   * @param file - File object
+   * @returns File URL
+   */
+  getUrl?: (file: FileSystemItem) => MayBePromise<string>;
 
-  getThumbnailUrl?: (file: FileInfo) => MayBePromise<string>;
+  /**
+   * Get thumbnail URL for file
+   * @param file - File object
+   * @returns Thumbnail URL
+   */
+  getThumbnailUrl?: (file: FileSystemItem) => MayBePromise<string>;
 
   /**
-   * Retrieve a list of files.
+   * Retrieve a list of files and folders.
    * Supports filtering, sorting, and pagination.
    *
-   * @param options.folderId Folder identifier (default: root folder)
-   * @param options.search Search query
-   * @param options.sortBy Field to sort by
-   * @param options.sortOrder Sort direction
-   * @param options.page Page number
-   * @param options.limit Number of items per page
-   * @returns List of files and optional pagination details
+   * @param options.folderId - Parent folder (or undefined for root)
+   * @param options.search - Search query
+   * @param options.sortBy - Field to sort by
+   * @param options.sortOrder - Sort direction
+   * @param options.page - Page number
+   * @param options.limit - Number of items per page
+   * @param options.itemType - Filter by item type
+   * @returns List of files/folders and optional pagination details
    */
-  getFiles: (options: {
+  getItems: (options: {
     folderId?: string;
     search?: string;
     sortBy?: SortState['sortBy'];
     sortOrder?: SortState['sortOrder'];
     page?: number;
     limit?: number;
-    itemType?: 'all' | 'file' | 'folder';
-  }) => Promise<{
-    files: FileInfo[];
-    pagination?: Partial<ApiPaginationResponse>;
-  }>;
+    itemType: 'all' | 'file' | 'folder';
+  }) => MayBePromise<{ items: FileSystemItem[]; pagination?: Partial<ApiPaginationResponse> }>;
 
   /**
    * Create a new folder.
    *
-   * @param data.name Folder name
-   * @param data.parentId Parent folder identifier (or null/undefined for root)
+   * @param name - Folder name
+   * @param parent - Parent folder (or undefined for root)
    * @returns The created folder object
    */
-  createFolder: (data: { name: string; parentId?: string | null }) => Promise<FolderInfo>;
+  createFolder: (name: string, parentid?: string) => MayBePromise<FileSystemItem>;
 
   /**
-   * Rename a folder.
+   * Rename an item (file or folder).
    *
-   * @param folderId Folder identifier
-   * @param newName New folder name
-   * @returns Updated folder object
+   * @param options.item - Item to rename (file or folder)
+   * @param options.newName - New item name
+   * @returns Updated item with changed fields
    */
-  renameFolder?: (folderId: string, newName: string) => Promise<FolderOperationResult>;
+  renameItem?: (item: FileSystemItem, newName: string) => MayBePromise<FileSystemItemUpdate>;
 
   /**
-   * Delete a folder.
+   * Delete an item (file or folder).
+   * When useSoftDelete is enabled, moves item to trashPath instead of permanent deletion.
    *
-   * @param folderId Folder identifier
-   * @returns true if deletion was successful
+   * @param item - Item to delete (file or folder)
+   * @throws {Error} If deletion fails
    */
-  deleteFolder: (folderId: string) => Promise<boolean>;
+  deleteItem?: (item: FileSystemItem) => MayBePromise<void>;
 
   /**
    * Upload a file.
    *
-   * @param file.name File name
-   * @param file.size File size
-   * @param file.type MIME type
-   * @param file.folderId Target folder identifier (or null/undefined for root)
-   * @param file.data File data (Blob or base64 string)
-   * @param file.thumbnail Thumbnail image
-   * @param file.dimensions Image dimensions
-   * @param file.aspectRatio Aspect ratio
-   * @param file.extension File extension
-   * @returns The uploaded file object
+   * @param file.name - File name
+   * @param file.size - File size
+   * @param file.type - MIME type
+   * @param file.folderId - Target folder (or undefined for root)
+   * @param file.data - File data (Blob or base64 string)
+   * @param file.thumbnail - Thumbnail image
+   * @param file.dimensions - Image dimensions
+   * @param file.aspectRatio - Aspect ratio
+   * @param file.extension - File extension
+   * @returns The uploaded file with changed fields
    */
   uploadFile: (file: {
     name: string;
     size: number;
     type: string;
-    folderId?: string | null;
+    folderId?: string;
     data: Blob | string;
     thumbnail?: string;
     dimensions?: string;
     aspectRatio?: string;
     extension?: string;
-  }) => Promise<FileOperationResult>;
+  }) => MayBePromise<FileSystemItemUpdate>;
 
   /**
    * Upload a file by URL.
@@ -1446,64 +1528,68 @@ export interface StorageProvider {
    * to the current server. If it does, return the existing file object
    * instead of uploading it again.
    *
-   * @param data.url File URL
-   * @param data.folderId Target folder identifier (or null/undefined for root)
-   * @param data.noFolder If true, the file should be uploaded to a temporary
-   * folder (for example, when editing a file)
-   * @returns The uploaded or existing file object
+   * @param url - File URL
+   * @param folderId - Target folder (or undefined for root). If not specified,
+   * uses the root folder.
+   * @returns The uploaded or existing complete file object
    */
-  uploadFileByUrl: (data: { url: string; folderId?: string | null; noFolder?: boolean }) => Promise<FileInfo>;
+  uploadFileByUrl: (url: string, folderId?: string) => MayBePromise<FileSystemItem>;
 
   /**
-   * Delete a file.
+   * Delete multiple items (files or folders).
    *
-   * @param fileId File identifier
-   * @returns true if deletion was successful
+   * @param items - Array of items to delete (files or folders)
+   * @returns Batch operation result with success/failure details
    */
-  deleteFile: (fileId: string) => Promise<boolean>;
+  deleteItems?: (items: FileSystemItem[]) => MayBePromise<BatchResult<never>>;
 
   /**
-   * Rename a file.
-   *
-   * @param fileId File identifier
-   * @param newName New file name
-   * @returns Updated file object
+   * Move a single item to the target folder
+   * @param item - Item to move (file or folder)
+   * @param targetFolderId - Destination folder. If undefined, uses root folder
+   * @returns The moved item with changed fields
    */
-  renameFile?: (fileId: string, newName: string) => Promise<FileOperationResult>;
+  moveItem?: (item: FileSystemItem, targetFolderId?: string) => MayBePromise<FileSystemItemUpdate>;
 
   /**
-   * Move a file or folder to another location.
-   *
-   * @param options.itemId Identifier of the item to move
-   * @param options.targetFolderId Target folder identifier
-   * @param options.isFolder true if the item is a folder
-   * @returns true if the move operation was successful
+   * Move multiple items to the target folder
+   * @param items - Array of items to move (files or folders)
+   * @param targetFolderId - Destination folder. If undefined, uses root folder
+   * @returns Batch operation result with success/failure details
    */
-  moveItem: (options: { itemId: string; targetFolderId: string; isFolder: boolean }) => Promise<FileOperationResult>;
+  moveItems?: (
+    items: FileSystemItem[],
+    targetFolderId?: string
+  ) => MayBePromise<BatchResult<FileSystemItemUpdate>>;
 
   /**
-   * Copy a file or folder.
-   *
-   * @param options.itemId Identifier of the item to copy
-   * @param options.targetFolderId Target folder identifier
-   * @param options.isFolder true if the item is a folder
-   * @returns Object with the new item identifier (and optionally a new URL)
+   * Copy a single item to the target folder
+   * @param item - Item to copy (file or folder)
+   * @param targetFolderId - Destination folder. If undefined, uses root folder
+   * @returns The copied item with changed fields
    */
-  copyItem: (options: {
-    itemId: string;
-    targetFolderId: string;
-    isFolder: boolean;
-  }) => Promise<FileOperationResult>;
+  copyItem?: (item: FileSystemItem, targetFolderId?: string) => MayBePromise<FileSystemItemUpdate>;
+
+  /**
+   * Copy multiple items to the target folder
+   * @param items - Array of items to copy (files or folders)
+   * @param targetFolderId - Destination folder. If undefined, uses root folder
+   * @returns Batch operation result with success/failure details
+   */
+  copyItems?: (
+    items: FileSystemItem[],
+    targetFolderId?: string
+  ) => MayBePromise<BatchResult<FileSystemItemUpdate>>;
 
   /**
    * Update file metadata or content.
    *
-   * @param fileId File identifier
-   * @param updates Object with fields to update (name, type, data, thumbnail, etc.)
-   * @returns Updated file object
+   * @param file - File to update
+   * @param updates - Object with fields to update (name, type, data, thumbnail, etc.)
+   * @returns Updated file with changed fields
    */
   updateFile?: (
-    fileId: string,
+    file: FileSystemItem,
     updates: {
       name?: string;
       type?: string;
@@ -1513,15 +1599,22 @@ export interface StorageProvider {
       aspectRatio?: string;
       extension?: string;
     },
-  ) => Promise<FileOperationResult>;
+  ) => MayBePromise<FileSystemItemUpdate>;
 }
 
-declare module ExportedApi {
+declare namespace ExportedApi {
   export interface Options {
     storageProvider?: StorageProvider;
   }
 
   export interface FileManagerOptions {
+    /**
+     * Enables trash functionality for deleted files.
+     * When enabled, deleted files are moved to trash instead of permanent deletion.
+     * @default true
+     */
+    enableTrash?: boolean;
+
     /**
      * Enables paging in the file manager view.
      * If false or undefined, paging is disabled and all items are loaded at once.
@@ -1550,6 +1643,54 @@ declare module ExportedApi {
      */
     enableUpdateFile?: boolean;
 
+    /**
+     * Enables file editing capabilities.
+     * Includes functions for modifying file content or properties.
+     * @default true
+     */
+    enableEdit?: boolean;
+    /**
+     * Enables copying files.
+     * Allows creating copies of files.
+     * @default true
+     */
+    enableMoveFile?: boolean;
+    /**
+     * Enables copying folders.
+     * Allows creating copies of folders.
+     * @default true
+     */
+    enableMoveFolder?: boolean;
+    /**
+     * Enables copying files.
+     * Allows creating copies of files.
+     * @default true
+     */
+    enableCopyFile?: boolean;
+    /**
+     * Enables copying folders.
+     * Allows creating copies of folders.
+     * @default true
+     */
+    enableCopyFolder?: boolean;
+    /**
+     * Enables deleting files and folders.
+     * When trash is enabled, files are moved to trash, otherwise permanently deleted.
+     * @default true
+     */
+    enableDelete?: boolean;
+    /**
+     * Default folder name
+     */
+    defaultFolderName?: string;
+
+    /**
+     * Enables multiple selection of files and folders.
+     * Allows selecting multiple items for batch operations.
+     * @default true
+     */
+    multiSelect?: boolean;
+
     /**
      * Enables client-side sorting of files.
      * - If `true`, default sorting is applied (by name ascending).
@@ -1559,7 +1700,11 @@ declare module ExportedApi {
      */
     clientSideSorting?:
       | boolean
-      | ((items: FileInfo[], sortBy?: SortState['sortBy'], sortOrder?: SortState['sortOrder']) => FileInfo[]);
+      | ((
+          items: FileSystemItem[],
+          sortBy?: SortState['sortBy'],
+          sortOrder?: SortState['sortOrder'],
+        ) => FileSystemItem[]);
 
     /**
      * Enables client-side pagination of files.
@@ -1568,7 +1713,7 @@ declare module ExportedApi {
      *   and should return a paginated array of files.
      * @default false
      */
-    clientSidePaging?: boolean | ((items: FileInfo[], page?: number, limit?: number) => FileInfo[]);
+    clientSidePaging?: boolean | ((items: FileSystemItem[], page?: number, limit?: number) => FileSystemItem[]);
 
     /**
      * Enables client-side filtering of files.
@@ -1577,50 +1722,59 @@ declare module ExportedApi {
      *   and should return a filtered array of files.
      * @default false
      */
-    clientSideFilter?: boolean | ((items: FileInfo[], search?: string) => FileInfo[]);
+    clientSideFilter?: boolean | ((items: FileSystemItem[], search?: string) => FileSystemItem[]);
 
     /**
      * Configuration for cache behavior in the file manager.
+     * Defines caching strategy for performance optimization.
      */
     cacheStrategy?: {
       /**
        * Time-to-live (TTL) in milliseconds for cached items.
        * After this period, cached items will be considered stale.
-       *
+       * @default 300000 (5 minutes)
        */
       ttl?: number;
 
       /**
        * TTL in milliseconds for cached items when an error occurs during loading.
+       * Determines how long to keep cache on network or server errors.
+       * @default 60000 (1 minute)
        */
       errorTtl?: number;
 
       /**
        * Allows inserting new items into sorted lists without marking the view as stale.
+       * Useful for dynamically adding items without full cache refresh.
+       * @default false
        */
       allowSortedInsert?: boolean;
 
       /**
        * Allows inserting new items that may not match current filters without marking the view as stale.
+       * @default false
        */
       allowSearchInsert?: boolean;
 
       /**
        * Marks the view as stale when a paginated page is full and cannot accommodate new items.
+       * @default true
        */
       invalidateOnPaginationFull?: boolean;
 
       /**
        * Custom comparator function for sorting entities.
        * Receives two entities and optional query parameters, should return -1, 0, or 1.
+       * @default File/folder name comparison
        */
-      comparator?: (a: FileInfo, b: FileInfo, params?: any) => number;
+      comparator?: (a: FileSystemItem, b: FileSystemItem, params?: any) => number;
 
       /**
        * Function to determine if a given entity matches the current filters.
        * Returns `true` if the entity should be included.
+       * @default File/folder name search
        */
-      filterMatch?: (entity: FileInfo, params?: any) => boolean;
+      filterMatch?: (entity: FileSystemItem, params?: any) => boolean;
     };
   }