@types/node 11.10.6 → 11.11.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: Fri, 08 Mar 2019 22:58:43 GMT
+ * Last updated: Tue, 12 Mar 2019 23:39: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/assert.d.ts

@@ -33,17 +33,17 @@ declare module "assert" {
         function deepStrictEqual(actual: any, expected: any, message?: string | Error): void;
         function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
 
-        function throws(block: Function, message?: string | Error): void;
-        function throws(block: Function, error: RegExp | Function | Object | Error, message?: string | Error): void;
-        function doesNotThrow(block: Function, message?: string | Error): void;
-        function doesNotThrow(block: Function, error: RegExp | Function, message?: string | Error): void;
+        function throws(block: () => any, message?: string | Error): void;
+        function throws(block: () => any, error: RegExp | Function | Object | Error, message?: string | Error): void;
+        function doesNotThrow(block: () => any, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void;
 
         function ifError(value: any): void;
 
-        function rejects(block: Function | Promise<any>, message?: string | Error): Promise<void>;
-        function rejects(block: Function | Promise<any>, error: RegExp | Function | Object | Error, message?: string | Error): Promise<void>;
-        function doesNotReject(block: Function | Promise<any>, message?: string | Error): Promise<void>;
-        function doesNotReject(block: Function | Promise<any>, error: RegExp | Function, message?: string | Error): Promise<void>;
+        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(block: (() => Promise<any>) | Promise<any>, error: RegExp | Function | Object | Error, message?: string | Error): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, error: RegExp | Function, message?: string | Error): Promise<void>;
 
         const strict: typeof internal;
     }

node/child_process.d.ts

@@ -264,6 +264,7 @@ declare module "child_process" {
         execArgv?: string[];
         silent?: boolean;
         stdio?: StdioOptions;
+        detached?: boolean;
         windowsVerbatimArguments?: boolean;
     }
     function fork(modulePath: string, args?: ReadonlyArray<string>, options?: ForkOptions): ChildProcess;

node/cluster.d.ts

@@ -92,7 +92,7 @@ declare module "cluster" {
 
     interface Cluster extends events.EventEmitter {
         Worker: Worker;
-        disconnect(callback?: Function): void;
+        disconnect(callback?: () => void): void;
         fork(env?: any): Worker;
         isMaster: boolean;
         isWorker: boolean;
@@ -121,7 +121,7 @@ declare module "cluster" {
         addListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
         addListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
         addListener(event: "online", listener: (worker: Worker) => void): this;
-        addListener(event: "setup", listener: (settings: any) => void): this;
+        addListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "disconnect", worker: Worker): boolean;
@@ -130,7 +130,7 @@ declare module "cluster" {
         emit(event: "listening", worker: Worker, address: Address): boolean;
         emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
         emit(event: "online", worker: Worker): boolean;
-        emit(event: "setup", settings: any): boolean;
+        emit(event: "setup", settings: ClusterSettings): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "disconnect", listener: (worker: Worker) => void): this;
@@ -139,7 +139,7 @@ declare module "cluster" {
         on(event: "listening", listener: (worker: Worker, address: Address) => void): this;
         on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
         on(event: "online", listener: (worker: Worker) => void): this;
-        on(event: "setup", listener: (settings: any) => void): this;
+        on(event: "setup", listener: (settings: ClusterSettings) => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "disconnect", listener: (worker: Worker) => void): this;
@@ -148,7 +148,7 @@ declare module "cluster" {
         once(event: "listening", listener: (worker: Worker, address: Address) => void): this;
         once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
         once(event: "online", listener: (worker: Worker) => void): this;
-        once(event: "setup", listener: (settings: any) => void): this;
+        once(event: "setup", listener: (settings: ClusterSettings) => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "disconnect", listener: (worker: Worker) => void): this;
@@ -157,7 +157,7 @@ declare module "cluster" {
         prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
         prependListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
         prependListener(event: "online", listener: (worker: Worker) => void): this;
-        prependListener(event: "setup", listener: (settings: any) => void): this;
+        prependListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): this;
@@ -167,10 +167,10 @@ declare module "cluster" {
         // the handle is a net.Socket or net.Server object, or undefined.
         prependOnceListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;
         prependOnceListener(event: "online", listener: (worker: Worker) => void): this;
-        prependOnceListener(event: "setup", listener: (settings: any) => void): this;
+        prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
     }
 
-    function disconnect(callback?: Function): void;
+    function disconnect(callback?: () => void): void;
     function fork(env?: any): Worker;
     const isMaster: boolean;
     const isWorker: boolean;
@@ -200,7 +200,7 @@ declare module "cluster" {
      // the handle is a net.Socket or net.Server object, or undefined.
     function addListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
     function addListener(event: "online", listener: (worker: Worker) => void): Cluster;
-    function addListener(event: "setup", listener: (settings: any) => void): Cluster;
+    function addListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
 
     function emit(event: string | symbol, ...args: any[]): boolean;
     function emit(event: "disconnect", worker: Worker): boolean;
@@ -209,7 +209,7 @@ declare module "cluster" {
     function emit(event: "listening", worker: Worker, address: Address): boolean;
     function emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
     function emit(event: "online", worker: Worker): boolean;
-    function emit(event: "setup", settings: any): boolean;
+    function emit(event: "setup", settings: ClusterSettings): boolean;
 
     function on(event: string, listener: (...args: any[]) => void): Cluster;
     function on(event: "disconnect", listener: (worker: Worker) => void): Cluster;
@@ -218,7 +218,7 @@ declare module "cluster" {
     function on(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
     function on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;  // the handle is a net.Socket or net.Server object, or undefined.
     function on(event: "online", listener: (worker: Worker) => void): Cluster;
-    function on(event: "setup", listener: (settings: any) => void): Cluster;
+    function on(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
 
     function once(event: string, listener: (...args: any[]) => void): Cluster;
     function once(event: "disconnect", listener: (worker: Worker) => void): Cluster;
@@ -227,7 +227,7 @@ declare module "cluster" {
     function once(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
     function once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;  // the handle is a net.Socket or net.Server object, or undefined.
     function once(event: "online", listener: (worker: Worker) => void): Cluster;
-    function once(event: "setup", listener: (settings: any) => void): Cluster;
+    function once(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
 
     function removeListener(event: string, listener: (...args: any[]) => void): Cluster;
     function removeAllListeners(event?: string): Cluster;
@@ -244,7 +244,7 @@ declare module "cluster" {
      // the handle is a net.Socket or net.Server object, or undefined.
     function prependListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
     function prependListener(event: "online", listener: (worker: Worker) => void): Cluster;
-    function prependListener(event: "setup", listener: (settings: any) => void): Cluster;
+    function prependListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
 
     function prependOnceListener(event: string, listener: (...args: any[]) => void): Cluster;
     function prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
@@ -254,7 +254,7 @@ declare module "cluster" {
      // the handle is a net.Socket or net.Server object, or undefined.
     function prependOnceListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
     function prependOnceListener(event: "online", listener: (worker: Worker) => void): Cluster;
-    function prependOnceListener(event: "setup", listener: (settings: any) => void): Cluster;
+    function prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
 
     function eventNames(): string[];
 }

node/crypto.d.ts

@@ -185,10 +185,8 @@ declare module "crypto" {
     interface Cipher extends NodeJS.ReadWriteStream {
         update(data: BinaryLike): Buffer;
         update(data: string, input_encoding: Utf8AsciiBinaryEncoding): Buffer;
-        update(data: Binary, output_encoding: HexBase64BinaryEncoding): string;
-        update(data: Binary, input_encoding: any, output_encoding: HexBase64BinaryEncoding): string;
-        // second arg ignored
-        update(data: string, input_encoding: Utf8AsciiBinaryEncoding, output_encoding: HexBase64BinaryEncoding): string;
+        update(data: Binary, input_encoding: undefined, output_encoding: HexBase64BinaryEncoding): string;
+        update(data: string, input_encoding: Utf8AsciiBinaryEncoding | undefined, output_encoding: HexBase64BinaryEncoding): string;
         final(): Buffer;
         final(output_encoding: string): string;
         setAutoPadding(auto_padding?: boolean): this;
@@ -227,9 +225,8 @@ declare module "crypto" {
     interface Decipher extends NodeJS.ReadWriteStream {
         update(data: Binary): Buffer;
         update(data: string, input_encoding: HexBase64BinaryEncoding): Buffer;
-        update(data: Binary, input_encoding: any, output_encoding: Utf8AsciiBinaryEncoding): string;
-        // second arg is ignored
-        update(data: string, input_encoding: HexBase64BinaryEncoding, output_encoding: Utf8AsciiBinaryEncoding): string;
+        update(data: Binary, input_encoding: undefined, output_encoding: Utf8AsciiBinaryEncoding): string;
+        update(data: string, input_encoding: HexBase64BinaryEncoding | undefined, output_encoding: Utf8AsciiBinaryEncoding): string;
         final(): Buffer;
         final(output_encoding: string): string;
         setAutoPadding(auto_padding?: boolean): this;

node/dgram.d.ts

@@ -39,7 +39,7 @@ declare module "dgram" {
         bind(port?: number, address?: string, callback?: () => void): void;
         bind(port?: number, callback?: () => void): void;
         bind(callback?: () => void): void;
-        bind(options: BindOptions, callback?: Function): void;
+        bind(options: BindOptions, callback?: () => void): void;
         close(callback?: () => void): void;
         address(): AddressInfo | string;
         setBroadcast(flag: boolean): void;

node/domain.d.ts

@@ -2,12 +2,12 @@ declare module "domain" {
     import * as events from "events";
 
     class Domain extends events.EventEmitter implements NodeJS.Domain {
-        run(fn: Function): void;
-        add(emitter: events.EventEmitter): void;
-        remove(emitter: events.EventEmitter): void;
-        bind(cb: (err: Error, data: any) => any): any;
-        intercept(cb: (data: any) => any): any;
-        members: any[];
+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+        add(emitter: events.EventEmitter | NodeJS.Timer): void;
+        remove(emitter: events.EventEmitter | NodeJS.Timer): void;
+        bind<T extends Function>(cb: T): T;
+        intercept<T extends Function>(cb: T): T;
+        members: Array<events.EventEmitter | NodeJS.Timer>;
         enter(): void;
         exit(): void;
     }

node/globals.d.ts

@@ -360,7 +360,7 @@ declare const Buffer: {
      * Creates a new Buffer using the passed {data}
      * @param data data to create a new Buffer
      */
-    from(data: any[]): Buffer;
+    from(data: number[]): Buffer;
     from(data: Uint8Array): Buffer;
     /**
      * Creates a new Buffer containing the given JavaScript string {str}.
@@ -465,7 +465,17 @@ declare namespace NodeJS {
         showProxy?: boolean;
         maxArrayLength?: number | null;
         breakLength?: number;
-        compact?: boolean;
+        /**
+         * Setting this to `false` causes each object key
+         * to be displayed on a new line. It will also add new lines to text that is
+         * longer than `breakLength`. If set to a number, the most `n` inner elements
+         * are united on a single line as long as all properties fit into
+         * `breakLength`. Short array elements are also grouped together. Note that no
+         * text will be reduced below 16 characters, no matter the `breakLength` size.
+         * For more information, see the example below.
+         * @default `true`
+         */
+        compact?: boolean | number;
         sorted?: boolean | ((a: string, b: string) => number);
     }
 
@@ -601,12 +611,11 @@ declare namespace NodeJS {
 
     interface WritableStream extends EventEmitter {
         writable: boolean;
-        write(buffer: Buffer | string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        end(cb?: Function): void;
-        end(buffer: Buffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
+        write(buffer: Buffer | Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        write(str: string, encoding?: string, cb?: (err?: Error | null) => void): boolean;
+        end(cb?: () => void): void;
+        end(data: string | Uint8Array | Buffer, cb?: () => void): void;
+        end(str: string, encoding?: string, cb?: () => void): void;
     }
 
     interface ReadWriteStream extends ReadableStream, WritableStream { }
@@ -614,11 +623,11 @@ declare namespace NodeJS {
     interface Events extends EventEmitter { }
 
     interface Domain extends Events {
-        run(fn: Function): void;
-        add(emitter: Events): void;
-        remove(emitter: Events): void;
-        bind(cb: (err: Error, data: any) => any): any;
-        intercept(cb: (data: any) => any): any;
+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+        add(emitter: EventEmitter | Timer): void;
+        remove(emitter: EventEmitter | Timer): void;
+        bind<T extends Function>(cb: T): T;
+        intercept<T extends Function>(cb: T): T;
 
         addListener(event: string, listener: (...args: any[]) => void): this;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -702,9 +711,9 @@ declare namespace NodeJS {
         readonly writableLength: number;
         columns?: number;
         rows?: number;
-        _write(chunk: any, encoding: string, callback: Function): void;
-        _destroy(err: Error | null, callback: Function): void;
-        _final(callback: Function): void;
+        _write(chunk: any, encoding: string, callback: (err?: null | Error) => void): void;
+        _destroy(err: Error | null, callback: (err?: null | Error) => void): void;
+        _final(callback: (err?: null | Error) => void): void;
         setDefaultEncoding(encoding: string): this;
         cork(): void;
         uncork(): void;
@@ -716,7 +725,7 @@ declare namespace NodeJS {
         isRaw?: boolean;
         setRawMode?(mode: boolean): void;
         _read(size: number): void;
-        _destroy(err: Error | null, callback: Function): void;
+        _destroy(err: Error | null, callback: (err?: null | Error) => void): void;
         push(chunk: any, encoding?: string): boolean;
         destroy(error?: Error): void;
     }

node/http.d.ts

@@ -1,8 +1,8 @@
 declare module "http" {
     import * as events from "events";
-    import * as net from "net";
     import * as stream from "stream";
     import { URL } from "url";
+    import { Socket, Server as NetServer } from "net";
 
     // incoming headers will never contain number
     interface IncomingHttpHeaders {
@@ -85,7 +85,7 @@ declare module "http" {
         timeout?: number;
         setHost?: boolean;
         // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L278
-        createConnection?: (options: ClientRequestArgs, oncreate: (err: Error, socket: net.Socket) => void) => net.Socket;
+        createConnection?: (options: ClientRequestArgs, oncreate: (err: Error, socket: Socket) => void) => Socket;
     }
 
     interface ServerOptions {
@@ -95,17 +95,23 @@ declare module "http" {
 
     type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
 
-    class Server extends net.Server {
+    class Server extends NetServer {
         constructor(requestListener?: RequestListener);
         constructor(options: ServerOptions, requestListener?: RequestListener);
 
         setTimeout(msecs?: number, callback?: () => void): this;
         setTimeout(callback: () => void): this;
-        maxHeadersCount: number;
+        /**
+         * Limits maximum incoming headers count. If set to 0, no limit will be applied.
+         * @default 2000
+         * {@link https://nodejs.org/api/http.html#http_server_maxheaderscount}
+         */
+        maxHeadersCount: number | null;
         timeout: number;
         /**
          * Limit the amount of time the parser will wait to receive the complete HTTP headers.
          * @default 40000
+         * {@link https://nodejs.org/api/http.html#http_server_headerstimeout}
          */
         headersTimeout: number;
         keepAliveTimeout: number;
@@ -120,7 +126,7 @@ declare module "http" {
         sendDate: boolean;
         finished: boolean;
         headersSent: boolean;
-        connection: net.Socket;
+        connection: Socket;
 
         constructor();
 
@@ -142,8 +148,8 @@ declare module "http" {
 
         constructor(req: IncomingMessage);
 
-        assignSocket(socket: net.Socket): void;
-        detachSocket(socket: net.Socket): void;
+        assignSocket(socket: Socket): void;
+        detachSocket(socket: Socket): void;
         // https://github.com/nodejs/node/blob/master/test/parallel/test-http-write-callbacks.js#L53
         // no args in writeContinue callback
         writeContinue(callback?: () => void): void;
@@ -153,27 +159,27 @@ declare module "http" {
 
     // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L77
     class ClientRequest extends OutgoingMessage {
-        connection: net.Socket;
-        socket: net.Socket;
+        connection: Socket;
+        socket: Socket;
         aborted: number;
 
         constructor(url: string | URL | ClientRequestArgs, cb?: (res: IncomingMessage) => void);
 
         readonly path: string;
         abort(): void;
-        onSocket(socket: net.Socket): void;
+        onSocket(socket: Socket): void;
         setTimeout(timeout: number, callback?: () => void): this;
         setNoDelay(noDelay?: boolean): void;
         setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
     }
 
     class IncomingMessage extends stream.Readable {
-        constructor(socket: net.Socket);
+        constructor(socket: Socket);
 
         httpVersion: string;
         httpVersionMajor: number;
         httpVersionMinor: number;
-        connection: net.Socket;
+        connection: Socket;
         headers: IncomingHttpHeaders;
         rawHeaders: string[];
         trailers: { [key: string]: string | undefined };
@@ -195,7 +201,7 @@ declare module "http" {
          * Only valid for response obtained from http.ClientRequest.
          */
         statusMessage?: string;
-        socket: net.Socket;
+        socket: Socket;
         destroy(error?: Error): void;
     }
 
@@ -226,8 +232,12 @@ declare module "http" {
     class Agent {
         maxFreeSockets: number;
         maxSockets: number;
-        sockets: any;
-        requests: any;
+        readonly sockets: {
+            readonly [key: string]: Socket[];
+        };
+        readonly requests: {
+            readonly [key: string]: IncomingMessage[];
+        };
 
         constructor(opts?: AgentOptions);
 
@@ -249,7 +259,6 @@ declare module "http" {
 
     function createServer(requestListener?: RequestListener): Server;
     function createServer(options: ServerOptions, requestListener?: RequestListener): Server;
-    function createClient(port?: number, host?: string): any;
 
     // although RequestOptions are passed as ClientRequestArgs to ClientRequest directly,
     // create interface RequestOptions would make the naming more clear to developers

node/http2.d.ts

@@ -558,7 +558,7 @@ declare module "http2" {
         prependOnceListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
     }
 
-    export class Http2ServerResponse extends events.EventEmitter {
+    export class Http2ServerResponse extends stream.Stream {
         private constructor();
         addTrailers(trailers: OutgoingHttpHeaders): void;
         connection: net.Socket | tls.TLSSocket;

node/https.d.ts

@@ -26,7 +26,19 @@ declare module "https" {
 
         setTimeout(callback: () => void): this;
         setTimeout(msecs?: number, callback?: () => void): this;
+        /**
+         * Limits maximum incoming headers count. If set to 0, no limit will be applied.
+         * @default 2000
+         * {@link https://nodejs.org/api/http.html#http_server_maxheaderscount}
+         */
+        maxHeadersCount: number | null;
         timeout: number;
+        /**
+         * Limit the amount of time the parser will wait to receive the complete HTTP headers.
+         * @default 40000
+         * {@link https://nodejs.org/api/http.html#http_server_headerstimeout}
+         */
+        headersTimeout: number;
         keepAliveTimeout: number;
     }
 

node/index.d.ts

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

node/net.d.ts

@@ -38,22 +38,18 @@ declare module "net" {
         constructor(options?: SocketConstructorOpts);
 
         // Extended base methods
-        write(buffer: Buffer): boolean;
-        write(buffer: Buffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, fd?: string): boolean;
-        write(data: any, encoding?: string, callback?: Function): void;
-
-        connect(options: SocketConnectOpts, connectionListener?: Function): this;
-        connect(port: number, host: string, connectionListener?: Function): this;
-        connect(port: number, connectionListener?: Function): this;
-        connect(path: string, connectionListener?: Function): this;
+        write(buffer: Buffer | Uint8Array | string, cb?: (err?: Error) => void): boolean;
+        write(str: Buffer | Uint8Array | string, encoding?: string, cb?: (err?: Error) => void): boolean;
+
+        connect(options: SocketConnectOpts, connectionListener?: () => void): this;
+        connect(port: number, host: string, connectionListener?: () => void): this;
+        connect(port: number, connectionListener?: () => void): this;
+        connect(path: string, connectionListener?: () => void): this;
 
         setEncoding(encoding?: string): this;
         pause(): this;
         resume(): this;
-        setTimeout(timeout: number, callback?: Function): this;
+        setTimeout(timeout: number, callback?: () => void): this;
         setNoDelay(noDelay?: boolean): this;
         setKeepAlive(enable?: boolean, initialDelay?: number): this;
         address(): AddressInfo | string;
@@ -72,11 +68,9 @@ declare module "net" {
         readonly remotePort?: number;
 
         // Extended base methods
-        end(): void;
-        end(buffer: Buffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-        end(data?: any, encoding?: string): void;
+        end(cb?: () => void): void;
+        end(buffer: Buffer | Uint8Array | string, cb?: () => void): void;
+        end(str: Buffer | Uint8Array | string, encoding?: string, cb?: () => void): void;
 
         /**
          * events.EventEmitter
@@ -169,15 +163,15 @@ declare module "net" {
         constructor(connectionListener?: (socket: Socket) => void);
         constructor(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean }, connectionListener?: (socket: Socket) => void);
 
-        listen(port?: number, hostname?: string, backlog?: number, listeningListener?: Function): this;
-        listen(port?: number, hostname?: string, listeningListener?: Function): this;
-        listen(port?: number, backlog?: number, listeningListener?: Function): this;
-        listen(port?: number, listeningListener?: Function): this;
-        listen(path: string, backlog?: number, listeningListener?: Function): this;
-        listen(path: string, listeningListener?: Function): this;
-        listen(options: ListenOptions, listeningListener?: Function): this;
-        listen(handle: any, backlog?: number, listeningListener?: Function): this;
-        listen(handle: any, listeningListener?: Function): this;
+        listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
+        listen(port?: number, hostname?: string, listeningListener?: () => void): this;
+        listen(port?: number, backlog?: number, listeningListener?: () => void): this;
+        listen(port?: number, listeningListener?: () => void): this;
+        listen(path: string, backlog?: number, listeningListener?: () => void): this;
+        listen(path: string, listeningListener?: () => void): this;
+        listen(options: ListenOptions, listeningListener?: () => void): this;
+        listen(handle: any, backlog?: number, listeningListener?: () => void): this;
+        listen(handle: any, listeningListener?: () => void): this;
         close(callback?: (err?: Error) => void): this;
         address(): AddressInfo | string | null;
         getConnections(cb: (error: Error | null, count: number) => void): void;
@@ -243,12 +237,12 @@ declare module "net" {
 
     function createServer(connectionListener?: (socket: Socket) => void): Server;
     function createServer(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean }, connectionListener?: (socket: Socket) => void): Server;
-    function connect(options: NetConnectOpts, connectionListener?: Function): Socket;
-    function connect(port: number, host?: string, connectionListener?: Function): Socket;
-    function connect(path: string, connectionListener?: Function): Socket;
-    function createConnection(options: NetConnectOpts, connectionListener?: Function): Socket;
-    function createConnection(port: number, host?: string, connectionListener?: Function): Socket;
-    function createConnection(path: string, connectionListener?: Function): Socket;
+    function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;
+    function connect(port: number, host?: string, connectionListener?: () => void): Socket;
+    function connect(path: string, connectionListener?: () => void): Socket;
+    function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
+    function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
+    function createConnection(path: string, connectionListener?: () => void): Socket;
     function isIP(input: string): number;
     function isIPv4(input: string): boolean;
     function isIPv6(input: string): boolean;

node/os.d.ts

@@ -28,6 +28,14 @@ declare module "os" {
         scopeid: number;
     }
 
+    interface UserInfo<T> {
+        username: T;
+        uid: number;
+        gid: number;
+        shell: T;
+        homedir: T;
+    }
+
     type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
 
     function hostname(): string;
@@ -40,7 +48,8 @@ declare module "os" {
     function release(): string;
     function networkInterfaces(): { [index: string]: NetworkInterfaceInfo[] };
     function homedir(): string;
-    function userInfo(options?: { encoding: string }): { username: string, uid: number, gid: number, shell: any, homedir: string };
+    function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
+    function userInfo(options?: { encoding: string }): UserInfo<string>;
     const constants: {
         UV_UDP_REUSEADDR: number;
         signals: {

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "11.10.6",
+    "version": "11.11.3",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -206,6 +206,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "5a541b828ac8f19d35f61d8293c56f5384e73103fc555958b76b6f07f94a9461",
+    "typesPublisherContentHash": "fe634731186673eb47bb5241e8aa1bb927577525c2e697fad1e2ec5c73517e25",
     "typeScriptVersion": "2.0"
 }

node/path.d.ts

@@ -129,8 +129,8 @@ declare module "path" {
 
     namespace posix {
         function normalize(p: string): string;
-        function join(...paths: any[]): string;
-        function resolve(...pathSegments: any[]): string;
+        function join(...paths: string[]): string;
+        function resolve(...pathSegments: string[]): string;
         function isAbsolute(p: string): boolean;
         function relative(from: string, to: string): string;
         function dirname(p: string): string;
@@ -144,8 +144,8 @@ declare module "path" {
 
     namespace win32 {
         function normalize(p: string): string;
-        function join(...paths: any[]): string;
-        function resolve(...pathSegments: any[]): string;
+        function join(...paths: string[]): string;
+        function resolve(...pathSegments: string[]): string;
         function isAbsolute(p: string): boolean;
         function relative(from: string, to: string): string;
         function dirname(p: string): string;

node/punycode.d.ts

@@ -8,5 +8,5 @@ declare module "punycode" {
         decode(string: string): number[];
         encode(codePoints: number[]): string;
     }
-    const version: any;
+    const version: string;
 }

node/querystring.d.ts

@@ -1,11 +1,11 @@
 declare module "querystring" {
     interface StringifyOptions {
-        encodeURIComponent?: Function;
+        encodeURIComponent?: (str: string) => string;
     }
 
     interface ParseOptions {
         maxKeys?: number;
-        decodeURIComponent?: Function;
+        decodeURIComponent?: (str: string) => string;
     }
 
     interface ParsedUrlQuery { [key: string]: string | string[]; }

node/readline.d.ts

@@ -110,7 +110,7 @@ declare module "readline" {
     type ReadLine = Interface; // type forwarded for backwards compatiblity
 
     type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err: any, result: CompleterResult) => void) => any;
+    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => any;
 
     type CompleterResult = [string[], string];
 

node/stream.d.ts

@@ -31,7 +31,7 @@ declare module "stream" {
             unshift(chunk: any): void;
             wrap(oldStream: NodeJS.ReadableStream): this;
             push(chunk: any, encoding?: string): boolean;
-            _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             destroy(error?: Error): void;
 
             /**
@@ -112,7 +112,7 @@ declare module "stream" {
             constructor(opts?: WritableOptions);
             _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
             _writev?(chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
-            _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             _final(callback: (error?: Error | null) => void): void;
             write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
             write(chunk: any, encoding?: string, cb?: (error: Error | null | undefined) => void): boolean;
@@ -212,8 +212,8 @@ declare module "stream" {
             _writev?(chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
             _destroy(error: Error | null, callback: (error: Error | null) => void): void;
             _final(callback: (error?: Error | null) => void): void;
-            write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
             write(chunk: any, encoding?: string, cb?: (error: Error | null | undefined) => void): boolean;
+            write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
             setDefaultEncoding(encoding: string): this;
             end(cb?: () => void): void;
             end(chunk: any, cb?: () => void): void;

node/tls.d.ts

@@ -180,13 +180,13 @@ declare module "tls" {
          * Could be used to speed up handshake establishment when reconnecting to the server.
          * @returns ASN.1 encoded TLS session or undefined if none was negotiated.
          */
-        getSession(): any;
+        getSession(): Buffer | undefined;
         /**
          * NOTE: Works only with client TLS sockets.
          * Useful only for debugging, for session reuse provide session option to tls.connect().
          * @returns TLS session ticket or undefined if none was negotiated.
          */
-        getTLSTicket(): any;
+        getTLSTicket(): Buffer | undefined;
         /**
          * Initiate TLS renegotiation process.
          *
@@ -196,8 +196,9 @@ declare module "tls" {
          * requestCert (See tls.createServer() for details).
          * @param callback - callback(err) will be executed with null as err, once the renegotiation
          * is successfully completed.
+         * @return `undefined` when socket is destroy, `false` if negotiaion can't be initiated.
          */
-        renegotiate(options: { rejectUnauthorized?: boolean, requestCert?: boolean }, callback: (err: Error | null) => void): any;
+        renegotiate(options: { rejectUnauthorized?: boolean, requestCert?: boolean }, callback: (err: Error | null) => void): undefined | boolean;
         /**
          * Set maximum TLS fragment size (default and maximum value is: 16384, minimum is: 512).
          * Smaller fragment size decreases buffering latency on the client: large fragments are buffered by
@@ -291,50 +292,50 @@ declare module "tls" {
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        addListener(event: "newSession", listener: (sessionId: any, sessionData: any, callback: (err: Error, resp: Buffer) => void) => void): this;
-        addListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: Function) => void): this;
-        addListener(event: "resumeSession", listener: (sessionId: any, callback: (err: Error, sessionData: any) => void) => void): this;
+        addListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        addListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        addListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         addListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "tlsClientError", err: Error, tlsSocket: TLSSocket): boolean;
-        emit(event: "newSession", sessionId: any, sessionData: any, callback: (err: Error, resp: Buffer) => void): boolean;
-        emit(event: "OCSPRequest", certificate: Buffer, issuer: Buffer, callback: Function): boolean;
-        emit(event: "resumeSession", sessionId: any, callback: (err: Error, sessionData: any) => void): boolean;
+        emit(event: "newSession", sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
+        emit(event: "OCSPRequest", certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
+        emit(event: "resumeSession", sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
         emit(event: "secureConnection", tlsSocket: TLSSocket): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        on(event: "newSession", listener: (sessionId: any, sessionData: any, callback: (err: Error, resp: Buffer) => void) => void): this;
-        on(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: Function) => void): this;
-        on(event: "resumeSession", listener: (sessionId: any, callback: (err: Error, sessionData: any) => void) => void): this;
+        on(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        on(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        on(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         on(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        once(event: "newSession", listener: (sessionId: any, sessionData: any, callback: (err: Error, resp: Buffer) => void) => void): this;
-        once(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: Function) => void): this;
-        once(event: "resumeSession", listener: (sessionId: any, callback: (err: Error, sessionData: any) => void) => void): this;
+        once(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        once(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        once(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         once(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependListener(event: "newSession", listener: (sessionId: any, sessionData: any, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: Function) => void): this;
-        prependListener(event: "resumeSession", listener: (sessionId: any, callback: (err: Error, sessionData: any) => void) => void): this;
+        prependListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        prependListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         prependListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependOnceListener(event: "newSession", listener: (sessionId: any, sessionData: any, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: Function) => void): this;
-        prependOnceListener(event: "resumeSession", listener: (sessionId: any, callback: (err: Error, sessionData: any) => void) => void): this;
+        prependOnceListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
     }
 
     interface SecurePair {
-        encrypted: any;
-        cleartext: any;
+        encrypted: TLSSocket;
+        cleartext: TLSSocket;
     }
 
     type SecureVersion = 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
@@ -388,6 +389,9 @@ declare module "tls" {
     function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
     function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
     function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+    /**
+     * @deprecated
+     */
     function createSecurePair(credentials?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
     function createSecureContext(details: SecureContextOptions): SecureContext;
     function getCiphers(): string[];

node/worker_threads.d.ts

@@ -72,51 +72,51 @@ declare module "worker_threads" {
         postMessage(value: any, transferList?: Array<ArrayBuffer | MessagePort>): void;
         ref(): void;
         unref(): void;
-        terminate(callback?: (err: any, exitCode: number) => void): void;
+        terminate(callback?: (err: Error, exitCode: number) => void): void;
 
-        addListener(event: "error", listener: (err: any) => void): this;
+        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: "online", listener: () => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
-        emit(event: "error", err: any): boolean;
+        emit(event: "error", err: Error): boolean;
         emit(event: "exit", exitCode: number): boolean;
         emit(event: "message", value: any): boolean;
         emit(event: "online"): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
 
-        on(event: "error", listener: (err: any) => void): this;
+        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: "online", listener: () => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
 
-        once(event: "error", listener: (err: 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: "online", listener: () => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
 
-        prependListener(event: "error", listener: (err: 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: "online", listener: () => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
-        prependOnceListener(event: "error", listener: (err: 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: "online", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
-        removeListener(event: "error", listener: (err: 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: "online", listener: () => void): this;
         removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
-        off(event: "error", listener: (err: 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: "online", listener: () => void): this;