alemonjs 2.1.18 → 2.1.20

package/lib/cbp/core/connection-manager.js

@@ -1,67 +0,0 @@
-import { WebSocket } from 'ws';
-
-const createConnectionState = () => ({
-    connections: new Map(),
-    lastActivity: new Map(),
-    metadata: new Map()
-});
-const addConnection = (state, id, ws, metadata) => {
-    const newState = {
-        connections: new Map(state.connections),
-        lastActivity: new Map(state.lastActivity),
-        metadata: new Map(state.metadata)
-    };
-    newState.connections.set(id, ws);
-    newState.lastActivity.set(id, Date.now());
-    if (metadata) {
-        newState.metadata.set(id, metadata);
-    }
-    return newState;
-};
-const removeConnection = (state, id) => {
-    const newState = {
-        connections: new Map(state.connections),
-        lastActivity: new Map(state.lastActivity),
-        metadata: new Map(state.metadata)
-    };
-    const ws = newState.connections.get(id);
-    if (ws && ws.readyState === WebSocket.OPEN) {
-        ws.close();
-    }
-    newState.connections.delete(id);
-    newState.lastActivity.delete(id);
-    newState.metadata.delete(id);
-    return newState;
-};
-const getConnection = (state, id) => {
-    return state.connections.get(id);
-};
-const getHealthyConnectionIds = (state) => {
-    const healthyIds = [];
-    for (const [id, ws] of state.connections.entries()) {
-        if (ws.readyState === WebSocket.OPEN) {
-            healthyIds.push(id);
-        }
-    }
-    return healthyIds;
-};
-const getConnectionStats = (state) => {
-    const total = state.connections.size;
-    const healthy = getHealthyConnectionIds(state).length;
-    return {
-        total,
-        healthy,
-        unhealthy: total - healthy,
-        lastUpdate: Date.now()
-    };
-};
-const clearAllConnections = (state) => {
-    for (const ws of state.connections.values()) {
-        if (ws.readyState === WebSocket.OPEN) {
-            ws.close();
-        }
-    }
-    return createConnectionState();
-};
-
-export { addConnection, clearAllConnections, createConnectionState, getConnection, getConnectionStats, getHealthyConnectionIds, removeConnection };

package/lib/cbp/core/constants.d.ts

@@ -1,19 +0,0 @@
-export declare const USER_AGENT_HEADER = "user-agent";
-export declare const DEVICE_ID_HEADER = "x-device-id";
-export declare const FULL_RECEIVE_HEADER = "x-full-receive";
-export declare const USER_AGENT_HEADER_VALUE_MAP: {
-    readonly platform: "platform";
-    readonly client: "client";
-    readonly testone: "testone";
-};
-export declare const TIME_CONFIG: {
-    readonly TIMEOUT: number;
-    readonly RECONNECT_INTERVAL: number;
-    readonly HEARTBEAT_INTERVAL: number;
-};
-export declare const HEALTH_CHECK_CONFIG: {
-    readonly INTERVAL: 30000;
-    readonly MAX_CONSECUTIVE_FAILURES: 3;
-    readonly PING_TIMEOUT: 5000;
-};
-export declare const generateUniqueId: () => string;

package/lib/cbp/core/constants.js

@@ -1,23 +0,0 @@
-const USER_AGENT_HEADER = 'user-agent';
-const DEVICE_ID_HEADER = 'x-device-id';
-const FULL_RECEIVE_HEADER = 'x-full-receive';
-const USER_AGENT_HEADER_VALUE_MAP = {
-    platform: 'platform',
-    client: 'client',
-    testone: 'testone'
-};
-const TIME_CONFIG = {
-    TIMEOUT: 1000 * 60 * 3,
-    RECONNECT_INTERVAL: 1000 * 6,
-    HEARTBEAT_INTERVAL: 1000 * 18
-};
-const HEALTH_CHECK_CONFIG = {
-    INTERVAL: 30000,
-    MAX_CONSECUTIVE_FAILURES: 3,
-    PING_TIMEOUT: 5000
-};
-const generateUniqueId = () => {
-    return Date.now().toString(36) + Math.random().toString(36).substring(2);
-};
-
-export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEALTH_CHECK_CONFIG, TIME_CONFIG, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, generateUniqueId };

