@types/node 11.12.1 → 11.13.0

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js ( http://nodejs.org/ ).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node
 
 Additional Details
- * Last updated: Fri, 29 Mar 2019 07:45:57 GMT
+ * Last updated: Mon, 01 Apr 2019 19:40:47 GMT
  * Dependencies: none
  * Global values: Buffer, NodeJS, Symbol, __dirname, __filename, clearImmediate, clearInterval, clearTimeout, console, exports, global, module, process, queueMicrotask, require, setImmediate, setInterval, setTimeout
 

node/child_process.d.ts

@@ -19,9 +19,9 @@ declare module "child_process" {
         readonly pid: number;
         readonly connected: boolean;
         kill(signal?: string): void;
-        send(message: any, callback?: (error: Error) => void): boolean;
-        send(message: any, sendHandle?: net.Socket | net.Server, callback?: (error: Error) => void): boolean;
-        send(message: any, sendHandle?: net.Socket | net.Server, options?: MessageOptions, callback?: (error: Error) => void): boolean;
+        send(message: any, callback?: (error: Error | null) => void): boolean;
+        send(message: any, sendHandle?: net.Socket | net.Server, callback?: (error: Error | null) => void): boolean;
+        send(message: any, sendHandle?: net.Socket | net.Server, options?: MessageOptions, callback?: (error: Error | null) => void): boolean;
         disconnect(): void;
         unref(): void;
         ref(): void;
@@ -78,6 +78,20 @@ declare module "child_process" {
         prependOnceListener(event: "message", listener: (message: any, sendHandle: net.Socket | net.Server) => void): this;
     }
 
+    // return this object when stdio option is undefined or not specified
+    interface ChildProcessWithoutNullStreams extends ChildProcess {
+        stdin: Writable;
+        stdout: Readable;
+        stderr: Readable;
+        readonly stdio: [
+            Writable, // stdin
+            Readable, // stdout
+            Readable, // stderr
+            Readable | Writable | null | undefined, // extra, no modification
+            Readable | Writable | null | undefined // extra, no modification
+        ];
+    }
+
     interface MessageOptions {
         keepOpen?: boolean;
     }
@@ -110,8 +124,14 @@ declare module "child_process" {
         windowsVerbatimArguments?: boolean;
     }
 
-    function spawn(command: string, options?: SpawnOptions): ChildProcess;
-    function spawn(command: string, args?: ReadonlyArray<string>, options?: SpawnOptions): ChildProcess;
+    interface SpawnOptionsWithoutStdio extends SpawnOptions {
+        stdio?: 'pipe' | Array<null | undefined | 'pipe'>;
+    }
+
+    function spawn(command: string, options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
+    function spawn(command: string, options: SpawnOptions): ChildProcess;
+    function spawn(command: string, args?: ReadonlyArray<string>, options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptions): ChildProcess;
 
     interface ExecOptions extends CommonOptions {
         shell?: string;

node/cluster.d.ts

@@ -24,7 +24,7 @@ declare module "cluster" {
     class Worker extends events.EventEmitter {
         id: number;
         process: child.ChildProcess;
-        send(message: any, sendHandle?: any, callback?: (error: Error) => void): boolean;
+        send(message: any, sendHandle?: any, callback?: (error: Error | null) => void): boolean;
         kill(signal?: string): void;
         destroy(signal?: string): void;
         disconnect(): void;

node/crypto.d.ts

@@ -261,7 +261,7 @@ declare module "crypto" {
     }
 
     function createPrivateKey(key: PrivateKeyInput | string | Buffer): KeyObject;
-    function createPublicKey(key: PublicKeyInput | string | Buffer): KeyObject;
+    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject): KeyObject;
     function createSecretKey(key: Buffer): KeyObject;
 
     function createSign(algorithm: string, options?: stream.WritableOptions): Signer;

node/events.d.ts

@@ -2,6 +2,7 @@ declare module "events" {
     class internal extends NodeJS.EventEmitter { }
 
     namespace internal {
+        function once(emitter: EventEmitter, event: string | symbol): Promise<any>;
          class EventEmitter extends internal {
             /** @deprecated since v4.0.0 */
             static listenerCount(emitter: EventEmitter, event: string | symbol): number;

node/globals.d.ts

@@ -891,7 +891,7 @@ declare namespace NodeJS {
         domain: Domain;
 
         // Worker
-        send?(message: any, sendHandle?: any): void;
+        send?(message: any, sendHandle?: any, options?: { swallowErrors?: boolean}, callback?: (error: Error | null) => void): boolean;
         disconnect(): void;
         connected: boolean;
 

node/https.d.ts

@@ -22,6 +22,7 @@ declare module "https" {
     }
 
     class Server extends tls.Server {
+        constructor(requestListener?: http.RequestListener);
         constructor(options: ServerOptions, requestListener?: http.RequestListener);
 
         setTimeout(callback: () => void): this;
@@ -42,6 +43,7 @@ declare module "https" {
         keepAliveTimeout: number;
     }
 
+    function createServer(requestListener?: http.RequestListener): Server;
     function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
     function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
     function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;

node/index.d.ts

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

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "11.12.1",
+    "version": "11.13.0",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -206,6 +206,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "cb9390d3eeee04565632639f525e6230d0b5cf4f18f250f5ae780db3d59c49f9",
+    "typesPublisherContentHash": "f650903133b29f714d48239d0401ba23695ef6bdb390e447918ee3d997cb3350",
     "typeScriptVersion": "2.0"
 }

node/tls.d.ts

@@ -276,11 +276,7 @@ declare module "tls" {
     }
 
     class Server extends net.Server {
-        addContext(hostName: string, credentials: {
-            key: string;
-            cert: string;
-            ca: string;
-        }): void;
+        addContext(hostName: string, credentials: SecureContextOptions): void;
 
         /**
          * events.EventEmitter
@@ -385,6 +381,7 @@ declare module "tls" {
      * Returns Error object, populating it with the reason, host and cert on failure.  On success, returns undefined.
      */
     function checkServerIdentity(host: string, cert: PeerCertificate): Error | undefined;
+    function createServer(secureConnectionListener?: (socket: TLSSocket) => void): Server;
     function createServer(options: TlsOptions, secureConnectionListener?: (socket: TLSSocket) => void): Server;
     function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
     function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;

node/tty.d.ts

@@ -39,6 +39,9 @@ declare module "tty" {
          * @default `process.env`
          */
         getColorDepth(env?: {}): number;
+        hasColors(depth?: number): boolean;
+        hasColors(env?: {}): boolean;
+        hasColors(depth: number, env?: {}): boolean;
         getWindowSize(): [number, number];
         columns: number;
         rows: number;

node/v8.d.ts

@@ -1,4 +1,6 @@
 declare module "v8" {
+    import { Readable } from "stream";
+
     interface HeapSpaceInfo {
         space_name: string;
         space_size: number;
@@ -25,4 +27,24 @@ declare module "v8" {
     function getHeapStatistics(): HeapInfo;
     function getHeapSpaceStatistics(): HeapSpaceInfo[];
     function setFlagsFromString(flags: string): void;
+    /**
+     * Generates a snapshot of the current V8 heap and returns a Readable
+     * Stream that may be used to read the JSON serialized representation.
+     * This conversation was marked as resolved by joyeecheung
+     * This JSON stream format is intended to be used with tools such as
+     * Chrome DevTools. The JSON schema is undocumented and specific to the
+     * V8 engine, and may change from one version of V8 to the next.
+     */
+    function getHeapSnapshot(): Readable;
+
+    /**
+     *
+     * @param fileName The file path where the V8 heap snapshot is to be
+     * saved. If not specified, a file name with the pattern
+     * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
+     * generated, where `{pid}` will be the PID of the Node.js process,
+     * `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from
+     * the main Node.js thread or the id of a worker thread.
+     */
+    function writeHeapSnapshot(fileName?: string): string;
 }

node/worker_threads.d.ts

@@ -1,4 +1,5 @@
 declare module "worker_threads" {
+    import { Context } from "vm";
     import { EventEmitter } from "events";
     import { Readable, Writable } from "stream";
 
@@ -73,6 +74,21 @@ declare module "worker_threads" {
         ref(): void;
         unref(): void;
         terminate(callback?: (err: Error, exitCode: number) => void): void;
+        /**
+         * Transfer a `MessagePort` to a different `vm` Context. The original `port`
+         * object will be rendered unusable, and the returned `MessagePort` instance will
+         * take its place.
+         *
+         * The returned `MessagePort` will be an object in the target context, and will
+         * inherit from its global `Object` class. Objects passed to the
+         * `port.onmessage()` listener will also be created in the target context
+         * and inherit from its global `Object` class.
+         *
+         * However, the created `MessagePort` will no longer inherit from
+         * `EventEmitter`, and only `port.onmessage()` can be used to receive
+         * events using it.
+         */
+        moveMessagePortToContext(port: MessagePort, context: Context): MessagePort;
 
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (exitCode: number) => void): this;