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/timers.d.ts (7351B)

declare module "node:timers" {
    import { Abortable } from "node:events";
    import * as promises from "node:timers/promises";
    export interface TimerOptions extends Abortable {
        /**
         * Set to `false` to indicate that the scheduled `Timeout`
         * should not require the Node.js event loop to remain active.
         * @default true
         */
        ref?: boolean | undefined;
    }
    global {
        namespace NodeJS {
            /**
             * This object is created internally and is returned from `setImmediate()`. It
             * can be passed to `clearImmediate()` in order to cancel the scheduled
             * actions.
             *
             * By default, when an immediate is scheduled, the Node.js event loop will continue
             * running as long as the immediate is active. The `Immediate` object returned by
             * `setImmediate()` exports both `immediate.ref()` and `immediate.unref()`
             * functions that can be used to control this default behavior.
             */
            interface Immediate extends RefCounted, Disposable {
                /**
                 * If true, the `Immediate` object will keep the Node.js event loop active.
                 * @since v11.0.0
                 */
                hasRef(): boolean;
                /**
                 * When called, requests that the Node.js event loop _not_ exit so long as the
                 * `Immediate` is active. Calling `immediate.ref()` multiple times will have no
                 * effect.
                 *
                 * By default, all `Immediate` objects are "ref'ed", making it normally unnecessary
                 * to call `immediate.ref()` unless `immediate.unref()` had been called previously.
                 * @since v9.7.0
                 * @returns a reference to `immediate`
                 */
                ref(): this;
                /**
                 * When called, the active `Immediate` object will not require the Node.js event
                 * loop to remain active. If there is no other activity keeping the event loop
                 * running, the process may exit before the `Immediate` object's callback is
                 * invoked. Calling `immediate.unref()` multiple times will have no effect.
                 * @since v9.7.0
                 * @returns a reference to `immediate`
                 */
                unref(): this;
                /**
                 * Cancels the immediate. This is similar to calling `clearImmediate()`.
                 * @since v20.5.0, v18.18.0
                 */
                [Symbol.dispose](): void;
                _onImmediate(...args: any[]): void;
            }
            // Legacy interface used in Node.js v9 and prior
            // TODO: remove in a future major version bump
            /** @deprecated Use `NodeJS.Timeout` instead. */
            interface Timer extends RefCounted {
                hasRef(): boolean;
                refresh(): this;
                [Symbol.toPrimitive](): number;
            }
            /**
             * This object is created internally and is returned from `setTimeout()` and
             * `setInterval()`. It can be passed to either `clearTimeout()` or
             * `clearInterval()` in order to cancel the scheduled actions.
             *
             * By default, when a timer is scheduled using either `setTimeout()` or
             * `setInterval()`, the Node.js event loop will continue running as long as the
             * timer is active. Each of the `Timeout` objects returned by these functions
             * export both `timeout.ref()` and `timeout.unref()` functions that can be used to
             * control this default behavior.
             */
            interface Timeout extends RefCounted, Disposable, Timer {
                /**
                 * Cancels the timeout.
                 * @since v0.9.1
                 * @legacy Use `clearTimeout()` instead.
                 * @returns a reference to `timeout`
                 */
                close(): this;
                /**
                 * If true, the `Timeout` object will keep the Node.js event loop active.
                 * @since v11.0.0
                 */
                hasRef(): boolean;
                /**
                 * When called, requests that the Node.js event loop _not_ exit so long as the
                 * `Timeout` is active. Calling `timeout.ref()` multiple times will have no effect.
                 *
                 * By default, all `Timeout` objects are "ref'ed", making it normally unnecessary
                 * to call `timeout.ref()` unless `timeout.unref()` had been called previously.
                 * @since v0.9.1
                 * @returns a reference to `timeout`
                 */
                ref(): this;
                /**
                 * Sets the timer's start time to the current time, and reschedules the timer to
                 * call its callback at the previously specified duration adjusted to the current
                 * time. This is useful for refreshing a timer without allocating a new
                 * JavaScript object.
                 *
                 * Using this on a timer that has already called its callback will reactivate the
                 * timer.
                 * @since v10.2.0
                 * @returns a reference to `timeout`
                 */
                refresh(): this;
                /**
                 * When called, the active `Timeout` object will not require the Node.js event loop
                 * to remain active. If there is no other activity keeping the event loop running,
                 * the process may exit before the `Timeout` object's callback is invoked. Calling
                 * `timeout.unref()` multiple times will have no effect.
                 * @since v0.9.1
                 * @returns a reference to `timeout`
                 */
                unref(): this;
                /**
                 * Coerce a `Timeout` to a primitive. The primitive can be used to
                 * clear the `Timeout`. The primitive can only be used in the
                 * same thread where the timeout was created. Therefore, to use it
                 * across `worker_threads` it must first be passed to the correct
                 * thread. This allows enhanced compatibility with browser
                 * `setTimeout()` and `setInterval()` implementations.
                 * @since v14.9.0, v12.19.0
                 */
                [Symbol.toPrimitive](): number;
                /**
                 * Cancels the timeout.
                 * @since v20.5.0, v18.18.0
                 */
                [Symbol.dispose](): void;
                _onTimeout(...args: any[]): void;
            }
        }
    }
    import clearImmediate = globalThis.clearImmediate;
    import clearInterval = globalThis.clearInterval;
    import clearTimeout = globalThis.clearTimeout;
    import setImmediate = globalThis.setImmediate;
    import setInterval = globalThis.setInterval;
    import setTimeout = globalThis.setTimeout;
    export { clearImmediate, clearInterval, clearTimeout, promises, setImmediate, setInterval, setTimeout };
}
declare module "timers" {
    export * from "node:timers";
}

cmd: