@types/node 15.6.2 → 15.12.2

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: Wed, 02 Jun 2021 07:31:33 GMT
+ * Last updated: Mon, 07 Jun 2021 23:01:23 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

@@ -1,4 +1,6 @@
 declare module 'buffer' {
+    import { BinaryLike } from 'crypto';
+
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -19,4 +21,64 @@ declare module 'buffer' {
     };
 
     export { BuffType as Buffer };
+
+    /**
+     * @experimental
+     */
+    export interface BlobOptions {
+        /**
+         * @default 'utf8'
+         */
+        encoding?: BufferEncoding;
+
+        /**
+         * The Blob content-type. The intent is for `type` to convey
+         * the MIME media type of the data, however no validation of the type format
+         * is performed.
+         */
+        type?: string;
+    }
+
+    /**
+     * @experimental
+     */
+    export class Blob {
+        /**
+         * Returns a promise that fulfills with an {ArrayBuffer} containing a copy of the `Blob` data.
+         */
+        readonly size: number;
+
+        /**
+         * The content-type of the `Blob`.
+         */
+        readonly type: string;
+
+        /**
+         * Creates a new `Blob` object containing a concatenation of the given sources.
+         *
+         * {ArrayBuffer}, {TypedArray}, {DataView}, and {Buffer} sources are copied into
+         * the 'Blob' and can therefore be safely modified after the 'Blob' is created.
+         *
+         * String sources are also copied into the `Blob`.
+         */
+        constructor(sources: Array<(BinaryLike | Blob)>, options?: BlobOptions);
+
+        arrayBuffer(): Promise<ArrayBuffer>;
+
+        /**
+         * @param start The starting index.
+         * @param end The ending index.
+         * @param type The content-type for the new `Blob`
+         */
+        slice(start?: number, end?: number, type?: string): Blob;
+
+        /**
+         * Returns a promise that resolves the contents of the `Blob` decoded as a UTF-8 string.
+         */
+        text(): Promise<string>;
+    }
+}
+
+declare module 'node:buffer' {
+    export * from 'buffer';
 }

node/child_process.d.ts

@@ -4,7 +4,7 @@ declare module 'child_process' {
     import * as net from 'net';
     import { Writable, Readable, Stream, Pipe } from 'stream';
 
-    type Serializable = string | object | number | boolean;
+    type Serializable = string | object | number | boolean | bigint;
     type SendHandle = net.Socket | net.Server;
 
     interface ChildProcess extends EventEmitter {
@@ -20,7 +20,7 @@ declare module 'child_process' {
             Readable | Writable | null | undefined // extra
         ];
         readonly killed: boolean;
-        readonly pid: number;
+        readonly pid?: number;
         readonly connected: boolean;
         readonly exitCode: number | null;
         readonly signalCode: NodeJS.Signals | null;
@@ -135,12 +135,18 @@ declare module 'child_process' {
 
     type SerializationType = 'json' | 'advanced';
 
-    interface MessagingOptions {
+    interface MessagingOptions extends Abortable {
         /**
          * Specify the kind of serialization used for sending messages between processes.
          * @default 'json'
          */
         serialization?: SerializationType;
+
+        /**
+         * The signal value to be used when the spawned process will be killed by the abort signal.
+         * @default 'SIGTERM'
+         */
+        killSignal?: NodeJS.Signals | number;
     }
 
     interface ProcessEnvOptions {
@@ -451,7 +457,6 @@ declare module 'child_process' {
 
     interface SpawnSyncOptions extends CommonSpawnOptions {
         input?: string | NodeJS.ArrayBufferView;
-        killSignal?: NodeJS.Signals | number;
         maxBuffer?: number;
         encoding?: BufferEncoding | 'buffer' | null;
     }

node/console.d.ts

@@ -25,16 +25,16 @@ declare module 'console' {
              */
             countReset(label?: string): void;
             /**
-             * The `console.debug()` function is an alias for {@link console.log()}.
+             * The `console.debug()` function is an alias for {@link console.log}.
              */
             debug(message?: any, ...optionalParams: any[]): void;
             /**
-             * Uses {@link util.inspect()} on `obj` and prints the resulting string to `stdout`.
+             * Uses {@link util.inspect} on `obj` and prints the resulting string to `stdout`.
              * This function bypasses any custom `inspect()` function defined on `obj`.
              */
             dir(obj: any, options?: InspectOptions): void;
             /**
-             * This method calls {@link console.log()} passing it the arguments received. Please note that this method does not produce any XML formatting
+             * This method calls {@link console.log} passing it the arguments received. Please note that this method does not produce any XML formatting
              */
             dirxml(...data: any[]): void;
             /**
@@ -47,7 +47,7 @@ declare module 'console' {
              */
             group(...label: any[]): void;
             /**
-             * The `console.groupCollapsed()` function is an alias for {@link console.group()}.
+             * The `console.groupCollapsed()` function is an alias for {@link console.group}.
              */
             groupCollapsed(...label: any[]): void;
             /**
@@ -55,7 +55,7 @@ declare module 'console' {
              */
             groupEnd(): void;
             /**
-             * The {@link console.info()} function is an alias for {@link console.log()}.
+             * The {@link console.info} function is an alias for {@link console.log}.
              */
             info(message?: any, ...optionalParams: any[]): void;
             /**
@@ -72,19 +72,19 @@ declare module 'console' {
              */
             time(label?: string): void;
             /**
-             * Stops a timer that was previously started by calling {@link console.time()} and prints the result to `stdout`.
+             * Stops a timer that was previously started by calling {@link console.time} and prints the result to `stdout`.
              */
             timeEnd(label?: string): void;
             /**
-             * For a timer that was previously started by calling {@link console.time()}, prints the elapsed time and other `data` arguments to `stdout`.
+             * For a timer that was previously started by calling {@link console.time}, prints the elapsed time and other `data` arguments to `stdout`.
              */
             timeLog(label?: string, ...data: any[]): void;
             /**
-             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format()} formatted message and stack trace to the current position in the code.
+             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format} formatted message and stack trace to the current position in the code.
              */
             trace(message?: any, ...optionalParams: any[]): void;
             /**
-             * The {@link console.warn()} function is an alias for {@link console.error()}.
+             * The {@link console.warn} function is an alias for {@link console.error}.
              */
             warn(message?: any, ...optionalParams: any[]): void;
 

node/crypto.d.ts

@@ -197,6 +197,45 @@ declare module 'crypto' {
         passphrase?: string | Buffer;
     }
 
+    interface JwkKeyExportOptions {
+        format: 'jwk';
+    }
+
+    interface JsonWebKey {
+        crv?: string;
+        d?: string;
+        dp?: string;
+        dq?: string;
+        e?: string;
+        k?: string;
+        kty?: string;
+        n?: string;
+        p?: string;
+        q?: string;
+        qi?: string;
+        x?: string;
+        y?: string;
+    }
+
+    interface AsymmetricKeyDetails {
+        /**
+         * Key size in bits (RSA, DSA).
+         */
+        modulusLength?: number;
+        /**
+         * Public exponent (RSA).
+         */
+        publicExponent?: bigint;
+        /**
+         * Size of q in bits (DSA).
+         */
+        divisorLength?: number;
+        /**
+         * Name of the curve (EC).
+         */
+        namedCurve?: string;
+    }
+
     class KeyObject {
         private constructor();
         asymmetricKeyType?: KeyType;
@@ -205,6 +244,13 @@ declare module 'crypto' {
          * bytes. This property is `undefined` for symmetric keys.
          */
         asymmetricKeySize?: number;
+        /**
+         * This property exists only on asymmetric keys. Depending on the type of the key,
+         * this object contains information about the key. None of the information obtained
+         * through this property can be used to uniquely identify a key or to compromise the
+         * security of the key.
+         */
+        asymmetricKeyDetails?: AsymmetricKeyDetails;
         export(options: KeyExportOptions<'pem'>): string | Buffer;
         export(options?: KeyExportOptions<'der'>): Buffer;
         symmetricKeySize?: number;
@@ -1163,22 +1209,28 @@ declare module 'crypto' {
      * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is
      * dependent upon the key type (especially Ed25519 and Ed448).
      *
-     * If `key` is not a [`KeyObject`][], this function behaves as if `key` had been
-     * passed to [`crypto.createPrivateKey()`][].
+     * If `key` is not a `KeyObject`, this function behaves as if `key` had been
+     * passed to `crypto.createPrivateKey().
      */
     function sign(
         algorithm: string | null | undefined,
         data: NodeJS.ArrayBufferView,
         key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput,
     ): Buffer;
+    function sign(
+        algorithm: string | null | undefined,
+        data: NodeJS.ArrayBufferView,
+        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput,
+        callback: (error: Error | null, data: Buffer) => void
+    ): void;
 
     /**
      * Calculates and returns the signature for `data` using the given private key and
      * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is
      * dependent upon the key type (especially Ed25519 and Ed448).
      *
-     * If `key` is not a [`KeyObject`][], this function behaves as if `key` had been
-     * passed to [`crypto.createPublicKey()`][].
+     * If `key` is not a `KeyObject`, this function behaves as if `key` had been
+     * passed to `crypto.createPublicKey()`.
      */
     function verify(
         algorithm: string | null | undefined,
@@ -1186,6 +1238,13 @@ declare module 'crypto' {
         key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput,
         signature: NodeJS.ArrayBufferView,
     ): boolean;
+    function verify(
+        algorithm: string | null | undefined,
+        data: NodeJS.ArrayBufferView,
+        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput,
+        signature: NodeJS.ArrayBufferView,
+        callback: (error: Error | null, result: boolean) => void
+    ): void;
 
     /**
      * Computes the Diffie-Hellman secret based on a privateKey and a publicKey.
@@ -1254,7 +1313,7 @@ declare module 'crypto' {
      *
      * The supplied `callback` function is called with two arguments: `err` and `derivedKey`.
      * If an errors occurs while deriving the key, `err` will be set; otherwise `err` will be `null`.
-     * The successfully generated `derivedKey` will be passed to the callback as an [`ArrayBuffer`][].
+     * The successfully generated `derivedKey` will be passed to the callback as an `ArrayBuffer`.
      * An error will be thrown if any of the input aguments specify invalid values or types.
      */
     function hkdf(digest: string, key: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => any): void;
@@ -1263,7 +1322,7 @@ declare module 'crypto' {
      * Provides a synchronous HKDF key derivation function as defined in RFC 5869.
      * The given `key`, `salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
      *
-     * The successfully generated `derivedKey` will be returned as an [`ArrayBuffer`][].
+     * The successfully generated `derivedKey` will be returned as an `ArrayBuffer`.
      * An error will be thrown if any of the input aguments specify invalid values or types,
      * or if the derived key cannot be generated.
      */
@@ -1372,6 +1431,16 @@ declare module 'crypto' {
          */
         readonly keyUsage: string[];
 
+        /**
+         * The issuer identification included in this certificate.
+         */
+        readonly issuer: string;
+
+        /**
+         * The issuer certificate or `undefined` if the issuer certificate is not available.
+         */
+        readonly issuerCertificate?: X509Certificate;
+
         /**
          * The public key for this certificate.
          */
@@ -1438,7 +1507,7 @@ declare module 'crypto' {
         toJSON(): string;
 
         /**
-         * Returns information about this certificate using the legacy [certificate object][] encoding.
+         * Returns information about this certificate using the legacy certificate object encoding.
          */
         toLegacyObject(): PeerCertificate;
 
@@ -1453,4 +1522,57 @@ declare module 'crypto' {
          */
         verify(publicKey: KeyObject): boolean;
     }
+
+    type LargeNumberLike = NodeJS.ArrayBufferView | SharedArrayBuffer | ArrayBuffer | bigint;
+
+    interface GeneratePrimeOptions {
+        add?: LargeNumberLike;
+        rem?: LargeNumberLike;
+        /**
+         * @default false
+         */
+        safe?: boolean;
+        bigint?: boolean;
+    }
+
+    interface GeneratePrimeOptionsBigInt extends GeneratePrimeOptions {
+        bigint: true;
+    }
+
+    interface GeneratePrimeOptionsArrayBuffer extends GeneratePrimeOptions {
+        bigint?: false;
+    }
+
+    function generatePrime(size: number, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
+    function generatePrime(size: number, options: GeneratePrimeOptionsBigInt, callback: (err: Error | null, prime: bigint) => void): void;
+    function generatePrime(size: number, options: GeneratePrimeOptionsArrayBuffer, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
+    function generatePrime(size: number, options: GeneratePrimeOptions, callback: (err: Error | null, prime: ArrayBuffer | bigint) => void): void;
+
+    function generatePrimeSync(size: number): ArrayBuffer;
+    function generatePrimeSync(size: number, options: GeneratePrimeOptionsBigInt): bigint;
+    function generatePrimeSync(size: number, options: GeneratePrimeOptionsArrayBuffer): ArrayBuffer;
+    function generatePrimeSync(size: number, options: GeneratePrimeOptions): ArrayBuffer | bigint;
+
+    interface CheckPrimeOptions {
+        /**
+         * The number of Miller-Rabin probabilistic primality iterations to perform.
+         * When the value is 0 (zero), a number of checks is used that yields a false positive rate of at most 2-64 for random input.
+         * Care must be used when selecting a number of checks.
+         * Refer to the OpenSSL documentation for the BN_is_prime_ex function nchecks options for more details.
+         *
+         * @default 0
+         */
+        checks?: number;
+    }
+
+    /**
+     * Checks the primality of the candidate.
+     */
+    function checkPrime(value: LargeNumberLike, callback: (err: Error | null, result: boolean) => void): void;
+    function checkPrime(value: LargeNumberLike, options: CheckPrimeOptions, callback: (err: Error | null, result: boolean) => void): void;
+
+    /**
+     * Checks the primality of the candidate.
+     */
+    function checkPrimeSync(value: LargeNumberLike, options?: CheckPrimeOptions): boolean;
 }

node/dgram.d.ts

@@ -1,7 +1,7 @@
 declare module 'dgram' {
     import { AddressInfo } from 'net';
     import * as dns from 'dns';
-    import EventEmitter = require('events');
+    import { EventEmitter, Abortable } from 'events';
 
     interface RemoteInfo {
         address: string;
@@ -19,7 +19,7 @@ declare module 'dgram' {
 
     type SocketType = "udp4" | "udp6";
 
-    interface SocketOptions {
+    interface SocketOptions extends Abortable {
         type: SocketType;
         reuseAddr?: boolean;
         /**

node/fs/promises.d.ts

@@ -17,6 +17,7 @@ declare module 'fs/promises' {
         BufferEncodingOption,
         OpenMode,
         Mode,
+        WatchOptions,
     } from 'fs';
 
     interface FileHandle {
@@ -555,4 +556,37 @@ declare module 'fs/promises' {
     function readFile(path: PathLike | FileHandle, options?: BaseEncodingOptions & Abortable & { flag?: OpenMode } | BufferEncoding | null): Promise<string | Buffer>;
 
     function opendir(path: string, options?: OpenDirOptions): Promise<Dir>;
+
+    /**
+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
+     * If `encoding` is not supplied, the default of `'utf8'` is used.
+     * If `persistent` is not supplied, the default of `true` is used.
+     * If `recursive` is not supplied, the default of `false` is used.
+     */
+    function watch(filename: PathLike, options: WatchOptions & { encoding: "buffer" } | "buffer"): AsyncIterable<Buffer>;
+
+    /**
+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
+     * If `encoding` is not supplied, the default of `'utf8'` is used.
+     * If `persistent` is not supplied, the default of `true` is used.
+     * If `recursive` is not supplied, the default of `false` is used.
+     */
+    function watch(
+        filename: PathLike,
+        options?: WatchOptions | BufferEncoding
+    ): AsyncIterable<string>;
+
+    /**
+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
+     * If `encoding` is not supplied, the default of `'utf8'` is used.
+     * If `persistent` is not supplied, the default of `true` is used.
+     * If `recursive` is not supplied, the default of `false` is used.
+     */
+    function watch(filename: PathLike, options: WatchOptions | string): AsyncIterable<string> | AsyncIterable<Buffer>;
 }