@types/node 14.18.21 → 14.18.24

node v14.18/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v14.
 
 ### Additional Details
- * Last updated: Tue, 07 Jun 2022 19:01:36 GMT
+ * Last updated: Mon, 15 Aug 2022 18:32:43 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

node v14.18/crypto.d.ts

@@ -406,9 +406,9 @@ declare module 'crypto' {
         private constructor();
         generateKeys(): Buffer;
         generateKeys(encoding: BinaryToTextEncoding): string;
-        computeSecret(other_public_key: NodeJS.ArrayBufferView): Buffer;
-        computeSecret(other_public_key: string, input_encoding: BinaryToTextEncoding): Buffer;
-        computeSecret(other_public_key: NodeJS.ArrayBufferView, output_encoding: BinaryToTextEncoding): string;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding?: null, outputEncoding?: null): Buffer;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding?: null): Buffer;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding: null, outputEncoding: BinaryToTextEncoding): string;
         computeSecret(
             other_public_key: string,
             input_encoding: BinaryToTextEncoding,
@@ -428,7 +428,42 @@ declare module 'crypto' {
         setPrivateKey(private_key: string, encoding: BufferEncoding): void;
         verifyError: number;
     }
-    function getDiffieHellman(group_name: string): DiffieHellman;
+    /**
+     * The `DiffieHellmanGroup` class takes a well-known modp group as its argument.
+     * It works the same as `DiffieHellman`, except that it does not allow changing its keys after creation.
+     * In other words, it does not implement `setPublicKey()` or `setPrivateKey()` methods.
+     *
+     * ```js
+     * const { createDiffieHellmanGroup } = await import('node:crypto');
+     * const dh = createDiffieHellmanGroup('modp1');
+     * ```
+     * The name (e.g. `'modp1'`) is taken from [RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt) (modp1 and 2) and [RFC 3526](https://www.rfc-editor.org/rfc/rfc3526.txt):
+     * ```bash
+     * $ perl -ne 'print "$1\n" if /"(modp\d+)"/' src/node_crypto_groups.h
+     * modp1  #  768 bits
+     * modp2  # 1024 bits
+     * modp5  # 1536 bits
+     * modp14 # 2048 bits
+     * modp15 # etc.
+     * modp16
+     * modp17
+     * modp18
+     * ```
+     * @since v0.7.5
+     */
+    const DiffieHellmanGroup: DiffieHellmanGroupConstructor;
+    interface DiffieHellmanGroupConstructor {
+        new(name: string): DiffieHellmanGroup;
+        (name: string): DiffieHellmanGroup;
+        readonly prototype: DiffieHellmanGroup;
+    }
+    type DiffieHellmanGroup = Omit<DiffieHellman, 'setPublicKey' | 'setPrivateKey'>;
+    function getDiffieHellman(groupName: string): DiffieHellmanGroup;
+    /**
+     * An alias for {@link getDiffieHellman}
+     * @since v0.9.3
+     */
+    function createDiffieHellmanGroup(name: string): DiffieHellmanGroup;
     function pbkdf2(
         password: BinaryLike,
         salt: BinaryLike,
@@ -531,6 +566,12 @@ declare module 'crypto' {
     function getCiphers(): string[];
     function getCurves(): string[];
     function getFips(): 1 | 0;
+    /**
+     * Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build. Throws an error if FIPS mode is not available.
+     * @since v10.0.0
+     * @param bool `true` to enable FIPS mode.
+     */
+    function setFips(bool: boolean): void;
     function getHashes(): string[];
     class ECDH {
         private constructor();
@@ -1207,6 +1248,35 @@ declare module 'crypto' {
      * 'dh' (for Diffie-Hellman), 'ec' (for ECDH), 'x448', or 'x25519' (for ECDH-ES).
      */
     function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
+    /**
+     * Load and set the `engine` for some or all OpenSSL functions (selected by flags).
+     *
+     * `engine` could be either an id or a path to the engine's shared library.
+     *
+     * The optional `flags` argument uses `ENGINE_METHOD_ALL` by default.
+     * The `flags` is a bit field taking one of or a mix of the following flags (defined in `crypto.constants`):
+     *
+     * - `crypto.constants.ENGINE_METHOD_RSA`
+     * - `crypto.constants.ENGINE_METHOD_DSA`
+     * - `crypto.constants.ENGINE_METHOD_DH`
+     * - `crypto.constants.ENGINE_METHOD_RAND`
+     * - `crypto.constants.ENGINE_METHOD_EC`
+     * - `crypto.constants.ENGINE_METHOD_CIPHERS`
+     * - `crypto.constants.ENGINE_METHOD_DIGESTS`
+     * - `crypto.constants.ENGINE_METHOD_PKEY_METHS`
+     * - `crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS`
+     * - `crypto.constants.ENGINE_METHOD_ALL`
+     * - `crypto.constants.ENGINE_METHOD_NONE`
+     *
+     * The flags below are deprecated in OpenSSL-1.1.0.
+     *
+     * - `crypto.constants.ENGINE_METHOD_ECDH`
+     * - `crypto.constants.ENGINE_METHOD_ECDSA`
+     * - `crypto.constants.ENGINE_METHOD_STORE`
+     * @since v0.11.11
+     * @param [flags=crypto.constants.ENGINE_METHOD_ALL]
+     */
+    function setEngine(engine: string, flags?: number): void;
 }
 declare module 'node:crypto' {
     export * from 'crypto';

node v14.18/fs/promises.d.ts

@@ -1,21 +1,22 @@
 declare module 'fs/promises' {
     import {
-        Stats,
+        BaseEncodingOptions,
         BigIntStats,
-        StatOptions,
-        WriteVResult,
-        ReadVResult,
-        PathLike,
-        RmDirOptions,
-        RmOptions,
-        MakeDirectoryOptions,
+        BufferEncodingOption,
+        constants as fsConstants,
+        Dir,
         Dirent,
+        MakeDirectoryOptions,
+        Mode,
         OpenDirOptions,
-        Dir,
-        BaseEncodingOptions,
-        BufferEncodingOption,
         OpenMode,
-        Mode,
+        PathLike,
+        ReadVResult,
+        RmDirOptions,
+        RmOptions,
+        StatOptions,
+        Stats,
+        WriteVResult,
     } from 'fs';
 
     interface FileHandle {
@@ -161,6 +162,8 @@ declare module 'fs/promises' {
         close(): Promise<void>;
     }
 
+    const constants: typeof fsConstants;
+
     /**
      * Asynchronously tests a user's permissions for the file specified by path.
      * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.

node v14.18/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "14.18.21",
+    "version": "14.18.24",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "0e120850d2efd3c212686946890a557c78b49f575a98e7575b49a55b2ddd9e90",
-    "typeScriptVersion": "3.9"
+    "typesPublisherContentHash": "0d6282534ea851ab2bd3427dd6705c2353d9f3e55173f87ab76179d3deb892e9",
+    "typeScriptVersion": "4.0"
 }

node v14.18/path.d.ts

@@ -54,18 +54,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.
              *
@@ -74,41 +75,50 @@ 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 path the path to evaluate.
              * @param ext 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, ext?: 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 '/'.
              */
@@ -120,15 +130,16 @@ declare module 'path' {
             /**
              * 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.