@types/node 14.11.4 → 14.11.8

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: Tue, 06 Oct 2020 00:12:23 GMT
+ * Last updated: Fri, 09 Oct 2020 06:51:10 GMT
  * Dependencies: none
  * Global values: `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

node/assert.d.ts

@@ -91,7 +91,29 @@ declare module 'assert' {
         function match(value: string, regExp: RegExp, message?: string | Error): void;
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
 
-        const strict: typeof assert;
+        const strict: Omit<
+            typeof assert,
+            | 'strict'
+            | 'deepEqual'
+            | 'notDeepEqual'
+            | 'equal'
+            | 'notEqual'
+            | 'ok'
+            | 'strictEqual'
+            | 'deepStrictEqual'
+            | 'ifError'
+        > & {
+            (value: any, message?: string | Error): asserts value;
+            strict: typeof strict;
+            deepEqual: typeof deepStrictEqual;
+            notDeepEqual: typeof notDeepStrictEqual;
+            equal: typeof strictEqual;
+            notEqual: typeof notStrictEqual;
+            ok(value: any, message?: string | Error): asserts value;
+            strictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+            deepStrictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+            ifError(value: any): asserts value is null | undefined;
+        };
     }
 
     export = assert;

node/crypto.d.ts

@@ -278,7 +278,7 @@ declare module "crypto" {
 
     function createPrivateKey(key: PrivateKeyInput | string | Buffer): KeyObject;
     function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject): KeyObject;
-    function createSecretKey(key: Buffer): KeyObject;
+    function createSecretKey(key: NodeJS.ArrayBufferView): KeyObject;
 
     function createSign(algorithm: string, options?: stream.WritableOptions): Signer;
 
@@ -448,7 +448,7 @@ declare module "crypto" {
     /** @deprecated since v10.0.0 */
     const DEFAULT_ENCODING: BufferEncoding;
 
-    type KeyType = 'rsa' | 'dsa' | 'ec' | 'ed25519' | 'x25519';
+    type KeyType = 'rsa' | 'dsa' | 'ec' | 'ed25519' | 'ed448' | 'x25519' | 'x448';
     type KeyFormat = 'pem' | 'der';
 
     interface BasePrivateKeyEncodingOptions<T extends KeyFormat> {
@@ -468,12 +468,24 @@ declare module "crypto" {
          */
     }
 
+    interface ED448KeyPairKeyObjectOptions {
+        /**
+         * No options.
+         */
+    }
+
     interface X25519KeyPairKeyObjectOptions {
        /**
         * No options.
         */
     }
 
+    interface X448KeyPairKeyObjectOptions {
+       /**
+        * No options.
+        */
+    }
+
     interface ECKeyPairKeyObjectOptions {
         /**
          * Name of the curve to use.
@@ -568,6 +580,16 @@ declare module "crypto" {
         };
     }
 
+    interface ED448KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
+        publicKeyEncoding: {
+            type: 'spki';
+            format: PubF;
+        };
+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
+            type: 'pkcs8';
+        };
+    }
+
     interface X25519KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
         publicKeyEncoding: {
             type: 'spki';
@@ -578,6 +600,16 @@ declare module "crypto" {
         };
     }
 
+    interface X448KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
+        publicKeyEncoding: {
+            type: 'spki';
+            format: PubF;
+        };
+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
+            type: 'pkcs8';
+        };
+    }
+
     interface KeyPairSyncResult<T1 extends string | Buffer, T2 extends string | Buffer> {
         publicKey: T1;
         privateKey: T2;
@@ -605,13 +637,25 @@ declare module "crypto" {
     function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
-    function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
+    function generateKeyPairSync(type: 'ed25519', options?: ED25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
+
+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+    function generateKeyPairSync(type: 'ed448', options?: ED448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
 
     function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
     function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
-    function generateKeyPairSync(type: 'x25519', options: X25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
+    function generateKeyPairSync(type: 'x25519', options?: X25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
+
+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+    function generateKeyPairSync(type: 'x448', options?: X448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
 
     function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
     function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
@@ -635,13 +679,25 @@ declare module "crypto" {
     function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
     function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
     function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+
+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
+    function generateKeyPair(type: 'ed448', options: ED448KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
 
     function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
     function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
     function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
     function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'x25519', options: X25519KeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+    function generateKeyPair(type: 'x25519', options: X25519KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+
+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
+    function generateKeyPair(type: 'x448', options: X448KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
 
     namespace generateKeyPair {
         function __promisify__(type: "rsa", options: RSAKeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
@@ -666,13 +722,25 @@ declare module "crypto" {
         function __promisify__(type: "ed25519", options: ED25519KeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
         function __promisify__(type: "ed25519", options: ED25519KeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
         function __promisify__(type: "ed25519", options: ED25519KeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
-        function __promisify__(type: "ed25519", options: ED25519KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+        function __promisify__(type: "ed25519", options?: ED25519KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+
+        function __promisify__(type: "ed448", options: ED448KeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
+        function __promisify__(type: "ed448", options: ED448KeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
+        function __promisify__(type: "ed448", options: ED448KeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
+        function __promisify__(type: "ed448", options: ED448KeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
+        function __promisify__(type: "ed448", options?: ED448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
 
         function __promisify__(type: "x25519", options: X25519KeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
         function __promisify__(type: "x25519", options: X25519KeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
         function __promisify__(type: "x25519", options: X25519KeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
         function __promisify__(type: "x25519", options: X25519KeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
-        function __promisify__(type: "x25519", options: X25519KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+        function __promisify__(type: "x25519", options?: X25519KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+
+        function __promisify__(type: "x448", options: X448KeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
+        function __promisify__(type: "x448", options: X448KeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
+        function __promisify__(type: "x448", options: X448KeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
+        function __promisify__(type: "x448", options: X448KeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
+        function __promisify__(type: "x448", options?: X448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
     }
 
     /**

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "14.11.4",
+    "version": "14.11.8",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -246,6 +246,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "c9f281dca3a2c83d3ec1cb1962cf197c93097f9401920f7d394a27de75625caa",
+    "typesPublisherContentHash": "2648fdcf6d0b183d3a081cb17833d47c55084f5245aa4f9a8ea246ed71a45a8b",
     "typeScriptVersion": "3.2"
 }

node/punycode.d.ts

@@ -1,12 +1,68 @@
 declare module "punycode" {
+    /**
+     * @deprecated since v7.0.0
+     * The version of the punycode module bundled in Node.js is being deprecated.
+     * In a future major version of Node.js this module will be removed.
+     * Users currently depending on the punycode module should switch to using
+     * the userland-provided Punycode.js module instead.
+     */
     function decode(string: string): string;
+    /**
+     * @deprecated since v7.0.0
+     * The version of the punycode module bundled in Node.js is being deprecated.
+     * In a future major version of Node.js this module will be removed.
+     * Users currently depending on the punycode module should switch to using
+     * the userland-provided Punycode.js module instead.
+     */
     function encode(string: string): string;
+    /**
+     * @deprecated since v7.0.0
+     * The version of the punycode module bundled in Node.js is being deprecated.
+     * In a future major version of Node.js this module will be removed.
+     * Users currently depending on the punycode module should switch to using
+     * the userland-provided Punycode.js module instead.
+     */
     function toUnicode(domain: string): string;
+    /**
+     * @deprecated since v7.0.0
+     * The version of the punycode module bundled in Node.js is being deprecated.
+     * In a future major version of Node.js this module will be removed.
+     * Users currently depending on the punycode module should switch to using
+     * the userland-provided Punycode.js module instead.
+     */
     function toASCII(domain: string): string;
+    /**
+     * @deprecated since v7.0.0
+     * The version of the punycode module bundled in Node.js is being deprecated.
+     * In a future major version of Node.js this module will be removed.
+     * Users currently depending on the punycode module should switch to using
+     * the userland-provided Punycode.js module instead.
+     */
     const ucs2: ucs2;
     interface ucs2 {
+        /**
+         * @deprecated since v7.0.0
+         * The version of the punycode module bundled in Node.js is being deprecated.
+         * In a future major version of Node.js this module will be removed.
+         * Users currently depending on the punycode module should switch to using
+         * the userland-provided Punycode.js module instead.
+         */
         decode(string: string): number[];
+        /**
+         * @deprecated since v7.0.0
+         * The version of the punycode module bundled in Node.js is being deprecated.
+         * In a future major version of Node.js this module will be removed.
+         * Users currently depending on the punycode module should switch to using
+         * the userland-provided Punycode.js module instead.
+         */
         encode(codePoints: number[]): string;
     }
+    /**
+     * @deprecated since v7.0.0
+     * The version of the punycode module bundled in Node.js is being deprecated.
+     * In a future major version of Node.js this module will be removed.
+     * Users currently depending on the punycode module should switch to using
+     * the userland-provided Punycode.js module instead.
+     */
     const version: string;
 }

node/wasi.d.ts

@@ -6,11 +6,13 @@ declare module 'wasi' {
          * WASI command itself.
          */
         args?: string[];
+
         /**
          * An object similar to `process.env` that the WebAssembly
          * application will see as its environment.
          */
         env?: object;
+
         /**
          * This object represents the WebAssembly application's
          * sandbox directory structure. The string keys of `preopens` are treated as
@@ -27,6 +29,24 @@ declare module 'wasi' {
          * @default false
          */
         returnOnExit?: boolean;
+
+        /**
+         * The file descriptor used as standard input in the WebAssembly application.
+         * @default 0
+         */
+        stdin?: number;
+
+        /**
+         * The file descriptor used as standard output in the WebAssembly application.
+         * @default 1
+         */
+        stdout?: number;
+
+        /**
+         * The file descriptor used as standard error in the WebAssembly application.
+         * @default 2
+         */
+        stderr?: number;
     }
 
     class WASI {
@@ -40,11 +60,25 @@ declare module 'wasi' {
          *
          * `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
          * `memory`. If `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `start()` is called more than once, an exception is thrown.
          */
         start(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+
+        /**
+         * Attempt to initialize `instance` as a WASI reactor by invoking its `_initialize()` export, if it is present.
+         * If `instance` contains a `_start()` export, then an exception is thrown.
+         *
+         * `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
+         * `memory`. If `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `initialize()` is called more than once, an exception is thrown.
+         */
+        initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+
         /**
          * Is an object that implements the WASI system call API. This object
-         * should be passed as the `wasi_unstable` import during the instantiation of a
+         * should be passed as the `wasi_snapshot_preview1` import during the instantiation of a
          * [`WebAssembly.Instance`][].
          */
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types

node/worker_threads.d.ts

@@ -3,9 +3,11 @@ declare module "worker_threads" {
     import { EventEmitter } from "events";
     import { Readable, Writable } from "stream";
     import { URL } from "url";
+    import { FileHandle } from "fs/promises";
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
+    const resourceLimits: ResourceLimits;
     const SHARE_ENV: unique symbol;
     const threadId: number;
     const workerData: any;
@@ -15,43 +17,53 @@ declare module "worker_threads" {
         readonly port2: MessagePort;
     }
 
+    type TransferListItem = ArrayBuffer | MessagePort | FileHandle;
+
     class MessagePort extends EventEmitter {
         close(): void;
-        postMessage(value: any, transferList?: Array<ArrayBuffer | MessagePort>): void;
+        postMessage(value: any, transferList?: TransferListItem[]): void;
         ref(): void;
         unref(): void;
         start(): void;
 
         addListener(event: "close", listener: () => void): this;
         addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: "messageerror", listener: (error: Error) => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         emit(event: "close"): boolean;
         emit(event: "message", value: any): boolean;
+        emit(event: "messageerror", error: Error): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
 
         on(event: "close", listener: () => void): this;
         on(event: "message", listener: (value: any) => void): this;
+        on(event: "messageerror", listener: (error: Error) => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
 
         once(event: "close", listener: () => void): this;
         once(event: "message", listener: (value: any) => void): this;
+        once(event: "messageerror", listener: (error: Error) => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
 
         prependListener(event: "close", listener: () => void): this;
         prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: "messageerror", listener: (error: Error) => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         prependOnceListener(event: "close", listener: () => void): this;
         prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         removeListener(event: "close", listener: () => void): this;
         removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: "messageerror", listener: (error: Error) => void): this;
         removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         off(event: "close", listener: () => void): this;
         off(event: "message", listener: (value: any) => void): this;
+        off(event: "messageerror", listener: (error: Error) => void): this;
         off(event: string | symbol, listener: (...args: any[]) => void): this;
     }
 
@@ -74,14 +86,28 @@ declare module "worker_threads" {
         /**
          * Additional data to send in the first worker message.
          */
-        transferList?: Array<ArrayBuffer | MessagePort>;
+        transferList?: TransferListItem[];
         trackUnmanagedFds?: boolean;
     }
 
     interface ResourceLimits {
+        /**
+         * The maximum size of a heap space for recently created objects.
+         */
         maxYoungGenerationSizeMb?: number;
+        /**
+         * The maximum size of the main heap in MB.
+         */
         maxOldGenerationSizeMb?: number;
+        /**
+         * The size of a pre-allocated memory range used for generated code.
+         */
         codeRangeSizeMb?: number;
+        /**
+         * The default maximum stack size for the thread. Small values may lead to unusable Worker instances.
+         * @default 4
+         */
+        stackSizeMb?: number;
     }
 
     class Worker extends EventEmitter {
@@ -98,7 +124,7 @@ declare module "worker_threads" {
          */
         constructor(filename: string | URL, options?: WorkerOptions);
 
-        postMessage(value: any, transferList?: Array<ArrayBuffer | MessagePort>): void;
+        postMessage(value: any, transferList?: TransferListItem[]): void;
         ref(): void;
         unref(): void;
         /**
@@ -120,52 +146,72 @@ declare module "worker_threads" {
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (exitCode: number) => void): this;
         addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: "messageerror", listener: (error: Error) => void): this;
         addListener(event: "online", listener: () => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         emit(event: "error", err: Error): boolean;
         emit(event: "exit", exitCode: number): boolean;
         emit(event: "message", value: any): boolean;
+        emit(event: "messageerror", error: Error): boolean;
         emit(event: "online"): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
 
         on(event: "error", listener: (err: Error) => void): this;
         on(event: "exit", listener: (exitCode: number) => void): this;
         on(event: "message", listener: (value: any) => void): this;
+        on(event: "messageerror", listener: (error: Error) => void): this;
         on(event: "online", listener: () => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
 
         once(event: "error", listener: (err: Error) => void): this;
         once(event: "exit", listener: (exitCode: number) => void): this;
         once(event: "message", listener: (value: any) => void): this;
+        once(event: "messageerror", listener: (error: Error) => void): this;
         once(event: "online", listener: () => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
 
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(event: "exit", listener: (exitCode: number) => void): this;
         prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: "messageerror", listener: (error: Error) => void): this;
         prependListener(event: "online", listener: () => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
         prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
         prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
         prependOnceListener(event: "online", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         removeListener(event: "error", listener: (err: Error) => void): this;
         removeListener(event: "exit", listener: (exitCode: number) => void): this;
         removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: "messageerror", listener: (error: Error) => void): this;
         removeListener(event: "online", listener: () => void): this;
         removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         off(event: "error", listener: (err: Error) => void): this;
         off(event: "exit", listener: (exitCode: number) => void): this;
         off(event: "message", listener: (value: any) => void): this;
+        off(event: "messageerror", listener: (error: Error) => void): this;
         off(event: "online", listener: () => void): this;
         off(event: string | symbol, listener: (...args: any[]) => void): this;
     }
 
+    /**
+     * Mark an object as not transferable.
+     * If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.
+     *
+     * In particular, this makes sense for objects that can be cloned, rather than transferred,
+     * and which are used by other objects on the sending side. For example, Node.js marks
+     * the `ArrayBuffer`s it uses for its Buffer pool with this.
+     *
+     * This operation cannot be undone.
+     */
+    function markAsUntransferable(object: object): void;
+
     /**
      * Transfer a `MessagePort` to a different `vm` Context. The original `port`
      * object will be rendered unusable, and the returned `MessagePort` instance will

node/zlib.d.ts

@@ -19,6 +19,8 @@ declare module "zlib" {
         memLevel?: number; // compression only
         strategy?: number; // compression only
         dictionary?: NodeJS.ArrayBufferView | ArrayBuffer; // deflate/inflate only, empty dictionary by default
+        info?: boolean;
+        maxOutputLength?: number;
     }
 
     interface BrotliOptions {
@@ -40,6 +42,7 @@ declare module "zlib" {
              */
             [key: number]: boolean | number;
         };
+        maxOutputLength?: number;
     }
 
     interface Zlib {
@@ -111,6 +114,43 @@ declare module "zlib" {
     function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
 
+    namespace brotliCompress {
+        function __promisify__(buffer: InputType, options: BrotliOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+    }
+    namespace brotliDecompress {
+        function __promisify__(buffer: InputType, options: BrotliOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+    }
+    namespace deflate {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+    namespace deflateRaw {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+    namespace gzip {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+    namespace gunzip {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+    namespace inflate {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+    namespace inflateRaw {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+    namespace unzip {
+        function __promisify__(buffer: InputType): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+    }
+
     namespace constants {
         const BROTLI_DECODE: number;
         const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;