FM / node

/var/www/qr4y.kz/server/delivery/node_modules/@types/node/

/var/www/qr4y.kz/server/delivery/node_modules/@types/node

Name	Size	Mode	Actions
assert/	-	0755	rm
dns/	-	0755	rm
fs/	-	0755	rm
stream/	-	0755	rm
timers/	-	0755	rm
assert.d.ts	38561	0755	edit dl rm
async_hooks.d.ts	20933	0755	edit dl rm
buffer.d.ts	102175	0755	edit dl rm
child_process.d.ts	66120	0755	edit dl rm
cluster.d.ts	20539	0755	edit dl rm
console.d.ts	18331	0755	edit dl rm
constants.d.ts	613	0755	edit dl rm
crypto.d.ts	152409	0755	edit dl rm
dgram.d.ts	26735	0755	edit dl rm
diagnostics_channel.d.ts	5936	0755	edit dl rm
dns.d.ts	29697	0755	edit dl rm
domain.d.ts	7805	0755	edit dl rm
events.d.ts	29065	0755	edit dl rm
fs.d.ts	176211	0755	edit dl rm
globals.d.ts	9252	0755	edit dl rm
globals.global.d.ts	39	0755	edit dl rm
http.d.ts	64373	0755	edit dl rm
http2.d.ts	112387	0755	edit dl rm
https.d.ts	21371	0755	edit dl rm
index.d.ts	6394	0755	edit dl rm
inspector.d.ts	125418	0755	edit dl rm
LICENSE	1141	0755	edit dl rm
module.d.ts	4089	0755	edit dl rm
net.d.ts	36766	0755	edit dl rm
os.d.ts	16674	0755	edit dl rm
package.json	5105	0755	edit dl rm
path.d.ts	7064	0755	edit dl rm
perf_hooks.d.ts	21036	0755	edit dl rm
process.d.ts	73093	0755	edit dl rm
punycode.d.ts	5482	0755	edit dl rm
querystring.d.ts	6487	0755	edit dl rm
readline.d.ts	26488	0755	edit dl rm
README.md	2499	0755	edit dl rm
repl.d.ts	19463	0755	edit dl rm
stream.d.ts	64203	0755	edit dl rm
string_decoder.d.ts	2818	0755	edit dl rm
timers.d.ts	4604	0755	edit dl rm
tls.d.ts	50769	0755	edit dl rm
trace_events.d.ts	6780	0755	edit dl rm
tty.d.ts	9854	0755	edit dl rm
url.d.ts	39297	0755	edit dl rm
util.d.ts	64299	0755	edit dl rm
v8.d.ts	15269	0755	edit dl rm
vm.d.ts	20970	0755	edit dl rm
wasi.d.ts	7051	0755	edit dl rm
worker_threads.d.ts	32234	0755	edit dl rm
zlib.d.ts	19520	0755	edit dl rm

Edit: /var/www/qr4y.kz/server/delivery/node_modules/@types/node/globals.d.ts (9252B)

// Declare "static" methods in Error
interface ErrorConstructor {
    /** Create .stack property on a target object */
    captureStackTrace(targetObject: object, constructorOpt?: Function): void;

/**
     * Optional override for formatting stack traces
     *
     * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
     */
    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;

stackTraceLimit: number;
}

/*-----------------------------------------------*
 *                                               *
 *                   GLOBAL                      *
 *                                               *
 ------------------------------------------------*/

// For backwards compability
interface NodeRequire extends NodeJS.Require { }
interface RequireResolve extends NodeJS.RequireResolve { }
interface NodeModule extends NodeJS.Module { }

declare var process: NodeJS.Process;
declare var console: Console;

declare var __filename: string;
declare var __dirname: string;

declare var require: NodeRequire;
declare var module: NodeModule;

// Same as module.exports
declare var exports: any;

/**
 * Only available if `--expose-gc` is passed to the process.
 */
declare var gc: undefined | (() => void);

//#region borrowed
// from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
/** A controller object that allows you to abort one or more DOM requests as and when desired. */
interface AbortController {
    /**
     * Returns the AbortSignal object associated with this object.
     */

readonly signal: AbortSignal;
    /**
     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
     */
    abort(): void;
}

/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
interface AbortSignal {
    /**
     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
     */
    readonly aborted: boolean;
}

declare var AbortController: {
    prototype: AbortController;
    new(): AbortController;
};

declare var AbortSignal: {
    prototype: AbortSignal;
    new(): AbortSignal;
    // TODO: Add abort() static
};
//#endregion borrowed

