@types/node 15.12.2 → 15.14.0

node/README.md

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

node/buffer.d.ts

@@ -77,6 +77,34 @@ declare module 'buffer' {
          */
         text(): Promise<string>;
     }
+
+    /**
+     * Decodes a string of Base64-encoded data into bytes, and encodes those bytes into a string using Latin-1 (ISO-8859-1).
+     *
+     * This function is only provided for compatibility with legacy web platform APIs
+     * and should never be used in new code, because they use strings to represent
+     * binary data and predate the introduction of typed arrays in JavaScript.
+     * For code running using Node.js APIs, converting between base64-encoded strings
+     * and binary data should be performed using `Buffer.from(str, 'base64')` and
+     * `buf.toString('base64')`.
+     *
+     * @deprecated dom compatibility
+     */
+     export function atob(input: string): string;
+
+    /**
+     * Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes into a string using Base64.
+     *
+     * This function is only provided for compatibility with legacy web platform APIs
+     * and should never be used in new code, because they use strings to represent
+     * binary data and predate the introduction of typed arrays in JavaScript.
+     * For code running using Node.js APIs, converting between base64-encoded strings
+     * and binary data should be performed using `Buffer.from(str, 'base64')` and
+     * `buf.toString('base64')`.
+     *
+     * @deprecated dom compatibility
+     */
+     export function btoa(input: string): string;
 }
 
 declare module 'node:buffer' {

node/child_process.d.ts

@@ -147,6 +147,11 @@ declare module 'child_process' {
          * @default 'SIGTERM'
          */
         killSignal?: NodeJS.Signals | number;
+
+        /**
+         * In milliseconds the maximum amount of time the process is allowed to run.
+         */
+        timeout?: number;
     }
 
     interface ProcessEnvOptions {
@@ -483,14 +488,17 @@ declare module 'child_process' {
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
 
-    interface ExecSyncOptions extends CommonOptions {
-        input?: string | Uint8Array;
+    interface CommonExecOptions extends ProcessEnvOptions {
+        input?: string | NodeJS.ArrayBufferView;
         stdio?: StdioOptions;
-        shell?: string;
         killSignal?: NodeJS.Signals | number;
         maxBuffer?: number;
         encoding?: BufferEncoding | 'buffer' | null;
     }
+
+    interface ExecSyncOptions extends CommonExecOptions {
+        shell?: string;
+    }
     interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
         encoding: BufferEncoding;
     }
@@ -502,12 +510,7 @@ declare module 'child_process' {
     function execSync(command: string, options?: ExecSyncOptionsWithBufferEncoding): Buffer;
     function execSync(command: string, options?: ExecSyncOptions): Buffer;
 
-    interface ExecFileSyncOptions extends CommonOptions {
-        input?: string | NodeJS.ArrayBufferView;
-        stdio?: StdioOptions;
-        killSignal?: NodeJS.Signals | number;
-        maxBuffer?: number;
-        encoding?: BufferEncoding;
+    interface ExecFileSyncOptions extends CommonExecOptions {
         shell?: boolean | string;
     }
     interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions {

node/crypto.d.ts

@@ -196,11 +196,9 @@ declare module 'crypto' {
         cipher?: string;
         passphrase?: string | Buffer;
     }
-
     interface JwkKeyExportOptions {
         format: 'jwk';
     }
-
     interface JsonWebKey {
         crv?: string;
         d?: string;
@@ -215,6 +213,7 @@ declare module 'crypto' {
         qi?: string;
         x?: string;
         y?: string;
+        [key: string]: unknown;
     }
 
     interface AsymmetricKeyDetails {
@@ -236,6 +235,10 @@ declare module 'crypto' {
         namedCurve?: string;
     }
 
+    interface JwkKeyExportOptions {
+        format: 'jwk';
+    }
+
     class KeyObject {
         private constructor();
         asymmetricKeyType?: KeyType;
@@ -253,6 +256,7 @@ declare module 'crypto' {
         asymmetricKeyDetails?: AsymmetricKeyDetails;
         export(options: KeyExportOptions<'pem'>): string | Buffer;
         export(options?: KeyExportOptions<'der'>): Buffer;
+        export(options?: JwkKeyExportOptions): JsonWebKey;
         symmetricKeySize?: number;
         type: KeyObjectType;
     }
@@ -376,8 +380,15 @@ declare module 'crypto' {
         type?: 'pkcs1' | 'spki';
     }
 
-    function createPrivateKey(key: PrivateKeyInput | string | Buffer): KeyObject;
-    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject): KeyObject;
+    function generateKey(type: 'hmac' | 'aes', options: {length: number}, callback: (err: Error | null, key: KeyObject) => void): void;
+
+    interface JsonWebKeyInput {
+        key: JsonWebKey;
+        format: 'jwk';
+    }
+
+    function createPrivateKey(key: PrivateKeyInput | string | Buffer | JsonWebKeyInput): KeyObject;
+    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput): KeyObject;
     function createSecretKey(key: NodeJS.ArrayBufferView): KeyObject;
 
     function createSign(algorithm: string, options?: stream.WritableOptions): Signer;

node/fs/promises.d.ts

@@ -1,5 +1,6 @@
 declare module 'fs/promises' {
     import { Abortable } from 'events';
+    import { Stream } from 'stream';
     import {
         Stats,
         BigIntStats,
@@ -512,7 +513,11 @@ declare module 'fs/promises' {
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'w'` is used.
      */
-    function writeFile(path: PathLike | FileHandle, data: string | Uint8Array, options?: BaseEncodingOptions & { mode?: Mode, flag?: OpenMode } & Abortable | BufferEncoding | null): Promise<void>;
+    function writeFile(
+        path: PathLike | FileHandle,
+        data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | Stream,
+        options?: BaseEncodingOptions & { mode?: Mode, flag?: OpenMode } & Abortable | BufferEncoding | null
+        ): Promise<void>;
 
     /**
      * Asynchronously append data to a file, creating the file if it does not exist.

node/http.d.ts

@@ -229,6 +229,11 @@ declare module 'http' {
         setTimeout(timeout: number, callback?: () => void): this;
         setNoDelay(noDelay?: boolean): void;
         setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+        /**
+         * Returns an array containing the unique names of the current outgoing raw headers.
+         * Header names are returned with their exact casing being set.
+         */
+        getRawHeaderNames(): string[];
 
         addListener(event: 'abort', listener: () => void): this;
         addListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;

node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 15.12
+// Type definitions for non-npm package Node.js 15.14
 // Project: http://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>

node/net.d.ts

@@ -273,6 +273,7 @@ declare module 'net' {
          * @param type Either 'ipv4' or 'ipv6'. Default: 'ipv4'.
          */
         addAddress(address: string, type?: IPVersion): void;
+        addAddress(address: SocketAddress): void;
 
         /**
          * Adds a rule to block a range of IP addresses from start (inclusive) to end (inclusive).
@@ -282,6 +283,7 @@ declare module 'net' {
          * @param type Either 'ipv4' or 'ipv6'. Default: 'ipv4'.
          */
         addRange(start: string, end: string, type?: IPVersion): void;
+        addRange(start: SocketAddress, end: SocketAddress): void;
 
         /**
          * Adds a rule to block a range of IP addresses specified as a subnet mask.
@@ -291,6 +293,7 @@ declare module 'net' {
          * 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'. Default: 'ipv4'.
          */
+        addSubnet(net: SocketAddress, prefix: number): void;
         addSubnet(net: string, prefix: number, type?: IPVersion): void;
 
         /**
@@ -299,6 +302,7 @@ declare module 'net' {
          * @param address The IP address to check
          * @param type Either 'ipv4' or 'ipv6'. Default: 'ipv4'.
          */
+        check(address: SocketAddress): boolean;
         check(address: string, type?: IPVersion): boolean;
     }
 
@@ -323,4 +327,38 @@ declare module 'net' {
     function isIP(input: string): number;
     function isIPv4(input: string): boolean;
     function isIPv6(input: string): boolean;
+
+    interface SocketAddressInitOptions {
+        /**
+         * The network address as either an IPv4 or IPv6 string.
+         * @default 127.0.0.1
+         */
+        address?: string;
+        /**
+         * @default `'ipv4'`
+         */
+        family?: IPVersion;
+        /**
+         * An IPv6 flow-label used only if `family` is `'ipv6'`.
+         * @default 0
+         */
+        flowlabel?: number;
+        /**
+         * An IP port.
+         * @default 0
+         */
+        port?: number;
+    }
+
+    // TODO: Mark as clonable if `kClone` symbol is set in node.
+    /**
+     * Immutable socket address.
+     */
+    class SocketAddress {
+        constructor(options: SocketAddressInitOptions);
+        readonly address: string;
+        readonly family: IPVersion;
+        readonly port: number;
+        readonly flowlabel: number;
+    }
 }

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "15.12.2",
+    "version": "15.14.0",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -227,6 +227,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "9713490f7bb15f02ab4ef68c39e2ec33cdecadbc39062c33ca86f9e4d8018d9b",
+    "typesPublisherContentHash": "61808f4174f8094e6d1396d1a7038b6ff05a773d74844d41d45e476e5b30f0eb",
     "typeScriptVersion": "3.6"
 }

node/process.d.ts

@@ -59,6 +59,7 @@ declare module 'process' {
                 | 'android'
                 | 'darwin'
                 | 'freebsd'
+                | 'haiku'
                 | 'linux'
                 | 'openbsd'
                 | 'sunos'