@filebox/core 1.0.10

package/dist/src/crypt/file-encryptor.d.ts

@@ -0,0 +1,168 @@
+/**
+ * 支持的加密算法类型
+ *
+ * 推荐算法（生产环境）：
+ * - AES-CTR: ⭐⭐⭐ 最推荐！流加密，适合大文件，支持随机访问，跨平台兼容
+ * - ChaCha20: ⭐⭐ 现代流加密，性能好，安全可靠
+ *
+ * 特殊场景：
+ * - AES-GCM: ⭐ 带认证标签，防篡改。⚠️ 不支持分块加密，大文件会消耗大量内存！
+ *
+ * 不推荐（仅用于兼容）：
+ * - RC4: ⚠️ 已被认为不安全，仅用于演示和兼容旧系统
+ */
+export type EncryptionAlgorithm = "AES-CTR" | "AES-GCM" | "RC4" | "ChaCha20";
+export declare function normalizeEncryptionAlgorithm(algorithm?: string): EncryptionAlgorithm;
+/**
+ * 部分加密配置
+ */
+export interface PartialEncryptionConfig {
+    /** 加密类型: 'percentage' 百分比 | 'size' 固定大小 | 'full' 完整加密 */
+    type: "percentage" | "size" | "full";
+    /** 当 type='percentage' 时，表示加密的百分比 (0-100) */
+    percentage?: number;
+    /** 当 type='size' 时，表示加密的字节数 */
+    bytes?: number;
+}
+/**
+ * 文件流加密类
+ * 支持多种流加密算法：AES-CTR、AES-GCM、RC4、ChaCha20
+ * 优先考虑性能，适合大文件处理
+ * 支持部分加密：可以只加密文件的前面部分
+ */
+export declare class FileEncryptor {
+    private password;
+    private salt;
+    private _initialized;
+    private fileKey;
+    private iv;
+    private cryptoKey;
+    private algorithm;
+    chunkSize: number;
+    private partialEncryption;
+    constructor(password: string, salt: Uint8Array, algorithm?: EncryptionAlgorithm);
+    init(): Promise<FileEncryptor>;
+    /**
+     * 加密单个数据块
+     * @param chunk 要加密的数据块
+     * @param offset 当前块在文件中的偏移量（用于计算counter）
+     */
+    encryptChunk(chunk: Uint8Array, offset?: number): Promise<Uint8Array>;
+    /**
+     * 解密单个数据块
+     * @param chunk 要解密的数据块
+     * @param offset 当前块在文件中的偏移量（用于计算counter）
+     */
+    decryptChunk(chunk: Uint8Array, offset?: number): Promise<Uint8Array>;
+    /**
+     * 流式加密（适用于 ReadableStream，支持部分加密）
+     * @param stream 输入流
+     * @param totalSize 文件总大小（用于计算部分加密）
+     * @returns 加密后的流
+     */
+    createEncryptStream(stream: ReadableStream<Uint8Array>, totalSize?: number): ReadableStream<Uint8Array>;
+    /**
+     * 流式解密（适用于 ReadableStream，支持部分加密的文件）
+     * @param stream 加密的输入流
+     * @param totalSize 文件总大小（用于计算部分解密）
+     * @returns 解密后的流
+     */
+    createDecryptStream(stream: ReadableStream<Uint8Array>, totalSize?: number): ReadableStream<Uint8Array>;
+    /**
+     * 加密整个 Blob/File（支持部分加密）
+     * @param blob 要加密的 Blob 或 File
+     * @returns 加密后的 Blob
+     */
+    encryptBlob(blob: Blob): Promise<Blob>;
+    /**
+     * 解密整个 Blob（支持部分加密的文件）
+     * @param blob 加密的 Blob
+     * @returns 解密后的 Blob
+     */
+    decryptBlob(blob: Blob): Promise<Blob>;
+    /**
+     * 根据偏移量计算 counter
+     * AES-CTR 需要每个块有不同的 counter
+     */
+    private _getCounter;
+    /**
+     * AES-CTR 加密
+     */
+    private _encryptAesCtr;
+    /**
+     * AES-CTR 解密
+     */
+    private _decryptAesCtr;
+    /**
+     * AES-GCM 加密（带认证）
+     */
+    private _encryptAesGcm;
+    /**
+     * AES-GCM 解密
+     */
+    private _decryptAesGcm;
+    /**
+     * RC4 加密（手写实现，支持流式加密和偏移量）
+     *
+     * ⚠️ 安全警告：RC4 已被认为不安全，存在多个已知漏洞
+     * - 不应用于生产环境
+     * - 仅用于演示和兼容旧系统
+     * - 建议使用 AES-CTR 或 ChaCha20 代替
+     *
+     * 注意：crypto-js 的 RC4 不支持偏移量，所以这里使用手写实现
+     */
+    private _encryptRc4;
+    /**
+     * RC4 解密（与加密相同）
+     */
+    private _decryptRc4;
+    /**
+     * ChaCha20 QuarterRound 函数
+     */
+    private _chacha20QuarterRound;
+    /**
+     * ChaCha20 核心块函数
+     */
+    private _chacha20Block;
+    /**
+     * ChaCha20 加密（手写实现，无第三方依赖）
+     */
+    private _encryptChaCha20;
+    /**
+     * ChaCha20 解密（与加密相同）
+     */
+    private _decryptChaCha20;
+    /**
+     * 设置块大小（用于性能优化）
+     * @param size 块大小（字节）
+     */
+    setChunkSize(size: number): void;
+    /**
+     * 获取当前使用的算法
+     */
+    getAlgorithm(): EncryptionAlgorithm;
+    /**
+     * 设置部分加密配置
+     * @param config 部分加密配置
+     * @example
+     * // 加密前 10%
+     * encryptor.setPartialEncryption({ type: 'percentage', percentage: 10 });
+     *
+     * // 加密前 5MB
+     * encryptor.setPartialEncryption({ type: 'size', bytes: 5 * 1024 * 1024 });
+     *
+     * // 加密整个文件
+     * encryptor.setPartialEncryption({ type: 'full' });
+     */
+    setPartialEncryption(config: PartialEncryptionConfig): void;
+    /**
+     * 获取部分加密配置
+     */
+    getPartialEncryption(): PartialEncryptionConfig;
+    /**
+     * 计算需要加密的字节数
+     * @param totalSize 文件总大小
+     * @returns 需要加密的字节数
+     */
+    private _calculateEncryptBytes;
+}

package/dist/src/crypt/fs-crypt.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 文件名/字符串加密类
+ * 提供可逆的文件名加密功能
+ * 使用 AES-CTR 模式产生短密文（流密码，输入多长输出多长）
+ */
+export declare class FsCrypt {
+    private static readonly FILENAME_MARKER_DELIMITER;
+    private password;
+    private salt;
+    private _initialized;
+    private reversibleKey;
+    private iv;
+    private filenameMarker;
+    constructor(password: string, salt: Uint8Array);
+    init(): Promise<FsCrypt>;
+    private createFilenameMarker;
+    private hasCurrentMarker;
+    private stripCurrentMarker;
+    reversibleEncrypt(filename: string): Promise<string>;
+    reversibleDecrypt(encryptedName: string): Promise<string>;
+    encryptFilename(filename: string): Promise<string>;
+    decryptFilename(encryptedFilename: string): Promise<string>;
+    isEncrypted(filename: string): Promise<boolean>;
+}

package/dist/src/crypt/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 加密模块
+ * 提供文件名加密和文件流加密功能
+ * 支持部分加密：可以只加密文件的前面部分
+ */
+export { FsCrypt } from "./fs-crypt";
+export { FileEncryptor, type EncryptionAlgorithm, type PartialEncryptionConfig, normalizeEncryptionAlgorithm, } from "./file-encryptor";
+export { hexToUint8Array, arrayBufferToBase64Url, base64UrlToArrayBuffer, deriveKey, } from "./utils";
+export { DEFAULT_ENCRYPTION_SALT_HEX, CONTENT_ENCRYPTION_EXTENSION, normalizeEncryptionFeatureEnabled, isFilenameEncryptionEnabled, isContentEncryptionEnabled, addContentEncryptionSuffix, stripContentEncryptionSuffix, isContentEncryptedName, calculateEncryptedBytes, normalizeEncryptionSaltHex, normalizePartialEncryption, resolveEncryptionProfile, applyEncryptionQueryParams, parseEncryptionQueryParams, type EncryptionProfile, } from "./protocol";

package/dist/src/crypt/protocol.d.ts

@@ -0,0 +1,27 @@
+import { type EncryptionAlgorithm, type PartialEncryptionConfig } from "./file-encryptor";
+export declare const DEFAULT_ENCRYPTION_SALT_HEX = "66697865642d73616c742d656d652d636f7272656374";
+export declare const CONTENT_ENCRYPTION_EXTENSION = ".enc";
+export interface EncryptionProfile {
+    password: string;
+    saltHex: string;
+    salt: Uint8Array;
+    algorithm: EncryptionAlgorithm;
+    partialEncryption: PartialEncryptionConfig;
+}
+export declare function normalizeEncryptionFeatureEnabled(value: unknown, fallback?: boolean): boolean;
+export declare function isFilenameEncryptionEnabled(config?: Record<string, any>): boolean;
+export declare function isContentEncryptionEnabled(config?: Record<string, any>): boolean;
+export declare function normalizeEncryptionSaltHex(value?: string | null): string;
+export declare function normalizePartialEncryption(config?: PartialEncryptionConfig | null): PartialEncryptionConfig;
+export declare function calculateEncryptedBytes(totalSize: number, config?: PartialEncryptionConfig | null): number;
+export declare function resolveEncryptionProfile(input?: {
+    password?: string | null;
+    salt?: string | null;
+    algorithm?: string | null;
+    partialEncryption?: PartialEncryptionConfig | null;
+}): EncryptionProfile;
+export declare function isContentEncryptedName(name: string): boolean;
+export declare function addContentEncryptionSuffix(name: string): string;
+export declare function stripContentEncryptionSuffix(name: string): string;
+export declare function applyEncryptionQueryParams(url: URL, profile: Pick<EncryptionProfile, "algorithm" | "partialEncryption">): URL;
+export declare function parseEncryptionQueryParams(url: URL): Partial<Pick<EncryptionProfile, "algorithm" | "partialEncryption">> | null;

package/dist/src/crypt/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 工具函数
+ */
+export declare function hexToUint8Array(hexString: string): Uint8Array;
+export declare function arrayBufferToBase64Url(buffer: Uint8Array): string;
+export declare function base64UrlToArrayBuffer(base64Url: string): Uint8Array;
+export declare function deriveKey(password: string, salt: Uint8Array, keyLength?: number): Promise<Uint8Array>;

package/dist/src/crypt.d.ts

@@ -0,0 +1,2 @@
+export { FsCrypt, FileEncryptor, normalizeEncryptionAlgorithm, DEFAULT_ENCRYPTION_SALT_HEX, CONTENT_ENCRYPTION_EXTENSION, normalizeEncryptionFeatureEnabled, isFilenameEncryptionEnabled, isContentEncryptionEnabled, addContentEncryptionSuffix, stripContentEncryptionSuffix, isContentEncryptedName, calculateEncryptedBytes, normalizeEncryptionSaltHex, normalizePartialEncryption, resolveEncryptionProfile, applyEncryptionQueryParams, parseEncryptionQueryParams, hexToUint8Array, arrayBufferToBase64Url, base64UrlToArrayBuffer, deriveKey, } from "./crypt/index";
+export type { EncryptionAlgorithm, PartialEncryptionConfig, EncryptionProfile, } from "./crypt/index.ts";

package/dist/src/crypto-shim.d.ts

@@ -0,0 +1,2 @@
+declare let cryptoInstance: any;
+export default cryptoInstance;

package/dist/src/debug.d.ts

@@ -0,0 +1,9 @@
+import debug from "debug";
+export declare const createDebug: (namespace: string) => debug.Debugger;
+export declare const coreDebug: debug.Debugger;
+export declare const fsDebug: debug.Debugger;
+export declare const volumeDebug: debug.Debugger;
+export declare const pathDebug: debug.Debugger;
+export declare const cacheDebug: debug.Debugger;
+export declare const pluginDebug: debug.Debugger;
+export default debug;

package/dist/src/enums/index.d.ts

@@ -0,0 +1,8 @@
+export declare enum Mode {
+    "indirect" = 0,
+    "direct" = 1
+}
+export declare enum MatchMode {
+    Normal = "normal",
+    Strict = "strict"
+}

package/dist/src/error.d.ts

@@ -0,0 +1,6 @@
+declare const handleError: (type: string, data?: any) => {
+    type: string;
+    message: string;
+    data: any;
+};
+export default handleError;

package/dist/src/filter.d.ts