//#region ArrayLike.at()
interface RelativeIndexable<T> {
    /**
     * Takes an integer value and returns the item at that index,
     * allowing for positive and negative integers.
     * Negative integers count back from the last item in the array.
     */
    at(index: number): T | undefined;
}
interface String extends RelativeIndexable<string> {}
interface Array<T> extends RelativeIndexable<T> {}
interface Int8Array extends RelativeIndexable<number> {}
interface Uint8Array extends RelativeIndexable<number> {}
interface Uint8ClampedArray extends RelativeIndexable<number> {}
interface Int16Array extends RelativeIndexable<number> {}
interface Uint16Array extends RelativeIndexable<number> {}
interface Int32Array extends RelativeIndexable<number> {}
interface Uint32Array extends RelativeIndexable<number> {}
interface Float32Array extends RelativeIndexable<number> {}
interface Float64Array extends RelativeIndexable<number> {}
interface BigInt64Array extends RelativeIndexable<bigint> {}
interface BigUint64Array extends RelativeIndexable<bigint> {}
//#endregion ArrayLike.at() end

/**
 * @since v17.0.0
 *
 * Creates a deep clone of an object.
 */
declare function structuredClone<T>(
    value: T,
    transfer?: { transfer: ReadonlyArray<import('worker_threads').TransferListItem> },
): T;

/*----------------------------------------------*
*                                               *
*               GLOBAL INTERFACES               *
*                                               *
*-----------------------------------------------*/
declare namespace NodeJS {
    interface CallSite {
        /**
         * Value of "this"
         */
        getThis(): unknown;

/**
         * Type of "this" as a string.
         * This is the name of the function stored in the constructor field of
         * "this", if available.  Otherwise the object's [[Class]] internal
         * property.
         */
        getTypeName(): string | null;

/**
         * Current function
         */
        getFunction(): Function | undefined;

/**
         * Name of the current function, typically its name property.
         * If a name property is not available an attempt will be made to try
         * to infer a name from the function's context.
         */
        getFunctionName(): string | null;

/**
         * Name of the property [of "this" or one of its prototypes] that holds
         * the current function
         */
        getMethodName(): string | null;

/**
         * Name of the script [if this function was defined in a script]
         */
        getFileName(): string | null;

/**
         * Current line number [if this function was defined in a script]
         */
        getLineNumber(): number | null;

/**
         * Current column number [if this function was defined in a script]
         */
        getColumnNumber(): number | null;

/**
         * A call site object representing the location where eval was called
         * [if this function was created using a call to eval]
         */
        getEvalOrigin(): string | undefined;

/**
         * Is this a toplevel invocation, that is, is "this" the global object?
         */
        isToplevel(): boolean;

/**
         * Does this call take place in code defined by a call to eval?
         */
        isEval(): boolean;

/**
         * Is this call in native V8 code?
         */
        isNative(): boolean;

/**
         * Is this a constructor call?
         */
        isConstructor(): boolean;
    }

interface ErrnoException extends Error {
        errno?: number | undefined;
        code?: string | undefined;
        path?: string | undefined;
        syscall?: string | undefined;
    }

interface ReadableStream extends EventEmitter {
        readable: boolean;
        read(size?: number): string | Buffer;
        setEncoding(encoding: BufferEncoding): this;
        pause(): this;
        resume(): this;
        isPaused(): boolean;
        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
        unpipe(destination?: WritableStream): this;
        unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
        wrap(oldStream: ReadableStream): this;
        [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
    }

interface WritableStream extends EventEmitter {
        writable: boolean;
        write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
        write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
        end(cb?: () => void): this;
        end(data: string | Uint8Array, cb?: () => void): this;
        end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
    }

interface ReadWriteStream extends ReadableStream, WritableStream { }

interface RefCounted {
        ref(): this;
        unref(): this;
    }

interface Require {
        (id: string): any;
        resolve: RequireResolve;
        cache: Dict<NodeModule>;
        /**
         * @deprecated
         */
        extensions: RequireExtensions;
        main: Module | undefined;
    }

interface RequireResolve {
        (id: string, options?: { paths?: string[] | undefined; }): string;
        paths(request: string): string[] | null;
    }

interface RequireExtensions extends Dict<(m: Module, filename: string) => any> {
        '.js': (m: Module, filename: string) => any;
        '.json': (m: Module, filename: string) => any;
        '.node': (m: Module, filename: string) => any;
    }
    interface Module {
        /**
         * `true` if the module is running during the Node.js preload
         */
        isPreloading: boolean;
        exports: any;
        require: Require;
        id: string;
        filename: string;
        loaded: boolean;
        /** @deprecated since v14.6.0 Please use `require.main` and `module.children` instead. */
        parent: Module | null | undefined;
        children: Module[];
        /**
         * @since v11.14.0
         *
         * The directory name of the module. This is usually the same as the path.dirname() of the module.id.
         */
        path: string;
        paths: string[];
    }

interface Dict<T> {
        [key: string]: T | undefined;
    }

interface ReadOnlyDict<T> {
        readonly [key: string]: T | undefined;
    }
}

cmd: