@types/node 15.3.0 → 15.6.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: Fri, 14 May 2021 19:01:37 GMT
+ * Last updated: Wed, 02 Jun 2021 07:31:33 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

node/child_process.d.ts

@@ -1,13 +1,13 @@
 declare module 'child_process' {
     import { BaseEncodingOptions } from 'fs';
-    import * as events from 'events';
+    import { EventEmitter, Abortable } from 'events';
     import * as net from 'net';
     import { Writable, Readable, Stream, Pipe } from 'stream';
 
     type Serializable = string | object | number | boolean;
     type SendHandle = net.Socket | net.Server;
 
-    interface ChildProcess extends events.EventEmitter {
+    interface ChildProcess extends EventEmitter {
         stdin: Writable | null;
         stdout: Readable | null;
         stderr: Readable | null;
@@ -129,7 +129,9 @@ declare module 'child_process' {
         keepOpen?: boolean;
     }
 
-    type StdioOptions = "pipe" | "ignore" | "inherit" | Array<("pipe" | "ipc" | "ignore" | "inherit" | Stream | number | null | undefined)>;
+    type IOType = "overlapped" | "pipe" | "ignore" | "inherit";
+
+    type StdioOptions = IOType | Array<(IOType | "ipc" | Stream | number | null | undefined)>;
 
     type SerializationType = 'json' | 'advanced';
 
@@ -159,7 +161,7 @@ declare module 'child_process' {
         timeout?: number;
     }
 
-    interface CommonSpawnOptions extends CommonOptions, MessagingOptions {
+    interface CommonSpawnOptions extends CommonOptions, MessagingOptions, Abortable {
         argv0?: string;
         stdio?: StdioOptions;
         shell?: boolean | string;
@@ -171,11 +173,12 @@ declare module 'child_process' {
     }
 
     interface SpawnOptionsWithoutStdio extends SpawnOptions {
-        stdio?: 'pipe' | Array<null | undefined | 'pipe'>;
+        stdio?: StdioPipeNamed | StdioPipe[];
     }
 
     type StdioNull = 'inherit' | 'ignore' | Stream;
-    type StdioPipe = undefined | null | 'pipe';
+    type StdioPipeNamed = 'pipe' | 'overlapped';
+    type StdioPipe = undefined | null | StdioPipeNamed;
 
     interface SpawnOptionsWithStdioTuple<
         Stdin extends StdioNull | StdioPipe,
@@ -330,11 +333,12 @@ declare module 'child_process' {
         function __promisify__(command: string, options?: (BaseEncodingOptions & ExecOptions) | null): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
     }
 
-    interface ExecFileOptions extends CommonOptions {
+    interface ExecFileOptions extends CommonOptions, Abortable {
         maxBuffer?: number;
         killSignal?: NodeJS.Signals | number;
         windowsVerbatimArguments?: boolean;
         shell?: boolean | string;
+        signal?: AbortSignal;
     }
     interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
         encoding: BufferEncoding;
@@ -434,7 +438,7 @@ declare module 'child_process' {
         ): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
     }
 
-    interface ForkOptions extends ProcessEnvOptions, MessagingOptions {
+    interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable {
         execPath?: string;
         execArgv?: string[];
         silent?: boolean;

node/crypto.d.ts

@@ -1,5 +1,6 @@
 declare module 'crypto' {
     import * as stream from 'stream';
+    import { PeerCertificate } from 'tls';
 
     interface Certificate {
         /**
@@ -1267,4 +1268,189 @@ declare module 'crypto' {
      * or if the derived key cannot be generated.
      */
     function hkdfSync(digest: string, key: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
+
+    interface SecureHeapUsage {
+        /**
+         * The total allocated secure heap size as specified using the `--secure-heap=n` command-line flag.
+         */
+        total: number;
+
+        /**
+         * The minimum allocation from the secure heap as specified using the `--secure-heap-min` command-line flag.
+         */
+        min: number;
+
+        /**
+         * The total number of bytes currently allocated from the secure heap.
+         */
+        used: number;
+
+        /**
+         * The calculated ratio of `used` to `total` allocated bytes.
+         */
+        utilization: number;
+    }
+
+    function secureHeapUsed(): SecureHeapUsage;
+
+    // TODO: X509Certificate
+
+    interface RandomUUIDOptions {
+        /**
+         * By default, to improve performance,
+         * Node.js will pre-emptively generate and persistently cache enough
+         * random data to generate up to 128 random UUIDs. To generate a UUID
+         * without using the cache, set `disableEntropyCache` to `true`.
+         *
+         * @default `false`
+         */
+        disableEntropyCache?: boolean;
+    }
+
+    function randomUUID(options?: RandomUUIDOptions): string;
+
+    interface X509CheckOptions {
+        /**
+         * @default 'always'
+         */
+        subject: 'always' | 'never';
+
+        /**
+         * @default true
+         */
+        wildcards: boolean;
+
+        /**
+         * @default true
+         */
+        partialWildcards: boolean;
+
+        /**
+         * @default false
+         */
+        multiLabelWildcards: boolean;
+
+        /**
+         * @default false
+         */
+        singleLabelSubdomains: boolean;
+    }
+
+    class X509Certificate {
+        /**
+         * Will be `true` if this is a Certificate Authority (ca) certificate.
+         */
+        readonly ca: boolean;
+
+        /**
+         * The SHA-1 fingerprint of this certificate.
+         */
+        readonly fingerprint: string;
+
+        /**
+         * The SHA-256 fingerprint of this certificate.
+         */
+        readonly fingerprint256: string;
+
+        /**
+         * The complete subject of this certificate.
+         */
+        readonly subject: string;
+
+        /**
+         * The subject alternative name specified for this certificate.
+         */
+        readonly subjectAltName: string;
+
+        /**
+         * The information access content of this certificate.
+         */
+        readonly infoAccess: string;
+
+        /**
+         * An array detailing the key usages for this certificate.
+         */
+        readonly keyUsage: string[];
+
+        /**
+         * The public key for this certificate.
+         */
+        readonly publicKey: KeyObject;
+
+        /**
+         * A `Buffer` containing the DER encoding of this certificate.
+         */
+        readonly raw: Buffer;
+
+        /**
+         * The serial number of this certificate.
+         */
+        readonly serialNumber: string;
+
+        /**
+         * Returns the PEM-encoded certificate.
+         */
+        readonly validFrom: string;
+
+        /**
+         * The date/time from which this certificate is considered valid.
+         */
+        readonly validTo: string;
+
+        constructor(buffer: BinaryLike);
+
+        /**
+         * Checks whether the certificate matches the given email address.
+         *
+         * Returns `email` if the certificate matches,`undefined` if it does not.
+         */
+        checkEmail(email: string, options?: X509CheckOptions): string | undefined;
+
+        /**
+         * Checks whether the certificate matches the given host name.
+         *
+         * Returns `name` if the certificate matches, `undefined` if it does not.
+         */
+        checkHost(name: string, options?: X509CheckOptions): string | undefined;
+
+        /**
+         * Checks whether the certificate matches the given IP address (IPv4 or IPv6).
+         *
+         * Returns `ip` if the certificate matches, `undefined` if it does not.
+         */
+        checkIP(ip: string, options?: X509CheckOptions): string | undefined;
+
+        /**
+         * Checks whether this certificate was issued by the given `otherCert`.
+         */
+        checkIssued(otherCert: X509Certificate): boolean;
+
+        /**
+         * Checks whether this certificate was issued by the given `otherCert`.
+         */
+        checkPrivateKey(privateKey: KeyObject): boolean;
+
+        /**
+         * There is no standard JSON encoding for X509 certificates. The
+         * `toJSON()` method returns a string containing the PEM encoded
+         * certificate.
+         */
+        toJSON(): string;
+
+        /**
+         * Returns information about this certificate using the legacy [certificate object][] encoding.
+         */
+        toLegacyObject(): PeerCertificate;
+
+        /**
+         * Returns the PEM-encoded certificate.
+         */
+        toString(): string;
+
+        /**
+         * Verifies that this certificate was signed by the given public key.
+         * Does not perform any other validation checks on the certificate.
+         */
+        verify(publicKey: KeyObject): boolean;
+    }
 }

node/events.d.ts

@@ -57,6 +57,13 @@ declare module 'events' {
     namespace EventEmitter {
         // Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
         export { internal as EventEmitter };
+
+        export interface Abortable {
+            /**
+             * When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
+             */
+            signal?: AbortSignal;
+        }
     }
 
     global {

node/fs/promises.d.ts

@@ -1,4 +1,5 @@
 declare module 'fs/promises' {
+    import { Abortable } from 'events';
     import {
         Stats,
         BigIntStats,
@@ -16,7 +17,6 @@ declare module 'fs/promises' {
         BufferEncodingOption,
         OpenMode,
         Mode,
-        Abortable,
     } from 'fs';
 
     interface FileHandle {

node/fs.d.ts

@@ -1,6 +1,6 @@
 declare module 'fs' {
     import * as stream from 'stream';
-    import EventEmitter = require('events');
+    import { Abortable, EventEmitter } from 'events';
     import { URL } from 'url';
     import * as promises from 'fs/promises';
 
@@ -142,11 +142,6 @@ declare module 'fs' {
         prependOnceListener(event: "close", listener: () => void): this;
     }
 
-    // TODO: Move this to a more central location
-    export interface Abortable {
-        signal?: AbortSignal;
-    }
-
     export class ReadStream extends stream.Readable {
         close(): void;
         bytesRead: number;
@@ -2067,15 +2062,10 @@ declare module 'fs' {
      */
     export function accessSync(path: PathLike, mode?: number): void;
 
-    /**
-     * Returns a new `ReadStream` object.
-     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
-     * URL support is _experimental_.
-     */
-    export function createReadStream(path: PathLike, options?: string | {
+    interface StreamOptions {
         flags?: string;
         encoding?: BufferEncoding;
-        fd?: number;
+        fd?: number | promises.FileHandle;
         mode?: number;
         autoClose?: boolean;
         /**
@@ -2083,25 +2073,26 @@ declare module 'fs' {
          */
         emitClose?: boolean;
         start?: number;
-        end?: number;
         highWaterMark?: number;
-    }): ReadStream;
+    }
+
+    interface ReadStreamOptions extends StreamOptions {
+        end?: number;
+    }
+
+    /**
+     * Returns a new `ReadStream` object.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * URL support is _experimental_.
+     */
+    export function createReadStream(path: PathLike, options?: string | ReadStreamOptions): ReadStream;
 
     /**
      * Returns a new `WriteStream` object.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * URL support is _experimental_.
      */
-    export function createWriteStream(path: PathLike, options?: string | {
-        flags?: string;
-        encoding?: BufferEncoding;
-        fd?: number;
-        mode?: number;
-        autoClose?: boolean;
-        emitClose?: boolean;
-        start?: number;
-        highWaterMark?: number;
-    }): WriteStream;
+    export function createWriteStream(path: PathLike, options?: string | StreamOptions): WriteStream;
 
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.

node/globals.d.ts

@@ -622,6 +622,10 @@ declare namespace NodeJS {
         '.node': (m: Module, filename: string) => any;
     }
     interface Module {
+        /**
+         * `true` if the module is running during the Node.js preload
+         */
+        isPreloading: boolean;
         exports: any;
         require: Require;
         id: string;

node/http.d.ts

@@ -167,7 +167,7 @@ declare module 'http' {
         finished: boolean;
         headersSent: boolean;
         /**
-         * @deprecate Use `socket` instead.
+         * @deprecated Use `socket` instead.
          */
         connection: Socket | null;
         socket: Socket | null;
@@ -175,7 +175,7 @@ declare module 'http' {
         constructor();
 
         setTimeout(msecs: number, callback?: () => void): this;
-        setHeader(name: string, value: number | string | ReadonlyArray<string>): void;
+        setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
         getHeader(name: string): number | string | string[] | undefined;
         getHeaders(): OutgoingHttpHeaders;
         getHeaderNames(): string[];
@@ -374,7 +374,8 @@ declare module 'http' {
          */
         timeout?: number;
         /**
-         * Scheduling strategy to apply when picking the next free socket to use. Default: 'fifo'.
+         * Scheduling strategy to apply when picking the next free socket to use.
+         * @default `lifo`
          */
         scheduling?: 'fifo' | 'lifo';
     }

node/index.d.ts

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

node/net.d.ts

@@ -1,6 +1,6 @@
 declare module 'net' {
     import * as stream from 'stream';
-    import EventEmitter = require('events');
+    import { Abortable, EventEmitter } from 'events';
     import * as dns from 'dns';
 
     type LookupFunction = (
@@ -168,7 +168,7 @@ declare module 'net' {
         prependOnceListener(event: "timeout", listener: () => void): this;
     }
 
-    interface ListenOptions {
+    interface ListenOptions extends Abortable {
         port?: number;
         host?: string;
         backlog?: number;

node/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@types/node",
-    "version": "15.3.0",
+    "version": "15.6.2",
     "description": "TypeScript definitions for Node.js",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
     "contributors": [
         {
@@ -226,6 +227,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "db9f33705bb813befe4fef062f49dad7d922e4feb6d132c446fd94911812a697",
-    "typeScriptVersion": "3.5"
+    "typesPublisherContentHash": "f62422deccbd466260cb63740d207022259eb7fc7b6e7c406be463b9d1b0cd19",
+    "typeScriptVersion": "3.6"
 }

node/perf_hooks.d.ts

@@ -88,7 +88,10 @@ declare module 'perf_hooks' {
      * @param util1 The result of a previous call to eventLoopUtilization()
      * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
      */
-    type EventLoopUtilityFunction = (util1?: EventLoopUtilization, util2?: EventLoopUtilization) => EventLoopUtilization;
+    type EventLoopUtilityFunction = (
+        util1?: EventLoopUtilization,
+        util2?: EventLoopUtilization,
+    ) => EventLoopUtilization;
 
     interface Performance {
         /**
@@ -122,7 +125,7 @@ declare module 'perf_hooks' {
          * @param startMark
          * @param endMark
          */
-        measure(name: string, startMark: string, endMark: string): void;
+        measure(name: string, startMark?: string, endMark?: string): void;
 
         /**
          * An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.

node/process.d.ts

@@ -11,6 +11,18 @@ declare module 'process' {
             interface ReadStream extends tty.ReadStream {}
             interface WriteStream extends tty.WriteStream {}
 
+            interface MemoryUsageFn {
+                /**
+                 * The `process.memoryUsage()` method iterate over each page to gather informations about memory
+                 * usage which can be slow depending on the program memory allocations.
+                 */
+                (): MemoryUsage;
+                /**
+                 * method returns an integer representing the Resident Set Size (RSS) in bytes.
+                 */
+                rss(): number;
+            }
+
             interface MemoryUsage {
                 rss: number;
                 heapTotal: number;
@@ -289,7 +301,7 @@ declare module 'process' {
                 platform: Platform;
                 /** @deprecated since v14.0.0 - use `require.main` instead. */
                 mainModule?: Module;
-                memoryUsage(): MemoryUsage;
+                memoryUsage: MemoryUsageFn;
                 cpuUsage(previousValue?: CpuUsage): CpuUsage;
                 nextTick(callback: Function, ...args: any[]): void;
                 release: ProcessRelease;

node/stream.d.ts

@@ -1,5 +1,5 @@
 declare module 'stream' {
-    import EventEmitter = require('events');
+    import { EventEmitter, Abortable } from 'events';
     import * as streamPromises from "stream/promises";
 
     class internal extends EventEmitter {
@@ -11,16 +11,20 @@ declare module 'stream' {
             constructor(opts?: ReadableOptions);
         }
 
-        interface ReadableOptions {
+        interface StreamOptions<T extends Stream> extends Abortable {
+            emitClose?: boolean;
             highWaterMark?: number;
-            encoding?: BufferEncoding;
             objectMode?: boolean;
-            read?(this: Readable, size: number): void;
-            construct?(this: Readable, callback: (error?: Error | null) => void): void;
-            destroy?(this: Readable, error: Error | null, callback: (error: Error | null) => void): void;
+            construct?(this: T, callback: (error?: Error | null) => void): void;
+            destroy?(this: T, error: Error | null, callback: (error: Error | null) => void): void;
             autoDestroy?: boolean;
         }
 
+        interface ReadableOptions extends StreamOptions<Readable> {
+            encoding?: BufferEncoding;
+            read?(this: Readable, size: number): void;
+        }
+
         class Readable extends Stream implements NodeJS.ReadableStream {
             /**
              * A utility method for creating Readable Streams out of iterators.
@@ -127,18 +131,12 @@ declare module 'stream' {
             [Symbol.asyncIterator](): AsyncIterableIterator<any>;
         }
 
-        interface WritableOptions {
-            highWaterMark?: number;
+        interface WritableOptions extends StreamOptions<Writable> {
             decodeStrings?: boolean;
             defaultEncoding?: BufferEncoding;
-            objectMode?: boolean;
-            emitClose?: boolean;
-            construct?(this: Writable, callback: (error?: Error | null) => void): void;
             write?(this: Writable, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             writev?(this: Writable, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
-            destroy?(this: Writable, error: Error | null, callback: (error: Error | null) => void): void;
             final?(this: Writable, callback: (error?: Error | null) => void): void;
-            autoDestroy?: boolean;
         }
 
         class Writable extends Stream implements NodeJS.WritableStream {
@@ -293,6 +291,16 @@ declare module 'stream' {
 
         class PassThrough extends Transform { }
 
+        /**
+         * Attaches an AbortSignal to a readable or writeable stream. This lets code
+         * control stream destruction using an `AbortController`.
+         *
+         * Calling `abort` on the `AbortController` corresponding to the passed
+         * `AbortSignal` will behave the same way as calling `.destroy(new AbortError())`
+         * on the stream.
+         */
+        function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
+
         interface FinishedOptions {
             error?: boolean;
             readable?: boolean;

node/tls.d.ts

@@ -553,6 +553,9 @@ declare module 'tls' {
         prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }
 
+    /**
+     * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
+     */
     interface SecurePair {
         encrypted: TLSSocket;
         cleartext: TLSSocket;

node/util/types.d.ts

@@ -51,7 +51,3 @@ declare module 'util/types' {
     function isWeakMap(object: any): object is WeakMap<any, any>;
     function isWeakSet(object: any): object is WeakSet<any>;
 }
-
-declare module 'node:util/types' {
-    export * from 'util/types';
-}

node/worker_threads.d.ts

@@ -1,10 +1,11 @@
 declare module 'worker_threads' {
     import { Context } from 'vm';
-    import EventEmitter = require('events');
+    import { EventEmitter } from 'events';
+    import { EventLoopUtilityFunction } from 'perf_hooks';
+    import { FileHandle } from 'fs/promises';
     import { Readable, Writable } from 'stream';
     import { URL } from 'url';
-    import { FileHandle } from 'fs/promises';
-    import { EventLoopUtilityFunction } from 'perf_hooks';
+    import { X509Certificate } from 'crypto';
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -19,10 +20,10 @@ declare module 'worker_threads' {
     }
 
     interface WorkerPerformance {
-        eventLoopUtilitzation: EventLoopUtilityFunction;
+        eventLoopUtilization: EventLoopUtilityFunction;
     }
 
-    type TransferListItem = ArrayBuffer | MessagePort | FileHandle;
+    type TransferListItem = ArrayBuffer | MessagePort | FileHandle | X509Certificate;
 
     class MessagePort extends EventEmitter {
         close(): void;
@@ -209,6 +210,22 @@ declare module 'worker_threads' {
         off(event: string | symbol, listener: (...args: any[]) => void): this;
     }
 
+    interface BroadcastChannel extends NodeJS.RefCounted {}
+
+    /**
+     * See https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
+     */
+    class BroadcastChannel {
+        readonly name: string;
+        onmessage: (message: unknown) => void;
+        onmessageerror: (message: unknown) => void;
+
+        constructor(name: string);
+
+        close(): void;
+        postMessage(message: unknown): void;
+    }
+
     /**
      * Mark an object as not transferable.
      * If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.