@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/module.d.ts

@@ -0,0 +1,187 @@
+declare module "node:module" {
+    import { URL } from "node:url";
+    class Module {
+        constructor(id: string, parent?: Module);
+    }
+    interface Module extends NodeJS.Module {
+    }
+    namespace Module {
+        export { Module };
+    }
+    namespace Module {
+        const builtinModules: readonly string[];
+        function createRequire(path: string | URL): NodeJS.Require;
+        namespace constants {
+            namespace compileCacheStatus {
+                const ENABLED: number;
+                const ALREADY_ENABLED: number;
+                const FAILED: number;
+                const DISABLED: number;
+            }
+        }
+        interface EnableCompileCacheOptions {
+            directory?: string | undefined;
+            portable?: boolean | undefined;
+        }
+        interface EnableCompileCacheResult {
+            status: number;
+            message?: string;
+            directory?: string;
+        }
+        function enableCompileCache(options?: string | EnableCompileCacheOptions): EnableCompileCacheResult;
+        function flushCompileCache(): void;
+        function getCompileCacheDir(): string | undefined;
+        function findPackageJSON(specifier: string | URL, base?: string | URL): string | undefined;
+        function isBuiltin(moduleName: string): boolean;
+        interface RegisterOptions<Data> {
+            parentURL?: string | URL | undefined;
+            data?: Data | undefined;
+            transferList?: any[] | undefined;
+        }
+        function register<Data = any>(specifier: string | URL, parentURL?: string | URL, options?: RegisterOptions<Data>): void;
+        function register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
+        interface RegisterHooksOptions {
+            load?: LoadHookSync | undefined;
+            resolve?: ResolveHookSync | undefined;
+        }
+        interface ModuleHooks {
+            deregister(): void;
+        }
+        function registerHooks(options: RegisterHooksOptions): ModuleHooks;
+        interface StripTypeScriptTypesOptions {
+            mode?: "strip" | "transform" | undefined;
+            sourceMap?: boolean | undefined;
+            sourceUrl?: string | undefined;
+        }
+        function stripTypeScriptTypes(code: string, options?: StripTypeScriptTypesOptions): string;
+        function syncBuiltinESMExports(): void;
+        interface ImportAttributes extends NodeJS.Dict<string> {
+            type?: string | undefined;
+        }
+        type ImportPhase = "source" | "evaluation";
+        type ModuleFormat = "addon" | "builtin" | "commonjs" | "commonjs-typescript" | "json" | "module" | "module-typescript" | "wasm";
+        type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
+        type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
+        interface ResolveHookContext {
+            conditions: string[];
+            importAttributes: ImportAttributes;
+            parentURL: string | undefined;
+        }
+        interface ResolveFnOutput {
+            format?: string | null | undefined;
+            importAttributes?: ImportAttributes | undefined;
+            shortCircuit?: boolean | undefined;
+            url: string;
+        }
+        type ResolveHook = (specifier: string, context: ResolveHookContext, nextResolve: (specifier: string, context?: Partial<ResolveHookContext>) => ResolveFnOutput | Promise<ResolveFnOutput>) => ResolveFnOutput | Promise<ResolveFnOutput>;
+        type ResolveHookSync = (specifier: string, context: ResolveHookContext, nextResolve: (specifier: string, context?: Partial<ResolveHookContext>) => ResolveFnOutput) => ResolveFnOutput;
+        interface LoadHookContext {
+            conditions: string[];
+            format: string | null | undefined;
+            importAttributes: ImportAttributes;
+        }
+        interface LoadFnOutput {
+            format: string | null | undefined;
+            shortCircuit?: boolean | undefined;
+            source?: ModuleSource | undefined;
+        }
+        type LoadHook = (url: string, context: LoadHookContext, nextLoad: (url: string, context?: Partial<LoadHookContext>) => LoadFnOutput | Promise<LoadFnOutput>) => LoadFnOutput | Promise<LoadFnOutput>;
+        type LoadHookSync = (url: string, context: LoadHookContext, nextLoad: (url: string, context?: Partial<LoadHookContext>) => LoadFnOutput) => LoadFnOutput;
+        interface SourceMapsSupport {
+            enabled: boolean;
+            nodeModules: boolean;
+            generatedCode: boolean;
+        }
+        function getSourceMapsSupport(): SourceMapsSupport;
+        function findSourceMap(path: string): SourceMap | undefined;
+        interface SetSourceMapsSupportOptions {
+            nodeModules?: boolean | undefined;
+            generatedCode?: boolean | undefined;
+        }
+        function setSourceMapsSupport(enabled: boolean, options?: SetSourceMapsSupportOptions): void;
+        interface SourceMapConstructorOptions {
+            lineLengths?: readonly number[] | undefined;
+        }
+        interface SourceMapPayload {
+            file: string;
+            version: number;
+            sources: string[];
+            sourcesContent: string[];
+            names: string[];
+            mappings: string;
+            sourceRoot: string;
+        }
+        interface SourceMapping {
+            generatedLine: number;
+            generatedColumn: number;
+            originalSource: string;
+            originalLine: number;
+            originalColumn: number;
+        }
+        interface SourceOrigin {
+            name: string | undefined;
+            fileName: string;
+            lineNumber: number;
+            columnNumber: number;
+        }
+        class SourceMap {
+            constructor(payload: SourceMapPayload, options?: SourceMapConstructorOptions);
+            readonly payload: SourceMapPayload;
+            findEntry(lineOffset: number, columnOffset: number): SourceMapping | {};
+            findOrigin(lineNumber: number, columnNumber: number): SourceOrigin | {};
+        }
+        function runMain(main?: string): void;
+        function wrap(script: string): string;
+    }
+    global {
+        namespace NodeJS {
+            interface Module {
+                children: Module[];
+                exports: any;
+                filename: string;
+                id: string;
+                isPreloading: boolean;
+                loaded: boolean;
+                parent: Module | null | undefined;
+                path: string;
+                paths: string[];
+                require(id: string): any;
+            }
+            interface Require {
+                (id: string): any;
+                cache: Dict<Module>;
+                extensions: RequireExtensions;
+                main: Module | undefined;
+                resolve: RequireResolve;
+            }
+            interface RequireExtensions extends Dict<(module: Module, filename: string) => any> {
+                ".js": (module: Module, filename: string) => any;
+                ".json": (module: Module, filename: string) => any;
+                ".node": (module: Module, filename: string) => any;
+            }
+            interface RequireResolveOptions {
+                paths?: string[] | undefined;
+            }
+            interface RequireResolve {
+                (request: string, options?: RequireResolveOptions): string;
+                paths(request: string): string[] | null;
+            }
+        }
+        var __dirname: string;
+        var __filename: string;
+        var exports: NodeJS.Module["exports"];
+        var module: NodeJS.Module;
+        var require: NodeJS.Require;
+        interface NodeModule extends NodeJS.Module {
+        }
+        interface NodeRequire extends NodeJS.Require {
+        }
+        interface RequireResolve extends NodeJS.RequireResolve {
+        }
+    }
+    export = Module;
+}
+declare module "module" {
+    import module = require("node:module");
+    export = module;
+}

package/types/node/net.d.ts

@@ -0,0 +1,266 @@
+declare module "node:net" {
+    import { NonSharedBuffer } from "node:buffer";
+    import * as dns from "node:dns";
+    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
+    import * as stream from "node:stream";
+    type LookupFunction = (hostname: string, options: dns.LookupOptions, callback: (err: NodeJS.ErrnoException | null, address: string | dns.LookupAddress[], family?: number) => void) => void;
+    interface AddressInfo {
+        address: string;
+        family: string;
+        port: number;
+    }
+    interface SocketConstructorOpts {
+        fd?: number | undefined;
+        allowHalfOpen?: boolean | undefined;
+        onread?: OnReadOpts | undefined;
+        readable?: boolean | undefined;
+        writable?: boolean | undefined;
+        signal?: AbortSignal | undefined;
+        noDelay?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
+        blockList?: BlockList | undefined;
+        typeOfService?: number | undefined;
+    }
+    interface OnReadOpts {
+        buffer: Uint8Array | (() => Uint8Array);
+        callback(bytesWritten: number, buffer: Uint8Array): boolean;
+    }
+    interface TcpSocketConnectOpts {
+        port: number;
+        host?: string | undefined;
+        localAddress?: string | undefined;
+        localPort?: number | undefined;
+        hints?: number | undefined;
+        family?: number | undefined;
+        lookup?: LookupFunction | undefined;
+        autoSelectFamily?: boolean | undefined;
+        autoSelectFamilyAttemptTimeout?: number | undefined;
+    }
+    interface IpcSocketConnectOpts {
+        path: string;
+    }
+    type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
+    type SocketReadyState = "opening" | "open" | "readOnly" | "writeOnly" | "closed";
+    interface SocketEventMap extends Omit<stream.DuplexEventMap, "close"> {
+        "close": [
+            hadError: boolean
+        ];
+        "connect": [
+        ];
+        "connectionAttempt": [
+            ip: string,
+            port: number,
+            family: number
+        ];
+        "connectionAttemptFailed": [
+            ip: string,
+            port: number,
+            family: number,
+            error: Error
+        ];
+        "connectionAttemptTimeout": [
+            ip: string,
+            port: number,
+            family: number
+        ];
+        "data": [
+            data: string | NonSharedBuffer
+        ];
+        "lookup": [
+            err: Error | null,
+            address: string,
+            family: number | null,
+            host: string
+        ];
+        "ready": [
+        ];
+        "timeout": [
+        ];
+    }
+    class Socket extends stream.Duplex {
+        constructor(options?: SocketConstructorOpts);
+        destroySoon(): void;
+        write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+        connect(options: SocketConnectOpts, connectionListener?: () => void): this;
+        connect(port: number, host: string, connectionListener?: () => void): this;
+        connect(port: number, connectionListener?: () => void): this;
+        connect(path: string, connectionListener?: () => void): this;
+        setEncoding(encoding?: BufferEncoding): this;
+        pause(): this;
+        resetAndDestroy(): this;
+        resume(): this;
+        setTimeout(timeout: number, callback?: () => void): this;
+        setNoDelay(noDelay?: boolean): this;
+        setKeepAlive(enable?: boolean, initialDelay?: number): this;
+        getTypeOfService(): number;
+        setTypeOfService(tos: number): this;
+        address(): AddressInfo | {};
+        unref(): this;
+        ref(): this;
+        readonly autoSelectFamilyAttemptedAddresses: string[];
+        readonly bufferSize: number;
+        readonly bytesRead: number;
+        readonly bytesWritten: number;
+        readonly connecting: boolean;
+        readonly pending: boolean;
+        readonly destroyed: boolean;
+        readonly localAddress?: string;
+        readonly localPort?: number;
+        readonly localFamily?: string;
+        readonly readyState: SocketReadyState;
+        readonly remoteAddress: string | undefined;
+        readonly remoteFamily: string | undefined;
+        readonly remotePort: number | undefined;
+        readonly timeout?: number;
+        end(callback?: () => void): this;
+        end(buffer: Uint8Array | string, callback?: () => void): this;
+        end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
+        addListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof SocketEventMap>(eventName: E, ...args: SocketEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof SocketEventMap>(eventName: E, listener?: (...args: SocketEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof SocketEventMap>(eventName: E): ((...args: SocketEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof SocketEventMap>(eventName: E): ((...args: SocketEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof SocketEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    interface ListenOptions extends Abortable {
+        backlog?: number | undefined;
+        exclusive?: boolean | undefined;
+        host?: string | undefined;
+        ipv6Only?: boolean | undefined;
+        reusePort?: boolean | undefined;
+        path?: string | undefined;
+        port?: number | undefined;
+        readableAll?: boolean | undefined;
+        writableAll?: boolean | undefined;
+    }
+    interface ServerOpts {
+        allowHalfOpen?: boolean | undefined;
+        pauseOnConnect?: boolean | undefined;
+        noDelay?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
+        highWaterMark?: number | undefined;
+        blockList?: BlockList | undefined;
+    }
+    interface DropArgument {
+        localAddress?: string;
+        localPort?: number;
+        localFamily?: string;
+        remoteAddress?: string;
+        remotePort?: number;
+        remoteFamily?: string;
+    }
+    interface ServerEventMap {
+        "close": [
+        ];
+        "connection": [
+            socket: Socket
+        ];
+        "error": [
+            err: Error
+        ];
+        "listening": [
+        ];
+        "drop": [
+            data?: DropArgument
+        ];
+    }
+    class Server implements EventEmitter {
+        constructor(connectionListener?: (socket: Socket) => void);
+        constructor(options?: ServerOpts, connectionListener?: (socket: Socket) => void);
+        listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
+        listen(port?: number, hostname?: string, listeningListener?: () => void): this;
+        listen(port?: number, backlog?: number, listeningListener?: () => void): this;
+        listen(port?: number, listeningListener?: () => void): this;
+        listen(path: string, backlog?: number, listeningListener?: () => void): this;
+        listen(path: string, listeningListener?: () => void): this;
+        listen(options: ListenOptions, listeningListener?: () => void): this;
+        listen(handle: any, backlog?: number, listeningListener?: () => void): this;
+        listen(handle: any, listeningListener?: () => void): this;
+        close(callback?: (err?: Error) => void): this;
+        address(): AddressInfo | string | null;
+        getConnections(cb: (error: Error | null, count: number) => void): this;
+        ref(): this;
+        unref(): this;
+        maxConnections: number;
+        connections: number;
+        readonly listening: boolean;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    interface Server extends InternalEventEmitter<ServerEventMap> {
+    }
+    type IPVersion = "ipv4" | "ipv6";
+    class BlockList {
+        addAddress(address: string, type?: IPVersion): void;
+        addAddress(address: SocketAddress): void;
+        addRange(start: string, end: string, type?: IPVersion): void;
+        addRange(start: SocketAddress, end: SocketAddress): void;
+        addSubnet(net: SocketAddress, prefix: number): void;
+        addSubnet(net: string, prefix: number, type?: IPVersion): void;
+        check(address: SocketAddress): boolean;
+        check(address: string, type?: IPVersion): boolean;
+        rules: readonly string[];
+        static isBlockList(value: unknown): value is BlockList;
+        fromJSON(data: string | readonly string[]): void;
+        toJSON(): readonly string[];
+    }
+    interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
+        timeout?: number | undefined;
+    }
+    interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {
+        timeout?: number | undefined;
+    }
+    type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;
+    function createServer(connectionListener?: (socket: Socket) => void): Server;
+    function createServer(options?: ServerOpts, connectionListener?: (socket: Socket) => void): Server;
+    function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;
+    function connect(port: number, host?: string, connectionListener?: () => void): Socket;
+    function connect(path: string, connectionListener?: () => void): Socket;
+    function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
+    function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
+    function createConnection(path: string, connectionListener?: () => void): Socket;
+    function getDefaultAutoSelectFamily(): boolean;
+    function setDefaultAutoSelectFamily(value: boolean): void;
+    function getDefaultAutoSelectFamilyAttemptTimeout(): number;
+    function setDefaultAutoSelectFamilyAttemptTimeout(value: number): void;
+    function isIP(input: string): number;
+    function isIPv4(input: string): boolean;
+    function isIPv6(input: string): boolean;
+    interface SocketAddressInitOptions {
+        address?: string | undefined;
+        family?: IPVersion | undefined;
+        flowlabel?: number | undefined;
+        port?: number | undefined;
+    }
+    class SocketAddress {
+        constructor(options: SocketAddressInitOptions);
+        readonly address: string;
+        readonly family: IPVersion;
+        readonly port: number;
+        readonly flowlabel: number;
+        static parse(input: string): SocketAddress | undefined;
+    }
+}
+declare module "net" {
+    export * from "node:net";
+}

package/types/node/os.d.ts

@@ -0,0 +1,236 @@
+declare module "node:os" {
+    import { NonSharedBuffer } from "buffer";
+    interface CpuInfo {
+        model: string;
+        speed: number;
+        times: {
+            user: number;
+            nice: number;
+            sys: number;
+            idle: number;
+            irq: number;
+        };
+    }
+    interface NetworkInterfaceBase {
+        address: string;
+        netmask: string;
+        mac: string;
+        internal: boolean;
+        cidr: string | null;
+        scopeid?: number;
+    }
+    interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
+        family: "IPv4";
+    }
+    interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
+        family: "IPv6";
+        scopeid: number;
+    }
+    interface UserInfo<T> {
+        username: T;
+        uid: number;
+        gid: number;
+        shell: T | null;
+        homedir: T;
+    }
+    type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
+    function hostname(): string;
+    function loadavg(): number[];
+    function uptime(): number;
+    function freemem(): number;
+    function totalmem(): number;
+    function cpus(): CpuInfo[];
+    function availableParallelism(): number;
+    function type(): string;
+    function release(): string;
+    function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
+    function homedir(): string;
+    interface UserInfoOptions {
+        encoding?: BufferEncoding | "buffer" | undefined;
+    }
+    interface UserInfoOptionsWithBufferEncoding extends UserInfoOptions {
+        encoding: "buffer";
+    }
+    interface UserInfoOptionsWithStringEncoding extends UserInfoOptions {
+        encoding?: BufferEncoding | undefined;
+    }
+    function userInfo(options?: UserInfoOptionsWithStringEncoding): UserInfo<string>;
+    function userInfo(options: UserInfoOptionsWithBufferEncoding): UserInfo<NonSharedBuffer>;
+    function userInfo(options: UserInfoOptions): UserInfo<string | NonSharedBuffer>;
+    type SignalConstants = {
+        [key in NodeJS.Signals]: number;
+    };
+    namespace constants {
+        const UV_UDP_REUSEADDR: number;
+        namespace signals { }
+        const signals: SignalConstants;
+        namespace errno {
+            const E2BIG: number;
+            const EACCES: number;
+            const EADDRINUSE: number;
+            const EADDRNOTAVAIL: number;
+            const EAFNOSUPPORT: number;
+            const EAGAIN: number;
+            const EALREADY: number;
+            const EBADF: number;
+            const EBADMSG: number;
+            const EBUSY: number;
+            const ECANCELED: number;
+            const ECHILD: number;
+            const ECONNABORTED: number;
+            const ECONNREFUSED: number;
+            const ECONNRESET: number;
+            const EDEADLK: number;
+            const EDESTADDRREQ: number;
+            const EDOM: number;
+            const EDQUOT: number;
+            const EEXIST: number;
+            const EFAULT: number;
+            const EFBIG: number;
+            const EHOSTUNREACH: number;
+            const EIDRM: number;
+            const EILSEQ: number;
+            const EINPROGRESS: number;
+            const EINTR: number;
+            const EINVAL: number;
+            const EIO: number;
+            const EISCONN: number;
+            const EISDIR: number;
+            const ELOOP: number;
+            const EMFILE: number;
+            const EMLINK: number;
+            const EMSGSIZE: number;
+            const EMULTIHOP: number;
+            const ENAMETOOLONG: number;
+            const ENETDOWN: number;
+            const ENETRESET: number;
+            const ENETUNREACH: number;
+            const ENFILE: number;
+            const ENOBUFS: number;
+            const ENODATA: number;
+            const ENODEV: number;
+            const ENOENT: number;
+            const ENOEXEC: number;
+            const ENOLCK: number;
+            const ENOLINK: number;
+            const ENOMEM: number;
+            const ENOMSG: number;
+            const ENOPROTOOPT: number;
+            const ENOSPC: number;
+            const ENOSR: number;
+            const ENOSTR: number;
+            const ENOSYS: number;
+            const ENOTCONN: number;
+            const ENOTDIR: number;
+            const ENOTEMPTY: number;
+            const ENOTSOCK: number;
+            const ENOTSUP: number;
+            const ENOTTY: number;
+            const ENXIO: number;
+            const EOPNOTSUPP: number;
+            const EOVERFLOW: number;
+            const EPERM: number;
+            const EPIPE: number;
+            const EPROTO: number;
+            const EPROTONOSUPPORT: number;
+            const EPROTOTYPE: number;
+            const ERANGE: number;
+            const EROFS: number;
+            const ESPIPE: number;
+            const ESRCH: number;
+            const ESTALE: number;
+            const ETIME: number;
+            const ETIMEDOUT: number;
+            const ETXTBSY: number;
+            const EWOULDBLOCK: number;
+            const EXDEV: number;
+            const WSAEINTR: number;
+            const WSAEBADF: number;
+            const WSAEACCES: number;
+            const WSAEFAULT: number;
+            const WSAEINVAL: number;
+            const WSAEMFILE: number;
+            const WSAEWOULDBLOCK: number;
+            const WSAEINPROGRESS: number;
+            const WSAEALREADY: number;
+            const WSAENOTSOCK: number;
+            const WSAEDESTADDRREQ: number;
+            const WSAEMSGSIZE: number;
+            const WSAEPROTOTYPE: number;
+            const WSAENOPROTOOPT: number;
+            const WSAEPROTONOSUPPORT: number;
+            const WSAESOCKTNOSUPPORT: number;
+            const WSAEOPNOTSUPP: number;
+            const WSAEPFNOSUPPORT: number;
+            const WSAEAFNOSUPPORT: number;
+            const WSAEADDRINUSE: number;
+            const WSAEADDRNOTAVAIL: number;
+            const WSAENETDOWN: number;
+            const WSAENETUNREACH: number;
+            const WSAENETRESET: number;
+            const WSAECONNABORTED: number;
+            const WSAECONNRESET: number;
+            const WSAENOBUFS: number;
+            const WSAEISCONN: number;
+            const WSAENOTCONN: number;
+            const WSAESHUTDOWN: number;
+            const WSAETOOMANYREFS: number;
+            const WSAETIMEDOUT: number;
+            const WSAECONNREFUSED: number;
+            const WSAELOOP: number;
+            const WSAENAMETOOLONG: number;
+            const WSAEHOSTDOWN: number;
+            const WSAEHOSTUNREACH: number;
+            const WSAENOTEMPTY: number;
+            const WSAEPROCLIM: number;
+            const WSAEUSERS: number;
+            const WSAEDQUOT: number;
+            const WSAESTALE: number;
+            const WSAEREMOTE: number;
+            const WSASYSNOTREADY: number;
+            const WSAVERNOTSUPPORTED: number;
+            const WSANOTINITIALISED: number;
+            const WSAEDISCON: number;
+            const WSAENOMORE: number;
+            const WSAECANCELLED: number;
+            const WSAEINVALIDPROCTABLE: number;
+            const WSAEINVALIDPROVIDER: number;
+            const WSAEPROVIDERFAILEDINIT: number;
+            const WSASYSCALLFAILURE: number;
+            const WSASERVICE_NOT_FOUND: number;
+            const WSATYPE_NOT_FOUND: number;
+            const WSA_E_NO_MORE: number;
+            const WSA_E_CANCELLED: number;
+            const WSAEREFUSED: number;
+        }
+        namespace dlopen {
+            const RTLD_LAZY: number;
+            const RTLD_NOW: number;
+            const RTLD_GLOBAL: number;
+            const RTLD_LOCAL: number;
+            const RTLD_DEEPBIND: number;
+        }
+        namespace priority {
+            const PRIORITY_LOW: number;
+            const PRIORITY_BELOW_NORMAL: number;
+            const PRIORITY_NORMAL: number;
+            const PRIORITY_ABOVE_NORMAL: number;
+            const PRIORITY_HIGH: number;
+            const PRIORITY_HIGHEST: number;
+        }
+    }
+    const devNull: string;
+    const EOL: string;
+    function arch(): NodeJS.Architecture;
+    function version(): string;
+    function platform(): NodeJS.Platform;
+    function machine(): string;
+    function tmpdir(): string;
+    function endianness(): "BE" | "LE";
+    function getPriority(pid?: number): number;
+    function setPriority(priority: number): void;
+    function setPriority(pid: number, priority: number): void;
+}
+declare module "os" {
+    export * from "node:os";
+}