/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import { createReadStream, createWriteStream, Dirent, Stats } from "fs";
import { Readable } from "stream";
import { FileSystem, WalkOptions } from "./fileSystem";
import { Pattern } from "./matcher";
/** 表示一个内存模拟的文件系统 */
export declare class MemoryFileSystem extends FileSystem {
    /** 判断当前文件系统是否是物理文件系统 */
    get native(): boolean;
    /** 判断当前文件系统是否忽略大小写 */
    readonly isCaseInsensitive = false;
    /**
     * 获取原始数据，键是绝对路径，值有三种类型：
     * - 字符串：表示文本文件内容
     * - 缓存对象：表示二进制文件数据
     * - null：表示一个文件夹
     */
    readonly data: Map<string, string | Buffer>;
    /**
     * 创建一个 IO 错误
     * @param syscall 系统调用
     * @param code 错误码
     * @param errno 错误代码
     * @param path 发送错误的路径
     * @param message 错误的信息
     */
    protected createError(syscall: string, code: string, errno: number, path: string, message: string): NodeJS.ErrnoException;
    /**
     * 获取文件或文件夹的属性
     * @param path 要获取的路径
     * @param resolveLink 如果是软链接，是否解析链接引用的路径属性
     */
    getStat(path: string, resolveLink?: boolean): Promise<Stats>;
    /**
     * 判断指定的路径是否存在
     * @param path 要判断的路径
     * @returns 如果路径不存在，则返回 `false`，否则返回 `true`
     */
    exists(path: string): Promise<boolean>;
    /**
     * 判断指定的文件是否存在
     * @param path 要判断的路径
     * @returns 如果文件不存在或路径不是一个文件，则返回 `false`，否则返回 `true`
     */
    existsFile(path: string): Promise<boolean>;
    /**
     * 判断指定的文件夹是否存在
     * @param path 要判断的路径
     * @returns 如果文件夹不存在或路径不是一个文件，则返回 `false`，否则返回 `true`
     */
    existsDir(path: string): Promise<boolean>;
    /**
     * 如果指定的路径不存在则直接返回，否则返回重命名后的新路径
     * @param path 要测试的文件或文件夹路径
     * @param append 如果路径已存在则添加的文件名后缀，其中的数字会递增直到文件不存在
     */
    ensureNotExists(path: string, append?: string): Promise<string>;
    /**
     * 创建一个文件夹
     * @param path 要创建的文件夹路径
     */
    createDir(path: string): Promise<void>;
    /**
     * 创建一个临时文件夹
     * @param parent 临时文件夹的根目录
     * @returns 返回已创建文件夹路径
     */
    createTempDir(parent?: string): Promise<string>;
    /**
     * 删除指定的文件夹
     * @param path 要删除的文件夹路径
     * @param recursive 是否删除所有所有子文件夹和文件，如果为 `false` 则只删除空文件夹
     * @returns 返回删除的文件数
     */
    deleteDir(path: string, recursive?: boolean): Promise<number>;
    /**
     * 清空指定的文件夹
     * @param path 要清空的文件夹路径
     * @returns 返回删除的文件数
     */
    cleanDir(path: string): Promise<number>;
    /**
     * 如果路径所在的文件夹是空的则删除所在文件夹
     * @param path 文件夹内的文件路径
     * @returns 返回已删除的文件夹数，如果文件夹不空，返回 `0`
     */
    deleteParentDirIfEmpty(path: string): Promise<number>;
    /**
     * 删除指定的文件或软链接
     * @param path 要删除的文件路径
     * @returns 如果删除成功则返回 `true`，否则说明文件不存在，返回 `false`
     */
    deleteFile(path: string): Promise<boolean>;
    /**
     * 深度遍历指定的路径并执行回调
     * @param path 要遍历的文件或文件夹路径
     * @param options 遍历的选项
     */
    walk(path: string, options: WalkOptions): Promise<void>;
    /**
     * 获取文件夹内的所有文件和文件夹组成的数组
     * @param path 要读取的文件夹路径
     * @param withFileTypes 是否包含文件类型信息
     */
    readDir(path: string, withFileTypes: true): Promise<Dirent[]>;
    /**
     * 获取文件夹内的所有文件和文件夹组成的数组
     * @param path 要读取的文件夹路径
     * @param withFileTypes 是否包含文件类型信息
     */
    readDir(path: string, withFileTypes?: boolean): Promise<string[]>;
    /**
     * 读取指定文件的二进制内容
     * @param path 要读取的文件路径
     */
    readFile(path: string): Promise<Buffer>;
    /**
     * 读取指定文件的文本内容
     * @param path 要读取的文件路径
     * @param encoding 文件的编码
     */
    readFile(path: string, encoding: BufferEncoding): Promise<string>;
    /**
     * 将内容写入指定的文件
     * @param path 要写入的文件路径
     * @param data 要写入的文件数据
     * @param overwrite 是否允许覆盖现有的目标
     * @returns 如果写入成功则返回 `true`，否则说明目标已存在，返回 `false`
     */
    writeFile(path: string, data: string | Buffer, overwrite?: boolean): Promise<boolean>;
    /**
     * 在指定文件末尾追加内容
     * @param path 要创建的文件路径
     * @param data 要写入的文件数据
     */
    appendFile(path: string, data: string | Buffer): Promise<void>;
    /**
     * 创建一个软链接
     * @param path 要创建的文件路径
     * @param target 要链接的目标路径
     * @param overwrite 是否覆盖已有的目标
     * @returns 如果创建成功则返回 `true`，否则说明目标已存在，返回 `false`
     */
    createLink(path: string, target: string, overwrite?: boolean): Promise<boolean>;
    /**
     * 读取软链接的实际地址
     * @param path 要读取的软链接路径
     */
    readLink(path: string): Promise<string>;
    /**
     * 创建一个用于读取指定文件的流
     * @param path 要读取的文件路径
     * @param options 附加选项
     */
    createReadStream(path: string, options?: Parameters<typeof createReadStream>[1]): {
        readonly path: string;
        readonly data?: string | Buffer | null;
        readonly bytesRead: number;
        readonly pending: boolean;
        _read(size: number): void;
        close(): void;
        readonly readableAborted: boolean;
        readable: boolean;
        readonly readableDidRead: boolean;
        readonly readableEncoding: BufferEncoding;
        readonly readableEnded: boolean;
        readonly readableFlowing: boolean;
        readonly readableHighWaterMark: number;
        readonly readableLength: number;
        readonly readableObjectMode: boolean;
        destroyed: boolean;
        _construct?(callback: (error?: Error) => void): void;
        read(size?: number): any;
        setEncoding(encoding: BufferEncoding): any;
        pause(): any;
        resume(): any;
        isPaused(): boolean;
        unpipe(destination?: NodeJS.WritableStream): any;
        unshift(chunk: any, encoding?: BufferEncoding): void;
        wrap(stream: NodeJS.ReadableStream): any;
        push(chunk: any, encoding?: BufferEncoding): boolean;
        _destroy(error: Error, callback: (error?: Error) => void): void;
        destroy(error?: Error): any;
        addListener(event: "close", listener: () => void): any;
        addListener(event: "data", listener: (chunk: any) => void): any;
        addListener(event: "end", listener: () => void): any;
        addListener(event: "error", listener: (err: Error) => void): any;
        addListener(event: "pause", listener: () => void): any;
        addListener(event: "readable", listener: () => void): any;
        addListener(event: "resume", listener: () => void): any;
        addListener(event: string | symbol, listener: (...args: any[]) => void): any;
        emit(event: "close"): boolean;
        emit(event: "data", chunk: any): boolean;
        emit(event: "end"): boolean;
        emit(event: "error", err: Error): boolean;
        emit(event: "pause"): boolean;
        emit(event: "readable"): boolean;
        emit(event: "resume"): boolean;
        emit(event: string | symbol, ...args: any[]): boolean;
        on(event: "close", listener: () => void): any;
        on(event: "data", listener: (chunk: any) => void): any;
        on(event: "end", listener: () => void): any;
        on(event: "error", listener: (err: Error) => void): any;
        on(event: "pause", listener: () => void): any;
        on(event: "readable", listener: () => void): any;
        on(event: "resume", listener: () => void): any;
        on(event: string | symbol, listener: (...args: any[]) => void): any;
        once(event: "close", listener: () => void): any;
        once(event: "data", listener: (chunk: any) => void): any;
        once(event: "end", listener: () => void): any;
        once(event: "error", listener: (err: Error) => void): any;
        once(event: "pause", listener: () => void): any;
        once(event: "readable", listener: () => void): any;
        once(event: "resume", listener: () => void): any;
        once(event: string | symbol, listener: (...args: any[]) => void): any;
        prependListener(event: "close", listener: () => void): any;
        prependListener(event: "data", listener: (chunk: any) => void): any;
        prependListener(event: "end", listener: () => void): any;
        prependListener(event: "error", listener: (err: Error) => void): any;
        prependListener(event: "pause", listener: () => void): any;
        prependListener(event: "readable", listener: () => void): any;
        prependListener(event: "resume", listener: () => void): any;
        prependListener(event: string | symbol, listener: (...args: any[]) => void): any;
        prependOnceListener(event: "close", listener: () => void): any;
        prependOnceListener(event: "data", listener: (chunk: any) => void): any;
        prependOnceListener(event: "end", listener: () => void): any;
        prependOnceListener(event: "error", listener: (err: Error) => void): any;
        prependOnceListener(event: "pause", listener: () => void): any;
        prependOnceListener(event: "readable", listener: () => void): any;
        prependOnceListener(event: "resume", listener: () => void): any;
        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): any;
        removeListener(event: "close", listener: () => void): any;
        removeListener(event: "data", listener: (chunk: any) => void): any;
        removeListener(event: "end", listener: () => void): any;
        removeListener(event: "error", listener: (err: Error) => void): any;
        removeListener(event: "pause", listener: () => void): any;
        removeListener(event: "readable", listener: () => void): any;
        removeListener(event: "resume", listener: () => void): any;
        removeListener(event: string | symbol, listener: (...args: any[]) => void): any;
        [Symbol.asyncIterator](): AsyncIterableIterator<any>;
        pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
            end?: boolean;
        }): T;
        off(eventName: string | symbol, listener: (...args: any[]) => void): any;
        removeAllListeners(event?: string | symbol): any;
        setMaxListeners(n: number): any;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        listenerCount(eventName: string | symbol): number;
        eventNames(): (string | symbol)[];
    };
    /**
     * 创建一个用于写入指定文件的流
     * @param path 要读取的文件路径
     * @param options 附加选项
     */
    createWriteStream(path: string, options?: Parameters<typeof createWriteStream>[1]): {
        readonly path: string;
        bytesWritten: number;
        error?: Error;
        readonly pending: boolean;
        _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): Promise<void>;
        _final(callback: (error?: Error | null) => void): void;
        close(): any;
        readonly writable: boolean;
        readonly writableEnded: boolean;
        readonly writableFinished: boolean;
        readonly writableHighWaterMark: number;
        readonly writableLength: number;
        readonly writableObjectMode: boolean;
        readonly writableCorked: number;
        destroyed: boolean;
        _writev?(chunks: {
            chunk: any;
            encoding: BufferEncoding;
        }[], callback: (error?: Error) => void): void;
        _construct?(callback: (error?: Error) => void): void;
        _destroy(error: Error, callback: (error?: Error) => void): void;
        write(chunk: any, callback?: (error: Error) => void): boolean;
        write(chunk: any, encoding: BufferEncoding, callback?: (error: Error) => void): boolean;
        setDefaultEncoding(encoding: BufferEncoding): any;
        end(cb?: () => void): any;
        end(chunk: any, cb?: () => void): any;
        end(chunk: any, encoding: BufferEncoding, cb?: () => void): any;
        cork(): void;
        uncork(): void;
        destroy(error?: Error): any;
        addListener(event: "close", listener: () => void): any;
        addListener(event: "drain", listener: () => void): any;
        addListener(event: "error", listener: (err: Error) => void): any;
        addListener(event: "finish", listener: () => void): any;
        addListener(event: "pipe", listener: (src: Readable) => void): any;
        addListener(event: "unpipe", listener: (src: Readable) => void): any;
        addListener(event: string | symbol, listener: (...args: any[]) => void): any;
        emit(event: "close"): boolean;
        emit(event: "drain"): boolean;
        emit(event: "error", err: Error): boolean;
        emit(event: "finish"): boolean;
        emit(event: "pipe", src: Readable): boolean;
        emit(event: "unpipe", src: Readable): boolean;
        emit(event: string | symbol, ...args: any[]): boolean;
        on(event: "close", listener: () => void): any;
        on(event: "drain", listener: () => void): any;
        on(event: "error", listener: (err: Error) => void): any;
        on(event: "finish", listener: () => void): any;
        on(event: "pipe", listener: (src: Readable) => void): any;
        on(event: "unpipe", listener: (src: Readable) => void): any;
        on(event: string | symbol, listener: (...args: any[]) => void): any;
        once(event: "close", listener: () => void): any;
        once(event: "drain", listener: () => void): any;
        once(event: "error", listener: (err: Error) => void): any;
        once(event: "finish", listener: () => void): any;
        once(event: "pipe", listener: (src: Readable) => void): any;
        once(event: "unpipe", listener: (src: Readable) => void): any;
        once(event: string | symbol, listener: (...args: any[]) => void): any;
        prependListener(event: "close", listener: () => void): any;
        prependListener(event: "drain", listener: () => void): any;
        prependListener(event: "error", listener: (err: Error) => void): any;
        prependListener(event: "finish", listener: () => void): any;
        prependListener(event: "pipe", listener: (src: Readable) => void): any;
        prependListener(event: "unpipe", listener: (src: Readable) => void): any;
        prependListener(event: string | symbol, listener: (...args: any[]) => void): any;
        prependOnceListener(event: "close", listener: () => void): any;
        prependOnceListener(event: "drain", listener: () => void): any;
        prependOnceListener(event: "error", listener: (err: Error) => void): any;
        prependOnceListener(event: "finish", listener: () => void): any;
        prependOnceListener(event: "pipe", listener: (src: Readable) => void): any;
        prependOnceListener(event: "unpipe", listener: (src: Readable) => void): any;
        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): any;
        removeListener(event: "close", listener: () => void): any;
        removeListener(event: "drain", listener: () => void): any;
        removeListener(event: "error", listener: (err: Error) => void): any;
        removeListener(event: "finish", listener: () => void): any;
        removeListener(event: "pipe", listener: (src: Readable) => void): any;
        removeListener(event: "unpipe", listener: (src: Readable) => void): any;
        removeListener(event: string | symbol, listener: (...args: any[]) => void): any;
        pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
            end?: boolean;
        }): T;
        off(eventName: string | symbol, listener: (...args: any[]) => void): any;
        removeAllListeners(event?: string | symbol): any;
        setMaxListeners(n: number): any;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        listenerCount(eventName: string | symbol): number;
        eventNames(): (string | symbol)[];
    };
    /**
     * 复制指定的文件夹
     * @param src 要复制的源路径
     * @param dest 要复制的目标路径
     * @param overwrite 是否覆盖已有的目标
     * @param preserveLinks 是否保留链接
     * @param ignore 忽略的通配符
     * @returns 返回已复制的文件数
     */
    copyDir(src: string, dest: string, overwrite?: boolean, preserveLinks?: boolean, ignore?: Pattern): Promise<number>;
    /**
     * 复制指定的文件
     * @param src 要复制的源路径
     * @param dest 要复制的目标路径
     * @param overwrite 是否覆盖已有的目标
     * @returns 如果复制成功则返回 `true`，否则说明目标已存在，返回 `false`
     */
    copyFile(src: string, dest: string, overwrite?: boolean): Promise<boolean>;
    /**
     * 移动指定的文件夹
     * @param src 要移动的源路径
     * @param dest 要移动的目标路径
     * @param overwrite 是否允许覆盖现有的目标
     * @param preserveLinks 是否保留链接
     * @returns 返回已移动的文件数
     */
    moveDir(src: string, dest: string, overwrite?: boolean, preserveLinks?: boolean): Promise<number>;
    /**
     * 移动指定的文件
     * @param src 要移动的源路径
     * @param dest 要移动的目标路径
     * @param overwrite 是否允许覆盖现有的目标
     * @returns 如果移动成功则返回 `true`，否则说明目标已存在，返回 `false`
     */
    moveFile(src: string, dest: string, overwrite?: boolean): Promise<boolean>;
    /**
     * 获取指定路径区分大小写的实际路径，如果地址不存在则返回 `null`
     * @param path 原路径
     */
    getRealPath(path: string): Promise<string>;
}