@@ -0,0 +1,12 @@
+import { MatchMode } from "./enums";
+interface Filter {
+    name: string | null;
+    size: string | null;
+    type: string | null;
+    mode: MatchMode;
+}
+export declare function filterList(data: any[], filter: Filter): {
+    filteredFiles: any[];
+    unfilteredFiles: any[];
+};
+export {};

package/dist/src/fs/http_fs.d.ts

@@ -0,0 +1,40 @@
+import FileSystem from ".";
+import Stat from "../stat";
+interface Folder {
+    id: string;
+    thumb: string;
+    name: string;
+    size: string;
+    created: string;
+    mtime: string;
+    ext: string;
+    fullPath: string;
+    type: string;
+    bytes: string;
+}
+declare class Http extends FileSystem<Folder> {
+    getRecursiveKey(target: Folder): string | number;
+    constructor(options: any);
+    get(_: any, path: string): Promise<{
+        name: string;
+        href: string;
+        mtime: string;
+        size: string;
+        type: string | false;
+    }>;
+    link(stat: Stat): Promise<{}>;
+    request(path: string): Promise<string>;
+    fetchList(path: string): Promise<Folder[]>;
+    parseHtml(ctx: any): Folder[];
+    getThumbnail(target: Folder): string;
+    getId(target: Folder): string;
+    getName(target: Folder): string;
+    getSize(target: Folder): string;
+    getBytes(target: Folder): string;
+    getCreated(target: Folder): string;
+    getCTime(target: Folder): string;
+    getMTime(target: Folder): string;
+    getExt(target: Folder): string;
+    isFile(target: Folder): boolean;
+}
+export default Http;

package/dist/src/fs/index.d.ts

@@ -0,0 +1,95 @@
+import Stat from "../stat";
+import { Cache } from "../cache";
+import { Mode } from "../enums";
+export interface FileSystemType<T> {
+    mkdir?: (stat: Stat, name: string) => Promise<any>;
+    remove?: (stat: Stat) => Promise<any>;
+    rename?: (stat: Stat, name: string) => Promise<any>;
+    copy?: (source: Stat, target: Stat) => Promise<any>;
+    move?: (source: Stat, target: Stat) => Promise<any>;
+    link?: (stat: Stat) => Promise<any>;
+    fetchList: (id: string | number) => Promise<any>;
+    search?: (data: any) => Promise<any>;
+    rapidupload?: (stat: Stat, file: any) => Promise<any>;
+    upload?: (stat: Stat, file: any) => Promise<any>;
+    share?: (stat: Stat, obj: any) => Promise<any>;
+    save?: (stat: Stat, obj: any) => Promise<any>;
+    getThumbnail?: (target: T) => string;
+    getRecursiveKey?: (target: T) => string | number;
+    getId: (target: T) => string | number;
+    getName: (target: T) => string;
+    getSize: (target: T) => string | number | null;
+    getATime?: (target: T) => string | number | null;
+    getCTime?: (target: T) => string | number;
+    getMTime: (target: T) => string | number;
+    getHash?: (target: T) => any;
+    getQuota?: (target: T) => any;
+    getExt: (target: T) => string;
+    isFile: (target: T) => boolean;
+    isEmpty?: (target: T) => boolean;
+}
+interface FSConfig {
+    cid?: string;
+    name: string;
+    provider: string;
+    ttl?: number;
+    userConfig?: any;
+    auth?: any;
+    rootPath: string;
+    cacheStrategy: any;
+}
+declare abstract class FileSystem<T> implements FileSystemType<T> {
+    private cid;
+    mode: Mode;
+    private name;
+    private provider;
+    private downExpireTime;
+    private userConfig;
+    workPath: string;
+    cache?: Cache;
+    root: any;
+    protected auth: any;
+    private duplicateList;
+    constructor(fsConfig: FSConfig);
+    private initCache;
+    private initProxy;
+    private parse;
+    private getCacheOrFetch;
+    private isRoot;
+    private resolvePath;
+    list(path: string, options: {
+        pagination: {
+            page: number;
+            pageSize: number;
+        };
+        sort: {
+            field: string;
+            order: string;
+        };
+    }): Promise<any>;
+    private getListByPath;
+    private getListByRecursive;
+    private unwrapListPayload;
+    formatList(resp: any[], workPath: string, path: string): any[];
+    format(data: any, workPath: string): Stat;
+    private findTarget;
+    hasMethod(method: string): boolean;
+    private getCacheKey;
+    private getRealPath;
+    abstract getName(data: T): string;
+    abstract getId(data: T): number | string;
+    abstract getThumbnail?(data: T): string;
+    abstract getSize(data: T): number | string | null;
+    abstract getCTime?(data: T): number | string;
+    abstract getMTime(data: T): number | string;
+    abstract getExt(data: T): string;
+    abstract isFile(data: T): boolean;
+    abstract fetchList(keyOrPath: string | number, options?: any): Promise<any>;
+    abstract getRecursiveKey(target: T): string | number;
+    getATime?(data: T): number | string;
+    getQuota?(data: T): any;
+    getHash?(data: T): any;
+    search?(data: any): Promise<any>;
+    [key: string]: any;
+}
+export default FileSystem;

package/dist/src/index.d.ts

@@ -0,0 +1,51 @@
+import { Emitter, EventType } from "mitt";
+import { Volume, ReadOnlyVolume } from "./volume";
+import Stat from "./stat";
+import Plugin from "./plugin";
+import { ICacheStrategy } from "./cache";
+export type EventCallback = (...args: any[]) => Promise<any> | any;
+interface FileBoxOptions {
+    events?: Record<string, EventCallback | EventCallback[]>;
+    plugins?: Array<any>;
+    cacheStrategy?: ICacheStrategy;
+}
+declare class FileBox {
+    options: FileBoxOptions;
+    emitter: Emitter<Record<EventType, any>>;
+    volumeMap: Map<string, any>;
+    fs: any;
+    static plugin: typeof Plugin;
+    cacheStrategy?: ICacheStrategy;
+    [key: string]: any;
+    constructor(options?: FileBoxOptions);
+    static use(module: any): typeof FileBox;
+    getProvider(provider: string): any;
+    mount(options: any): Promise<Volume & ReadOnlyVolume & any>;
+    mountRaw(options: any): void;
+    unmount(volume: any): Promise<void>;
+    /**
+     * 设置全局缓存策略
+     */
+    setCache(cacheStrategy: ICacheStrategy): void;
+    /**
+     * 获取全局缓存策略
+     */
+    getCache(): ICacheStrategy | undefined;
+    readFile(path: string): Promise<any>;
+    stat(path: string): Promise<any>;
+    list(path: string, options?: any): Promise<any>;
+    mkdir(path: string | Stat, options?: any): Promise<any>;
+    rename(path: string | Stat, newName: string): Promise<any>;
+    remove(path: string | Stat): Promise<any>;
+    upload(path: string, file: any, uploadProgress?: any): Promise<any>;
+    download(path: string, options?: any): Promise<any>;
+    copy(src: string, dest: string, options?: any): Promise<any>;
+    move(src: string, dest: string, options?: any): Promise<any>;
+    bulkRemove(options: any): Promise<any>;
+    _getProvider(path: string): {
+        fs: any;
+        driverPath: string;
+    };
+    getVolume(volume?: string, _options?: any): any;
+}
+export default FileBox;

package/dist/src/lock.d.ts

@@ -0,0 +1,9 @@
+import Stat from "./stat";
+export default class Lock {
+    private __lock;
+    constructor(lock?: string[]);
+    private _getPath;
+    lock(path: string | Stat): void;
+    unlock(path: string | Stat): void;
+    isLock(path: string | Stat): boolean;
+}

package/dist/src/path.d.ts

@@ -0,0 +1,65 @@
+import pathBrowserify from "path-browserify";
+export declare const basename: (this: void, path: string, ext?: string) => string, dirname: (this: void, path: string) => string, extname: (this: void, path: string) => string, format: (this: void, pathObject: Partial<pathBrowserify.PathObject>) => string, isAbsolute: (this: void, path: string) => boolean, join: (this: void, ...paths: string[]) => string, normalize: (this: void, path: string) => string, parse: (this: void, path: string) => pathBrowserify.PathObject, relative: (this: void, from: string, to: string) => string, resolve: (this: void, ...pathSegments: string[]) => string, sep: string, delimiter: string;
+/**
+ * 将路径分割为[目录, 最后一部分]
+ * @example
+ * reverseSplist('/foo/bar/baz') => ['/foo/bar', 'baz']
+ * reverseSplist('foo/bar') => ['foo', 'bar']
+ */
+export declare function reverseSplist(path: string): [string, string];
+/**
+ * 将路径转换为数组形式
+ * @example
+ * toArray('/foo/bar/baz') => ['foo', 'bar', 'baz']
+ */
+export declare function toArray(path: string, sep?: string): string[];
+/**
+ * 分割路径为[挂载点, 相对路径]
+ * @example
+ * split('/drive1/foo/bar') => ['drive1', '/foo/bar']
+ */
+export declare function split(path: string, options?: {
+    separator?: string;
+    normalizeFirst?: boolean;
+}): [string, string];
+/**
+ * 检查路径是否为根路径
+ */
+export declare function isRoot(path: string): boolean;
+/**
+ * 获取路径的上级目录和文件名
+ */
+export declare function getParentAndName(path: string): {
+    parent: string;
+    name: string;
+};
+/**
+ * 合并多个路径段
+ */
+export declare function joinPath(...paths: string[]): string;
+/**
+ * 规范化路径（简化别名）
+ */
+export declare function normalizePath(path: string): string;
+declare const _default: {
+    basename: (this: void, path: string, ext?: string) => string;
+    dirname: (this: void, path: string) => string;
+    extname: (this: void, path: string) => string;
+    format: (this: void, pathObject: Partial<pathBrowserify.PathObject>) => string;
+    isAbsolute: (this: void, path: string) => boolean;
+    join: (this: void, ...paths: string[]) => string;
+    normalize: (this: void, path: string) => string;
+    parse: (this: void, path: string) => pathBrowserify.PathObject;
+    relative: (this: void, from: string, to: string) => string;
+    resolve: (this: void, ...pathSegments: string[]) => string;
+    sep: string;
+    delimiter: string;
+    reverseSplist: typeof reverseSplist;
+    toArray: typeof toArray;
+    split: typeof split;
+    isRoot: typeof isRoot;
+    getParentAndName: typeof getParentAndName;
+    joinPath: typeof joinPath;
+    normalizePath: typeof normalizePath;
+};
+export default _default;

package/dist/src/plugin.d.ts

@@ -0,0 +1,16 @@
+declare class Plugin {
+    private static plugins;
+    constructor();
+    static get(name: string): any;
+    static has(name: string): boolean;
+    static list(): any[];
+    static values(): MapIterator<any>;
+    static keys(): MapIterator<string>;
+    static entries(): MapIterator<[string, any]>;
+    static get size(): number;
+    static install(plugin: any): void;
+    static uninstall(name: string): void;
+    onload(): void;
+    unload(): void;
+}
+export default Plugin;

package/dist/src/stat.d.ts

@@ -0,0 +1,64 @@
+declare const rawDataSymbol: unique symbol;
+export interface IStat {
+    id: string | number;
+    name: string;
+    size: any;
+    byte: number | null;
+    thumbnail: string | null;
+    atime?: string | null;
+    ctime?: string | null;
+    mtime: string | null;
+    type: string | null;
+    hash?: {
+        md5?: string;
+        sha1?: string;
+        sha256?: string;
+    };
+}
+export type StatConstructorParams = Omit<IStat, "rawData"> & {
+    rawData?: Record<string, any>;
+    parsePath: string;
+    rootPath: string;
+    mountPath: string;
+    provider: string;
+    duplicate?: number;
+    cid?: string | null;
+};
+declare class Stat implements IStat {
+    #private;
+    id: IStat["id"];
+    name: IStat["name"];
+    original_name: IStat["name"];
+    size: IStat["size"];
+    byte: IStat["byte"];
+    thumbnail: IStat["thumbnail"];
+    atime: IStat["atime"];
+    ctime: IStat["ctime"];
+    mtime: IStat["mtime"];
+    type: IStat["type"];
+    hash: IStat["hash"];
+    provider: string;
+    mountPath: string;
+    parent: string;
+    path: string;
+    relative: string;
+    is_duplicate: boolean;
+    duplicate_num: number;
+    duplicate_flag: string;
+    fid: number;
+    cid: string | null;
+    mime: string | boolean;
+    driver_name: string;
+    isStat: boolean;
+    basename: string;
+    [rawDataSymbol]: any;
+    constructor({ id, name, size, thumbnail, type, atime, ctime, mtime, rawData, provider, mountPath, parsePath, rootPath, hash, duplicate, cid, }: StatConstructorParams);
+    private formatDate;
+    private normalizePath;
+    getRawData(key?: string): any;
+    get file(): boolean;
+    get directory(): boolean;
+    get rootPath(): string;
+    get realPath(): string;
+}
+export default Stat;