package/lib/cbp/core/load-balancer.d.ts

@@ -1,37 +0,0 @@
-import { ConnectionState } from './connection-manager';
-export type LoadBalanceStrategy = 'round-robin' | 'least-connections' | 'random' | 'first-available';
-export declare const LoadBalanceStrategyEnum: {
-    readonly ROUND_ROBIN: "round-robin";
-    readonly LEAST_CONNECTIONS: "least-connections";
-    readonly RANDOM: "random";
-    readonly FIRST_AVAILABLE: "first-available";
-};
-export interface LoadBalancerState {
-    strategy: LoadBalanceStrategy;
-    roundRobinIndex: number;
-    bindingCounts: Map<string, number>;
-}
-export declare const createLoadBalancerState: (strategy?: LoadBalanceStrategy) => LoadBalancerState;
-export declare const selectByRoundRobin: (availableIds: string[], currentIndex: number) => {
-    selectedId: string | null;
-    nextIndex: number;
-};
-export declare const selectByLeastConnections: (availableIds: string[], bindingCounts: Map<string, number>) => string | null;
-export declare const selectByRandom: (availableIds: string[]) => string | null;
-export declare const selectFirstAvailable: (availableIds: string[]) => string | null;
-export declare const selectConnection: (connectionState: ConnectionState, balancerState: LoadBalancerState) => {
-    selectedId: string | null;
-    newBalancerState: LoadBalancerState;
-};
-export declare const incrementBindingCount: (balancerState: LoadBalancerState, connectionId: string) => LoadBalancerState;
-export declare const decrementBindingCount: (balancerState: LoadBalancerState, connectionId: string) => LoadBalancerState;
-export declare const getLoadBalancerStats: (balancerState: LoadBalancerState) => {
-    strategy: LoadBalanceStrategy;
-    roundRobinIndex: number;
-    totalConnections: number;
-    totalBindings: number;
-    bindingCounts: {
-        [k: string]: number;
-    };
-    lastUpdate: number;
-};

package/lib/cbp/core/load-balancer.js

@@ -1,118 +0,0 @@
-import { getHealthyConnectionIds } from './connection-manager.js';
-
-const LoadBalanceStrategyEnum = {
-    ROUND_ROBIN: 'round-robin',
-    LEAST_CONNECTIONS: 'least-connections',
-    RANDOM: 'random',
-    FIRST_AVAILABLE: 'first-available'
-};
-const createLoadBalancerState = (strategy = 'round-robin') => ({
-    strategy,
-    roundRobinIndex: 0,
-    bindingCounts: new Map()
-});
-const selectByRoundRobin = (availableIds, currentIndex) => {
-    if (availableIds.length === 0) {
-        return { selectedId: null, nextIndex: currentIndex };
-    }
-    const selectedId = availableIds[currentIndex % availableIds.length];
-    const nextIndex = (currentIndex + 1) % availableIds.length;
-    return { selectedId, nextIndex };
-};
-const selectByLeastConnections = (availableIds, bindingCounts) => {
-    if (availableIds.length === 0) {
-        return null;
-    }
-    let selectedId = availableIds[0];
-    let minConnections = bindingCounts.get(selectedId) || 0;
-    for (let i = 1; i < availableIds.length; i++) {
-        const id = availableIds[i];
-        const connections = bindingCounts.get(id) || 0;
-        if (connections < minConnections) {
-            minConnections = connections;
-            selectedId = id;
-        }
-    }
-    return selectedId;
-};
-const selectByRandom = (availableIds) => {
-    if (availableIds.length === 0) {
-        return null;
-    }
-    const randomIndex = Math.floor(Math.random() * availableIds.length);
-    return availableIds[randomIndex];
-};
-const selectFirstAvailable = (availableIds) => {
-    return availableIds.length > 0 ? availableIds[0] : null;
-};
-const selectConnection = (connectionState, balancerState) => {
-    const availableIds = getHealthyConnectionIds(connectionState);
-    if (availableIds.length === 0) {
-        return { selectedId: null, newBalancerState: balancerState };
-    }
-    let selectedId = null;
-    const newBalancerState = { ...balancerState };
-    switch (balancerState.strategy) {
-        case 'round-robin': {
-            const result = selectByRoundRobin(availableIds, balancerState.roundRobinIndex);
-            selectedId = result.selectedId;
-            newBalancerState.roundRobinIndex = result.nextIndex;
-            break;
-        }
-        case 'least-connections': {
-            selectedId = selectByLeastConnections(availableIds, balancerState.bindingCounts);
-            break;
-        }
-        case 'random': {
-            selectedId = selectByRandom(availableIds);
-            break;
-        }
-        case 'first-available': {
-            selectedId = selectFirstAvailable(availableIds);
-            break;
-        }
-        default: {
-            const result = selectByRoundRobin(availableIds, balancerState.roundRobinIndex);
-            selectedId = result.selectedId;
-            newBalancerState.roundRobinIndex = result.nextIndex;
-            break;
-        }
-    }
-    return { selectedId, newBalancerState };
-};
-const incrementBindingCount = (balancerState, connectionId) => {
-    const newBindingCounts = new Map(balancerState.bindingCounts);
-    const currentCount = newBindingCounts.get(connectionId) || 0;
-    newBindingCounts.set(connectionId, currentCount + 1);
-    return {
-        ...balancerState,
-        bindingCounts: newBindingCounts
-    };
-};
-const decrementBindingCount = (balancerState, connectionId) => {
-    const newBindingCounts = new Map(balancerState.bindingCounts);
-    const currentCount = newBindingCounts.get(connectionId) || 0;
-    if (currentCount > 0) {
-        newBindingCounts.set(connectionId, currentCount - 1);
-    }
-    else {
-        newBindingCounts.delete(connectionId);
-    }
-    return {
-        ...balancerState,
-        bindingCounts: newBindingCounts
-    };
-};
-const getLoadBalancerStats = (balancerState) => {
-    const totalBindings = Array.from(balancerState.bindingCounts.values()).reduce((sum, count) => sum + count, 0);
-    return {
-        strategy: balancerState.strategy,
-        roundRobinIndex: balancerState.roundRobinIndex,
-        totalConnections: balancerState.bindingCounts.size,
-        totalBindings,
-        bindingCounts: Object.fromEntries(balancerState.bindingCounts),
-        lastUpdate: Date.now()
-    };
-};
-
-export { LoadBalanceStrategyEnum, createLoadBalancerState, decrementBindingCount, getLoadBalancerStats, incrementBindingCount, selectByLeastConnections, selectByRandom, selectByRoundRobin, selectConnection, selectFirstAvailable };

package/lib/cbp/processor/heandle.d.ts

@@ -1,3 +0,0 @@
-import { Result } from '../../core';
-import type { Apis } from '../../types';
-export declare const sendAPI: (data: Apis) => Promise<Result[]>;

package/lib/cbp/processor/heandle.js

@@ -1,32 +0,0 @@
-import { ResultCode } from '../../core/variable.js';
-import 'fs';
-import 'path';
-import 'yaml';
-import { createResult } from '../../core/utils.js';
-import { generateUniqueId, deviceId, apiResolves, apiTimeouts, timeoutTime } from './config.js';
-import * as flattedJSON from 'flatted';
-
-const sendAPI = (data) => {
-    const ApiId = generateUniqueId();
-    return new Promise(resolve => {
-        if (!global.chatbotClient?.send) {
-            resolve([createResult(ResultCode.Fail, 'Chatbot client is not available', null)]);
-            return;
-        }
-        data.apiId = ApiId;
-        data.DeviceId = deviceId;
-        global.chatbotClient?.send(flattedJSON.stringify(data));
-        apiResolves.set(ApiId, resolve);
-        const timeout = setTimeout(() => {
-            if (!apiResolves.has(ApiId) || !apiTimeouts.has(ApiId)) {
-                return;
-            }
-            apiResolves.delete(ApiId);
-            apiTimeouts.delete(ApiId);
-            resolve([createResult(ResultCode.Fail, '接口超时', null)]);
-        }, timeoutTime);
-        apiTimeouts.set(ApiId, timeout);
-    });
-};
-
-export { sendAPI };

package/lib/cbp/processor/request-handler.d.ts

@@ -1,17 +0,0 @@
-import { Result } from '../../core';
-type ResolversValue = (value: Result[]) => void;
-export interface RequestHandlerState {
-    resolvers: Map<string, ResolversValue>;
-    timeouts: Map<string, NodeJS.Timeout>;
-    requestType: string;
-    idField: 'actionId' | 'apiId';
-}
-export declare const createRequestHandlerState: (requestType: string, idField: "actionId" | "apiId") => RequestHandlerState;
-export declare const sendRequest: <T>(state: RequestHandlerState, data: T & {
-    DeviceId?: string;
-}) => Promise<Result[]>;
-export declare const handleRequestResponse: (state: RequestHandlerState, requestId: string, results: Result[]) => void;
-export declare const handleRequestTimeout: (state: RequestHandlerState, requestId: string) => void;
-export declare const getPendingRequestCount: (state: RequestHandlerState) => number;
-export declare const destroyRequestHandler: (state: RequestHandlerState) => void;
-export {};

package/lib/cbp/processor/request-handler.js

@@ -1,65 +0,0 @@
-import * as flattedJSON from 'flatted';
-import { ResultCode } from '../../core/variable.js';
-import 'fs';
-import 'path';
-import 'yaml';
-import { createResult } from '../../core/utils.js';
-import { deviceId, timeoutTime } from './config.js';
-import { generateUniqueId } from '../core/constants.js';
-
-const createRequestHandlerState = (requestType, idField) => ({
-    resolvers: new Map(),
-    timeouts: new Map(),
-    requestType,
-    idField
-});
-const sendRequest = (state, data) => {
-    const requestId = generateUniqueId();
-    return new Promise(resolve => {
-        data[state.idField] = requestId;
-        data.DeviceId = deviceId;
-        global.chatbotClient.send(flattedJSON.stringify(data));
-        state.resolvers.set(requestId, resolve);
-        const timeout = setTimeout(() => {
-            handleRequestTimeout(state, requestId);
-        }, timeoutTime);
-        state.timeouts.set(requestId, timeout);
-    });
-};
-const handleRequestResponse = (state, requestId, results) => {
-    const resolver = state.resolvers.get(requestId);
-    const timeout = state.timeouts.get(requestId);
-    if (resolver) {
-        state.resolvers.delete(requestId);
-        if (timeout) {
-            clearTimeout(timeout);
-            state.timeouts.delete(requestId);
-        }
-        resolver(results);
-    }
-};
-const handleRequestTimeout = (state, requestId) => {
-    const resolver = state.resolvers.get(requestId);
-    if (resolver) {
-        state.resolvers.delete(requestId);
-        state.timeouts.delete(requestId);
-        const timeoutResult = createResult(ResultCode.Fail, `${state.requestType}请求超时`, null);
-        resolver([timeoutResult]);
-    }
-};
-const getPendingRequestCount = (state) => {
-    return state.resolvers.size;
-};
-const destroyRequestHandler = (state) => {
-    for (const timeout of state.timeouts.values()) {
-        clearTimeout(timeout);
-    }
-    for (const [_requestId, resolver] of state.resolvers.entries()) {
-        const cancelResult = createResult(ResultCode.FailInternal, `${state.requestType}请求已取消`, null);
-        resolver([cancelResult]);
-    }
-    state.resolvers.clear();
-    state.timeouts.clear();
-};
-
-export { createRequestHandlerState, destroyRequestHandler, getPendingRequestCount, handleRequestResponse, handleRequestTimeout, sendRequest };

package/lib/polyfills/fs-promises.d.ts

@@ -1,41 +0,0 @@
-export declare const readFile: (path: string, encoding?: string) => Promise<Buffer>;
-export declare const writeFile: (path: string, data: any) => Promise<void>;
-export declare const readdir: (path: string) => Promise<string[]>;
-export declare const mkdir: (path: string, options?: any) => Promise<void>;
-export declare const stat: (path: string) => Promise<any>;
-export declare const unlink: (path: string) => Promise<void>;
-export declare const rmdir: (path: string, options?: any) => Promise<void>;
-export declare const rename: (oldPath: string, newPath: string) => Promise<void>;
-export declare const copyFile: (src: string, dest: string, flags?: number) => Promise<void>;
-export declare const appendFile: (path: string, data: string, options?: any) => Promise<void>;
-export declare const access: (path: string, mode?: number) => Promise<void>;
-export declare const readlink: (path: string) => Promise<string>;
-export declare const symlink: (target: string, path: string, type?: string) => Promise<void>;
-export declare const lstat: (path: string) => Promise<any>;
-export declare const chmod: (path: string, mode: number) => Promise<void>;
-export declare const chown: (path: string, uid: number, gid: number) => Promise<void>;
-export declare const realpath: (path: string) => Promise<string>;
-export declare const mkdtemp: (prefix: string) => Promise<string>;
-export declare const opendir: (path: string) => Promise<any>;
-declare const _default: {
-    readFile: (path: string, encoding?: string) => Promise<Buffer>;
-    writeFile: (path: string, data: any) => Promise<void>;
-    readdir: (path: string) => Promise<string[]>;
-    mkdir: (path: string, options?: any) => Promise<void>;
-    stat: (path: string) => Promise<any>;
-    unlink: (path: string) => Promise<void>;
-    rmdir: (path: string, options?: any) => Promise<void>;
-    rename: (oldPath: string, newPath: string) => Promise<void>;
-    copyFile: (src: string, dest: string, flags?: number) => Promise<void>;
-    appendFile: (path: string, data: string, options?: any) => Promise<void>;
-    access: (path: string, mode?: number) => Promise<void>;
-    readlink: (path: string) => Promise<string>;
-    symlink: (target: string, path: string, type?: string) => Promise<void>;
-    lstat: (path: string) => Promise<any>;
-    chmod: (path: string, mode: number) => Promise<void>;
-    chown: (path: string, uid: number, gid: number) => Promise<void>;
-    realpath: (path: string) => Promise<string>;
-    mkdtemp: (prefix: string) => Promise<string>;
-    opendir: (path: string) => Promise<any>;
-};
-export default _default;

package/lib/polyfills/fs-promises.js

@@ -1,138 +0,0 @@
-const readFile = async (path, encoding) => {
-    console.warn(`[AlemonJS Browser] fs/promises.readFile('${path}') is not available in browser, returning empty buffer`);
-    return Buffer.from('');
-};
-const writeFile = async (path, data) => {
-    console.warn(`[AlemonJS Browser] fs/promises.writeFile('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const readdir = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.readdir('${path}') is not available in browser, returning empty array`);
-    return Promise.resolve([]);
-};
-const mkdir = async (path, options) => {
-    console.warn(`[AlemonJS Browser] fs/promises.mkdir('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const stat = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.stat('${path}') is not available in browser, returning mock stats`);
-    return Promise.resolve({
-        isDirectory: () => false,
-        isFile: () => false,
-        isBlockDevice: () => false,
-        isCharacterDevice: () => false,
-        isSymbolicLink: () => false,
-        isFIFO: () => false,
-        isSocket: () => false,
-        dev: 0,
-        ino: 0,
-        mode: 0,
-        nlink: 0,
-        uid: 0,
-        gid: 0,
-        rdev: 0,
-        size: 0,
-        blksize: 0,
-        blocks: 0,
-        atimeMs: 0,
-        mtimeMs: 0,
-        ctimeMs: 0,
-        birthtimeMs: 0,
-        atime: new Date(),
-        mtime: new Date(),
-        ctime: new Date(),
-        birthtime: new Date()
-    });
-};
-const unlink = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.unlink('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const rmdir = async (path, options) => {
-    console.warn(`[AlemonJS Browser] fs/promises.rmdir('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const rename = async (oldPath, newPath) => {
-    console.warn(`[AlemonJS Browser] fs/promises.rename('${oldPath}', '${newPath}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const copyFile = async (src, dest, flags) => {
-    console.warn(`[AlemonJS Browser] fs/promises.copyFile('${src}', '${dest}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const appendFile = async (path, data, options) => {
-    console.warn(`[AlemonJS Browser] fs/promises.appendFile('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const access = async (path, mode) => {
-    console.warn(`[AlemonJS Browser] fs/promises.access('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const readlink = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.readlink('${path}') is not available in browser, returning empty string`);
-    return Promise.resolve('');
-};
-const symlink = async (target, path, type) => {
-    console.warn(`[AlemonJS Browser] fs/promises.symlink('${target}', '${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const lstat = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.lstat('${path}') is not available in browser, returning mock stats`);
-    return stat(path);
-};
-const chmod = async (path, mode) => {
-    console.warn(`[AlemonJS Browser] fs/promises.chmod('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const chown = async (path, uid, gid) => {
-    console.warn(`[AlemonJS Browser] fs/promises.chown('${path}') is not available in browser, operation skipped`);
-    return Promise.resolve();
-};
-const realpath = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.realpath('${path}') is not available in browser, returning empty string`);
-    return Promise.resolve('');
-};
-const mkdtemp = async (prefix) => {
-    console.warn(`[AlemonJS Browser] fs/promises.mkdtemp('${prefix}') is not available in browser, returning mock path`);
-    return Promise.resolve(`/tmp/${prefix}${Math.random().toString(36).substr(2, 9)}`);
-};
-const opendir = async (path) => {
-    console.warn(`[AlemonJS Browser] fs/promises.opendir('${path}') is not available in browser, returning mock dir`);
-    const mockDir = {
-        [Symbol.asyncIterator]: () => {
-            return {
-                next: () => Promise.resolve({ done: true, value: null })
-            };
-        },
-        close: async () => {
-            console.warn('[AlemonJS Browser] Mock dir close() called');
-        },
-        path: path,
-        read: async () => null,
-        readSync: () => null
-    };
-    return Promise.resolve(mockDir);
-};
-var fsPromises = {
-    readFile,
-    writeFile,
-    readdir,
-    mkdir,
-    stat,
-    unlink,
-    rmdir,
-    rename,
-    copyFile,
-    appendFile,
-    access,
-    readlink,
-    symlink,
-    lstat,
-    chmod,
-    chown,
-    realpath,
-    mkdtemp,
-    opendir
-};
-
-export { access, appendFile, chmod, chown, copyFile, fsPromises as default, lstat, mkdir, mkdtemp, opendir, readFile, readdir, readlink, realpath, rename, rmdir, stat, symlink, unlink, writeFile };

package/lib/polyfills/fs.d.ts

@@ -1,103 +0,0 @@
-export declare const existsSync: (path: string) => boolean;
-export declare const readFileSync: (path: string, encoding?: string) => string;
-export declare const writeFileSync: (path: string, data: string) => void;
-export declare const mkdirSync: (path: string, options?: any) => void;
-export declare const watch: (path: string, options?: any) => any;
-export declare const readdirSync: (path: string) => string[];
-export declare const statSync: (path: string) => any;
-export declare const unlinkSync: (path: string) => void;
-export declare const rmdirSync: (path: string, options?: any) => void;
-export declare const renameSync: (oldPath: string, newPath: string) => void;
-export declare const copyFileSync: (src: string, dest: string, flags?: number) => void;
-export declare const appendFileSync: (path: string, data: string, options?: any) => void;
-export declare const writeFile: (path: string, data: string, callback?: (err: any) => void) => void;
-export declare const readFile: (path: string, encoding: string, callback?: (err: any, data: string) => void) => void;
-export declare const mkdir: (path: string, options: any, callback?: (err: any) => void) => void;
-export declare const unlink: (path: string, callback?: (err: any) => void) => void;
-export declare const rmdir: (path: string, callback?: (err: any) => void) => void;
-export declare const rename: (oldPath: string, newPath: string, callback?: (err: any) => void) => void;
-export declare const promises: {
-    writeFile: (path: string, data: string) => Promise<void>;
-    readFile: (path: string, encoding?: string) => Promise<string>;
-    mkdir: (path: string, options?: any) => Promise<void>;
-    readdir: (path: string) => Promise<string[]>;
-    stat: (path: string) => Promise<any>;
-    unlink: (path: string) => Promise<void>;
-    rmdir: (path: string) => Promise<void>;
-};
-export declare const createReadStream: (path: string, options?: any) => any;
-export declare const createWriteStream: (path: string, options?: any) => any;
-export declare const constants: {
-    F_OK: number;
-    R_OK: number;
-    W_OK: number;
-    X_OK: number;
-    O_RDONLY: number;
-    O_WRONLY: number;
-    O_RDWR: number;
-    O_CREAT: number;
-    O_EXCL: number;
-    O_NOCTTY: number;
-    O_TRUNC: number;
-    O_APPEND: number;
-    O_DIRECTORY: number;
-    O_NOATIME: number;
-    O_NOFOLLOW: number;
-    O_SYNC: number;
-    O_DSYNC: number;
-    O_DIRECT: number;
-    O_NONBLOCK: number;
-};
-declare const _default: {
-    existsSync: (path: string) => boolean;
-    readFileSync: (path: string, encoding?: string) => string;
-    writeFileSync: (path: string, data: string) => void;
-    mkdirSync: (path: string, options?: any) => void;
-    watch: (path: string, options?: any) => any;
-    readdirSync: (path: string) => string[];
-    statSync: (path: string) => any;
-    unlinkSync: (path: string) => void;
-    rmdirSync: (path: string, options?: any) => void;
-    renameSync: (oldPath: string, newPath: string) => void;
-    copyFileSync: (src: string, dest: string, flags?: number) => void;
-    appendFileSync: (path: string, data: string, options?: any) => void;
-    writeFile: (path: string, data: string, callback?: (err: any) => void) => void;
-    readFile: (path: string, encoding: string, callback?: (err: any, data: string) => void) => void;
-    mkdir: (path: string, options: any, callback?: (err: any) => void) => void;
-    unlink: (path: string, callback?: (err: any) => void) => void;
-    rmdir: (path: string, callback?: (err: any) => void) => void;
-    rename: (oldPath: string, newPath: string, callback?: (err: any) => void) => void;
-    promises: {
-        writeFile: (path: string, data: string) => Promise<void>;
-        readFile: (path: string, encoding?: string) => Promise<string>;
-        mkdir: (path: string, options?: any) => Promise<void>;
-        readdir: (path: string) => Promise<string[]>;
-        stat: (path: string) => Promise<any>;
-        unlink: (path: string) => Promise<void>;
-        rmdir: (path: string) => Promise<void>;
-    };
-    createReadStream: (path: string, options?: any) => any;
-    createWriteStream: (path: string, options?: any) => any;
-    constants: {
-        F_OK: number;
-        R_OK: number;
-        W_OK: number;
-        X_OK: number;
-        O_RDONLY: number;
-        O_WRONLY: number;
-        O_RDWR: number;
-        O_CREAT: number;
-        O_EXCL: number;
-        O_NOCTTY: number;
-        O_TRUNC: number;
-        O_APPEND: number;
-        O_DIRECTORY: number;
-        O_NOATIME: number;
-        O_NOFOLLOW: number;
-        O_SYNC: number;
-        O_DSYNC: number;
-        O_DIRECT: number;
-        O_NONBLOCK: number;
-    };
-};
-export default _default;