@types/node 16.11.39 → 18.11.2

node v16.11/net.d.ts → node/net.d.ts

@@ -10,7 +10,7 @@
  * ```js
  * const net = require('net');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/net.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/net.js)
  */
 declare module 'net' {
     import * as stream from 'node:stream';
@@ -54,6 +54,9 @@ declare module 'net' {
         hints?: number | undefined;
         family?: number | undefined;
         lookup?: LookupFunction | undefined;
+        noDelay?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
     }
     interface IpcSocketConnectOpts extends ConnectOpts {
         path: string;
@@ -128,6 +131,17 @@ declare module 'net' {
          * @return The socket itself.
          */
         pause(): this;
+        /**
+         * Close the TCP connection by sending an RST packet and destroy the stream.
+         * If this TCP socket is in connecting status, it will send an RST packet
+         * and destroy this TCP socket once it is connected. Otherwise, it will call
+         * `socket.destroy` with an `ERR_SOCKET_CLOSED` Error. If this is not a TCP socket
+         * (for example, a pipe), calling this method will immediately throw
+         * an `ERR_INVALID_HANDLE_TYPE` Error.
+         * @since v18.3.0
+         * @return The socket itself.
+         */
+        resetAndDestroy(): this;
         /**
          * Resumes reading after a call to `socket.pause()`.
          * @return The socket itself.
@@ -205,7 +219,7 @@ declare module 'net' {
          */
         unref(): this;
         /**
-         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed socket will_not_ let the program exit if it's the only socket left (the default behavior).
+         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed socket will _not_ let the program exit if it's the only socket left (the default behavior).
          * If the socket is `ref`ed calling `ref` again will have no effect.
          * @since v0.9.1
          * @return The socket itself.
@@ -263,6 +277,11 @@ declare module 'net' {
          * @since v0.9.6
          */
         readonly localPort?: number;
+        /**
+         * The string representation of the local IP family. `'IPv4'` or `'IPv6'`.
+         * @since v18.8.0
+         */
+        readonly localFamily?: string;
         /**
          * This property represents the state of the connection as a string.
          * @see {https://nodejs.org/api/net.html#socketreadystate}
@@ -312,7 +331,8 @@ declare module 'net' {
          *   5. end
          *   6. error
          *   7. lookup
-         *   8. timeout
+         *   8. ready
+         *   9. timeout
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'close', listener: (hadError: boolean) => void): this;
@@ -399,6 +419,33 @@ declare module 'net' {
          * @default false
          */
         pauseOnConnect?: boolean | undefined;
+        /**
+         * If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
+         * @default false
+         * @since v16.5.0
+         */
+        noDelay?: boolean | undefined;
+        /**
+         * If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received,
+         * similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.
+         * @default false
+         * @since v16.5.0
+         */
+        keepAlive?: boolean | undefined;
+        /**
+         * If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
+         * @default 0
+         * @since v16.5.0
+         */
+        keepAliveInitialDelay?: number | undefined;
+    }
+    interface DropArgument {
+        localAddress?: string;
+        localPort?: number;
+        localFamily?: string;
+        remoteAddress?: string;
+        remotePort?: number;
+        remoteFamily?: string;
     }
     /**
      * This class is used to create a TCP or `IPC` server.
@@ -504,7 +551,7 @@ declare module 'net' {
          */
         getConnections(cb: (error: Error | null, count: number) => void): void;
         /**
-         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will_not_ let the program exit if it's the only server left (the default behavior).
+         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will _not_ let the program exit if it's the only server left (the default behavior).
          * If the server is `ref`ed calling `ref()` again will have no effect.
          * @since v0.9.1
          */
@@ -536,49 +583,56 @@ declare module 'net' {
          *   2. connection
          *   3. error
          *   4. listening
+         *   5. drop
          */
         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: 'drop', listener: (data?: DropArgument) => void): this;
         emit(event: string | symbol, ...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: 'drop', data?: DropArgument): 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: 'drop', listener: (data?: DropArgument) => 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: 'drop', listener: (data?: DropArgument) => 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: 'drop', listener: (data?: DropArgument) => 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: 'drop', listener: (data?: DropArgument) => void): this;
     }
     type IPVersion = 'ipv4' | 'ipv6';
     /**
      * The `BlockList` object can be used with some network APIs to specify rules for
      * disabling inbound or outbound access to specific IP addresses, IP ranges, or
      * IP subnets.
-     * @since v15.0.0
+     * @since v15.0.0, v14.18.0
      */
     class BlockList {
         /**
          * Adds a rule to block the given IP address.
-         * @since v15.0.0
+         * @since v15.0.0, v14.18.0
          * @param address An IPv4 or IPv6 address.
          * @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
          */
@@ -586,7 +640,7 @@ declare module 'net' {
         addAddress(address: SocketAddress): void;
         /**
          * Adds a rule to block a range of IP addresses from `start` (inclusive) to`end` (inclusive).
-         * @since v15.0.0
+         * @since v15.0.0, v14.18.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='ipv4'] Either `'ipv4'` or `'ipv6'`.
@@ -595,7 +649,7 @@ declare module 'net' {
         addRange(start: SocketAddress, end: SocketAddress): void;
         /**
          * Adds a rule to block a range of IP addresses specified as a subnet mask.
-         * @since v15.0.0
+         * @since v15.0.0, v14.18.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='ipv4'] Either `'ipv4'` or `'ipv6'`.
@@ -619,7 +673,7 @@ declare module 'net' {
          * console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
          * console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true
          * ```
