1 |
|
2 | interface ErrorConstructor {
|
3 |
|
4 | captureStackTrace(targetObject: object, constructorOpt?: Function): void;
|
5 |
|
6 | |
7 |
|
8 |
|
9 |
|
10 |
|
11 | prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
|
12 |
|
13 | stackTraceLimit: number;
|
14 | }
|
15 |
|
16 |
|
17 | interface String {
|
18 |
|
19 | trimLeft(): string;
|
20 |
|
21 | trimRight(): string;
|
22 |
|
23 |
|
24 | trimStart(): string;
|
25 |
|
26 | trimEnd(): string;
|
27 | }
|
28 |
|
29 | interface ImportMeta {
|
30 | url: string;
|
31 | }
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 |
|
40 | interface NodeRequire extends NodeJS.Require { }
|
41 | interface RequireResolve extends NodeJS.RequireResolve { }
|
42 | interface NodeModule extends NodeJS.Module { }
|
43 |
|
44 | declare var process: NodeJS.Process;
|
45 | declare var console: Console;
|
46 |
|
47 | declare var __filename: string;
|
48 | declare var __dirname: string;
|
49 |
|
50 | declare function setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
|
51 | declare namespace setTimeout {
|
52 | function __promisify__(ms: number): Promise<void>;
|
53 | function __promisify__<T>(ms: number, value: T): Promise<T>;
|
54 | }
|
55 | declare function clearTimeout(timeoutId: NodeJS.Timeout): void;
|
56 | declare function setInterval(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
|
57 | declare function clearInterval(intervalId: NodeJS.Timeout): void;
|
58 | declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
|
59 | declare namespace setImmediate {
|
60 | function __promisify__(): Promise<void>;
|
61 | function __promisify__<T>(value: T): Promise<T>;
|
62 | }
|
63 | declare function clearImmediate(immediateId: NodeJS.Immediate): void;
|
64 |
|
65 | declare function queueMicrotask(callback: () => void): void;
|
66 |
|
67 | declare var require: NodeRequire;
|
68 | declare var module: NodeModule;
|
69 |
|
70 | // Same as module.exports
|
71 | declare var exports: any;
|
72 |
|
73 | // Buffer class
|
74 | type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
|
75 |
|
76 | type WithImplicitCoercion<T> = T | { valueOf(): T };
|
77 |
|
78 |
|
79 |
|
80 |
|
81 |
|
82 |
|
83 | declare class Buffer extends Uint8Array {
|
84 | |
85 |
|
86 |
|
87 |
|
88 |
|
89 |
|
90 |
|
91 | constructor(str: string, encoding?: BufferEncoding);
|
92 | /**
|
93 | * Allocates a new buffer of {size} octets.
|
94 | *
|
95 | * @param size count of octets to allocate.
|
96 | * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
|
97 | */
|
98 | constructor(size: number);
|
99 | /**
|
100 | * Allocates a new buffer containing the given {array} of octets.
|
101 | *
|
102 | * @param array The octets to store.
|
103 | * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
|
104 | */
|
105 | constructor(array: Uint8Array);
|
106 | /**
|
107 | * Produces a Buffer backed by the same allocated memory as
|
108 | * the given {ArrayBuffer}/{SharedArrayBuffer}.
|
109 | *
|
110 | *
|
111 | * @param arrayBuffer The ArrayBuffer with which to share memory.
|
112 | * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
|
113 | */
|
114 | constructor(arrayBuffer: ArrayBuffer | SharedArrayBuffer);
|
115 | /**
|
116 | * Allocates a new buffer containing the given {array} of octets.
|
117 | *
|
118 | * @param array The octets to store.
|
119 | * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
|
120 | */
|
121 | constructor(array: ReadonlyArray<any>);
|
122 | /**
|
123 | * Copies the passed {buffer} data onto a new {Buffer} instance.
|
124 | *
|
125 | * @param buffer The buffer to copy.
|
126 | * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
|
127 | */
|
128 | constructor(buffer: Buffer);
|
129 | /**
|
130 | * When passed a reference to the .buffer property of a TypedArray instance,
|
131 | * the newly created Buffer will share the same allocated memory as the TypedArray.
|
132 | * The optional {byteOffset} and {length} arguments specify a memory range
|
133 | * within the {arrayBuffer} that will be shared by the Buffer.
|
134 | *
|
135 | * @param arrayBuffer The .buffer property of any TypedArray or a new ArrayBuffer()
|
136 | */
|
137 | static from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
|
138 | |
139 |
|
140 |
|
141 |
|
142 | static from(data: Uint8Array | ReadonlyArray<number>): Buffer;
|
143 | static from(data: WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>): Buffer;
|
144 | |
145 |
|
146 |
|
147 |
|
148 |
|
149 | static from(str: WithImplicitCoercion<string> | { [Symbol.toPrimitive](hint: 'string'): string }, encoding?: BufferEncoding): Buffer;
|
150 | |
151 |
|
152 |
|
153 |
|
154 | static of(...items: number[]): Buffer;
|
155 | |
156 |
|
157 |
|
158 |
|
159 |
|
160 | static isBuffer(obj: any): obj is Buffer;
|
161 | |
162 |
|
163 |
|
164 |
|
165 |
|
166 |
|
167 | static isEncoding(encoding: string): encoding is BufferEncoding;
|
168 | |
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 | static byteLength(
|
176 | string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
|
177 | encoding?: BufferEncoding
|
178 | ): number;
|
179 | |
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 | static concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;
|
191 | |
192 |
|
193 |
|
194 | static compare(buf1: Uint8Array, buf2: Uint8Array): number;
|
195 | |
196 |
|
197 |
|
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 | static alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
|
204 | |
205 |
|
206 |
|
207 |
|
208 |
|
209 |
|
210 | static allocUnsafe(size: number): Buffer;
|
211 | |
212 |
|
213 |
|
214 |
|
215 |
|
216 |
|
217 | static allocUnsafeSlow(size: number): Buffer;
|
218 | |
219 |
|
220 |
|
221 | static poolSize: number;
|
222 |
|
223 | write(string: string, encoding?: BufferEncoding): number;
|
224 | write(string: string, offset: number, encoding?: BufferEncoding): number;
|
225 | write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
|
226 | toString(encoding?: BufferEncoding, start?: number, end?: number): string;
|
227 | toJSON(): { type: 'Buffer'; data: number[] };
|
228 | equals(otherBuffer: Uint8Array): boolean;
|
229 | compare(
|
230 | otherBuffer: Uint8Array,
|
231 | targetStart?: number,
|
232 | targetEnd?: number,
|
233 | sourceStart?: number,
|
234 | sourceEnd?: number
|
235 | ): number;
|
236 | copy(targetBuffer: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
|
237 | |
238 |
|
239 |
|
240 |
|
241 |
|
242 |
|
243 |
|
244 |
|
245 | slice(begin?: number, end?: number): Buffer;
|
246 | |
247 |
|
248 |
|
249 |
|
250 |
|
251 |
|
252 |
|
253 |
|
254 | subarray(begin?: number, end?: number): Buffer;
|
255 | writeBigInt64BE(value: bigint, offset?: number): number;
|
256 | writeBigInt64LE(value: bigint, offset?: number): number;
|
257 | writeBigUInt64BE(value: bigint, offset?: number): number;
|
258 | writeBigUInt64LE(value: bigint, offset?: number): number;
|
259 | writeUIntLE(value: number, offset: number, byteLength: number): number;
|
260 | writeUIntBE(value: number, offset: number, byteLength: number): number;
|
261 | writeIntLE(value: number, offset: number, byteLength: number): number;
|
262 | writeIntBE(value: number, offset: number, byteLength: number): number;
|
263 | readBigUInt64BE(offset?: number): bigint;
|
264 | readBigUInt64LE(offset?: number): bigint;
|
265 | readBigInt64BE(offset?: number): bigint;
|
266 | readBigInt64LE(offset?: number): bigint;
|
267 | readUIntLE(offset: number, byteLength: number): number;
|
268 | readUIntBE(offset: number, byteLength: number): number;
|
269 | readIntLE(offset: number, byteLength: number): number;
|
270 | readIntBE(offset: number, byteLength: number): number;
|
271 | readUInt8(offset?: number): number;
|
272 | readUInt16LE(offset?: number): number;
|
273 | readUInt16BE(offset?: number): number;
|
274 | readUInt32LE(offset?: number): number;
|
275 | readUInt32BE(offset?: number): number;
|
276 | readInt8(offset?: number): number;
|
277 | readInt16LE(offset?: number): number;
|
278 | readInt16BE(offset?: number): number;
|
279 | readInt32LE(offset?: number): number;
|
280 | readInt32BE(offset?: number): number;
|
281 | readFloatLE(offset?: number): number;
|
282 | readFloatBE(offset?: number): number;
|
283 | readDoubleLE(offset?: number): number;
|
284 | readDoubleBE(offset?: number): number;
|
285 | reverse(): this;
|
286 | swap16(): Buffer;
|
287 | swap32(): Buffer;
|
288 | swap64(): Buffer;
|
289 | writeUInt8(value: number, offset?: number): number;
|
290 | writeUInt16LE(value: number, offset?: number): number;
|
291 | writeUInt16BE(value: number, offset?: number): number;
|
292 | writeUInt32LE(value: number, offset?: number): number;
|
293 | writeUInt32BE(value: number, offset?: number): number;
|
294 | writeInt8(value: number, offset?: number): number;
|
295 | writeInt16LE(value: number, offset?: number): number;
|
296 | writeInt16BE(value: number, offset?: number): number;
|
297 | writeInt32LE(value: number, offset?: number): number;
|
298 | writeInt32BE(value: number, offset?: number): number;
|
299 | writeFloatLE(value: number, offset?: number): number;
|
300 | writeFloatBE(value: number, offset?: number): number;
|
301 | writeDoubleLE(value: number, offset?: number): number;
|
302 | writeDoubleBE(value: number, offset?: number): number;
|
303 |
|
304 | fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
|
305 |
|
306 | indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
|
307 | lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
|
308 | entries(): IterableIterator<[number, number]>;
|
309 | includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
|
310 | keys(): IterableIterator<number>;
|
311 | values(): IterableIterator<number>;
|
312 | }
|
313 |
|
314 |
|
315 |
|
316 |
|
317 | interface AbortController {
|
318 | |
319 |
|
320 |
|
321 |
|
322 | readonly signal: AbortSignal;
|
323 | |
324 |
|
325 |
|
326 | abort(): void;
|
327 | }
|
328 |
|
329 |
|
330 | interface AbortSignal {
|
331 | |
332 |
|
333 |
|
334 | readonly aborted: boolean;
|
335 | }
|
336 |
|
337 | declare var AbortController: {
|
338 | prototype: AbortController;
|
339 | new(): AbortController;
|
340 | };
|
341 |
|
342 | declare var AbortSignal: {
|
343 | prototype: AbortSignal;
|
344 | new(): AbortSignal;
|
345 |
|
346 | };
|
347 |
|
348 |
|
349 |
|
350 |
|
351 |
|
352 |
|
353 |
|
354 | declare namespace NodeJS {
|
355 | interface InspectOptions {
|
356 | |
357 |
|
358 |
|
359 |
|
360 |
|
361 |
|
362 |
|
363 |
|
364 | getters?: 'get' | 'set' | boolean;
|
365 | showHidden?: boolean;
|
366 | |
367 |
|
368 |
|
369 | depth?: number | null;
|
370 | colors?: boolean;
|
371 | customInspect?: boolean;
|
372 | showProxy?: boolean;
|
373 | maxArrayLength?: number | null;
|
374 | |
375 |
|
376 |
|
377 |
|
378 |
|
379 |
|
380 | maxStringLength?: number | null;
|
381 | breakLength?: number;
|
382 | |
383 |
|
384 |
|
385 |
|
386 |
|
387 |
|
388 |
|
389 |
|
390 |
|
391 |
|
392 | compact?: boolean | number;
|
393 | sorted?: boolean | ((a: string, b: string) => number);
|
394 | }
|
395 |
|
396 | interface CallSite {
|
397 | /**
|
398 | * Value of "this"
|
399 | */
|
400 | getThis(): any;
|
401 |
|
402 | /**
|
403 | * Type of "this" as a string.
|
404 | * This is the name of the function stored in the constructor field of
|
405 | * "this", if available. Otherwise the object's [[Class]] internal
|
406 | * property.
|
407 | */
|
408 | getTypeName(): string | null;
|
409 |
|
410 | /**
|
411 | * Current function
|
412 | */
|
413 | getFunction(): Function | undefined;
|
414 |
|
415 | /**
|
416 | * Name of the current function, typically its name property.
|
417 | * If a name property is not available an attempt will be made to try
|
418 | * to infer a name from the function's context.
|
419 | */
|
420 | getFunctionName(): string | null;
|
421 |
|
422 | /**
|
423 | * Name of the property [of "this" or one of its prototypes] that holds
|
424 | * the current function
|
425 | */
|
426 | getMethodName(): string | null;
|
427 |
|
428 | /**
|
429 | * Name of the script [if this function was defined in a script]
|
430 | */
|
431 | getFileName(): string | null;
|
432 |
|
433 | /**
|
434 | * Current line number [if this function was defined in a script]
|
435 | */
|
436 | getLineNumber(): number | null;
|
437 |
|
438 | /**
|
439 | * Current column number [if this function was defined in a script]
|
440 | */
|
441 | getColumnNumber(): number | null;
|
442 |
|
443 | /**
|
444 | * A call site object representing the location where eval was called
|
445 | * [if this function was created using a call to eval]
|
446 | */
|
447 | getEvalOrigin(): string | undefined;
|
448 |
|
449 | /**
|
450 | * Is this a toplevel invocation, that is, is "this" the global object?
|
451 | */
|
452 | isToplevel(): boolean;
|
453 |
|
454 | /**
|
455 | * Does this call take place in code defined by a call to eval?
|
456 | */
|
457 | isEval(): boolean;
|
458 |
|
459 | /**
|
460 | * Is this call in native V8 code?
|
461 | */
|
462 | isNative(): boolean;
|
463 |
|
464 | /**
|
465 | * Is this a constructor call?
|
466 | */
|
467 | isConstructor(): boolean;
|
468 | }
|
469 |
|
470 | interface ErrnoException extends Error {
|
471 | errno?: number;
|
472 | code?: string;
|
473 | path?: string;
|
474 | syscall?: string;
|
475 | stack?: string;
|
476 | }
|
477 |
|
478 | interface ReadableStream extends EventEmitter {
|
479 | readable: boolean;
|
480 | read(size?: number): string | Buffer;
|
481 | setEncoding(encoding: BufferEncoding): this;
|
482 | pause(): this;
|
483 | resume(): this;
|
484 | isPaused(): boolean;
|
485 | pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
486 | unpipe(destination?: WritableStream): this;
|
487 | unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
|
488 | wrap(oldStream: ReadableStream): this;
|
489 | [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
|
490 | }
|
491 |
|
492 | interface WritableStream extends EventEmitter {
|
493 | writable: boolean;
|
494 | write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
|
495 | write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
|
496 | end(cb?: () => void): void;
|
497 | end(data: string | Uint8Array, cb?: () => void): void;
|
498 | end(str: string, encoding?: BufferEncoding, cb?: () => void): void;
|
499 | }
|
500 |
|
501 | interface ReadWriteStream extends ReadableStream, WritableStream { }
|
502 |
|
503 | interface Global {
|
504 | AbortController: typeof AbortController;
|
505 | AbortSignal: typeof AbortSignal;
|
506 | Array: typeof Array;
|
507 | ArrayBuffer: typeof ArrayBuffer;
|
508 | Boolean: typeof Boolean;
|
509 | Buffer: typeof Buffer;
|
510 | DataView: typeof DataView;
|
511 | Date: typeof Date;
|
512 | Error: typeof Error;
|
513 | EvalError: typeof EvalError;
|
514 | Float32Array: typeof Float32Array;
|
515 | Float64Array: typeof Float64Array;
|
516 | Function: typeof Function;
|
517 | Infinity: typeof Infinity;
|
518 | Int16Array: typeof Int16Array;
|
519 | Int32Array: typeof Int32Array;
|
520 | Int8Array: typeof Int8Array;
|
521 | Intl: typeof Intl;
|
522 | JSON: typeof JSON;
|
523 | Map: MapConstructor;
|
524 | Math: typeof Math;
|
525 | NaN: typeof NaN;
|
526 | Number: typeof Number;
|
527 | Object: typeof Object;
|
528 | Promise: typeof Promise;
|
529 | RangeError: typeof RangeError;
|
530 | ReferenceError: typeof ReferenceError;
|
531 | RegExp: typeof RegExp;
|
532 | Set: SetConstructor;
|
533 | String: typeof String;
|
534 | Symbol: Function;
|
535 | SyntaxError: typeof SyntaxError;
|
536 | TypeError: typeof TypeError;
|
537 | URIError: typeof URIError;
|
538 | Uint16Array: typeof Uint16Array;
|
539 | Uint32Array: typeof Uint32Array;
|
540 | Uint8Array: typeof Uint8Array;
|
541 | Uint8ClampedArray: typeof Uint8ClampedArray;
|
542 | WeakMap: WeakMapConstructor;
|
543 | WeakSet: WeakSetConstructor;
|
544 | clearImmediate: (immediateId: Immediate) => void;
|
545 | clearInterval: (intervalId: Timeout) => void;
|
546 | clearTimeout: (timeoutId: Timeout) => void;
|
547 | decodeURI: typeof decodeURI;
|
548 | decodeURIComponent: typeof decodeURIComponent;
|
549 | encodeURI: typeof encodeURI;
|
550 | encodeURIComponent: typeof encodeURIComponent;
|
551 | escape: (str: string) => string;
|
552 | eval: typeof eval;
|
553 | global: Global;
|
554 | isFinite: typeof isFinite;
|
555 | isNaN: typeof isNaN;
|
556 | parseFloat: typeof parseFloat;
|
557 | parseInt: typeof parseInt;
|
558 | setImmediate: (callback: (...args: any[]) => void, ...args: any[]) => Immediate;
|
559 | setInterval: (callback: (...args: any[]) => void, ms?: number, ...args: any[]) => Timeout;
|
560 | setTimeout: (callback: (...args: any[]) => void, ms?: number, ...args: any[]) => Timeout;
|
561 | queueMicrotask: typeof queueMicrotask;
|
562 | undefined: typeof undefined;
|
563 | unescape: (str: string) => string;
|
564 | gc: () => void;
|
565 | v8debug?: any;
|
566 | }
|
567 |
|
568 | interface RefCounted {
|
569 | ref(): this;
|
570 | unref(): this;
|
571 | }
|
572 |
|
573 |
|
574 | interface Timer extends RefCounted {
|
575 | hasRef(): boolean;
|
576 | refresh(): this;
|
577 | [Symbol.toPrimitive](): number;
|
578 | }
|
579 |
|
580 | interface Immediate extends RefCounted {
|
581 | hasRef(): boolean;
|
582 | _onImmediate: Function;
|
583 | }
|
584 |
|
585 | interface Timeout extends Timer {
|
586 | hasRef(): boolean;
|
587 | refresh(): this;
|
588 | [Symbol.toPrimitive](): number;
|
589 | }
|
590 |
|
591 | type TypedArray =
|
592 | | Uint8Array
|
593 | | Uint8ClampedArray
|
594 | | Uint16Array
|
595 | | Uint32Array
|
596 | | Int8Array
|
597 | | Int16Array
|
598 | | Int32Array
|
599 | | BigUint64Array
|
600 | | BigInt64Array
|
601 | | Float32Array
|
602 | | Float64Array;
|
603 | type ArrayBufferView = TypedArray | DataView;
|
604 |
|
605 | interface Require {
|
606 | (id: string): any;
|
607 | resolve: RequireResolve;
|
608 | cache: Dict<NodeModule>;
|
609 | |
610 |
|
611 |
|
612 | extensions: RequireExtensions;
|
613 | main: Module | undefined;
|
614 | }
|
615 |
|
616 | interface RequireResolve {
|
617 | (id: string, options?: { paths?: string[]; }): string;
|
618 | paths(request: string): string[] | null;
|
619 | }
|
620 |
|
621 | interface RequireExtensions extends Dict<(m: Module, filename: string) => any> {
|
622 | '.js': (m: Module, filename: string) => any;
|
623 | '.json': (m: Module, filename: string) => any;
|
624 | '.node': (m: Module, filename: string) => any;
|
625 | }
|
626 | interface Module {
|
627 | |
628 |
|
629 |
|
630 | isPreloading: boolean;
|
631 | exports: any;
|
632 | require: Require;
|
633 | id: string;
|
634 | filename: string;
|
635 | loaded: boolean;
|
636 |
|
637 | parent: Module | null | undefined;
|
638 | children: Module[];
|
639 | |
640 |
|
641 |
|
642 |
|
643 |
|
644 | path: string;
|
645 | paths: string[];
|
646 | }
|
647 |
|
648 | interface Dict<T> {
|
649 | [key: string]: T | undefined;
|
650 | }
|
651 |
|
652 | interface ReadOnlyDict<T> {
|
653 | readonly [key: string]: T | undefined;
|
654 | }
|
655 | }
|