@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/dns.js

@@ -0,0 +1,259 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+/**
+ * dns 模块。
+ *
+ * 实现的是 **lookup 一族**（getaddrinfo），也就是 99% 的代码真正用到的那部分：
+ *   lookup / lookupService / promises.lookup / promises.lookupService /
+ *   getServers / setServers / getDefaultResultOrder / setDefaultResultOrder / 常量。
+ *
+ * **resolve 一族（resolveMx / resolveTxt / resolve4 …）与 reverse 显式抛 ONJ_UNSUPPORTED**：
+ * 它们要做 DNS 记录级查询，需要 JNDI 的 DNS provider，而 com.sun.jndi.dns 不在 Android 里。
+ * 这不是"还没做"，是平台不成立 —— 所以给明确拒绝，不给半个实现。
+ *
+ * 与 Node 的差异（都在 BUILTINS.json 里）：
+ *   - 调用的**接口**是异步的（走 queueMicrotask），但底层 getaddrinfo 是同步的；
+ *   - getServers() 返回空数组：Android 的 DNS 由 netd 按网络管理，JVM 侧读不到；
+ *   - setServers() 抛 ONJ_UNSUPPORTED：无法重配 JVM 的解析器；
+ *   - hints 选项接受但不生效（Java 的 getAllByName 没有对应开关）；
+ *   - lookupService 的 service 用内置的常见端口表，未命中时给端口号字符串。
+ */
+const errors_1 = require("./lib/errors");
+const dnsDriver = __importStar(require("./lib/dns-driver"));
+const dnsPromises = require("./dns/promises");
+/** getaddrinfo 的错误码数值，与 libuv 对齐（Node 用同一套）。 */
+const GETADDRINFO_ERRNO = {
+    ENOTFOUND: -3008,
+    EAI_AGAIN: -3001,
+    EAI_FAIL: -3003,
+    EAI_NODATA: -3006,
+    EAI_NONAME: -3007,
+    ENODATA: -3006
+};
+/** 常见端口 -> 服务名。Node 的 lookupService 走 getnameinfo，这里用表代替。 */
+const SERVICE_NAMES = {
+    20: 'ftp-data', 21: 'ftp', 22: 'ssh', 23: 'telnet', 25: 'smtp', 53: 'domain',
+    80: 'http', 110: 'pop3', 143: 'imap', 443: 'https', 465: 'smtps', 587: 'submission',
+    993: 'imaps', 995: 'pop3s', 3306: 'mysql', 5432: 'postgresql', 6379: 'redis',
+    8080: 'http-alt', 8443: 'https-alt'
+};
+let resultOrder = 'verbatim';
+function dnsFailure(code, hostname) {
+    const error = new Error('getaddrinfo ' + code + ' ' + hostname);
+    error.code = code;
+    error.errno = GETADDRINFO_ERRNO[code] === undefined ? -3008 : GETADDRINFO_ERRNO[code];
+    error.syscall = 'getaddrinfo';
+    error.hostname = hostname;
+    return error;
+}
+function codeForFailure(failure) {
+    const mapped = failure;
+    if (mapped.code === 'ENOTFOUND' || mapped.code === 'EAI_AGAIN') {
+        return mapped.code;
+    }
+    const message = mapped.message === undefined ? '' : mapped.message;
+    if (/temporary failure in name resolution|unable to resolve host/i.test(message)) {
+        return 'EAI_AGAIN';
+    }
+    return 'ENOTFOUND';
+}
+function serviceNameOf(port) {
+    const known = SERVICE_NAMES[port];
+    return known === undefined ? String(port) : known;
+}
+function normalizeOptions(options) {
+    let family = 0;
+    let all = false;
+    let verbatim = resultOrder === 'verbatim';
+    if (typeof options === 'number') {
+        family = options;
+    }
+    else if (options !== undefined && options !== null) {
+        if (typeof options.family === 'number') {
+            family = options.family;
+        }
+        all = options.all === true;
+        if (typeof options.verbatim === 'boolean') {
+            verbatim = options.verbatim;
+        }
+    }
+    return { family: family, all: all, verbatim: verbatim };
+}
+function lookup(hostname, options, callback) {
+    let opts = options;
+    let done = callback;
+    if (typeof options === 'function') {
+        done = options;
+        opts = undefined;
+    }
+    if (typeof done !== 'function') {
+        throw new TypeError('The "callback" argument must be of type function');
+    }
+    const host = String(hostname);
+    const settings = normalizeOptions(opts);
+    queueMicrotask(function () {
+        let records;
+        try {
+            records = dnsDriver.getDriver().lookup(host);
+        }
+        catch (failure) {
+            done(dnsFailure(codeForFailure(failure), host));
+            return;
+        }
+        let filtered = records;
+        if (settings.family === 4 || settings.family === 6) {
+            filtered = records.filter(function (record) { return record.family === settings.family; });
+        }
+        if (!settings.verbatim) {
+            filtered = filtered.slice().sort(function (left, right) { return left.family - right.family; });
+        }
+        if (filtered.length === 0) {
+            done(dnsFailure('ENOTFOUND', host));
+            return;
+        }
+        if (settings.all) {
+            done(null, filtered);
+            return;
+        }
+        done(null, filtered[0].address, filtered[0].family);
+    });
+}
+function lookupService(address, port, callback) {
+    if (typeof callback !== 'function') {
+        throw new TypeError('The "callback" argument must be of type function');
+    }
+    const target = String(address);
+    const numericPort = Number(port);
+    queueMicrotask(function () {
+        let hostname;
+        try {
+            hostname = dnsDriver.getDriver().canonicalNameOf(target);
+        }
+        catch (failure) {
+            callback(dnsFailure(codeForFailure(failure), target));
+            return;
+        }
+        callback(null, hostname, serviceNameOf(numericPort));
+    });
+}
+/** Node 在 Android 这样的平台上读不到解析器配置，这里如实返回空数组。 */
+function getServers() {
+    return [];
+}
+function setServers() {
+    throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'dns.setServers() 无法实现：JVM 的解析器配置改不了（Android 由 netd 按网络管理）。');
+}
+function getDefaultResultOrder() {
+    return resultOrder;
+}
+function setDefaultResultOrder(order) {
+    const value = String(order);
+    if (value !== 'verbatim' && value !== 'ipv4first' && value !== 'ipv6first') {
+        throw new TypeError('Invalid result order: ' + value);
+    }
+    resultOrder = value;
+}
+function unsupportedResolve(name) {
+    return function () {
+        throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'dns.' + name + '() 需要 DNS 记录级查询，而这要 JNDI 的 DNS provider —— ' +
+            'com.sun.jndi.dns 不在 Android 里，所以这个能力在本平台不成立。' +
+            '需要解析主机名请用 dns.lookup()（getaddrinfo）。');
+    };
+}
+function Resolver() {
+    throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'dns.Resolver 需要可配置的 DNS 记录级查询，Android 上不成立（同 dns.resolve*）。');
+}
+/**
+ * getaddrinfo 的 hints 与错误码字符串。
+ *
+ * hints 的数值取 Node 自己的（ADDRCONFIG 1024 / V4MAPPED 2048 / ALL 256），
+ * 不是 libuv 的原始值 —— Node 在 lib/dns.js 里重映射过，对齐它才有意义。
+ * Java 的 getAllByName 没有对应开关，所以这几个只作为取值存在，传了不生效。
+ */
+const constants = {
+    ADDRCONFIG: 1024,
+    V4MAPPED: 2048,
+    ALL: 256,
+    NODATA: 'ENODATA',
+    FORMERR: 'EFORMERR',
+    SERVFAIL: 'ESERVFAIL',
+    NOTFOUND: 'ENOTFOUND',
+    NOTIMP: 'ENOTIMP',
+    REFUSED: 'EREFUSED',
+    BADQUERY: 'EBADQUERY',
+    BADNAME: 'EBADNAME',
+    BADFAMILY: 'EBADFAMILY',
+    BADRESP: 'EBADRESP',
+    CONNREFUSED: 'ECONNREFUSED',
+    TIMEOUT: 'ETIMEOUT',
+    EOF: 'EOF',
+    FILE: 'EFILE',
+    NOMEM: 'ENOMEM',
+    DESTRUCTION: 'EDESTRUCTION',
+    BADSTR: 'EBADSTR',
+    BADFLAGS: 'EBADFLAGS',
+    NONAME: 'ENONAME',
+    BADHINTS: 'EBADHINTS',
+    NOTINITIALIZED: 'ENOTINITIALIZED',
+    LOADIPHLPAPI: 'ELOADIPHLPAPI',
+    ADDRGETNETWORKPARAMS: 'EADDRGETNETWORKPARAMS',
+    CANCELLED: 'ECANCELLED'
+};
+const api = Object.assign({
+    lookup: lookup,
+    lookupService: lookupService,
+    resolve: unsupportedResolve('resolve'),
+    resolve4: unsupportedResolve('resolve4'),
+    resolve6: unsupportedResolve('resolve6'),
+    resolveAny: unsupportedResolve('resolveAny'),
+    resolveCaa: unsupportedResolve('resolveCaa'),
+    resolveCname: unsupportedResolve('resolveCname'),
+    resolveMx: unsupportedResolve('resolveMx'),
+    resolveNaptr: unsupportedResolve('resolveNaptr'),
+    resolveNs: unsupportedResolve('resolveNs'),
+    resolvePtr: unsupportedResolve('resolvePtr'),
+    resolveSoa: unsupportedResolve('resolveSoa'),
+    resolveSrv: unsupportedResolve('resolveSrv'),
+    resolveTlsa: unsupportedResolve('resolveTlsa'),
+    resolveTxt: unsupportedResolve('resolveTxt'),
+    reverse: unsupportedResolve('reverse'),
+    getServers: getServers,
+    setServers: setServers,
+    getDefaultResultOrder: getDefaultResultOrder,
+    setDefaultResultOrder: setDefaultResultOrder,
+    Resolver: Resolver,
+    promises: dnsPromises
+}, constants);
+module.exports = api;

package/dist/events.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Node events 模块的移植（EventEmitter）。
+ *
+ * 与 Node 的差异（有意为之）：
+ *   - 本实现是 ES class，不能用 `EventEmitter.call(this)` 这种函数式继承；
+ *     现代代码一律走 `class X extends EventEmitter`，不受影响。
+ *   - `captureRejections` 与 `events.on()`（异步迭代器）未实现。
+ */
+type EventListener = (...args: unknown[]) => void;
+type EventName = string | symbol;
+declare class EventEmitter {
+    static defaultMaxListeners: number;
+    static errorMonitor: symbol;
+    static EventEmitter: typeof EventEmitter;
+    static listenerCount(emitter: EventEmitter, name: EventName): number;
+    static getEventListeners(emitter: EventEmitter, name: EventName): EventListener[];
+    static once(emitter: EventEmitter, name: EventName): Promise<unknown[]>;
+    static on(emitter: EventEmitter, name: EventName): void;
+    constructor();
+    get maxListeners(): number;
+    set maxListeners(value: number);
+    setMaxListeners(count: number): this;
+    getMaxListeners(): number;
+    on(name: EventName, listener: EventListener): this;
+    addListener(name: EventName, listener: EventListener): this;
+    prependListener(name: EventName, listener: EventListener): this;
+    once(name: EventName, listener: EventListener): this;
+    prependOnceListener(name: EventName, listener: EventListener): this;
+    /** 内部注册入口。Node 的 EventEmitter 没有它，但 Process 只以实例导出，成员必须是 public。 */
+    addEntry(name: EventName, listener: EventListener, once: boolean, prepend?: boolean): this;
+    emit(name: EventName, ...args: unknown[]): boolean;
+    removeListener(name: EventName, listener: EventListener): this;
+    off(name: EventName, listener: EventListener): this;
+    removeAllListeners(name?: EventName): this;
+    listeners(name: EventName): EventListener[];
+    rawListeners(name: EventName): EventListener[];
+    listenerCount(name: EventName): number;
+    eventNames(): EventName[];
+}
+export = EventEmitter;

package/dist/events.js

@@ -0,0 +1,237 @@
+'use strict';
+const registry = new WeakMap();
+/** Node 用它旁听 error 事件而不消费它。 */
+const errorMonitor = Symbol.for('nodejs.errorMonitor');
+function stateOf(emitter) {
+    let current = registry.get(emitter);
+    if (current === undefined) {
+        current = { events: new Map(), maxListeners: 0 };
+        registry.set(emitter, current);
+    }
+    return current;
+}
+function listenersOf(emitter, name, create) {
+    const state = stateOf(emitter);
+    let list = state.events.get(name);
+    if (list === undefined && create) {
+        list = [];
+        state.events.set(name, list);
+    }
+    return list;
+}
+function unwrap(entry) {
+    const fn = entry.fn;
+    return entry.once && typeof fn.listener === 'function' ? fn.listener : entry.fn;
+}
+function indexFromEnd(list, fn) {
+    for (let i = list.length - 1; i >= 0; i -= 1) {
+        if (unwrap(list[i]) === fn || list[i].fn === fn) {
+            return i;
+        }
+    }
+    return -1;
+}
+class EventEmitter {
+    static listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+    }
+    static getEventListeners(emitter, name) {
+        return emitter.listeners(name);
+    }
+    static once(emitter, name) {
+        return new Promise(function (resolve, reject) {
+            function onEvent(...args) {
+                emitter.removeListener(name, onError);
+                resolve(args);
+            }
+            function onError(error) {
+                emitter.removeListener(name, onEvent);
+                reject(error);
+            }
+            emitter.once(name, onEvent);
+            if (name !== 'error') {
+                emitter.once('error', onError);
+            }
+        });
+    }
+    static on(emitter, name) {
+        void emitter;
+        void name;
+        throw new Error('node.operit 尚未实现 events.on()（异步迭代器）。');
+    }
+    constructor() {
+        stateOf(this);
+    }
+    get maxListeners() {
+        const current = stateOf(this).maxListeners;
+        return current === 0 ? EventEmitter.defaultMaxListeners : current;
+    }
+    set maxListeners(value) {
+        this.setMaxListeners(value);
+    }
+    setMaxListeners(count) {
+        const normalized = Number(count);
+        if (normalized < 0 || !isFinite(normalized)) {
+            throw new RangeError('The value of "n" is out of range. It must be a non-negative number.');
+        }
+        stateOf(this).maxListeners = Math.floor(normalized);
+        return this;
+    }
+    getMaxListeners() {
+        return this.maxListeners;
+    }
+    on(name, listener) {
+        return this.addEntry(name, listener, false);
+    }
+    addListener(name, listener) {
+        return this.addEntry(name, listener, false);
+    }
+    prependListener(name, listener) {
+        return this.addEntry(name, listener, false, true);
+    }
+    once(name, listener) {
+        return this.addEntry(name, listener, true);
+    }
+    prependOnceListener(name, listener) {
+        return this.addEntry(name, listener, true, true);
+    }
+    /** 内部注册入口。Node 的 EventEmitter 没有它，但 Process 只以实例导出，成员必须是 public。 */
+    addEntry(name, listener, once, prepend = false) {
+        if (typeof listener !== 'function') {
+            throw new TypeError('The "listener" argument must be of type function.');
+        }
+        const list = listenersOf(this, name, true);
+        if (list === undefined) {
+            return this;
+        }
+        const emitter = this;
+        let stored;
+        if (once) {
+            // once 的包装器自己摘除自己（与 Node 一致：emit 不做预先移除），
+            // 并在 .listener 上保留原函数，供 listeners() / rawListeners() 区分。
+            const wrapped = function (...args) {
+                removeEntry(emitter, name, wrapped);
+                listener.apply(emitter, args);
+            };
+            wrapped.listener = listener;
+            stored = { fn: wrapped, once: true };
+        }
+        else {
+            stored = { fn: listener, once: false };
+        }
+        if (prepend) {
+            list.unshift(stored);
+        }
+        else {
+            list.push(stored);
+        }
+        return this;
+    }
+    emit(name, ...args) {
+        const list = listenersOf(this, name, false);
+        const monitor = name === 'error' ? listenersOf(this, errorMonitor, false) : undefined;
+        if ((list === undefined || list.length === 0) && (monitor === undefined || monitor.length === 0)) {
+            if (name === 'error') {
+                const first = args[0];
+                if (first instanceof Error) {
+                    throw first;
+                }
+                const error = new Error('Unhandled error.' + (first === undefined ? '' : ' (' + String(first) + ')'));
+                error.context = first;
+                throw error;
+            }
+            return false;
+        }
+        if (monitor !== undefined) {
+            for (let i = 0; i < monitor.length; i += 1) {
+                monitor[i].fn.apply(this, args);
+            }
+        }
+        if (list === undefined || list.length === 0) {
+            return false;
+        }
+        const snapshot = list.slice();
+        for (let i = 0; i < snapshot.length; i += 1) {
+            const entry = snapshot[i];
+            if (entry.once && indexOfEntry(list, entry.fn) < 0) {
+                continue;
+            }
+            entry.fn.apply(this, args);
+        }
+        return true;
+    }
+    removeListener(name, listener) {
+        return this.off(name, listener);
+    }
+    off(name, listener) {
+        const list = listenersOf(this, name, false);
+        if (list === undefined) {
+            return this;
+        }
+        const index = indexFromEnd(list, listener);
+        if (index >= 0) {
+            list.splice(index, 1);
+            if (list.length === 0) {
+                stateOf(this).events.delete(name);
+            }
+        }
+        return this;
+    }
+    removeAllListeners(name) {
+        const state = stateOf(this);
+        if (name === undefined) {
+            state.events.clear();
+            return this;
+        }
+        state.events.delete(name);
+        return this;
+    }
+    listeners(name) {
+        const list = listenersOf(this, name, false);
+        if (list === undefined) {
+            return [];
+        }
+        return list.map(unwrap);
+    }
+    rawListeners(name) {
+        const list = listenersOf(this, name, false);
+        if (list === undefined) {
+            return [];
+        }
+        return list.map(function (entry) {
+            return entry.fn;
+        });
+    }
+    listenerCount(name) {
+        const list = listenersOf(this, name, false);
+        return list === undefined ? 0 : list.length;
+    }
+    eventNames() {
+        return Array.from(stateOf(this).events.keys());
+    }
+}
+EventEmitter.defaultMaxListeners = 10;
+EventEmitter.errorMonitor = errorMonitor;
+EventEmitter.EventEmitter = EventEmitter;
+function indexOfEntry(list, fn) {
+    for (let i = 0; i < list.length; i += 1) {
+        if (list[i].fn === fn) {
+            return i;
+        }
+    }
+    return -1;
+}
+function removeEntry(emitter, name, fn) {
+    const list = listenersOf(emitter, name, false);
+    if (list === undefined) {
+        return;
+    }
+    const index = indexOfEntry(list, fn);
+    if (index >= 0) {
+        list.splice(index, 1);
+        if (list.length === 0) {
+            stateOf(emitter).events.delete(name);
+        }
+    }
+}
+module.exports = EventEmitter;

package/dist/fs/promises.d.ts

@@ -0,0 +1,159 @@
+import { Buffer } from '../buffer';
+declare class FileHandle {
+    readonly fd: number;
+    closed: boolean;
+    constructor(fd: number);
+    private ensureOpen;
+    /** Node 的 FileHandle.read 返回 { bytesRead, buffer }，不是裸数字。 */
+    read(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{
+        bytesRead: number;
+        buffer: Uint8Array;
+    }>;
+    /** 同理，write 返回 { bytesWritten, buffer }，buffer 是调用方传入的原始数据。 */
+    write(data: unknown, ...rest: unknown[]): Promise<{
+        bytesWritten: number;
+        buffer: unknown;
+    }>;
+    readFile(options?: unknown): Promise<string | Uint8Array>;
+    writeFile(data: unknown, options?: unknown): Promise<void>;
+    appendFile(data: unknown, options?: unknown): Promise<void>;
+    stat(): Promise<unknown>;
+    truncate(length?: number): Promise<void>;
+    sync(): Promise<void>;
+    datasync(): Promise<void>;
+    close(): Promise<void>;
+}
+declare function open(path: unknown, flags?: unknown, mode?: unknown): Promise<FileHandle>;
+declare const api: {
+    open: typeof open;
+    readFile: (target: unknown, options?: unknown) => Promise<string | Buffer>;
+    writeFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+    appendFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+    stat: (target: unknown, options?: unknown) => Promise<{
+        readonly sizeValue: number;
+        readonly modeValue: number;
+        readonly atimeMsValue: number;
+        readonly mtimeMsValue: number;
+        readonly ctimeMsValue: number;
+        readonly birthtimeMsValue: number;
+        readonly fileLike: boolean;
+        readonly directoryLike: boolean;
+        readonly linkLike: boolean;
+        get size(): number;
+        get mode(): number;
+        get atimeMs(): number;
+        get mtimeMs(): number;
+        get ctimeMs(): number;
+        get birthtimeMs(): number;
+        get atime(): Date;
+        get mtime(): Date;
+        get ctime(): Date;
+        get birthtime(): Date;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+    } | undefined>;
+    lstat: (target: unknown, options?: unknown) => Promise<{
+        readonly sizeValue: number;
+        readonly modeValue: number;
+        readonly atimeMsValue: number;
+        readonly mtimeMsValue: number;
+        readonly ctimeMsValue: number;
+        readonly birthtimeMsValue: number;
+        readonly fileLike: boolean;
+        readonly directoryLike: boolean;
+        readonly linkLike: boolean;
+        get size(): number;
+        get mode(): number;
+        get atimeMs(): number;
+        get mtimeMs(): number;
+        get ctimeMs(): number;
+        get birthtimeMs(): number;
+        get atime(): Date;
+        get mtime(): Date;
+        get ctime(): Date;
+        get birthtime(): Date;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+    } | undefined>;
+    readdir: (target: unknown, options?: unknown) => Promise<string[] | {
+        readonly name: string;
+        readonly kind: number;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+    }[]>;
+    mkdir: (target: unknown, options?: unknown) => Promise<string | undefined>;
+    rm: (target: unknown, options?: unknown) => Promise<void>;
+    unlink: (target: unknown) => Promise<void>;
+    rmdir: (target: unknown, options?: unknown) => Promise<void>;
+    rename: (from: unknown, to: unknown) => Promise<void>;
+    copyFile: (from: unknown, to: unknown) => Promise<void>;
+    realpath: (target: unknown) => Promise<string>;
+    readlink: (target: unknown) => Promise<string>;
+    symlink: (target: unknown, linkPath: unknown) => Promise<void>;
+    chmod: (target: unknown, mode: unknown) => Promise<void>;
+    truncate: (target: unknown, length?: unknown) => Promise<void>;
+    utimes: (target: unknown, atime: unknown, mtime: unknown) => Promise<void>;
+    access: (target: unknown) => Promise<void>;
+    mkdtemp: (prefix: unknown) => Promise<string>;
+    constants: {
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+        COPYFILE_EXCL: number;
+        COPYFILE_FICLONE: number;
+        COPYFILE_FICLONE_FORCE: number;
+        UV_FS_COPYFILE_EXCL: number;
+        UV_FS_COPYFILE_FICLONE: number;
+        UV_FS_COPYFILE_FICLONE_FORCE: number;
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_RDWR: number;
+        O_CREAT: number;
+        O_EXCL: number;
+        O_TRUNC: number;
+        O_APPEND: number;
+        UV_FS_O_FILEMAP: number;
+        UV_FS_SYMLINK_DIR: number;
+        UV_FS_SYMLINK_JUNCTION: number;
+        UV_DIRENT_UNKNOWN: number;
+        UV_DIRENT_FILE: number;
+        UV_DIRENT_DIR: number;
+        UV_DIRENT_LINK: number;
+        UV_DIRENT_FIFO: number;
+        UV_DIRENT_SOCKET: number;
+        UV_DIRENT_CHAR: number;
+        UV_DIRENT_BLOCK: number;
+        S_IFMT: number;
+        S_IFREG: number;
+        S_IFDIR: number;
+        S_IFCHR: number;
+        S_IFIFO: number;
+        S_IFLNK: number;
+        S_IRUSR: number;
+        S_IWUSR: number;
+        S_IXUSR: number;
+        S_IRGRP: number;
+        S_IWGRP: number;
+        S_IXGRP: number;
+        S_IROTH: number;
+        S_IWOTH: number;
+        S_IXOTH: number;
+    };
+};
+export = api;