-         * @since v15.0.0
+         * @since v15.0.0, v14.18.0
          * @param address The IP address to check
          * @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
          */
@@ -650,7 +704,7 @@ declare module 'net' {
      *
      * The server can be a TCP server or an `IPC` server, depending on what it `listen()` to.
      *
-     * Here is an example of an TCP echo server which listens for connections
+     * Here is an example of a TCP echo server which listens for connections
      * on port 8124:
      *
      * ```js
@@ -729,19 +783,39 @@ declare module 'net' {
     function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
     function createConnection(path: string, connectionListener?: () => void): Socket;
     /**
-     * Tests if input is an IP address. Returns `0` for invalid strings,
-     * returns `4` for IP version 4 addresses, and returns `6` for IP version 6
-     * addresses.
+     * Returns `6` if `input` is an IPv6 address. Returns `4` if `input` is an IPv4
+     * address in [dot-decimal notation](https://en.wikipedia.org/wiki/Dot-decimal_notation) with no leading zeroes. Otherwise, returns`0`.
+     *
+     * ```js
+     * net.isIP('::1'); // returns 6
+     * net.isIP('127.0.0.1'); // returns 4
+     * net.isIP('127.000.000.001'); // returns 0
+     * net.isIP('127.0.0.1/24'); // returns 0
+     * net.isIP('fhqwhgads'); // returns 0
+     * ```
      * @since v0.3.0
      */
     function isIP(input: string): number;
     /**
-     * Returns `true` if input is a version 4 IP address, otherwise returns `false`.
+     * Returns `true` if `input` is an IPv4 address in [dot-decimal notation](https://en.wikipedia.org/wiki/Dot-decimal_notation) with no
+     * leading zeroes. Otherwise, returns `false`.
+     *
+     * ```js
+     * net.isIPv4('127.0.0.1'); // returns true
+     * net.isIPv4('127.000.000.001'); // returns false
+     * net.isIPv4('127.0.0.1/24'); // returns false
+     * net.isIPv4('fhqwhgads'); // returns false
+     * ```
      * @since v0.3.0
      */
     function isIPv4(input: string): boolean;
     /**
-     * Returns `true` if input is a version 6 IP address, otherwise returns `false`.
+     * Returns `true` if `input` is an IPv6 address. Otherwise, returns `false`.
+     *
+     * ```js
+     * net.isIPv6('::1'); // returns true
+     * net.isIPv6('fhqwhgads'); // returns false
+     * ```
      * @since v0.3.0
      */
     function isIPv6(input: string): boolean;
@@ -767,26 +841,25 @@ declare module 'net' {
         port?: number | undefined;
     }
     /**
-     * @since v15.14.0
+     * @since v15.14.0, v14.18.0
      */
     class SocketAddress {
         constructor(options: SocketAddressInitOptions);
         /**
-         * Either \`'ipv4'\` or \`'ipv6'\`.
-         * @since v15.14.0
+         * @since v15.14.0, v14.18.0
          */
         readonly address: string;
         /**
          * Either \`'ipv4'\` or \`'ipv6'\`.
-         * @since v15.14.0
+         * @since v15.14.0, v14.18.0
          */
         readonly family: IPVersion;
         /**
-         * @since v15.14.0
+         * @since v15.14.0, v14.18.0
          */
         readonly port: number;
         /**
-         * @since v15.14.0
+         * @since v15.14.0, v14.18.0
          */
         readonly flowlabel: number;
     }

node v16.11/os.d.ts → node/os.d.ts

@@ -5,7 +5,7 @@
  * ```js
  * const os = require('os');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/os.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/os.js)
  */
 declare module 'os' {
     interface CpuInfo {
@@ -28,6 +28,7 @@ declare module 'os' {
     }
     interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
         family: 'IPv4';
+        scopeid?: undefined;
     }
     interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
         family: 'IPv6';
@@ -387,7 +388,7 @@ declare module 'os' {
     const EOL: string;
     /**
      * Returns the operating system CPU architecture for which the Node.js binary was
-     * compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`, `'ppc64'`, `'s390'`, `'s390x'`, `'x32'`, and `'x64'`.
+     * compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`, `'ppc64'`, `'s390'`, `'s390x'`, and `'x64'`.
      *
      * The return value is equivalent to `process.arch`.
      * @since v0.5.0
@@ -402,8 +403,9 @@ declare module 'os' {
      */
     function version(): string;
     /**
-     * Returns a string identifying the operating system platform. The value is set
-     * at compile time. Possible values are `'aix'`, `'darwin'`, `'freebsd'`,`'linux'`, `'openbsd'`, `'sunos'`, and `'win32'`.
+     * Returns a string identifying the operating system platform for which
+     * the Node.js binary was compiled. The value is set at compile time.
+     * Possible values are `'aix'`, `'darwin'`, `'freebsd'`,`'linux'`,`'openbsd'`, `'sunos'`, and `'win32'`.
      *
      * The return value is equivalent to `process.platform`.
      *
@@ -412,6 +414,15 @@ declare module 'os' {
      * @since v0.5.0
      */
     function platform(): NodeJS.Platform;
+    /**
+     * Returns the machine type as a string, such as arm, aarch64, mips, mips64, ppc64, ppc64le, s390, s390x, i386, i686, x86_64.
+     *
+     * On POSIX systems, the machine type is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname).
+     * On Windows, `RtlGetVersion()` is used, and if it is not available, `GetVersionExW()` will be used.
+     * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+     * @since v18.9.0
+     */
+    function machine(): string;
     /**
      * Returns the operating system's default directory for temporary files as a
      * string.

node v16.11/package.json → node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.11.39",
+    "version": "18.11.2",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -110,11 +110,6 @@
             "url": "https://github.com/eps1lon",
             "githubUsername": "eps1lon"
         },
-        {
-            "name": "Seth Westphal",
-            "url": "https://github.com/westy92",
-            "githubUsername": "westy92"
-        },
         {
             "name": "Simon Schick",
             "url": "https://github.com/SimonSchick",
@@ -209,10 +204,22 @@
             "name": "wafuwafu13",
             "url": "https://github.com/wafuwafu13",
             "githubUsername": "wafuwafu13"
+        },
+        {
+            "name": "Matteo Collina",
+            "url": "https://github.com/mcollina",
+            "githubUsername": "mcollina"
         }
     ],
     "main": "",
     "types": "index.d.ts",
+    "typesVersions": {
+        "<4.9.0-0": {
+            "*": [
+                "ts4.8/*"
+            ]
+        }
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
@@ -220,6 +227,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "7aa869a029d31d031b0b348b049f4188caf1dcbd75bb266b15a944a752ecc044",
-    "typeScriptVersion": "3.9"
+    "typesPublisherContentHash": "d7bbee366053005eb9ad76ecf711181a2633097e3afe20ba0ac3309f73d09afc",
+    "typeScriptVersion": "4.1"
 }

node v16.11/path.d.ts → node/path.d.ts

@@ -13,7 +13,7 @@ declare module 'path/win32' {
  * ```js
  * const path = require('path');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/path.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/path.js)
  */
 declare module 'path' {
     namespace path {
@@ -69,18 +69,19 @@ declare module 'path' {
              * Normalize a string path, reducing '..' and '.' parts.
              * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
              *
-             * @param p string path to normalize.
+             * @param path string path to normalize.
+             * @throws {TypeError} if `path` is not a string.
              */
-            normalize(p: string): string;
+            normalize(path: string): string;
             /**
              * Join all arguments together and normalize the resulting path.
-             * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
              *
              * @param paths paths to join.
+             * @throws {TypeError} if any of the path segments is not a string.
              */
             join(...paths: string[]): string;
             /**
-             * The right-most parameter is considered {to}.  Other parameters are considered an array of {from}.
+             * The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
              *
              * Starting from leftmost {from} parameter, resolves {to} to an absolute path.
              *
@@ -89,61 +90,71 @@ declare module 'path' {
              * the current working directory is used as well. The resulting path is normalized,
              * and trailing slashes are removed unless the path gets resolved to the root directory.
              *
-             * @param pathSegments string paths to join.  Non-string arguments are ignored.
+             * @param paths A sequence of paths or path segments.
+             * @throws {TypeError} if any of the arguments is not a string.
              */
-            resolve(...pathSegments: string[]): string;
+            resolve(...paths: string[]): string;
             /**
              * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
              *
+             * If the given {path} is a zero-length string, `false` will be returned.
+             *
              * @param path path to test.
+             * @throws {TypeError} if `path` is not a string.
              */
-            isAbsolute(p: string): boolean;
+            isAbsolute(path: string): boolean;
             /**
-             * Solve the relative path from {from} to {to}.
+             * Solve the relative path from {from} to {to} based on the current working directory.
              * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
+             *
+             * @throws {TypeError} if either `from` or `to` is not a string.
              */
             relative(from: string, to: string): string;
             /**
              * Return the directory name of a path. Similar to the Unix dirname command.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            dirname(p: string): string;
+            dirname(path: string): string;
             /**
              * Return the last portion of a path. Similar to the Unix basename command.
              * Often used to extract the file name from a fully qualified path.
              *
-             * @param p the path to evaluate.
-             * @param ext optionally, an extension to remove from the result.
+             * @param path the path to evaluate.
+             * @param suffix optionally, an extension to remove from the result.
+             * @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string.
              */
-            basename(p: string, ext?: string): string;
+            basename(path: string, suffix?: string): string;
             /**
              * Return the extension of the path, from the last '.' to end of string in the last portion of the path.
-             * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
+             * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            extname(p: string): string;
+            extname(path: string): string;
             /**
              * The platform-specific file separator. '\\' or '/'.
              */
-            readonly sep: string;
+            readonly sep: '\\' | '/';
             /**
              * The platform-specific file delimiter. ';' or ':'.
              */
-            readonly delimiter: string;
+            readonly delimiter: ';' | ':';
             /**
              * Returns an object from a path string - the opposite of format().
              *
-             * @param pathString path to evaluate.
+             * @param path path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            parse(p: string): ParsedPath;
+            parse(path: string): ParsedPath;
             /**
              * Returns a path string from an object - the opposite of parse().
              *
-             * @param pathString path to evaluate.
+             * @param pathObject path to evaluate.
              */
-            format(pP: FormatInputPathObject): string;
+            format(pathObject: FormatInputPathObject): string;
             /**
              * On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
              * If path is not a string, path will be returned without modifications.