FM / ts4.8

/var/www/greso.tech/server/nsm/node_modules/@types/node/ts4.8/

/var/www/greso.tech/server/nsm/node_modules/@types/node/ts4.8

Name	Size	Mode	Actions
assert/	-	0755	rm
dns/	-	0755	rm
fs/	-	0755	rm
readline/	-	0755	rm
stream/	-	0755	rm
timers/	-	0755	rm
assert.d.ts	41218	0755	edit dl rm
async_hooks.d.ts	22585	0755	edit dl rm
buffer.d.ts	107224	0755	edit dl rm
child_process.d.ts	67998	0755	edit dl rm
cluster.d.ts	20640	0755	edit dl rm
console.d.ts	18342	0755	edit dl rm
constants.d.ts	613	0755	edit dl rm
crypto.d.ts	183913	0755	edit dl rm
dgram.d.ts	26787	0755	edit dl rm
diagnostics_channel.d.ts	7685	0755	edit dl rm
dns.d.ts	30126	0755	edit dl rm
dom-events.d.ts	5521	0755	edit dl rm
domain.d.ts	7820	0755	edit dl rm
events.d.ts	34401	0755	edit dl rm
fs.d.ts	182973	0755	edit dl rm
globals.d.ts	9714	0755	edit dl rm
globals.global.d.ts	39	0755	edit dl rm
http.d.ts	79056	0755	edit dl rm
http2.d.ts	113815	0755	edit dl rm
https.d.ts	23594	0755	edit dl rm
index.d.ts	3751	0755	edit dl rm
inspector.d.ts	125369	0755	edit dl rm
module.d.ts	4259	0755	edit dl rm
net.d.ts	40921	0755	edit dl rm
os.d.ts	18033	0755	edit dl rm
path.d.ts	7751	0755	edit dl rm
perf_hooks.d.ts	24303	0755	edit dl rm
process.d.ts	73684	0755	edit dl rm
punycode.d.ts	5482	0755	edit dl rm
querystring.d.ts	6545	0755	edit dl rm
readline.d.ts	22862	0755	edit dl rm
repl.d.ts	19489	0755	edit dl rm
stream.d.ts	72452	0755	edit dl rm
string_decoder.d.ts	2838	0755	edit dl rm
test.d.ts	43820	0755	edit dl rm
timers.d.ts	11675	0755	edit dl rm
tls.d.ts	54923	0755	edit dl rm
trace_events.d.ts	7928	0755	edit dl rm
tty.d.ts	10053	0755	edit dl rm
url.d.ts	39490	0755	edit dl rm
util.d.ts	82262	0755	edit dl rm
v8.d.ts	26127	0755	edit dl rm
vm.d.ts	38873	0755	edit dl rm
wasi.d.ts	6874	0755	edit dl rm
worker_threads.d.ts	33894	0755	edit dl rm
zlib.d.ts	19561	0755	edit dl rm

Edit: /var/www/greso.tech/server/nsm/node_modules/@types/node/ts4.8/domain.d.ts (7820B)

/**
 * **This module is pending deprecation.** Once a replacement API has been
 * finalized, this module will be fully deprecated. Most developers should
 * **not** have cause to use this module. Users who absolutely must have
 * the functionality that domains provide may rely on it for the time being
 * but should expect to have to migrate to a different solution
 * in the future.
 *
 * Domains provide a way to handle multiple different IO operations as a
 * single group. If any of the event emitters or callbacks registered to a
 * domain emit an `'error'` event, or throw an error, then the domain object
 * will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
 * exit immediately with an error code.
 * @deprecated Since v1.4.2 - Deprecated
 * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/domain.js)
 */
declare module 'domain' {
    import EventEmitter = require('node:events');
    /**
     * The `Domain` class encapsulates the functionality of routing errors and
     * uncaught exceptions to the active `Domain` object.
     *
     * To handle the errors that it catches, listen to its `'error'` event.
     */
    class Domain extends EventEmitter {
        /**
         * An array of timers and event emitters that have been explicitly added
         * to the domain.
         */
        members: Array<EventEmitter | NodeJS.Timer>;
        /**
         * The `enter()` method is plumbing used by the `run()`, `bind()`, and`intercept()` methods to set the active domain. It sets `domain.active` and`process.domain` to the domain, and implicitly
         * pushes the domain onto the domain
         * stack managed by the domain module (see {@link exit} for details on the
         * domain stack). The call to `enter()` delimits the beginning of a chain of
         * asynchronous calls and I/O operations bound to a domain.
         *
         * Calling `enter()` changes only the active domain, and does not alter the domain
         * itself. `enter()` and `exit()` can be called an arbitrary number of times on a
         * single domain.
         */
        enter(): void;
        /**
         * The `exit()` method exits the current domain, popping it off the domain stack.
         * Any time execution is going to switch to the context of a different chain of
         * asynchronous calls, it's important to ensure that the current domain is exited.
         * The call to `exit()` delimits either the end of or an interruption to the chain
         * of asynchronous calls and I/O operations bound to a domain.
         *
         * If there are multiple, nested domains bound to the current execution context,`exit()` will exit any domains nested within this domain.
         *
         * Calling `exit()` changes only the active domain, and does not alter the domain
         * itself. `enter()` and `exit()` can be called an arbitrary number of times on a
         * single domain.
         */
        exit(): void;
        /**
         * Run the supplied function in the context of the domain, implicitly
         * binding all event emitters, timers, and low-level requests that are
         * created in that context. Optionally, arguments can be passed to
         * the function.
         *
         * This is the most basic way to use a domain.
         *
         * ```js
         * const domain = require('node:domain');
         * const fs = require('node:fs');
         * const d = domain.create();
         * d.on('error', (er) => {
         *   console.error('Caught error!', er);
         * });
         * d.run(() => {
         *   process.nextTick(() => {
         *     setTimeout(() => { // Simulating some various async stuff
         *       fs.open('non-existent file', 'r', (er, fd) => {
         *         if (er) throw er;
         *         // proceed...
         *       });
         *     }, 100);
         *   });
         * });
         * ```
         *
         * In this example, the `d.on('error')` handler will be triggered, rather
         * than crashing the program.
         */
        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
        /**
         * Explicitly adds an emitter to the domain. If any event handlers called by
         * the emitter throw an error, or if the emitter emits an `'error'` event, it
         * will be routed to the domain's `'error'` event, just like with implicit
         * binding.
         *
         * This also works with timers that are returned from `setInterval()` and `setTimeout()`. If their callback function throws, it will be caught by
         * the domain `'error'` handler.
         *
         * If the Timer or `EventEmitter` was already bound to a domain, it is removed
         * from that one, and bound to this one instead.
         * @param emitter emitter or timer to be added to the domain
         */
        add(emitter: EventEmitter | NodeJS.Timer): void;
        /**
         * The opposite of {@link add}. Removes domain handling from the
         * specified emitter.
         * @param emitter emitter or timer to be removed from the domain
         */
        remove(emitter: EventEmitter | NodeJS.Timer): void;
        /**
         * The returned function will be a wrapper around the supplied callback
         * function. When the returned function is called, any errors that are
         * thrown will be routed to the domain's `'error'` event.
         *
         * ```js
         * const d = domain.create();
         *
         * function readSomeFile(filename, cb) {
         *   fs.readFile(filename, 'utf8', d.bind((er, data) => {
         *     // If this throws, it will also be passed to the domain.
         *     return cb(er, data ? JSON.parse(data) : null);
         *   }));
         * }
         *
         * d.on('error', (er) => {
         *   // An error occurred somewhere. If we throw it now, it will crash the program
         *   // with the normal line number and stack message.
         * });
         * ```
         * @param callback The callback function
         * @return The bound function
         */
        bind<T extends Function>(callback: T): T;
        /**
         * This method is almost identical to {@link bind}. However, in
         * addition to catching thrown errors, it will also intercept `Error` objects sent as the first argument to the function.
         *
         * In this way, the common `if (err) return callback(err);` pattern can be replaced
         * with a single error handler in a single place.
         *
         * ```js
         * const d = domain.create();
         *
         * function readSomeFile(filename, cb) {
         *   fs.readFile(filename, 'utf8', d.intercept((data) => {
         *     // Note, the first argument is never passed to the
         *     // callback since it is assumed to be the 'Error' argument
         *     // and thus intercepted by the domain.
         *
         *     // If this throws, it will also be passed to the domain
         *     // so the error-handling logic can be moved to the 'error'
         *     // event on the domain instead of being repeated throughout
         *     // the program.
         *     return cb(null, JSON.parse(data));
         *   }));
         * }
         *
         * d.on('error', (er) => {
         *   // An error occurred somewhere. If we throw it now, it will crash the program
         *   // with the normal line number and stack message.
         * });
         * ```
         * @param callback The callback function
         * @return The intercepted function
         */
        intercept<T extends Function>(callback: T): T;
    }
    function create(): Domain;
}
declare module 'node:domain' {
    export * from 'domain';
}

cmd: