@types/node 16.3.2 → 16.3.3

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, 14 Jul 2021 00:01:20 GMT
+ * Last updated: Fri, 16 Jul 2021 19:01:24 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`
 

node/assert/strict.d.ts

@@ -1,9 +1,9 @@
 declare module 'assert/strict' {
-    import { strict } from 'assert';
+    import { strict } from 'node:assert';
     export = strict;
 }
 
 declare module 'node:assert/strict' {
-    import * as assert from 'assert/strict';
-    export = assert;
+    import { strict } from 'node:assert';
+    export = strict;
 }

node/buffer.d.ts

@@ -1,5 +1,5 @@
 declare module 'buffer' {
-    import { BinaryLike } from 'crypto';
+    import { BinaryLike } from 'node:crypto';
 
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;

node/child_process.d.ts

@@ -1,8 +1,8 @@
 declare module 'child_process' {
-    import { ObjectEncodingOptions } from 'fs';
-    import { EventEmitter, Abortable } from 'events';
-    import * as net from 'net';
-    import { Writable, Readable, Stream, Pipe } from 'stream';
+    import { ObjectEncodingOptions } from 'node:fs';
+    import { EventEmitter, Abortable } from 'node:events';
+    import * as net from 'node:net';
+    import { Writable, Readable, Stream, Pipe } from 'node:stream';
 
     type Serializable = string | object | number | boolean | bigint;
     type SendHandle = net.Socket | net.Server;

node/cluster.d.ts

@@ -1,8 +1,8 @@
 // Requires `esModuleInterop: true`
 declare module 'cluster' {
-    import * as child from 'child_process';
-    import EventEmitter = require('events');
-    import * as net from 'net';
+    import * as child from 'node:child_process';
+    import EventEmitter = require('node:events');
+    import * as net from 'node:net';
 
     export interface ClusterSettings {
         execArgv?: string[] | undefined; // default: process.execArgv
@@ -184,4 +184,5 @@ declare module 'cluster' {
 
 declare module 'node:cluster' {
     export * from 'cluster';
+    export { default as default } from 'cluster';
 }

node/console.d.ts

@@ -1,5 +1,10 @@
 declare module 'console' {
-    import { InspectOptions } from 'util';
+    import console = require('node:console');
+    export = console;
+}
+
+declare module 'node:console' {
+    import { InspectOptions } from 'node:util';
 
     global {
         // This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
@@ -127,8 +132,3 @@ declare module 'console' {
 
     export = globalThis.console;
 }
-
-declare module 'node:console' {
-    import console = require('console');
-    export = console;
-}

node/constants.d.ts

@@ -1,8 +1,8 @@
 /** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
 declare module 'constants' {
-    import { constants as osConstants, SignalConstants } from 'os';
-    import { constants as cryptoConstants } from 'crypto';
-    import { constants as fsConstants } from 'fs';
+    import { constants as osConstants, SignalConstants } from 'node:os';
+    import { constants as cryptoConstants } from 'node:crypto';
+    import { constants as fsConstants } from 'node:fs';
 
     const exp: typeof osConstants.errno &
         typeof osConstants.priority &

node/crypto.d.ts

@@ -1,6 +1,6 @@
 declare module 'crypto' {
-    import * as stream from 'stream';
-    import { PeerCertificate } from 'tls';
+    import * as stream from 'node:stream';
+    import { PeerCertificate } from 'node:tls';
 
     interface Certificate {
         /**

node/dgram.d.ts

@@ -1,7 +1,7 @@
 declare module 'dgram' {
-    import { AddressInfo } from 'net';
-    import * as dns from 'dns';
-    import { EventEmitter, Abortable } from 'events';
+    import { AddressInfo } from 'node:net';
+    import * as dns from 'node:dns';
+    import { EventEmitter, Abortable } from 'node:events';
 
     interface RemoteInfo {
         address: string;

node/{diagnostic_channel.d.ts → diagnostics_channel.d.ts}

@@ -1,7 +1,7 @@
 /**
  * @experimental
  */
-declare module 'diagnostic_channel' {
+declare module 'diagnostics_channel' {
     /**
      * Returns wether a named channel has subscribers or not.
      */
@@ -33,6 +33,6 @@ declare module 'diagnostic_channel' {
     }
 }
 
-declare module 'node:diagnostic_channel' {
-    export * from 'diagnostic_channel';
+declare module 'node:diagnostics_channel' {
+    export * from 'diagnostics_channel';
 }

node/dns/promises.d.ts

@@ -14,7 +14,7 @@ declare module "dns/promises" {
         RecordWithTtl,
         ResolveOptions,
         ResolverOptions,
-    } from "dns";
+    } from "node:dns";
 
     function getServers(): string[];
 

node/dns.d.ts

@@ -1,5 +1,5 @@
 declare module 'dns' {
-    import * as dnsPromises from "dns/promises";
+    import * as dnsPromises from "node:dns/promises";
 
     // Supported getaddrinfo flags.
     export const ADDRCONFIG: number;

node/domain.d.ts

@@ -1,8 +1,8 @@
-/**
- * @deprecated
- */
+ /**
+  * @deprecated
+  */
 declare module 'domain' {
-    import EventEmitter = require('events');
+    import EventEmitter = require('node:events');
     class Domain extends EventEmitter {
         members: Array<EventEmitter | NodeJS.Timer>;
         enter(): void;
@@ -17,9 +17,9 @@ declare module 'domain' {
     function create(): Domain;
 }
 
-/**
- * @deprecated
- */
+ /**
+  * @deprecated
+  */
 declare module 'node:domain' {
     export * from 'domain';
 }

node/events.d.ts

@@ -53,7 +53,7 @@ declare module 'events' {
         static defaultMaxListeners: number;
     }
 
-    import internal = require('events');
+    import internal = require('node:events');
     namespace EventEmitter {
         // Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
         export { internal as EventEmitter };

node/fs/promises.d.ts

@@ -1,6 +1,6 @@
 declare module 'fs/promises' {
-    import { Abortable } from 'events';
-    import { Stream } from 'stream';
+    import { Abortable } from 'node:events';
+    import { Stream } from 'node:stream';
     import {
         Stats,
         BigIntStats,
@@ -19,7 +19,7 @@ declare module 'fs/promises' {
         OpenMode,
         Mode,
         WatchOptions,
-    } from 'fs';
+    } from 'node:fs';
 
     interface FlagAndOpenMode {
         mode?: Mode | undefined;

node/fs.d.ts

@@ -1,8 +1,8 @@
 declare module 'fs' {
-    import * as stream from 'stream';
-    import { Abortable, EventEmitter } from 'events';
-    import { URL } from 'url';
-    import * as promises from 'fs/promises';
+    import * as stream from 'node:stream';
+    import { Abortable, EventEmitter } from 'node:events';
+    import { URL } from 'node:url';
+    import * as promises from 'node:fs/promises';
 
     export { promises };
     /**

node/http.d.ts

@@ -1,7 +1,7 @@
 declare module 'http' {
-    import * as stream from 'stream';
-    import { URL } from 'url';
-    import { Socket, Server as NetServer } from 'net';
+    import * as stream from 'node:stream';
+    import { URL } from 'node:url';
+    import { Socket, Server as NetServer } from 'node:net';
 
     // incoming headers will never contain number
     interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {

node/http2.d.ts

@@ -1,18 +1,18 @@
 declare module 'http2' {
-    import EventEmitter = require('events');
-    import * as fs from 'fs';
-    import * as net from 'net';
-    import * as stream from 'stream';
-    import * as tls from 'tls';
-    import * as url from 'url';
+    import EventEmitter = require('node:events');
+    import * as fs from 'node:fs';
+    import * as net from 'node:net';
+    import * as stream from 'node:stream';
+    import * as tls from 'node:tls';
+    import * as url from 'node:url';
 
     import {
         IncomingHttpHeaders as Http1IncomingHttpHeaders,
         OutgoingHttpHeaders,
         IncomingMessage,
         ServerResponse,
-    } from 'http';
-    export { OutgoingHttpHeaders } from 'http';
+    } from 'node:http';
+    export { OutgoingHttpHeaders } from 'node:http';
 
     export interface IncomingHttpStatusHeader {
         ":status"?: number | undefined;

node/https.d.ts

@@ -1,7 +1,7 @@
 declare module 'https' {
-    import * as tls from 'tls';
-    import * as http from 'http';
-    import { URL } from 'url';
+    import * as tls from 'node:tls';
+    import * as http from 'node:http';
+    import { URL } from 'node:url';
 
     type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
 

node/inspector.d.ts

@@ -11,7 +11,7 @@
  * The inspector module provides an API for interacting with the V8 inspector.
  */
 declare module 'inspector' {
-    import EventEmitter = require('events');
+    import EventEmitter = require('node:events');
 
     interface InspectorNotification<T> {
         method: string;
@@ -1804,6 +1804,100 @@ declare module 'inspector' {
         }
     }
 
+    namespace NodeTracing {
+        interface TraceConfig {
+            /**
+             * Controls how the trace buffer stores data.
+             */
+            recordMode?: string;
+            /**
+             * Included category filters.
+             */
+            includedCategories: string[];
+        }
+
+        interface StartParameterType {
+            traceConfig: TraceConfig;
+        }
+
+        interface GetCategoriesReturnType {
+            /**
+             * A list of supported tracing categories.
+             */
+            categories: string[];
+        }
+
+        interface DataCollectedEventDataType {
+            value: Array<{}>;
+        }
+    }
+
+    namespace NodeWorker {
+        type WorkerID = string;
+
+        /**
+         * Unique identifier of attached debugging session.
+         */
+        type SessionID = string;
+
+        interface WorkerInfo {
+            workerId: WorkerID;
+            type: string;
+            title: string;
+            url: string;
+        }
+
+        interface SendMessageToWorkerParameterType {
+            message: string;
+            /**
+             * Identifier of the session.
+             */
+            sessionId: SessionID;
+        }
+
+        interface EnableParameterType {
+            /**
+             * Whether to new workers should be paused until the frontend sends `Runtime.runIfWaitingForDebugger`
+             * message to run them.
+             */
+            waitForDebuggerOnStart: boolean;
+        }
+
+        interface DetachParameterType {
+            sessionId: SessionID;
+        }
+
+        interface AttachedToWorkerEventDataType {
+            /**
+             * Identifier assigned to the session used to send/receive messages.
+             */
+            sessionId: SessionID;
+            workerInfo: WorkerInfo;
+            waitingForDebugger: boolean;
+        }
+
+        interface DetachedFromWorkerEventDataType {
+            /**
+             * Detached session identifier.
+             */
+            sessionId: SessionID;
+        }
+
+        interface ReceivedMessageFromWorkerEventDataType {
+            /**
+             * Identifier of a session which sends a message.
+             */
+            sessionId: SessionID;
+            message: string;
+        }
+    }
+
+    namespace NodeRuntime {
+        interface NotifyWhenWaitingForDisconnectParameterType {
+            enabled: boolean;
+        }
+    }
+
     /**
      * The inspector.Session is used for dispatching messages to the V8 inspector back-end and receiving message responses and notifications.
      */
@@ -2203,6 +2297,53 @@ declare module 'inspector' {
 
         post(method: "HeapProfiler.getSamplingProfile", callback?: (err: Error | null, params: HeapProfiler.GetSamplingProfileReturnType) => void): void;
 
+        /**
+         * Gets supported tracing categories.
+         */
+        post(method: "NodeTracing.getCategories", callback?: (err: Error | null, params: NodeTracing.GetCategoriesReturnType) => void): void;
+
+        /**
+         * Start trace events collection.
+         */
+        post(method: "NodeTracing.start", params?: NodeTracing.StartParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeTracing.start", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Stop trace events collection. Remaining collected events will be sent as a sequence of
+         * dataCollected events followed by tracingComplete event.
+         */
+        post(method: "NodeTracing.stop", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Sends protocol message over session with given id.
+         */
+        post(method: "NodeWorker.sendMessageToWorker", params?: NodeWorker.SendMessageToWorkerParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeWorker.sendMessageToWorker", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Instructs the inspector to attach to running workers. Will also attach to new workers
+         * as they start
+         */
+        post(method: "NodeWorker.enable", params?: NodeWorker.EnableParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeWorker.enable", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Detaches from all running workers and disables attaching to new workers as they are started.
+         */
+        post(method: "NodeWorker.disable", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Detached from the worker with given sessionId.
+         */
+        post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeWorker.detach", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Enable the `NodeRuntime.waitingForDisconnect`.
+         */
+        post(method: "NodeRuntime.notifyWhenWaitingForDisconnect", params?: NodeRuntime.NotifyWhenWaitingForDisconnectParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeRuntime.notifyWhenWaitingForDisconnect", callback?: (err: Error | null) => void): void;
+
         // Events
 
         addListener(event: string, listener: (...args: any[]) => void): this;
@@ -2297,6 +2438,41 @@ declare module 'inspector' {
          */
         addListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        addListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        addListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+
+        /**
+         * Issued when attached to a worker.
+         */
+        addListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+
+        /**
+         * Issued when detached from the worker.
+         */
+        addListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        addListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+
+        /**
+         * This event is fired instead of `Runtime.executionContextDestroyed` when
+         * enabled.
+         * It is fired when the Node process finished all code execution and is
+         * waiting for all frontends to disconnect.
+         */
+        addListener(event: "NodeRuntime.waitingForDisconnect", listener: () => void): this;
+
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "inspectorNotification", message: InspectorNotification<{}>): boolean;
         emit(event: "Runtime.executionContextCreated", message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
@@ -2319,6 +2495,12 @@ declare module 'inspector' {
         emit(event: "HeapProfiler.reportHeapSnapshotProgress", message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>): boolean;
         emit(event: "HeapProfiler.lastSeenObjectId", message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>): boolean;
         emit(event: "HeapProfiler.heapStatsUpdate", message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>): boolean;
+        emit(event: "NodeTracing.dataCollected", message: InspectorNotification<NodeTracing.DataCollectedEventDataType>): boolean;
+        emit(event: "NodeTracing.tracingComplete"): boolean;
+        emit(event: "NodeWorker.attachedToWorker", message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
+        emit(event: "NodeWorker.detachedFromWorker", message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
+        emit(event: "NodeWorker.receivedMessageFromWorker", message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): boolean;
+        emit(event: "NodeRuntime.waitingForDisconnect"): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
 
@@ -2412,6 +2594,41 @@ declare module 'inspector' {
          */
         on(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        on(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        on(event: "NodeTracing.tracingComplete", listener: () => void): this;
+
+        /**
+         * Issued when attached to a worker.
+         */
+        on(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+
+        /**
+         * Issued when detached from the worker.
+         */
+        on(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        on(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+
+        /**
+         * This event is fired instead of `Runtime.executionContextDestroyed` when
+         * enabled.
+         * It is fired when the Node process finished all code execution and is
+         * waiting for all frontends to disconnect.
+         */
+        on(event: "NodeRuntime.waitingForDisconnect", listener: () => void): this;
+
         once(event: string, listener: (...args: any[]) => void): this;
 
         /**
@@ -2504,6 +2721,41 @@ declare module 'inspector' {
          */
         once(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        once(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        once(event: "NodeTracing.tracingComplete", listener: () => void): this;
+
+        /**
+         * Issued when attached to a worker.
+         */
+        once(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+
+        /**
+         * Issued when detached from the worker.
+         */
+        once(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        once(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+
+        /**
+         * This event is fired instead of `Runtime.executionContextDestroyed` when
+         * enabled.
+         * It is fired when the Node process finished all code execution and is
+         * waiting for all frontends to disconnect.
+         */
+        once(event: "NodeRuntime.waitingForDisconnect", listener: () => void): this;
+
         prependListener(event: string, listener: (...args: any[]) => void): this;
 
         /**
@@ -2596,6 +2848,41 @@ declare module 'inspector' {
          */
         prependListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        prependListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        prependListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+
+        /**
+         * Issued when attached to a worker.
+         */
+        prependListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+
+        /**
+         * Issued when detached from the worker.
+         */
+        prependListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        prependListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+
+        /**
+         * This event is fired instead of `Runtime.executionContextDestroyed` when
+         * enabled.
+         * It is fired when the Node process finished all code execution and is
+         * waiting for all frontends to disconnect.
+         */
+        prependListener(event: "NodeRuntime.waitingForDisconnect", listener: () => void): this;
+
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
 
         /**
@@ -2687,6 +2974,41 @@ declare module 'inspector' {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         prependOnceListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        prependOnceListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        prependOnceListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+
+        /**
+         * Issued when attached to a worker.
+         */
+        prependOnceListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+
+        /**
+         * Issued when detached from the worker.
+         */
+        prependOnceListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        prependOnceListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+
+        /**
+         * This event is fired instead of `Runtime.executionContextDestroyed` when
+         * enabled.
+         * It is fired when the Node process finished all code execution and is
+         * waiting for all frontends to disconnect.
+         */
+        prependOnceListener(event: "NodeRuntime.waitingForDisconnect", listener: () => void): this;
     }
 
     // Top Level API
@@ -2719,5 +3041,6 @@ declare module 'inspector' {
 }
 
 declare module 'node:inspector' {
-    export * from 'inspector';
+    import EventEmitter = require('inspector');
+    export = EventEmitter;
 }

node/module.d.ts

@@ -1,5 +1,5 @@
 declare module 'module' {
-    import { URL } from 'url';
+    import { URL } from 'node:url';
     namespace Module {
         /**
          * Updates all the live bindings for builtin ES Modules to match the properties of the CommonJS exports.

node/net.d.ts

@@ -1,7 +1,7 @@
 declare module 'net' {
-    import * as stream from 'stream';
-    import { Abortable, EventEmitter } from 'events';
-    import * as dns from 'dns';
+    import * as stream from 'node:stream';
+    import { Abortable, EventEmitter } from 'node:events';
+    import * as dns from 'node:dns';
 
     type LookupFunction = (
         hostname: string,

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.3.2",
+    "version": "16.3.3",
     "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": "6d3b2fbef9e172f85e1d70e1c9b6dcd93b75d01f67a8c467634c8e99d55fdf74",
+    "typesPublisherContentHash": "046ee08897f6b1ab1ee2bd22e5df32d1fa1f782ba1d32a106aab33c28f7f1081",
     "typeScriptVersion": "3.6"
 }

node/perf_hooks.d.ts

@@ -1,5 +1,5 @@
 declare module 'perf_hooks' {
-    import { AsyncResource } from 'async_hooks';
+    import { AsyncResource } from 'node:async_hooks';
 
     type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
 

node/process.d.ts

@@ -1,6 +1,6 @@
 declare module 'process' {
-    import * as tty from 'tty';
-    import { Worker } from 'worker_threads';
+    import * as tty from 'node:tty';
+    import { Worker } from 'node:worker_threads';
 
     global {
         var process: NodeJS.Process;

node/readline.d.ts

@@ -1,5 +1,5 @@
 declare module 'readline' {
-    import { Abortable, EventEmitter } from 'events';
+    import { Abortable, EventEmitter } from 'node:events';
 
     interface Key {
         sequence?: string | undefined;

node/repl.d.ts

@@ -1,7 +1,7 @@
 declare module 'repl' {
-    import { Interface, Completer, AsyncCompleter } from 'readline';
-    import { Context } from 'vm';
-    import { InspectOptions } from 'util';
+    import { Interface, Completer, AsyncCompleter } from 'node:readline';
+    import { Context } from 'node:vm';
+    import { InspectOptions } from 'node:util';
 
     interface ReplOptions {
         /**

node/stream/promises.d.ts

@@ -1,6 +1,6 @@
 declare module "stream/promises" {
     import { FinishedOptions, PipelineSource, PipelineTransform,
-        PipelineDestination, PipelinePromise, PipelineOptions } from "stream";
+        PipelineDestination, PipelinePromise, PipelineOptions } from "node:stream";
 
     function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options?: FinishedOptions): Promise<void>;
 

node/stream.d.ts

@@ -1,6 +1,6 @@
 declare module 'stream' {
-    import { EventEmitter, Abortable } from 'events';
-    import * as streamPromises from "stream/promises";
+    import { EventEmitter, Abortable } from 'node:events';
+    import * as streamPromises from "node:stream/promises";
 
     class internal extends EventEmitter {
         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;

node/timers/promises.d.ts

@@ -1,5 +1,5 @@
 declare module 'timers/promises' {
-    import { TimerOptions } from 'timers';
+    import { TimerOptions } from 'node:timers';
 
     /**
      * Returns a promise that resolves after the specified delay in milliseconds.

node/timers.d.ts

@@ -1,6 +1,6 @@
 declare module 'timers' {
-    import { Abortable } from 'events';
-    import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'timers/promises';
+    import { Abortable } from 'node:events';
+    import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
 
     interface TimerOptions extends Abortable {
         /**
@@ -73,29 +73,3 @@ declare module 'timers' {
 declare module 'node:timers' {
     export * from 'timers';
 }
-
-declare module 'timers/promises' {
-    import { TimerOptions } from 'timers';
-
-    /**
-     * Returns a promise that resolves after the specified delay in milliseconds.
-     * @param delay defaults to 1
-     */
-    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
-
-    /**
-     * Returns a promise that resolves in the next tick.
-     */
-    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
-
-    /**
-     *
-     * Returns an async iterator that generates values in an interval of delay ms.
-     * @param delay defaults to 1
-     */
-    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
-}
-
-declare module 'node:timers/promises' {
-    export * from 'timers/promises';
-}

node/tls.d.ts

@@ -1,6 +1,6 @@
 declare module 'tls' {
-    import { X509Certificate } from 'crypto';
-    import * as net from 'net';
+    import { X509Certificate } from 'node:crypto';
+    import * as net from 'node:net';
 
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;

node/ts3.6/assert.d.ts

@@ -96,3 +96,8 @@ declare module 'assert' {
 
     export = assert;
 }
+
+declare module 'node:assert' {
+    import assert = require('assert');
+    export = assert;
+}

node/ts3.6/base.d.ts

@@ -23,7 +23,7 @@
 /// <reference path="../constants.d.ts" />
 /// <reference path="../crypto.d.ts" />
 /// <reference path="../dgram.d.ts" />
-/// <reference path="../diagnostic_channel.d.ts" />
+/// <reference path="../diagnostics_channel.d.ts" />
 /// <reference path="../dns.d.ts" />
 /// <reference path="../dns/promises.d.ts" />
 /// <reference path="../dns/promises.d.ts" />

node/tty.d.ts

@@ -1,5 +1,5 @@
 declare module 'tty' {
-    import * as net from 'net';
+    import * as net from 'node:net';
 
     function isatty(fd: number): boolean;
     class ReadStream extends net.Socket {

node/url.d.ts

@@ -1,6 +1,6 @@
 declare module 'url' {
-    import { ClientRequestArgs } from 'http';
-    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
+    import { ClientRequestArgs } from 'node:http';
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'node:querystring';
 
     // Input to `url.format`
     interface UrlObject {

node/util.d.ts

@@ -1,5 +1,5 @@
 declare module 'util' {
-    import * as types from 'util/types';
+    import * as types from 'node:util/types';
 
     export interface InspectOptions {
         /**
@@ -197,12 +197,12 @@ declare module 'util' {
     }
 }
 
-declare module 'node:util' {
-    export * from 'util';
+declare module 'util/types' {
+    export * from 'util/types';
 }
 
 declare module 'util/types' {
-    import { KeyObject, webcrypto } from 'crypto';
+    import { KeyObject, webcrypto } from 'node:crypto';
 
     function isAnyArrayBuffer(object: unknown): object is ArrayBufferLike;
     function isArgumentsObject(object: unknown): object is IArguments;
@@ -259,6 +259,10 @@ declare module 'util/types' {
     function isCryptoKey(object: unknown): object is webcrypto.CryptoKey;
 }
 
+declare module 'node:util' {
+    export * from 'util';
+}
+
 declare module 'node:util/types' {
     export * from 'util/types';
 }

node/v8.d.ts

@@ -1,5 +1,5 @@
 declare module 'v8' {
-    import { Readable } from 'stream';
+    import { Readable } from 'node:stream';
 
     interface HeapSpaceInfo {
         space_name: string;

node/worker_threads.d.ts

@@ -1,12 +1,12 @@
 declare module 'worker_threads' {
     import { Blob } from 'node:buffer';
-    import { Context } from 'vm';
-    import { EventEmitter } from 'events';
-    import { EventLoopUtilityFunction } from 'perf_hooks';
-    import { FileHandle } from 'fs/promises';
-    import { Readable, Writable } from 'stream';
-    import { URL } from 'url';
-    import { X509Certificate } from 'crypto';
+    import { Context } from 'node:vm';
+    import { EventEmitter } from 'node:events';
+    import { EventLoopUtilityFunction } from 'node:perf_hooks';
+    import { FileHandle } from 'node:fs/promises';
+    import { Readable, Writable } from 'node:stream';
+    import { URL } from 'node:url';
+    import { X509Certificate } from 'node:crypto';
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;

node/zlib.d.ts

@@ -1,5 +1,5 @@
 declare module 'zlib' {
-    import * as stream from 'stream';
+    import * as stream from 'node:stream';
 
     interface ZlibOptions {
         /**