@types/node 16.4.8 → 16.4.12

node/fs/promises.d.ts

@@ -108,8 +108,8 @@ declare module 'fs/promises' {
          * number of bytes read is zero.
          * @since v10.0.0
          * @param buffer A buffer that will be filled with the file data read.
-         * @param offset The location in the buffer at which to start filling.
-         * @param length The number of bytes to read.
+         * @param [offset=0] The location in the buffer at which to start filling.
+         * @param [length=buffer.byteLength] The number of bytes to read.
          * @param position The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an
          * integer, the current file position will remain unchanged.
          * @return Fulfills upon success with an object with two properties:
@@ -204,6 +204,7 @@ declare module 'fs/promises' {
          *
          * If `len` is negative then `0` will be used.
          * @since v10.0.0
+         * @param [len=0]
          * @return Fulfills with `undefined` upon success.
          */
         truncate(len?: number): Promise<void>;
@@ -242,8 +243,8 @@ declare module 'fs/promises' {
          * The kernel ignores the position argument and always appends the data to
          * the end of the file.
          * @since v10.0.0
-         * @param offset The start position from within `buffer` where the data to write begins.
-         * @param length The number of bytes from `buffer` to write.
+         * @param [offset=0] The start position from within `buffer` where the data to write begins.
+         * @param [length=buffer.byteLength] The number of bytes from `buffer` to write.
          * @param position The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position.
          * See the POSIX pwrite(2) documentation for more detail.
          */
@@ -336,6 +337,7 @@ declare module 'fs/promises' {
      * calls. Instead, user code should open/read/write the file directly and handle
      * the error raised if the file is not accessible.
      * @since v10.0.0
+     * @param [mode=fs.constants.F_OK]
      * @return Fulfills with `undefined` upon success.
      */
     function access(path: PathLike, mode?: number): Promise<void>;
@@ -369,7 +371,7 @@ declare module 'fs/promises' {
      * @since v10.0.0
      * @param src source filename to copy
      * @param dest destination filename of the copy operation
-     * @param mode Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g.
+     * @param [mode=0] Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g.
      * `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`)
      * @return Fulfills with `undefined` upon success.
      */
@@ -383,8 +385,8 @@ declare module 'fs/promises' {
      * by [Naming Files, Paths, and Namespaces](https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file). Under NTFS, if the filename contains
      * a colon, Node.js will open a file system stream, as described by[this MSDN page](https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams).
      * @since v10.0.0
-     * @param flags See `support of file system `flags``.
-     * @param mode Sets the file mode (permission and sticky bits) if the file is created.
+     * @param [flags='r'] See `support of file system `flags``.
+     * @param [mode=0o666] Sets the file mode (permission and sticky bits) if the file is created.
      * @return Fulfills with a {FileHandle} object.
      */
     function open(path: PathLike, flags: string | number, mode?: Mode): Promise<FileHandle>;
@@ -397,6 +399,7 @@ declare module 'fs/promises' {
     /**
      * Truncates (shortens or extends the length) of the content at `path` to `len`bytes.
      * @since v10.0.0
+     * @param [len=0]
      * @return Fulfills with `undefined` upon success.
      */
     function truncate(path: PathLike, len?: number): Promise<void>;
@@ -558,6 +561,7 @@ declare module 'fs/promises' {
      * to be absolute. When using `'junction'`, the `target` argument will
      * automatically be normalized to absolute path.
      * @since v10.0.0
+     * @param [type='file']
      * @return Fulfills with `undefined` upon success.
      */
     function symlink(target: PathLike, path: PathLike, type?: string | null): Promise<void>;

node/fs.d.ts

@@ -516,6 +516,7 @@ declare module 'fs' {
      *
      * See the POSIX [`truncate(2)`](http://man7.org/linux/man-pages/man2/truncate.2.html) documentation for more details.
      * @since v0.8.6
+     * @param [len=0]
      */
     export function truncate(path: PathLike, len: number | undefined | null, callback: NoParamCallback): void;
     /**
@@ -538,6 +539,7 @@ declare module 'fs' {
      * Passing a file descriptor is deprecated and may result in an error being thrown
      * in the future.
      * @since v0.8.6
+     * @param [len=0]
      */
     export function truncateSync(path: PathLike, len?: number | null): void;
     /**
@@ -581,6 +583,7 @@ declare module 'fs' {
      *
      * If `len` is negative then `0` will be used.
      * @since v0.8.6
+     * @param [len=0]
      */
     export function ftruncate(fd: number, len: number | undefined | null, callback: NoParamCallback): void;
     /**
@@ -602,6 +605,7 @@ declare module 'fs' {
      * For detailed information, see the documentation of the asynchronous version of
      * this API: {@link ftruncate}.
      * @since v0.8.6
+     * @param [len=0]
      */
     export function ftruncateSync(fd: number, len?: number | null): void;
     /**
@@ -1952,7 +1956,8 @@ declare module 'fs' {
      *
      * Functions based on `fs.open()` exhibit this behavior as well:`fs.writeFile()`, `fs.readFile()`, etc.
      * @since v0.0.2
-     * @param flags See `support of file system `flags``.
+     * @param [flags='r'] See `support of file system `flags``.
+     * @param [mode=0o666]
      */
     export function open(path: PathLike, flags: OpenMode, mode: Mode | undefined | null, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
     /**
@@ -1974,6 +1979,8 @@ declare module 'fs' {
      * For detailed information, see the documentation of the asynchronous version of
      * this API: {@link open}.
      * @since v0.1.21
+     * @param [flags='r']
+     * @param [mode=0o666]
      */
     export function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
     /**
@@ -2196,9 +2203,9 @@ declare module 'fs' {
      * If this method is invoked as its `util.promisify()` ed version, it returns
      * a promise for an `Object` with `bytesRead` and `buffer` properties.
      * @since v0.0.2
-     * @param buffer The buffer that the data will be written to.
-     * @param offset The position in `buffer` to write the data to.
-     * @param length The number of bytes to read.
+     * @param [buffer=Buffer.alloc(16384)] The buffer that the data will be written to.
+     * @param [offset=0] The position in `buffer` to write the data to.
+     * @param [length=buffer.byteLength] The number of bytes to read.
      * @param position Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If
      * `position` is an integer, the file position will be unchanged.
      */
@@ -2347,7 +2354,7 @@ declare module 'fs' {
                   encoding: BufferEncoding;
                   flag?: string | undefined;
               } & Abortable)
-            | string,
+            | BufferEncoding,
         callback: (err: NodeJS.ErrnoException | null, data: string) => void
     ): void;
     /**
@@ -2363,7 +2370,7 @@ declare module 'fs' {
             | (ObjectEncodingOptions & {
                   flag?: string | undefined;
               } & Abortable)
-            | string
+            | BufferEncoding
             | undefined
             | null,
         callback: (err: NodeJS.ErrnoException | null, data: string | Buffer) => void
@@ -2404,7 +2411,7 @@ declare module 'fs' {
                       encoding: BufferEncoding;
                       flag?: string | undefined;
                   }
-                | string
+                | BufferEncoding
         ): Promise<string>;
         /**
          * Asynchronously reads the entire contents of a file.
@@ -2420,7 +2427,7 @@ declare module 'fs' {
                 | (ObjectEncodingOptions & {
                       flag?: string | undefined;
                   })
-                | string
+                | BufferEncoding
                 | null
         ): Promise<string | Buffer>;
     }
@@ -2493,7 +2500,7 @@ declare module 'fs' {
                   mode?: Mode | undefined;
                   flag?: string | undefined;
               })
-        | string
+        | BufferEncoding
         | null;
     /**
      * When `file` is a filename, asynchronously writes data to the file, replacing the
@@ -2803,6 +2810,7 @@ declare module 'fs' {
      * If a `signal` is passed, aborting the corresponding AbortController will close
      * the returned `<fs.FSWatcher>`.
      * @since v0.5.10
+     * @param listener
      */
     export function watch(
         filename: PathLike,
@@ -3268,6 +3276,7 @@ declare module 'fs' {
      * ACL and therefore may report that a path is accessible even if the ACL restricts
      * the user from reading or writing to it.
      * @since v0.11.15
+     * @param [mode=fs.constants.F_OK]
      */
     export function access(path: PathLike, mode: number | undefined, callback: NoParamCallback): void;
     /**
@@ -3305,6 +3314,7 @@ declare module 'fs' {
      * }
      * ```
      * @since v0.11.15
+     * @param [mode=fs.constants.F_OK]
      */
     export function accessSync(path: PathLike, mode?: number): void;
     interface StreamOptions {
@@ -3474,7 +3484,7 @@ declare module 'fs' {
      * @since v8.5.0
      * @param src source filename to copy
      * @param dest destination filename of the copy operation
-     * @param mode modifiers for copy operation.
+     * @param [mode=0] modifiers for copy operation.
      */
     export function copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
     export function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
@@ -3513,7 +3523,7 @@ declare module 'fs' {
      * @since v8.5.0
      * @param src source filename to copy
      * @param dest destination filename of the copy operation
-     * @param mode modifiers for copy operation.
+     * @param [mode=0] modifiers for copy operation.
      */
     export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
     /**

node/http.d.ts

@@ -156,7 +156,12 @@ declare module 'http' {
         insecureHTTPParser?: boolean | undefined;
     }
     type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
-    interface HttpBase {
+    /**
+     * @since v0.1.17
+     */
+    class Server extends NetServer {
+        constructor(requestListener?: RequestListener);
+        constructor(options: ServerOptions, requestListener?: RequestListener);
         setTimeout(msecs?: number, callback?: () => void): this;
         setTimeout(callback: () => void): this;
         /**
@@ -179,14 +184,72 @@ declare module 'http' {
          * {@link https://nodejs.org/api/http.html#http_server_requesttimeout}
          */
         requestTimeout: number;
-    }
-    interface Server extends HttpBase {}
-    /**
-     * @since v0.1.17
-     */
-    class Server extends NetServer {
-        constructor(requestListener?: RequestListener);
-        constructor(options: ServerOptions, requestListener?: RequestListener);
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: 'close', listener: () => void): this;
+        addListener(event: 'connection', listener: (socket: Socket) => void): this;
+        addListener(event: 'error', listener: (err: Error) => void): this;
+        addListener(event: 'listening', listener: () => void): this;
+        addListener(event: 'checkContinue', listener: RequestListener): this;
+        addListener(event: 'checkExpectation', listener: RequestListener): this;
+        addListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
+        addListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        addListener(event: 'request', listener: RequestListener): this;
+        addListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        emit(event: string, ...args: any[]): boolean;
+        emit(event: 'close'): boolean;
+        emit(event: 'connection', socket: Socket): boolean;
+        emit(event: 'error', err: Error): boolean;
+        emit(event: 'listening'): boolean;
+        emit(event: 'checkContinue', req: IncomingMessage, res: ServerResponse): boolean;
+        emit(event: 'checkExpectation', req: IncomingMessage, res: ServerResponse): boolean;
+        emit(event: 'clientError', err: Error, socket: stream.Duplex): boolean;
+        emit(event: 'connect', req: IncomingMessage, socket: stream.Duplex, head: Buffer): boolean;
+        emit(event: 'request', req: IncomingMessage, res: ServerResponse): boolean;
+        emit(event: 'upgrade', req: IncomingMessage, socket: stream.Duplex, head: Buffer): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: 'close', listener: () => void): this;
+        on(event: 'connection', listener: (socket: Socket) => void): this;
+        on(event: 'error', listener: (err: Error) => void): this;
+        on(event: 'listening', listener: () => void): this;
+        on(event: 'checkContinue', listener: RequestListener): this;
+        on(event: 'checkExpectation', listener: RequestListener): this;
+        on(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
+        on(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        on(event: 'request', listener: RequestListener): this;
+        on(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: 'close', listener: () => void): this;
+        once(event: 'connection', listener: (socket: Socket) => void): this;
+        once(event: 'error', listener: (err: Error) => void): this;
+        once(event: 'listening', listener: () => void): this;
+        once(event: 'checkContinue', listener: RequestListener): this;
+        once(event: 'checkExpectation', listener: RequestListener): this;
+        once(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
+        once(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        once(event: 'request', listener: RequestListener): this;
+        once(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: 'close', listener: () => void): this;
+        prependListener(event: 'connection', listener: (socket: Socket) => void): this;
+        prependListener(event: 'error', listener: (err: Error) => void): this;
+        prependListener(event: 'listening', listener: () => void): this;
+        prependListener(event: 'checkContinue', listener: RequestListener): this;
+        prependListener(event: 'checkExpectation', listener: RequestListener): this;
+        prependListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
+        prependListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        prependListener(event: 'request', listener: RequestListener): this;
+        prependListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: 'close', listener: () => void): this;
+        prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
+        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+        prependOnceListener(event: 'listening', listener: () => void): this;
+        prependOnceListener(event: 'checkContinue', listener: RequestListener): this;
+        prependOnceListener(event: 'checkExpectation', listener: RequestListener): this;
+        prependOnceListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
+        prependOnceListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: 'request', listener: RequestListener): this;
+        prependOnceListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
     }
     /**
      * This class serves as the parent class of {@link ClientRequest} and {@link ServerResponse}. It is an abstract of outgoing message from

node/http2.d.ts

@@ -140,7 +140,7 @@ declare module 'http2' {
          * Closes the `Http2Stream` instance by sending an `RST_STREAM` frame to the
          * connected HTTP/2 peer.
          * @since v8.4.0
-         * @param code Unsigned 32-bit integer identifying the error code.
+         * @param [code=http2.constants.NGHTTP2_NO_ERROR] Unsigned 32-bit integer identifying the error code.
          * @param callback An optional function registered to listen for the `'close'` event.
          */
         close(code?: number, callback?: () => void): void;

node/https.d.ts

@@ -4,6 +4,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/https.js)
  */
 declare module 'https' {
+    import { Duplex } from 'node:stream';
     import * as tls from 'node:tls';
     import * as http from 'node:http';
     import { URL } from 'node:url';
@@ -25,7 +26,7 @@ declare module 'https' {
         constructor(options?: AgentOptions);
         options: AgentOptions;
     }
-    interface Server extends http.HttpBase {}
+    interface Server extends http.Server {}
     /**
      * See `http.Server` for more information.
      * @since v0.3.4
@@ -33,6 +34,108 @@ declare module 'https' {
     class Server extends tls.Server {
         constructor(requestListener?: http.RequestListener);
         constructor(options: ServerOptions, requestListener?: http.RequestListener);
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
+        addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        addListener(event: 'close', listener: () => void): this;
+        addListener(event: 'connection', listener: (socket: Duplex) => void): this;
+        addListener(event: 'error', listener: (err: Error) => void): this;
+        addListener(event: 'listening', listener: () => void): this;
+        addListener(event: 'checkContinue', listener: http.RequestListener): this;
+        addListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        addListener(event: 'request', listener: http.RequestListener): this;
+        addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        emit(event: string, ...args: any[]): boolean;
+        emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
+        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
+        emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
+        emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
+        emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
+        emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
+        emit(event: 'close'): boolean;
+        emit(event: 'connection', socket: Duplex): boolean;
+        emit(event: 'error', err: Error): boolean;
+        emit(event: 'listening'): boolean;
+        emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
+        emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): boolean;
+        emit(event: 'clientError', err: Error, socket: Duplex): boolean;
+        emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
+        emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
+        emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
+        on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        on(event: 'close', listener: () => void): this;
+        on(event: 'connection', listener: (socket: Duplex) => void): this;
+        on(event: 'error', listener: (err: Error) => void): this;
+        on(event: 'listening', listener: () => void): this;
+        on(event: 'checkContinue', listener: http.RequestListener): this;
+        on(event: 'checkExpectation', listener: http.RequestListener): this;
+        on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'request', listener: http.RequestListener): this;
+        on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
+        once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        once(event: 'close', listener: () => void): this;
+        once(event: 'connection', listener: (socket: Duplex) => void): this;
+        once(event: 'error', listener: (err: Error) => void): this;
+        once(event: 'listening', listener: () => void): this;
+        once(event: 'checkContinue', listener: http.RequestListener): this;
+        once(event: 'checkExpectation', listener: http.RequestListener): this;
+        once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'request', listener: http.RequestListener): this;
+        once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: 'close', listener: () => void): this;
+        prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
+        prependListener(event: 'error', listener: (err: Error) => void): this;
+        prependListener(event: 'listening', listener: () => void): this;
+        prependListener(event: 'checkContinue', listener: http.RequestListener): this;
+        prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependListener(event: 'request', listener: http.RequestListener): this;
+        prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: 'close', listener: () => void): this;
+        prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
+        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+        prependOnceListener(event: 'listening', listener: () => void): this;
+        prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
+        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: 'request', listener: http.RequestListener): this;
+        prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
     }
     /**
      * ```js

node/index.d.ts

@@ -42,6 +42,7 @@
 //                 Victor Perin <https://github.com/victorperin>
 //                 Yongsheng Zhang <https://github.com/ZYSzys>
 //                 NodeJS Contributors <https://github.com/NodeJS>
+//                 Linus Unnebäck <https://github.com/LinusU>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /**

node/net.d.ts

@@ -87,7 +87,7 @@ declare module 'net' {
          * See `Writable` stream `write()` method for more
          * information.
          * @since v0.1.90
-         * @param encoding Only used when data is `string`.
+         * @param [encoding='utf8'] Only used when data is `string`.
          */
         write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
         write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
@@ -165,6 +165,7 @@ declare module 'net' {
          * algorithm for the socket. Passing `false` for `noDelay` will enable Nagle's
          * algorithm.
          * @since v0.1.90
+         * @param [noDelay=true]
          * @return The socket itself.
          */
         setNoDelay(noDelay?: boolean): this;
@@ -183,6 +184,8 @@ declare module 'net' {
          * * `TCP_KEEPCNT=10`
          * * `TCP_KEEPINTVL=1`
          * @since v0.1.92
+         * @param [enable=false]
+         * @param [initialDelay=0]
          * @return The socket itself.
          */
         setKeepAlive(enable?: boolean, initialDelay?: number): this;
@@ -280,7 +283,7 @@ declare module 'net' {
          *
          * See `writable.end()` for further details.
          * @since v0.1.90
-         * @param encoding Only used when data is `string`.
+         * @param [encoding='utf8'] Only used when data is `string`.
          * @param callback Optional callback for when the socket is finished.
          * @return The socket itself.
          */
@@ -306,6 +309,7 @@ declare module 'net' {
         addListener(event: 'end', listener: () => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
         addListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        addListener(event: 'ready', listener: () => void): this;
         addListener(event: 'timeout', listener: () => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: 'close', hadError: boolean): boolean;
@@ -315,6 +319,7 @@ declare module 'net' {
         emit(event: 'end'): boolean;
         emit(event: 'error', err: Error): boolean;
         emit(event: 'lookup', err: Error, address: string, family: string | number, host: string): boolean;
+        emit(event: 'ready'): boolean;
         emit(event: 'timeout'): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'close', listener: (hadError: boolean) => void): this;
@@ -324,6 +329,7 @@ declare module 'net' {
         on(event: 'end', listener: () => void): this;
         on(event: 'error', listener: (err: Error) => void): this;
         on(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        on(event: 'ready', listener: () => void): this;
         on(event: 'timeout', listener: () => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'close', listener: (hadError: boolean) => void): this;
@@ -333,6 +339,7 @@ declare module 'net' {
         once(event: 'end', listener: () => void): this;
         once(event: 'error', listener: (err: Error) => void): this;
         once(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        once(event: 'ready', listener: () => void): this;
         once(event: 'timeout', listener: () => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'close', listener: (hadError: boolean) => void): this;
@@ -342,6 +349,7 @@ declare module 'net' {
         prependListener(event: 'end', listener: () => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
         prependListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        prependListener(event: 'ready', listener: () => void): this;
         prependListener(event: 'timeout', listener: () => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'close', listener: (hadError: boolean) => void): this;
@@ -351,6 +359,7 @@ declare module 'net' {
         prependOnceListener(event: 'end', listener: () => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        prependOnceListener(event: 'ready', listener: () => void): this;
         prependOnceListener(event: 'timeout', listener: () => void): this;
     }
     interface ListenOptions extends Abortable {
@@ -558,7 +567,7 @@ declare module 'net' {
          * Adds a rule to block the given IP address.
          * @since v15.0.0
          * @param address An IPv4 or IPv6 address.
-         * @param type Either `'ipv4'` or `'ipv6'`.
+         * @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
          */
         addAddress(address: string, type?: IPVersion): void;
         addAddress(address: SocketAddress): void;
@@ -567,7 +576,7 @@ declare module 'net' {
          * @since v15.0.0
          * @param start The starting IPv4 or IPv6 address in the range.
          * @param end The ending IPv4 or IPv6 address in the range.
-         * @param type Either `'ipv4'` or `'ipv6'`.
+         * @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
          */
         addRange(start: string, end: string, type?: IPVersion): void;
         addRange(start: SocketAddress, end: SocketAddress): void;
@@ -576,7 +585,7 @@ declare module 'net' {
          * @since v15.0.0
          * @param net The network IPv4 or IPv6 address.
          * @param prefix The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`.
-         * @param type Either `'ipv4'` or `'ipv6'`.
+         * @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
          */
         addSubnet(net: SocketAddress, prefix: number): void;
         addSubnet(net: string, prefix: number, type?: IPVersion): void;
@@ -599,7 +608,7 @@ declare module 'net' {
          * ```
          * @since v15.0.0
          * @param address The IP address to check
-         * @param type Either `'ipv4'` or `'ipv6'`.
+         * @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
          */
         check(address: SocketAddress): boolean;
         check(address: string, type?: IPVersion): boolean;

node/os.d.ts

@@ -430,7 +430,7 @@ declare module 'os' {
      * Returns the scheduling priority for the process specified by `pid`. If `pid` is
      * not provided or is `0`, the priority of the current process is returned.
      * @since v10.10.0
-     * @param pid The process ID to retrieve scheduling priority for.
+     * @param [pid=0] The process ID to retrieve scheduling priority for.
      */
     function getPriority(pid?: number): number;
     /**
@@ -444,7 +444,7 @@ declare module 'os' {
      * On Windows, setting priority to `PRIORITY_HIGHEST` requires elevated user
      * privileges. Otherwise the set priority will be silently reduced to`PRIORITY_HIGH`.
      * @since v10.10.0
-     * @param pid The process ID to set scheduling priority for.
+     * @param [pid=0] The process ID to set scheduling priority for.
      * @param priority The scheduling priority to assign to the process.
      */
     function setPriority(priority: number): void;

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.4.8",
+    "version": "16.4.12",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -214,6 +214,11 @@
             "name": "NodeJS Contributors",
             "url": "https://github.com/NodeJS",
             "githubUsername": "NodeJS"
+        },
+        {
+            "name": "Linus Unnebäck",
+            "url": "https://github.com/LinusU",
+            "githubUsername": "LinusU"
         }
     ],
     "main": "",
@@ -232,6 +237,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "09653edb27a1896712187332f491efb4bf99381b00b78f05e219f26450513dfb",
+    "typesPublisherContentHash": "72e2feda5b833f7d889625c0813da4a3ea14aeda595ba536a13d7f0418fb40ce",
     "typeScriptVersion": "3.6"
 }

node/process.d.ts

@@ -579,7 +579,7 @@ declare module 'process' {
                  * In `Worker` threads, this function stops the current thread rather
                  * than the current process.
                  * @since v0.1.13
-                 * @param code The exit code.
+                 * @param [code=0] The exit code.
                  */
                 exit(code?: number): never;
                 /**
@@ -935,7 +935,7 @@ declare module 'process' {
                  * debugger. See `Signal Events`.
                  * @since v0.0.6
                  * @param pid A process ID
-                 * @param signal The signal to send, either as a string or number.
+                 * @param [signal='SIGTERM'] The signal to send, either as a string or number.
                  */
                 kill(pid: number, signal?: string | number): true;
                 /**