FM / node

/home/techb158/balavpn.abdallabala.com/node_modules/@types/node/

/home/techb158/balavpn.abdallabala.com/node_modules/@types/node

Name	Size	Mode	Actions
assert/	-	0777	rm
dns/	-	0777	rm
fs/	-	0777	rm
inspector/	-	0777	rm
path/	-	0777	rm
readline/	-	0777	rm
stream/	-	0777	rm
test/	-	0777	rm
timers/	-	0777	rm
ts5.6/	-	0777	rm
ts5.7/	-	0777	rm
util/	-	0777	rm
web-globals/	-	0777	rm
zlib/	-	0777	rm
assert.d.ts	42891	0666	edit dl rm
async_hooks.d.ts	29929	0666	edit dl rm
buffer.buffer.d.ts	22604	0666	edit dl rm
buffer.d.ts	81152	0666	edit dl rm
child_process.d.ts	59930	0666	edit dl rm
cluster.d.ts	19527	0666	edit dl rm
console.d.ts	4250	0666	edit dl rm
constants.d.ts	491	0666	edit dl rm
crypto.d.ts	168455	0666	edit dl rm
dgram.d.ts	24921	0666	edit dl rm
diagnostics_channel.d.ts	34577	0666	edit dl rm
dns.d.ts	34348	0666	edit dl rm
domain.d.ts	6597	0666	edit dl rm
events.d.ts	47375	0666	edit dl rm
ffi.d.ts	20013	0666	edit dl rm
fs.d.ts	201283	0666	edit dl rm
globals.d.ts	5084	0666	edit dl rm
globals.typedarray.d.ts	4864	0666	edit dl rm
http.d.ts	96833	0666	edit dl rm
http2.d.ts	119039	0666	edit dl rm
https.d.ts	16812	0666	edit dl rm
index.d.ts	5019	0666	edit dl rm
inspector.d.ts	12198	0666	edit dl rm
inspector.generated.d.ts	228362	0666	edit dl rm
LICENSE	1141	0666	edit dl rm
module.d.ts	32983	0666	edit dl rm
net.d.ts	43748	0666	edit dl rm
os.d.ts	19193	0666	edit dl rm
package.json	4508	0666	edit dl rm
path.d.ts	7639	0666	edit dl rm
perf_hooks.d.ts	22973	0666	edit dl rm
process.d.ts	112070	0666	edit dl rm
punycode.d.ts	3780	0666	edit dl rm
querystring.d.ts	6642	0666	edit dl rm
quic.d.ts	33850	0666	edit dl rm
readline.d.ts	21216	0666	edit dl rm
README.md	1582	0666	edit dl rm
repl.d.ts	19023	0666	edit dl rm
sea.d.ts	2045	0666	edit dl rm
sqlite.d.ts	54652	0666	edit dl rm
stream.d.ts	90588	0666	edit dl rm
string_decoder.d.ts	1318	0666	edit dl rm
test.d.ts	111992	0666	edit dl rm
timers.d.ts	7351	0666	edit dl rm
tls.d.ts	58012	0666	edit dl rm
trace_events.d.ts	3842	0666	edit dl rm
tty.d.ts	11152	0666	edit dl rm
url.d.ts	25457	0666	edit dl rm
util.d.ts	65409	0666	edit dl rm
v8.d.ts	42920	0666	edit dl rm
vm.d.ts	53143	0666	edit dl rm
wasi.d.ts	6250	0666	edit dl rm
worker_threads.d.ts	29736	0666	edit dl rm
zlib.d.ts	22874	0666	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/node_modules/@types/node/ffi.d.ts (20013B)

declare module "node:ffi" {
    import { NonSharedBuffer } from "node:buffer";
    interface FunctionSignature {
        return?: ReturnType | undefined;
        arguments?: readonly ArgumentType[] | undefined;
    }
    interface FunctionDefinitions {
        [symbol: string]: FunctionSignature;
    }
    type CallbackFunction<R extends ReturnType = any, P extends readonly ArgumentType[] = any[]> = (
        ...args: { [K in keyof P]: ArgumentTypeMap[DataTypeMap[P[K]]] }
    ) => ReturnTypeMap[DataTypeMap[R]];
    interface WrappedFunction<R extends ReturnType = any, P extends readonly ArgumentType[] = any[]>
        extends CallbackFunction<R, P>
    {
        readonly pointer: bigint;
    }
    type CallbackFunctionFromSignature<T extends FunctionSignature> = CallbackFunction<
        ReturnTypeFromFunctionSignature<T>,
        ArgumentTypesFromFunctionSignature<T>
    >;
    type WrappedFunctionFromSignature<T extends FunctionSignature> = WrappedFunction<
        ReturnTypeFromFunctionSignature<T>,
        ArgumentTypesFromFunctionSignature<T>
    >;
    type WrappedFunctionsFromDefinitions<T extends FunctionDefinitions> = {
        [K in keyof T]: WrappedFunctionFromSignature<T[K]>;
    };
    type ReturnTypeFromFunctionSignature<T extends FunctionSignature> = "return" extends keyof T
        ? T extends { return: infer R extends ReturnType } ? R : any
        : "void";
    type ArgumentTypesFromFunctionSignature<T extends FunctionSignature> = "arguments" extends keyof T
        ? T extends { arguments: infer P extends readonly ArgumentType[] } ? P : any[]
        : [];
    interface DynamicLibraryResult<T extends FunctionDefinitions> extends Disposable {
        lib: DynamicLibrary;
        functions: WrappedFunctionsFromDefinitions<T>;
    }
    /**
     * The native shared library suffix for the current platform:
     *
     * * `'dylib'` on macOS
     * * `'so'` on Unix-like platforms
     * * `'dll'` on Windows
     *
     * This can be used to build portable library paths:
     *
     * ```js
     * const { suffix } = require('node:ffi');
     *
     * const path = `libsqlite3.${suffix}`;
     * ```
     * @since v26.1.0
     */
    const suffix: string;
    /**
     * Loads a dynamic library and resolves the requested function definitions.
     *
     * On Windows passing `null` is not supported.
     *
     * When `definitions` is omitted, `functions` is returned as an empty object until
     * symbols are resolved explicitly.
     *
     * The returned object also implements the explicit resource management protocol,
     * so it can be used with the `using` declaration. Disposing the returned
     * object closes the library handle.
     *
     * ```js
     * import { dlopen } from 'node:ffi';
     *
     * {
     *   using handle = dlopen('./mylib.so', {
     *     add_i32: { arguments: ['i32', 'i32'], return: 'i32' },
     *   });
     *   console.log(handle.functions.add_i32(20, 22));
     * } // handle.lib.close() is invoked automatically here.
     * ```
     *
     * ```js
     * import { dlopen } from 'node:ffi';
     *
     * const { lib, functions } = dlopen('./mylib.so', {
     *   add_i32: { arguments: ['i32', 'i32'], return: 'i32' },
     *   string_length: { arguments: ['pointer'], return: 'u64' },
     * });
     *
     * console.log(functions.add_i32(20, 22));
     * ```
     * @since v26.1.0
     * @param path Path to a dynamic library, or `null` to resolve symbols
     * from the current process image.
     * @param definitions Symbol definitions to resolve immediately.
     */
    function dlopen<const T extends FunctionDefinitions = {}>(
        path: string | null,
        definitions?: T,
    ): DynamicLibraryResult<T>;
    /**
     * Closes a dynamic library.
     *
     * This is equivalent to calling `handle.close()`.
     * @since v26.1.0
     */
    function dlclose(handle: DynamicLibrary): void;
    /**
     * Resolves a symbol address from a loaded library.
     *
     * This is equivalent to calling `handle.getSymbol(symbol)`.
     * @since v26.1.0
     */
    function dlsym(handle: DynamicLibrary, symbol: string): bigint;
    /**
     * @since v26.1.0
     */
    class DynamicLibrary {
        /**
         * Loads the dynamic library without resolving any functions eagerly.
         *
         * On Windows passing `null` is not supported.
         *
         * ```js
         * const { DynamicLibrary } = require('node:ffi');
         *
         * const lib = new DynamicLibrary('./mylib.so');
         * ```
         * @param path Path to a dynamic library, or `null` to resolve symbols
         * from the current process image.
         */
        constructor(path: string | null);
        /**
         * The path used to load the library.
         */
        readonly path: string;
        /**
         * An object containing previously resolved symbol addresses as `bigint` values.
         */
        readonly symbols: { [symbol: string]: bigint };
        /**
         * Closes the library handle.
         *
         * `DynamicLibrary` implements the explicit resource management protocol, so a
         * library instance can be managed with the `using` declaration. Leaving the
         * enclosing scope invokes `library.close()` automatically.
         *
         * ```js
         * import { DynamicLibrary } from 'node:ffi';
         *
         * {
         *   using lib = new DynamicLibrary('./mylib.so');
         *   // Use `lib` here; `lib.close()` is called when the block exits.
         * }
         * ```
         *
         * Calling `library.close()` (or disposing the library) more than once is a no-op.
         *
         * After a library has been closed:
         *
         * * Resolved function wrappers become invalid.
         * * Further symbol and function resolution throws.
         * * Registered callbacks are invalidated.
         *
         * Closing a library does not make previously exported callback pointers safe to
         * reuse. Node.js does not track or revoke callback pointers that have already
         * been handed to native code.
         *
         * If native code still holds a callback pointer after `library.close()` or after
         * `library.unregisterCallback(pointer)`, invoking that pointer has undefined
         * behavior, is not allowed, and is dangerous: it can crash the process, produce
         * incorrect output, or corrupt memory. Native code must stop using callback
         * addresses before the library is closed or before the callback is unregistered.
         *
         * Calling `library.close()` from one of the library's active callbacks is
         * unsupported and dangerous. The callback must return before the library is
         * closed.
         */
        close(): void;
        /**
         * Calls `library.close()`. This allows `DynamicLibrary` instances to be used with
         * the `using` declaration for automatic cleanup when the enclosing scope
         * exits. It is a no-op on a library that has already been closed.
         * @since v26.1.0
         */
        [Symbol.dispose](): void;
        /**
         * Resolves a symbol and returns a callable JavaScript wrapper.
         *
         * The returned function has a `.pointer` property containing the native function
         * address as a `bigint`.
         *
         * If the same symbol has already been resolved, requesting it again with a
         * different signature throws.
         *
         * ```js
         * const { DynamicLibrary } = require('node:ffi');
         *
         * const lib = new DynamicLibrary('./mylib.so');
         * const add = lib.getFunction('add_i32', {
         *   arguments: ['i32', 'i32'],
         *   return: 'i32',
         * });
         *
         * console.log(add(20, 22));
         * console.log(add.pointer);
         * ```
         */
        getFunction<const T extends FunctionSignature>(name: string, signature: T): WrappedFunctionFromSignature<T>;
        /**
         * When `definitions` is provided, resolves each named symbol and returns an
         * object containing callable wrappers.
         *
         * When `definitions` is omitted, returns wrappers for all functions that have
         * already been resolved on the library.
         */
        getFunctions(): { [symbol: string]: WrappedFunction };
        getFunctions<const T extends FunctionDefinitions>(definitions: T): WrappedFunctionsFromDefinitions<T>;
        /**
         * Resolves a symbol and returns its native address as a `bigint`.
         */
        getSymbol(name: string): bigint;
        /**
         * Returns an object containing all previously resolved symbol addresses.
         */
        getSymbols(): Record<string, bigint>;
        /**
         * Creates a native callback pointer backed by a JavaScript function.
         *
         * When `signature` is omitted, the callback uses a default `void ()` signature.
         *
         * The return value is the callback pointer address as a `bigint`. It can be
         * passed to native functions expecting a callback pointer.
         *
         * ```js
         * const { DynamicLibrary } = require('node:ffi');
         *
         * const lib = new DynamicLibrary('./mylib.so');
         *
         * const callback = lib.registerCallback(
         *   { arguments: ['i32'], return: 'i32' },
         *   (value) => value * 2,
         * );
         * ```
         *
         * Callbacks are subject to the following restrictions:
         *
         * * They must be invoked on the same system thread where they were created.
         * * They must not throw exceptions.
         * * They must not return promises.
         * * They must return a value compatible with the declared return type.
         * * They must not call `library.close()` on their owning library while running.
         * * They must not unregister themselves while running.
         *
         * Closing the owning library or unregistering the currently executing callback
         * from inside the callback is unsupported and dangerous. Doing so may crash the
         * process, produce incorrect output, or corrupt memory.
         */
        registerCallback(callback: () => void): bigint;
        registerCallback<const T extends FunctionSignature>(
            signature: T,
            callback: CallbackFunctionFromSignature<T>,
        ): bigint;
        /**
         * Releases a callback previously created with `library.registerCallback()`.
         *
         * Calling `library.unregisterCallback(pointer)` for a callback that is currently
         * executing is unsupported and dangerous. The callback must return before it is
         * unregistered.
         *
         * After `library.unregisterCallback(pointer)` returns, invoking that callback
         * pointer from native code has undefined behavior, is not allowed, and is
         * dangerous: it can crash the process, produce incorrect output, or corrupt
         * memory.
         */
        unregisterCallback(pointer: bigint): void;
        /**
         * Keeps the callback strongly referenced by JavaScript.
         */
        refCallback(pointer: bigint): void;
        /**
         * Allows the callback to become weakly referenced by JavaScript.
         *
         * If the callback function is later garbage collected, subsequent native
         * invocations become a no-op. Non-void return values are zero-initialized before
         * returning to native code.
         */
        unrefCallback(pointer: bigint): void;
    }
    function getInt8(pointer: bigint, offset?: number): number;
    function getUint8(pointer: bigint, offset?: number): number;
    function getInt16(pointer: bigint, offset?: number): number;
    function getUint16(pointer: bigint, offset?: number): number;
    function getInt32(pointer: bigint, offset?: number): number;
    function getUint32(pointer: bigint, offset?: number): number;
    function getInt64(pointer: bigint, offset?: number): bigint;
    function getUint64(pointer: bigint, offset?: number): bigint;
    function getFloat32(pointer: bigint, offset?: number): number;
    function getFloat64(pointer: bigint, offset?: number): number;
    function setInt8(pointer: bigint, offset: number, value: number): void;
    function setUint8(pointer: bigint, offset: number, value: number): void;
    function setInt16(pointer: bigint, offset: number, value: number): void;
    function setUint16(pointer: bigint, offset: number, value: number): void;
    function setInt32(pointer: bigint, offset: number, value: number): void;
    function setUint32(pointer: bigint, offset: number, value: number): void;
    function setInt64(pointer: bigint, offset: number, value: number | bigint): void;
    function setUint64(pointer: bigint, offset: number, value: number | bigint): void;
    function setFloat32(pointer: bigint, offset: number, value: number): void;
    function setFloat64(pointer: bigint, offset: number, value: number): void;
    /**
     * Reads a NUL-terminated UTF-8 string from native memory.
     *
     * If `pointer` is `0n`, `null` is returned.
     *
     * This function does not validate that `pointer` refers to readable memory or
     * that the pointed-to data is terminated with `\0`. Passing an invalid pointer,
     * a pointer to freed memory, or a pointer to bytes without a terminating NUL can
     * read unrelated memory, crash the process, or produce truncated or garbled
     * output.
     * @since v26.1.0
     */
    function toString(pointer: bigint): string | null;
    /**
     * Creates a `Buffer` from native memory.
     *
     * When `copy` is `true`, the returned `Buffer` owns its own copied memory.
     * When `copy` is `false`, the returned `Buffer` references the original native
     * memory directly.
     *
     * Using `copy: false` is a zero-copy escape hatch. The returned `Buffer` is a
     * writable view onto foreign memory, so writes in JavaScript update the original
     * native memory directly. The caller must guarantee that:
     *
     * * `pointer` remains valid for the entire lifetime of the returned `Buffer`.
     * * `length` stays within the allocated native region.
     * * no native code frees or repurposes that memory while JavaScript still uses
     *   the `Buffer`.
     * * Memory protection is observed. For example, read-only memory pages must not
     *   be written to.
     *
     * If these guarantees are not met, reading or writing the `Buffer` can corrupt
     * memory or crash the process.
     * @since v26.1.0
     * @param copy When `false`, creates a zero-copy view. **Default:** `true`.
     */
    function toBuffer(pointer: bigint, length: number, copy?: boolean): NonSharedBuffer;
    /**
     * Creates an `ArrayBuffer` from native memory.
     *
     * When `copy` is `true`, the returned `ArrayBuffer` contains copied bytes.
     * When `copy` is `false`, the returned `ArrayBuffer` references the original
     * native memory directly.
     *
     * The same lifetime and bounds requirements described for
     * `ffi.toBuffer(pointer, length, copy)` apply
     * here. With `copy: false`, the
     * returned `ArrayBuffer` is a zero-copy view of foreign memory and is only safe
     * while that memory remains allocated, unchanged in layout, and valid for the
     * entire exposed range.
     * @since v26.1.0
     * @param copy When `false`, creates a zero-copy view. **Default:** `true`.
     */
    function toArrayBuffer(pointer: bigint, length: number, copy?: boolean): ArrayBuffer;
    /**
     * Copies a JavaScript string into native memory and appends a trailing NUL
     * terminator.
     *
     * `length` must be large enough to hold the full encoded string plus the trailing
     * NUL terminator. For UTF-16 and UCS-2 encodings, the trailing terminator uses
     * two zero bytes.
     *
     * `pointer` must refer to writable native memory with at least `length` bytes of
     * available storage. This function does not allocate memory on its own.
     *
     * `string` must be a JavaScript string. `encoding` must be a string.
     * @since v26.1.0
     * @param encoding **Default:** `'utf8'`.
     */
    function exportString(string: string, pointer: bigint, length: number, encoding?: BufferEncoding): void;
    /**
     * Copies bytes from a `Buffer` into native memory.
     *
     * `length` must be at least `buffer.length`.
     *
     * `pointer` must refer to writable native memory with at least `length` bytes of
     * available storage. This function does not allocate memory on its own.
     *
     * `buffer` must be a Node.js `Buffer`.
     * @since v26.1.0
     */
    function exportBuffer(buffer: Buffer, pointer: bigint, length: number): void;
    /**
     * Copies bytes from an `ArrayBuffer` into native memory.
     *
     * `length` must be at least `arrayBuffer.byteLength`.
     *
     * `pointer` must refer to writable native memory with at least `length` bytes of
     * available storage. This function does not allocate memory on its own.
     * @since v26.1.0
     */
    function exportArrayBuffer(arrayBuffer: ArrayBuffer, pointer: bigint, length: number): void;
    /**
     * Copies bytes from an `ArrayBufferView` into native memory.
     *
     * `length` must be at least `arrayBufferView.byteLength`.
     *
     * `pointer` must refer to writable native memory with at least `length` bytes of
     * available storage. This function does not allocate memory on its own.
     * @since v26.1.0
     */
    function exportArrayBufferView(arrayBufferView: NodeJS.ArrayBufferView, pointer: bigint, length: number): void;
    /**
     * Returns the raw memory address of JavaScript-managed byte storage.
     *
     * This is unsafe and dangerous. The returned pointer can become invalid if the
     * underlying memory is detached, resized, transferred, or otherwise invalidated.
     * Using stale pointers can cause memory corruption or process crashes.
     * @since v26.1.0
     */
    function getRawPointer(source: ArrayBuffer | NodeJS.ArrayBufferView): bigint;
    type ReturnType = { [K in keyof DataTypeMap]: K }[keyof DataTypeMap];
    type ArgumentType = Exclude<ReturnType, "void">;
    interface DataTypeMap {
        void: "void";
        char: "number";
        bool: "number";
        i8: "number";
        int8: "number";
        u8: "number";
        uint8: "number";
        i16: "number";
        int16: "number";
        u16: "number";
        uint16: "number";
        i32: "number";
        int32: "number";
        u32: "number";
        uint32: "number";
        i64: "bigint";
        int64: "bigint";
        u64: "bigint";
        uint64: "bigint";
        float: "number";
        f32: "number";
        double: "number";
        f64: "number";
        pointer: "pointer";
        ptr: "pointer";
        function: "pointer";
        buffer: "pointer";
        arraybuffer: "pointer";
        string: "pointer";
        str: "pointer";
    }
    interface ArgumentTypeMap {
        "number": number;
        "bigint": bigint;
        "pointer": bigint | string | ArrayBuffer | NodeJS.ArrayBufferView | null;
    }
    interface ReturnTypeMap {
        // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
        "void": void;
        "number": number;
        "bigint": bigint;
        "pointer": bigint | null;
    }
    enum types {
        VOID = "void",
        POINTER = "pointer",
        BUFFER = "buffer",
        ARRAY_BUFFER = "arraybuffer",
        FUNCTION = "function",
        BOOL = "bool",
        CHAR = "char",
        STRING = "string",
        FLOAT = "float",
        DOUBLE = "double",
        INT_8 = "int8",
        UINT_8 = "uint8",
        INT_16 = "int16",
        UINT_16 = "uint16",
        INT_32 = "int32",
        UINT_32 = "uint32",
        INT_64 = "int64",
        UINT_64 = "uint64",
        FLOAT_32 = "float32",
        FLOAT_64 = "float64",
    }
}

cmd: