@types/node 11.12.4 → 11.13.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: Mon, 01 Apr 2019 19:34:50 GMT
+ * Last updated: Wed, 10 Apr 2019 17:21:43 GMT
  * Dependencies: none
  * Global values: Buffer, NodeJS, Symbol, __dirname, __filename, clearImmediate, clearInterval, clearTimeout, console, exports, global, module, process, queueMicrotask, require, setImmediate, setInterval, setTimeout
 

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

@@ -45,7 +45,7 @@ interface Console {
     /**
      * The `console.groupCollapsed()` function is an alias for {@link console.group()}.
      */
-    groupCollapsed(): void;
+    groupCollapsed(...label: any[]): void;
     /**
      * Decreases indentation of subsequent lines by two spaces.
      */
@@ -233,12 +233,12 @@ declare var module: NodeModule;
 declare var exports: any;
 
 // Buffer class
-type BufferEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "base64" | "latin1" | "binary" | "hex";
+type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
 interface Buffer extends Uint8Array {
     constructor: typeof Buffer;
-    write(string: string, encoding?: string): number;
-    write(string: string, offset: number, encoding?: string): number;
-    write(string: string, offset: number, length: number, encoding?: string): number;
+    write(string: string, encoding?: BufferEncoding): number;
+    write(string: string, offset: number, encoding?: BufferEncoding): number;
+    write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
     toString(encoding?: string, start?: number, end?: number): string;
     toJSON(): { type: 'Buffer', data: number[] };
     equals(otherBuffer: Uint8Array): boolean;
@@ -287,10 +287,10 @@ interface Buffer extends Uint8Array {
     writeDoubleLE(value: number, offset: number): number;
     writeDoubleBE(value: number, offset: number): number;
     fill(value: any, offset?: number, end?: number): this;
-    indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: string): number;
-    lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: string): number;
+    indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+    lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
     entries(): IterableIterator<[number, number]>;
-    includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;
+    includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
     keys(): IterableIterator<number>;
     values(): IterableIterator<number>;
 }
@@ -308,7 +308,7 @@ declare const Buffer: {
      * @param encoding encoding to use, optional.  Default is 'utf8'
      * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
      */
-    new(str: string, encoding?: string): Buffer;
+    new(str: string, encoding?: BufferEncoding): Buffer;
     /**
      * Allocates a new buffer of {size} octets.
      *
@@ -367,7 +367,7 @@ declare const Buffer: {
      * If provided, the {encoding} parameter identifies the character encoding.
      * If not provided, {encoding} defaults to 'utf8'.
      */
-    from(str: string, encoding?: string): Buffer;
+    from(str: string, encoding?: BufferEncoding): Buffer;
     /**
      * Creates a new Buffer using the passed {data}
      * @param values to create a new Buffer
@@ -385,7 +385,7 @@ declare const Buffer: {
      *
      * @param encoding string to test.
      */
-    isEncoding(encoding: string): boolean | undefined;
+    isEncoding(encoding: string): encoding is BufferEncoding
     /**
      * Gives the actual byte length of a string. encoding defaults to 'utf8'.
      * This is not the same as String.prototype.length since that returns the number of characters in a string.
@@ -393,7 +393,7 @@ declare const Buffer: {
      * @param string string to test.
      * @param encoding encoding used to evaluate (defaults to 'utf8')
      */
-    byteLength(string: string | NodeJS.TypedArray | DataView | ArrayBuffer | SharedArrayBuffer, encoding?: string): number;
+    byteLength(string: string | NodeJS.TypedArray | DataView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
     /**
      * Returns a buffer which is the result of concatenating all the buffers in the list together.
      *
@@ -418,7 +418,7 @@ declare const Buffer: {
      *    If parameter is omitted, buffer will be filled with zeros.
      * @param encoding encoding used for call to buf.fill while initalizing
      */
-    alloc(size: number, fill?: string | Buffer | number, encoding?: string): Buffer;
+    alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
     /**
      * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
      * of the newly created Buffer are unknown and may contain sensitive data.

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.4",
+    "version": "11.13.3",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -206,6 +206,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "acd2a15c38a9c89ae212cf7bae04bb1980689bdb26fe8a3201a5bfaa39c48cb6",
+    "typesPublisherContentHash": "63fa42bcd8b2cf54eb20f7b4198df34b302bd97b97235e575a7660e7a52f1c51",
     "typeScriptVersion": "2.0"
 }

node/querystring.d.ts

@@ -10,7 +10,14 @@ declare module "querystring" {
 
     interface ParsedUrlQuery { [key: string]: string | string[]; }
 
-    function stringify(obj?: {}, sep?: string, eq?: string, options?: StringifyOptions): string;
+    interface ParsedUrlQueryInput {
+        [key: string]:
+            // The value type here is a "poor man's `unknown`". When these types support TypeScript
+            // 3.0+, we can replace this with `unknown`.
+            {} | null | undefined;
+    }
+
+    function stringify(obj?: ParsedUrlQueryInput, sep?: string, eq?: string, options?: StringifyOptions): string;
     function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): ParsedUrlQuery;
     function escape(str: string): string;
     function unescape(str: string): string;

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/url.d.ts

@@ -1,5 +1,5 @@
 declare module "url" {
-    import { ParsedUrlQuery } from 'querystring';
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
 
     interface UrlObjectCommon {
         auth?: string;
@@ -17,7 +17,7 @@ declare module "url" {
     // Input to `url.format`
     interface UrlObject extends UrlObjectCommon {
         port?: string | number;
-        query?: string | null | { [key: string]: any };
+        query?: string | null | ParsedUrlQueryInput;
     }
 
     // Output of `url.parse`

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;