@emailmaker/filemanager 0.10.89 → 0.10.90

package/{129.533eb7b36d92578d2ead.js → 129.1f7048a0e93daec2ca44.js}

@@ -887,31 +887,6 @@ exports["default"] = Barcode;
 
 /***/ }),
 
-/***/ 2689:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports.ITF14 = exports.ITF = undefined;
-
-var _ITF = __webpack_require__(739);
-
-var _ITF2 = _interopRequireDefault(_ITF);
-
-var _ITF3 = __webpack_require__(8122);
-
-var _ITF4 = _interopRequireDefault(_ITF3);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-exports.ITF = _ITF2.default;
-exports.ITF14 = _ITF4.default;
-
-/***/ }),
-
 /***/ 2700:
 /***/ ((__unused_webpack_module, exports) => {
 
@@ -2086,6 +2061,31 @@ exports["default"] = CODE128AUTO;
 
 /***/ }),
 
+/***/ 5070:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ITF14 = exports.ITF = undefined;
+
+var _ITF = __webpack_require__(739);
+
+var _ITF2 = _interopRequireDefault(_ITF);
+
+var _ITF3 = __webpack_require__(8122);
+
+var _ITF4 = _interopRequireDefault(_ITF3);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.ITF = _ITF2.default;
+exports.ITF14 = _ITF4.default;
+
+/***/ }),
+
 /***/ 5099:
 /***/ ((__unused_webpack_module, exports) => {
 
@@ -3804,7 +3804,7 @@ var _CODE2 = __webpack_require__(1509);
 
 var _EAN_UPC = __webpack_require__(5726);
 
-var _ITF = __webpack_require__(2689);
+var _ITF = __webpack_require__(5070);
 
 var _MSI = __webpack_require__(8248);
 
@@ -3890,4 +3890,4 @@ exports.CODE93FullASCII = _CODE93FullASCII2.default;
 /***/ })
 
 }]);
-//# sourceMappingURL=129.533eb7b36d92578d2ead.js.map
+//# sourceMappingURL=129.1f7048a0e93daec2ca44.js.map

package/adapters/DataSourceProxyBase.d.ts

@@ -0,0 +1,225 @@
+import type { ApiPaginationResponse, BatchResult, File, FileManagerDataProviders, Folder, SortState, UploadFileResultData, UploadFilesRequest } from '../types';
+import type { FileSystemItem, GetFileDataOptions, StorageProvider, StorageProviderController } from '../types/storage';
+import { ViewStrategyOptions } from './TreeCache';
+/**
+ * DI config for {@link DataSourceProxyBase}.
+ * All fields are optional — the class works standalone with EN-only defaults.
+ */
+export interface DataSourceProxyConfig {
+    /**
+     * Custom fetch implementation (e.g. with CDN proxy, auth headers, retries).
+     * Used when loading file binary data via URL.
+     * Falls back to global `fetch` when omitted.
+     */
+    fetchWithProxy?: (url: string, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Subset of FileManager options used by {@link DataSourceProxyBase}.
+ */
+export interface FileManagerProxyOptions {
+    enableTrash?: boolean;
+    enablePagination?: boolean;
+    unifiedCatalogFetch?: boolean;
+    clientSideFilter?: boolean | ((items: FileSystemItem[], search?: string) => FileSystemItem[]);
+    clientSideSorting?: boolean | ((items: FileSystemItem[], sortBy?: SortState['sortBy'], sortOrder?: SortState['sortOrder']) => FileSystemItem[]);
+    clientSidePaging?: boolean | ((items: FileSystemItem[], page?: number, limit?: number) => FileSystemItem[]);
+    cacheStrategy?: ViewStrategyOptions & {
+        ttl?: number;
+        errorTtl?: number;
+    };
+}
+export interface DataSourceProxyOptions {
+    rootId?: string;
+    trashPath?: string;
+    tempPath?: string;
+    useSoftDelete?: boolean;
+    batchOperationFallback?: boolean;
+    validateDuplicates?: boolean;
+}
+/**
+ * Caching adapter: wraps a {@link StorageProvider} and exposes a {@link FileManagerDataProviders} interface.
+ * Handles client-side caching (TreeCache), soft-delete, pagination, and deduplication.
+ * Extend this class in a consumer app to add backend-specific logic.
+ */
+export declare class DataSourceProxyBase implements FileManagerDataProviders {
+    private readonly _dataProvider;
+    private readonly _options;
+    private readonly _pathOptions;
+    private readonly _cache;
+    private readonly _rootId;
+    private readonly _useSoftDelete;
+    private readonly _enableTrash;
+    private readonly _validateDuplicates;
+    /** Next `getFileData` for this normalized file id uses HTTP no-store (e.g. after overwrite). */
+    private readonly _blobFetchForceReloadOnceIds;
+    /** Frontend-only guard against reads racing with delete operations. */
+    private readonly _mutationRegistry;
+    private _findOrCreateFolderByPath;
+    private getTrashFolder;
+    private getTempFolder;
+    private readonly _config;
+    constructor(_dataProvider: StorageProvider, _options: FileManagerProxyOptions | undefined, _pathOptions: DataSourceProxyOptions, config?: DataSourceProxyConfig);
+    setController(controller: StorageProviderController): void;
+    clearCache(pathFolder?: string | null): Promise<void>;
+    /**
+     * After save/overwrite, the next `getFileData` for this file id will use `forceReload` (HTTP no-store).
+     */
+    markNextFileBlobFetchBypassHttpCache(fileId: string): void;
+    /**
+     * Нормализует идентификатор с использованием текущих rootId
+     */
+    normalizeId(id: string | null | undefined): string;
+    private _isDeletingId;
+    private _collectDeletingIds;
+    private _emptyFilesResult;
+    /**
+     * Проверяет валидность имени файла/папки
+     */
+    private _validateName;
+    /**
+     * Проверяет, что целевая папка в кэше является папкой (если она есть в кэше)
+     * Не проверяет существование, так как отсутствие в кэше не означает отсутствие на бэкенде
+     */
+    private _validateTargetFolderType;
+    /**
+     * Проверяет, существует ли элемент с указанным именем в целевой папке (только через кэш, без обращения к бэку)
+     */
+    private _checkNameExistsInCache;
+    private _getUrl;
+    private _getThumbnailUrl;
+    private _mapItem;
+    /**
+     * Проверяет, является ли targetFolderId дочерней папкой sourceFolderId (циклическая ссылка)
+     */
+    private _isAncestor;
+    getFile(folderId: string, name: string): Promise<FileSystemItem | null>;
+    /**
+     * File metadata by id: entity cache first; on miss, loads parent listing via {@link getFile} / {@link getFiles} (i.e. provider `getItems`).
+     * Only practical when ids are path-shaped and {@link StorageProvider.pathMode} is true; otherwise cache-only.
+     */
+    getFileById(fileId: string): Promise<File | null>;
+    private _getFileByPathStyleId;
+    getFileUrl(folderId: string, name: string): Promise<string | undefined>;
+    /**
+     * Получает список файлов и папок с поддержкой пагинации, фильтрации и сортировки
+     */
+    getFiles({ folderId, search, sortBy, sortOrder, page, limit, itemType, noFolder, }: {
+        folderId?: string | null;
+        search?: string;
+        sortBy?: SortState['sortBy'];
+        sortOrder?: SortState['sortOrder'];
+        page?: number;
+        limit?: number;
+        itemType: 'file' | 'folder' | 'all';
+        noFolder?: boolean;
+    }): Promise<{
+        files: File[];
+        pagination: Partial<ApiPaginationResponse>;
+    }>;
+    /**
+     * Стандартная клиентская сортировка файлов
+     */
+    private _defaultClientSideSort;
+    /**
+     * Получает данные файла в виде Blob
+     */
+    getFileData(fileId: string, options?: GetFileDataOptions): Promise<Blob>;
+    getFileData(file: File, options?: GetFileDataOptions): Promise<Blob>;
+    findFileByUrl(url: string): Promise<File | null>;
+    /**
+     * Получает количество элементов в папке
+     */
+    getChildrenCount(folderId?: string): Promise<number>;
+    private _isPathFolderNotFoundError;
+    /**
+     * Загружает файл на сервер
+     */
+    _uploadFile(file: {
+        name: string;
+        size: number;
+        type: string;
+        folderId?: string | null;
+        data: Blob | globalThis.File;
+    }): Promise<File>;
+    uploadFiles(request: UploadFilesRequest): Promise<BatchResult<UploadFileResultData>>;
+    /**
+     * Удаляет файл (либо полностью, либо перемещает в корзину в зависимости от настроек)
+     */
+    deleteFile(fileId: string): Promise<boolean>;
+    /**
+     * Удаляет файл (либо полностью, либо перемещает в корзину в зависимости от настроек)
+     */
+    deleteItems(itemIds: string[], options: {
+        permanent: boolean;
+    }): Promise<BatchResult<{}>>;
+    /**
+     * Полностью удаляет файлы
+     */
+    private hardDeleteItems;
+    /**
+     * Полностью удаляет файл без возможности восстановления
+     */
+    private hardDeleteItem;
+    /**
+     * Очищает корзину (удаляет все файлы из корзины)
+     */
+    cleanTrash(): Promise<{
+        success: boolean;
+        deletedCount?: number;
+    }>;
+    /**
+     * Создает новую папку
+     */
+    createFolder({ name, parentId, is_force_create, }: {
+        name: string;
+        parentId?: string | null;
+        is_force_create?: boolean;
+    }): Promise<Folder>;
+    /**
+     * Удаляет папку (либо полностью, либо перемещает в корзину в зависимости от настроек)
+     */
+    deleteFolder(folderId: string): Promise<boolean>;
+    /**
+     * Переименовывает папку
+     */
+    renameFolder(folderId: string, newName: string): Promise<Folder>;
+    /**
+     * Переименовывает файл
+     */
+    renameFile(fileId: string, newName: string): Promise<File>;
+    /**
+     * Перемещает элемент (файл или папку)
+     */
+    moveItem({ itemId, targetFolderId, isFolder, }: {
+        itemId: string;
+        targetFolderId: string | null;
+        isFolder: boolean;
+    }): Promise<boolean>;
+    moveItems(targetFolderId: string, itemIds: string[]): Promise<BatchResult<{}>>;
+    /**
+     * Копирует элемент (файл или папку)
+     */
+    copyItem({ itemId, targetFolderId, }: {
+        itemId: string;
+        targetFolderId: string | null;
+        isFolder: boolean;
+    }): Promise<boolean>;
+    copyItems(targetFolderId: string, items: Array<{
+        id: string;
+        newName?: string;
+    }> | string[]): Promise<BatchResult<{}>>;
+    /**
+     * Загружает файл по URL
+     */
+    uploadFileByUrl(data: {
+        url: string;
+        folderId?: string | null;
+        noFolder?: boolean;
+        name?: string;
+        eventSource?: 'upload' | 'uploadByUrl' | 'pixie' | 'iconStock' | 'imageStock' | 'gif';
+    }): Promise<File>;
+    /**
+     * Обновляет данные файла
+     */
+    updateFile(fileId: string, updates: Partial<Omit<File, 'id'>>): Promise<File>;
+}

package/adapters/FailedRequestCache.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Single store for short-lived cached request failures (negative cache).
+ * Used by {@link TreeCache} for children views and children counts; can be extended for other GETs.
+ */
+export declare class FailedRequestCache {
+    private readonly map;
+    /** Errors from {@link ViewCacheManager.getOrCreateChildren} */
+    static childrenViewKey(pKey: string, qKey: string): string;
+    /** Errors from {@link TreeCache.getChildrenCount} */
+    static childrenCountKey(normalizedParentKey: string): string;
+    /**
+     * Returns the cached error if still within TTL, otherwise null (entry may be removed).
+     */
+    getFreshError(key: string, errorTtlMs: number): unknown | null;
+    setError(key: string, error: unknown): void;
+    delete(key: string): void;
+    /** All list-view errors for one parent bucket (pKey). */
+    clearChildrenViewErrorsForParent(pKey: string): void;
+    clearAll(): void;
+}

package/adapters/MutationRegistry.d.ts

@@ -0,0 +1,6 @@
+export declare class MutationRegistry {
+    private readonly deletingIds;
+    beginDeleting(ids: Iterable<string>): void;
+    endDeleting(ids: Iterable<string>): void;
+    isDeleting(id: string | null | undefined): boolean;
+}

package/adapters/PathAwareStorageAdapter.d.ts

@@ -0,0 +1,70 @@
+import type { FileSystemItem, StorageProvider, FileSystemItemUpdate, GetFileDataOptions, MayBePromise, StorageProviderController, BatchResult, StorageUploadFilesRequest as UploadFilesRequest, StorageSortState as SortState, StorageApiPaginationResponse as ApiPaginationResponse } from '../types/storage';
+export declare class PathAwareStorageAdapter implements StorageProvider {
+    private readonly _inner;
+    readonly rootPath: string;
+    readonly trashId: string;
+    readonly trashPath: string;
+    readonly ensureFolderTrailingSlash: boolean;
+    private readonly _pathToId;
+    private readonly _idToPath;
+    getUrl?: (file: FileSystemItem) => MayBePromise<string>;
+    getThumbnailUrl?: (file: FileSystemItem) => MayBePromise<string>;
+    validateDuplicates?: boolean;
+    constructor(_inner: StorageProvider, rootPath?: string, trashId?: string, trashPath?: string, ensureFolderTrailingSlash?: boolean);
+    setController(controller: StorageProviderController): void;
+    clearCache?(pathFolder?: string | null): MayBePromise<void>;
+    private _getOrGenerateId;
+    pathForId(id: string, isFolder: boolean, silent?: boolean): string;
+    private _updateIdMapping;
+    getItems(options: {
+        folderId?: string;
+        search?: string;
+        sortBy?: SortState['sortBy'];
+        sortOrder?: SortState['sortOrder'];
+        page?: number;
+        limit?: number;
+        itemType: 'all' | 'file' | 'folder';
+    }): Promise<{
+        items: FileSystemItem[];
+        pagination?: Partial<ApiPaginationResponse>;
+    }>;
+    createFolder(name: string, parent?: string, is_force_create?: boolean): Promise<FileSystemItem>;
+    renameItem(item: FileSystemItem, newName: string): Promise<FileSystemItemUpdate>;
+    deleteItem(item: FileSystemItem, options: {
+        permanent: boolean;
+    }): Promise<void>;
+    uploadFile(file: {
+        name: string;
+        size: number;
+        type: string;
+        folderId?: string | null;
+        data: Blob | globalThis.File;
+        thumbnail?: string;
+        dimensions?: string;
+        aspectRatio?: string;
+        extension?: string;
+    }): Promise<FileSystemItemUpdate>;
+    uploadFiles(request: UploadFilesRequest): Promise<BatchResult<FileSystemItem>>;
+    findFileByUrl(url: string, folderId?: string): Promise<FileSystemItem | undefined>;
+    uploadFileByUrl(url: string, folderId?: string | null, options?: {
+        eventSource?: 'upload' | 'uploadByUrl' | 'pixie' | 'iconStock' | 'imageStock' | 'gif';
+    }): Promise<FileSystemItem>;
+    moveItem(item: FileSystemItem, targetFolderId?: string): Promise<FileSystemItemUpdate>;
+    moveItems(items: FileSystemItem[], targetFolderId?: string): Promise<BatchResult<FileSystemItemUpdate>>;
+    copyItems(items: FileSystemItem[], targetFolderId?: string): Promise<BatchResult<FileSystemItemUpdate>>;
+    deleteItems(items: FileSystemItem[], options: {
+        permanent: boolean;
+    }): Promise<BatchResult<never>>;
+    private remapCachedFolderContents;
+    private recursivelyRemoveMappings;
+    copyItem(item: FileSystemItem, targetFolderId?: string): Promise<FileSystemItemUpdate>;
+    updateFile(file: FileSystemItem, updates: {
+        name?: string;
+        data?: Blob | string;
+    }): Promise<FileSystemItemUpdate>;
+    getFileData(file: FileSystemItem, options?: GetFileDataOptions): Promise<Blob>;
+    cleanTrash(): Promise<{
+        success: boolean;
+        deletedCount?: number;
+    }>;
+}

package/adapters/TreeCache.d.ts

@@ -0,0 +1,181 @@
+import type { FileSystemItem } from '../types/storage';
+import { FailedRequestCache } from './FailedRequestCache';
+export interface QueryResult<T> {
+    items: T[];
+    total?: number;
+    totalPages?: number;
+    page?: number;
+    limit?: number;
+    [key: string]: unknown;
+}
+export interface ChildrenQueryParams {
+    page?: number;
+    pageSize?: number | string;
+    sortBy?: string;
+    sortOrder?: string;
+    search?: string;
+    itemType?: 'file' | 'folder' | 'all';
+    [key: string]: unknown;
+}
+/** When `fileManager.cacheStrategy.ttl` is unset: success/error cache and notification dedupe fallback (30 min). */
+export declare const DEFAULT_FILE_MANAGER_CACHE_TTL_MS: number;
+/**
+ * Configuration for {@link TreeCache}.
+ */
+export interface TreeCacheConfig {
+    ttl?: number;
+    errorTtl?: number;
+    /**
+     * Predicate: which errors count as "folder not found" (for negative cache / empty result).
+     * Default: checks error.code === 'folder_not_found' | 'path_folder_not_found' | 'FolderNotFound',
+     * or error.status === 404.
+     */
+    isFolderNotFoundError?: (err: unknown) => boolean;
+}
+/** Default predicate for "folder not found" errors. Can be overridden via {@link TreeCacheConfig.isFolderNotFoundError}. */
+export declare function defaultIsFolderNotFoundError(error: unknown): boolean;
+export declare class EntityCacheManager {
+    private readonly entities;
+    private readonly childrenByParent;
+    private readonly maxCacheSize;
+    private now;
+    private checkCacheSize;
+    getEntity(id: string): FileSystemItem | undefined;
+    getRecord(id: string): {
+        value: FileSystemItem;
+        updatedAt: number;
+    } | undefined;
+    getFileSystemItem(id: string): FileSystemItem | undefined;
+    getFolder(id: string): FileSystemItem | undefined;
+    getChildrenIds(parentId: string | null, opts?: {
+        onlyFileSystemItems?: boolean;
+        onlyFolders?: boolean;
+    }): string[];
+    searchByUrl(url: string): FileSystemItem | null;
+    upsertEntity(entity: FileSystemItem): void;
+    updateServerChildrenCount(folderId: string | null, serverCount: number | undefined): void;
+    deleteEntityById(id: string): {
+        entity: FileSystemItem | null;
+        parentId: string | null;
+    };
+    deleteFolderRecursive(folderId: string): {
+        deletedFolderRecords: FileSystemItem[];
+        deletedFileSystemItemRecords: FileSystemItem[];
+    };
+    moveEntityById(entityId: string, targetParentId: string | null): FileSystemItem | null;
+    copyFileSystemItem(fileId: string, newId: string, targetFolderId: string | null): FileSystemItem | null;
+    copyFolderShallow(folderId: string, newId: string, targetParentId: string | null): FileSystemItem | null;
+    isEntityStale(id: string, ttlMs: number): boolean;
+    touch(id: string, at?: number): void;
+    getEntitiesByIds<T extends FileSystemItem>(ids: string[]): (T | null)[];
+    searchByName(searchQuery: string, options?: {
+        parentId?: string | null;
+        recursive?: boolean;
+        itemType?: 'file' | 'folder' | 'all';
+        caseSensitive?: boolean;
+        limit?: number;
+    }): FileSystemItem[];
+    toJSON(): any;
+    static fromJSON(data: any): EntityCacheManager;
+}
+export interface ViewStrategyOptions {
+    allowSortedInsert?: boolean;
+    allowSearchInsert?: boolean;
+    invalidateOnPaginationFull?: boolean;
+    preloadPagesBefore?: number;
+    preloadPagesAfter?: number;
+    comparator?: (a: FileSystemItem, b: FileSystemItem, params?: ChildrenQueryParams) => number;
+    filterMatch?: (entity: FileSystemItem, params?: ChildrenQueryParams) => boolean;
+}
+export declare class ViewCacheManager {
+    private readonly views;
+    private readonly strategy;
+    private readonly ttl;
+    private readonly errorTtl;
+    private readonly entityTtl;
+    private readonly failedRequests;
+    private readonly isFolderNotFoundError;
+    private serverChildrenCountHandler?;
+    private childrenCountInvalidator?;
+    private readonly maxViewsPerParent;
+    constructor(options?: ViewStrategyOptions, ttl?: number, errorTtl?: number, entityTtl?: number, failedRequests?: FailedRequestCache, isFolderNotFoundError?: (err: unknown) => boolean);
+    setServerChildrenCountHandler(handler: (parentId: string | null, total: number | undefined, entitiesManager: EntityCacheManager) => void): void;
+    setChildrenCountInvalidator(handler: (parentId: string | null | undefined) => void): void;
+    private now;
+    private parentKey;
+    private isExpired;
+    private areEntitiesStale;
+    private isEntityTypeCompatible;
+    private cleanupOldViews;
+    getOrCreateChildren(parentId: string | null, params: ChildrenQueryParams, loader: (parentId: string | null, params: ChildrenQueryParams) => Promise<QueryResult<FileSystemItem>>, entitiesManager: EntityCacheManager): Promise<QueryResult<FileSystemItem>>;
+    /**
+     * Асинхронно предзагружает соседние страницы
+     * Проверяет loadId основного view перед применением результатов
+     */
+    private preloadPagesAsync;
+    private removeEmptyPageIfNeeded;
+    private updateTotalPagesForAllViews;
+    private isParamsSame;
+    private syncTotalsInSameViews;
+    private canSafelyModifySortedView;
+    private cascadeShiftPages;
+    private cascadeShiftToNextPage;
+    private tryInsertSorted;
+    private updateChildrenCountForOperation;
+    private adjustChildrenCount;
+    smartInvalidateChildrenViews(parentId: string | null, entity: FileSystemItem | null, operation: 'insert' | 'delete' | 'move' | 'copy' | 'update', entitiesManager: EntityCacheManager, prevParentId?: string | null, prevEntity?: FileSystemItem | null): void;
+    private shouldInvalidateCompletely;
+    private tryReinsertEntity;
+    private handleDelete;
+    private handleInsert;
+    private handleUpdate;
+    private handleMove;
+    forceInvalidateChildrenViews(parentId: string | null): void;
+    getKnownTotal(parentId: string | null): number | undefined;
+    toJSON(): any;
+    static fromJSON(data: any, opts?: {
+        failedRequests?: FailedRequestCache;
+        ttl?: number;
+        errorTtl?: number;
+        isFolderNotFoundError?: (err: unknown) => boolean;
+    }): ViewCacheManager;
+}
+export declare class TreeCache {
+    private readonly entities;
+    private readonly views;
+    private readonly ttl;
+    private readonly errorTtl;
+    private readonly failedRequests;
+    private readonly isFolderNotFoundError;
+    private readonly childrenCountPromises;
+    private invalidateChildrenCountCache;
+    constructor(viewOptions?: ViewStrategyOptions, ttl?: number, errorTtl?: number, config?: TreeCacheConfig);
+    getEntity(id: string): FileSystemItem | null;
+    getFileSystemItem(id: string): FileSystemItem | null;
+    getFolder(id: string): FileSystemItem | null;
+    getOrCreateChildren(parentId: string | null, params: ChildrenQueryParams, loader: (parentId: string | null, params: ChildrenQueryParams) => Promise<QueryResult<FileSystemItem>>): Promise<QueryResult<FileSystemItem>>;
+    upsertEntity(entity: FileSystemItem): void;
+    private isAncestor;
+    moveEntity(entityId: string, targetParentId: string | null): FileSystemItem | null;
+    copyEntity(entityId: string, targetParentId: string | null, newId?: string, overrides?: Partial<FileSystemItem>): FileSystemItem | null;
+    searchByUrl(url: string): FileSystemItem | null;
+    deleteEntity(entityId: string): FileSystemItem | null;
+    deleteFolderRecursive(folderId: string): {
+        deletedFileSystemItemIds: string[];
+        deletedFolderIds: string[];
+    };
+    forceInvalidate(id: string): void;
+    getChildrenIds(parentId: string | null): string[];
+    searchByName(searchQuery: string, options?: {
+        parentId?: string | null;
+        recursive?: boolean;
+        itemType?: 'file' | 'folder' | 'all';
+        caseSensitive?: boolean;
+        limit?: number;
+    }): FileSystemItem[];
+    getChildrenCount(folderId?: string, loader?: (folderId: string) => Promise<number>): Promise<number>;
+    toJSON(): any;
+    static fromJSON(data: any, viewOptions?: ViewStrategyOptions, config?: TreeCacheConfig): TreeCache;
+    private handleServerReportedChildrenCount;
+    private checkAndResolveChildrenCountConflict;
+}

package/components/FileContent/renderers/FileTableView.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ColumnsType } from 'antd/es/table';
+import type { TableColumnsType as ColumnsType } from 'antd';
 import type { FileListRowModel } from '../../../presentation/file-list/types';
 interface FileTableViewProps {
     rows: FileListRowModel[];

package/components/FileModals/FileModals.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { FormInstance } from 'antd/es/form';
+import type { FormInstance } from 'antd';
 import { File, Folder } from '../../types';
 interface FileModalsProps {
     isModalVisible: boolean;

package/components/Tag/index.d.ts

@@ -4,7 +4,7 @@ interface TagProps {
     style?: React.CSSProperties;
     color?: string;
     text?: string;
-    bordered?: boolean;
+    variant?: 'solid' | 'outlined' | 'filled';
     props?: any;
 }
 declare const Tag: React.FC<TagProps>;