@types/node 8.0.22 → 8.0.26

node/README.md

@@ -8,9 +8,9 @@ This package contains type definitions for Node.js (http://nodejs.org/).
 Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node
 
 Additional Details
- * Last updated: Mon, 14 Aug 2017 20:37:50 GMT
- * Dependencies: events, net, stream, url, child_process, tls, http, readline, crypto
+ * Last updated: Tue, 29 Aug 2017 21:31:37 GMT
+ * Dependencies: events, net, stream, url, child_process, tls, http, readline, crypto, fs
  * Global values: Buffer, NodeJS, SlowBuffer, Symbol, ___dirname, ___filename, clearImmediate, clearInterval, clearTimeout, console, exports, global, module, process, require, setImmediate, setInterval, setTimeout
 
 # Credits
-These definitions were written by Microsoft TypeScript <http://typescriptlang.org>, DefinitelyTyped <https://github.com/DefinitelyTyped/DefinitelyTyped>, Parambir Singh <https://github.com/parambirs>, Roberto Desideri <https://github.com/RobDesideri>, Christian Vaagland Tellnes <https://github.com/tellnes>, Wilco Bakker <https://github.com/WilcoBakker>, Nicolas Voigt <https://github.com/octo-sniffle>, Chigozirim C. <https://github.com/smac89>, Flarna <https://github.com/Flarna>, Mariusz Wiktorczyk <https://github.com/mwiktorczyk>, wwwy3y3 <https://github.com/wwwy3y3>, Daniel Imms <https://github.com/Tyriar>, Deividas Bakanas <https://github.com/DeividasBakanas>.
+These definitions were written by Microsoft TypeScript <http://typescriptlang.org>, DefinitelyTyped <https://github.com/DefinitelyTyped/DefinitelyTyped>, Parambir Singh <https://github.com/parambirs>, Roberto Desideri <https://github.com/RobDesideri>, Christian Vaagland Tellnes <https://github.com/tellnes>, Wilco Bakker <https://github.com/WilcoBakker>, Nicolas Voigt <https://github.com/octo-sniffle>, Chigozirim C. <https://github.com/smac89>, Flarna <https://github.com/Flarna>, Mariusz Wiktorczyk <https://github.com/mwiktorczyk>, wwwy3y3 <https://github.com/wwwy3y3>, Daniel Imms <https://github.com/Tyriar>, Deividas Bakanas <https://github.com/DeividasBakanas>, Kelvin Jin <https://github.com/kjin>.

node/index.d.ts

@@ -13,6 +13,7 @@
 //                 wwwy3y3 <https://github.com/wwwy3y3>
 //                 Daniel Imms <https://github.com/Tyriar>
 //                 Deividas Bakanas <https://github.com/DeividasBakanas>
+//                 Kelvin Jin <https://github.com/kjin>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
 
@@ -1011,7 +1012,7 @@ declare module "cluster" {
         id: string;
         process: child.ChildProcess;
         suicide: boolean;
-        send(message: any, sendHandle?: any): boolean;
+        send(message: any, sendHandle?: any, callback?: (error: Error) => void): boolean;
         kill(signal?: string): void;
         destroy(signal?: string): void;
         disconnect(): void;
@@ -1030,7 +1031,7 @@ declare module "cluster" {
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: "disconnect", listener: () => void): this;
-        addListener(event: "error", listener: (code: number, signal: string) => void): this;
+        addListener(event: "error", listener: (error: Error) => void): this;
         addListener(event: "exit", listener: (code: number, signal: string) => void): this;
         addListener(event: "listening", listener: (address: Address) => void): this;
         addListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
@@ -1038,7 +1039,7 @@ declare module "cluster" {
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "disconnect"): boolean;
-        emit(event: "error", code: number, signal: string): boolean;
+        emit(event: "error", error: Error): boolean;
         emit(event: "exit", code: number, signal: string): boolean;
         emit(event: "listening", address: Address): boolean;
         emit(event: "message", message: any, handle: net.Socket | net.Server): boolean;
@@ -1046,7 +1047,7 @@ declare module "cluster" {
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "disconnect", listener: () => void): this;
-        on(event: "error", listener: (code: number, signal: string) => void): this;
+        on(event: "error", listener: (error: Error) => void): this;
         on(event: "exit", listener: (code: number, signal: string) => void): this;
         on(event: "listening", listener: (address: Address) => void): this;
         on(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
@@ -1054,7 +1055,7 @@ declare module "cluster" {
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "disconnect", listener: () => void): this;
-        once(event: "error", listener: (code: number, signal: string) => void): this;
+        once(event: "error", listener: (error: Error) => void): this;
         once(event: "exit", listener: (code: number, signal: string) => void): this;
         once(event: "listening", listener: (address: Address) => void): this;
         once(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
@@ -1062,7 +1063,7 @@ declare module "cluster" {
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "disconnect", listener: () => void): this;
-        prependListener(event: "error", listener: (code: number, signal: string) => void): this;
+        prependListener(event: "error", listener: (error: Error) => void): this;
         prependListener(event: "exit", listener: (code: number, signal: string) => void): this;
         prependListener(event: "listening", listener: (address: Address) => void): this;
         prependListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
@@ -1070,7 +1071,7 @@ declare module "cluster" {
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "disconnect", listener: () => void): this;
-        prependOnceListener(event: "error", listener: (code: number, signal: string) => void): this;
+        prependOnceListener(event: "error", listener: (error: Error) => void): this;
         prependOnceListener(event: "exit", listener: (code: number, signal: string) => void): this;
         prependOnceListener(event: "listening", listener: (address: Address) => void): this;
         prependOnceListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
@@ -1272,27 +1273,27 @@ declare module "zlib" {
     export function createInflateRaw(options?: ZlibOptions): InflateRaw;
     export function createUnzip(options?: ZlibOptions): Unzip;
 
-    export function deflate(buf: Buffer | string, callback: (error: Error, result: Buffer) => void): void;
-    export function deflate(buf: Buffer | string, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
+    export function deflate(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function deflate(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
     export function deflateSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
-    export function deflateRaw(buf: Buffer | string, callback: (error: Error, result: Buffer) => void): void;
-    export function deflateRaw(buf: Buffer | string, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
+    export function deflateRaw(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function deflateRaw(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
     export function deflateRawSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
-    export function gzip(buf: Buffer, callback: (error: Error, result: Buffer) => void): void;
-    export function gzip(buf: Buffer, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
-    export function gzipSync(buf: Buffer, options?: ZlibOptions): Buffer;
-    export function gunzip(buf: Buffer, callback: (error: Error, result: Buffer) => void): void;
-    export function gunzip(buf: Buffer, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
-    export function gunzipSync(buf: Buffer, options?: ZlibOptions): Buffer;
-    export function inflate(buf: Buffer, callback: (error: Error, result: Buffer) => void): void;
-    export function inflate(buf: Buffer, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
-    export function inflateSync(buf: Buffer, options?: ZlibOptions): Buffer;
-    export function inflateRaw(buf: Buffer, callback: (error: Error, result: Buffer) => void): void;
-    export function inflateRaw(buf: Buffer, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
-    export function inflateRawSync(buf: Buffer, options?: ZlibOptions): Buffer;
-    export function unzip(buf: Buffer, callback: (error: Error, result: Buffer) => void): void;
-    export function unzip(buf: Buffer, options: ZlibOptions, callback: (error: Error, result: Buffer) => void): void;
-    export function unzipSync(buf: Buffer, options?: ZlibOptions): Buffer;
+    export function gzip(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function gzip(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
+    export function gzipSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
+    export function gunzip(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function gunzip(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
+    export function gunzipSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
+    export function inflate(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function inflate(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
+    export function inflateSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
+    export function inflateRaw(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function inflateRaw(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
+    export function inflateRawSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
+    export function unzip(buf: Buffer | string, callback: (error: Error | null, result: Buffer) => void): void;
+    export function unzip(buf: Buffer | string, options: ZlibOptions, callback: (error: Error | null, result: Buffer) => void): void;
+    export function unzipSync(buf: Buffer | string, options?: ZlibOptions): Buffer;
 
     export namespace constants {
         // Allowed flush values.
@@ -1379,14 +1380,24 @@ declare module "os" {
         };
     }
 
-    export interface NetworkInterfaceInfo {
+    export interface NetworkInterfaceBase {
         address: string;
         netmask: string;
-        family: string;
         mac: string;
         internal: boolean;
     }
 
+    export interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
+        family: "IPv4";
+    }
+
+    export interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
+        family: "IPv6";
+        scopeid: number;
+    }
+
+    export type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
+
     export function hostname(): string;
     export function loadavg(): number[];
     export function uptime(): number;
@@ -1809,6 +1820,7 @@ declare module "child_process" {
         stdout: stream.Readable;
         stderr: stream.Readable;
         stdio: [stream.Writable, stream.Readable, stream.Readable];
+        killed: boolean;
         pid: number;
         kill(signal?: string): void;
         send(message: any, callback?: (error: Error) => void): boolean;
@@ -1907,23 +1919,23 @@ declare module "child_process" {
     }
 
     // no `options` definitely means stdout/stderr are `string`.
-    export function exec(command: string, callback?: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
+    export function exec(command: string, callback?: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
 
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
-    export function exec(command: string, options: { encoding: "buffer" | null } & ExecOptions, callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
+    export function exec(command: string, options: { encoding: "buffer" | null } & ExecOptions, callback?: (error: Error | null, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
 
     // `options` with well known `encoding` means stdout/stderr are definitely `string`.
-    export function exec(command: string, options: { encoding: BufferEncoding } & ExecOptions, callback?: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
+    export function exec(command: string, options: { encoding: BufferEncoding } & ExecOptions, callback?: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
 
     // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
     // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
-    export function exec(command: string, options: { encoding: string } & ExecOptions, callback?: (error: Error, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
+    export function exec(command: string, options: { encoding: string } & ExecOptions, callback?: (error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
 
     // `options` without an `encoding` means stdout/stderr are definitely `string`.
-    export function exec(command: string, options: ExecOptions, callback?: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
+    export function exec(command: string, options: ExecOptions, callback?: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
 
     // fallback if nothing else matches. Worst case is always `string | Buffer`.
-    export function exec(command: string, options: ({ encoding?: string | null } & ExecOptions) | undefined | null, callback?: (error: Error, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
+    export function exec(command: string, options: ({ encoding?: string | null } & ExecOptions) | undefined | null, callback?: (error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
 
     // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
     export namespace exec {
@@ -1956,28 +1968,28 @@ declare module "child_process" {
     export function execFile(file: string, args: string[] | undefined | null, options: ({ encoding?: string | null } & ExecFileOptions) | undefined | null): ChildProcess;
 
     // no `options` definitely means stdout/stderr are `string`.
-    export function execFile(file: string, callback: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
+    export function execFile(file: string, callback: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
 
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
-    export function execFile(file: string, options: { encoding: "buffer" | null } & ExecFileOptions, callback: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
-    export function execFile(file: string, args: string[] | undefined | null, options: { encoding: "buffer" | null } & ExecFileOptions, callback: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
+    export function execFile(file: string, options: { encoding: "buffer" | null } & ExecFileOptions, callback: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
+    export function execFile(file: string, args: string[] | undefined | null, options: { encoding: "buffer" | null } & ExecFileOptions, callback: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
 
     // `options` with well known `encoding` means stdout/stderr are definitely `string`.
-    export function execFile(file: string, options: { encoding: BufferEncoding } & ExecFileOptions, callback: (error: Error, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
-    export function execFile(file: string, args: string[] | undefined | null, options: { encoding: BufferEncoding } & ExecFileOptions, callback: (error: Error, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
+    export function execFile(file: string, options: { encoding: BufferEncoding } & ExecFileOptions, callback: (error: Error | null, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
+    export function execFile(file: string, args: string[] | undefined | null, options: { encoding: BufferEncoding } & ExecFileOptions, callback: (error: Error | null, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
 
     // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
     // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
-    export function execFile(file: string, options: { encoding: string } & ExecFileOptions, callback: (error: Error, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
-    export function execFile(file: string, args: string[] | undefined | null, options: { encoding: string } & ExecFileOptions, callback: (error: Error, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
+    export function execFile(file: string, options: { encoding: string } & ExecFileOptions, callback: (error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
+    export function execFile(file: string, args: string[] | undefined | null, options: { encoding: string } & ExecFileOptions, callback: (error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
 
     // `options` without an `encoding` means stdout/stderr are definitely `string`.
-    export function execFile(file: string, options: ExecFileOptions, callback: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
-    export function execFile(file: string, args: string[] | undefined | null, options: ExecFileOptions, callback: (error: Error, stdout: string, stderr: string) => void): ChildProcess;
+    export function execFile(file: string, options: ExecFileOptions, callback: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
+    export function execFile(file: string, args: string[] | undefined | null, options: ExecFileOptions, callback: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
 
     // fallback if nothing else matches. Worst case is always `string | Buffer`.
-    export function execFile(file: string, options: ({ encoding?: string | null } & ExecFileOptions) | undefined | null, callback: ((error: Error, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null): ChildProcess;
-    export function execFile(file: string, args: string[] | undefined | null, options: ({ encoding?: string | null } & ExecFileOptions) | undefined | null, callback: ((error: Error, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null): ChildProcess;
+    export function execFile(file: string, options: ({ encoding?: string | null } & ExecFileOptions) | undefined | null, callback: ((error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null): ChildProcess;
+    export function execFile(file: string, args: string[] | undefined | null, options: ({ encoding?: string | null } & ExecFileOptions) | undefined | null, callback: ((error: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null): ChildProcess;
 
     // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
     export namespace execFile {
@@ -2480,7 +2492,7 @@ declare module "net" {
         listen(handle: any, listeningListener?: Function): Server;
         close(callback?: Function): Server;
         address(): { port: number; family: string; address: string; };
-        getConnections(cb: (error: Error, count: number) => void): void;
+        getConnections(cb: (error: Error | null, count: number) => void): void;
         ref(): Server;
         unref(): Server;
         maxConnections: number;
@@ -2575,8 +2587,8 @@ declare module "dgram" {
     export function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
 
     export interface Socket extends events.EventEmitter {
-        send(msg: Buffer | String | any[], port: number, address: string, callback?: (error: Error, bytes: number) => void): void;
-        send(msg: Buffer | String | any[], offset: number, length: number, port: number, address: string, callback?: (error: Error, bytes: number) => void): void;
+        send(msg: Buffer | String | any[], port: number, address: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: Buffer | String | any[], offset: number, length: number, port: number, address: string, callback?: (error: Error | null, bytes: number) => void): void;
         bind(port?: number, address?: string, callback?: () => void): void;
         bind(port?: number, callback?: () => void): void;
         bind(callback?: () => void): void;
@@ -2685,23 +2697,23 @@ declare module "fs" {
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: "change", listener: (eventType: string, filename: string | Buffer) => void): this;
-        addListener(event: "error", listener: (code: number, signal: string) => void): this;
+        addListener(event: "error", listener: (error: Error) => void): this;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "change", listener: (eventType: string, filename: string | Buffer) => void): this;
-        on(event: "error", listener: (code: number, signal: string) => void): this;
+        on(event: "error", listener: (error: Error) => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "change", listener: (eventType: string, filename: string | Buffer) => void): this;
-        once(event: "error", listener: (code: number, signal: string) => void): this;
+        once(event: "error", listener: (error: Error) => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "change", listener: (eventType: string, filename: string | Buffer) => void): this;
-        prependListener(event: "error", listener: (code: number, signal: string) => void): this;
+        prependListener(event: "error", listener: (error: Error) => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "change", listener: (eventType: string, filename: string | Buffer) => void): this;
-        prependOnceListener(event: "error", listener: (code: number, signal: string) => void): this;
+        prependOnceListener(event: "error", listener: (error: Error) => void): this;
     }
 
     export interface ReadStream extends stream.Readable {
@@ -4967,7 +4979,6 @@ declare module "stream" {
             pause(): this;
             resume(): this;
             isPaused(): boolean;
-            pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
             unpipe<T extends NodeJS.WritableStream>(destination?: T): this;
             unshift(chunk: any): void;
             wrap(oldStream: NodeJS.ReadableStream): Readable;
@@ -5821,3 +5832,817 @@ declare module "async_hooks" {
      */
     export function createHook(options: HookCallbacks): AsyncHook;
 }
+
+declare module "http2" {
+    import * as events from "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 { IncomingHttpHeaders, OutgoingHttpHeaders } from "http";
+    export { IncomingHttpHeaders, OutgoingHttpHeaders } from "http";
+
+    // Http2Stream
+
+    export interface StreamPriorityOptions {
+        exclusive?: boolean;
+        parent?: number;
+        weight?: number;
+        silent?: boolean;
+    }
+
+    export interface StreamState {
+        localWindowSize?: number;
+        state?: number;
+        streamLocalClose?: number;
+        streamRemoteClose?: number;
+        sumDependencyWeight?: number;
+        weight?: number;
+    }
+
+    export interface ServerStreamResponseOptions {
+        endStream?: boolean;
+        getTrailers?: (trailers: IncomingHttpHeaders) => void;
+    }
+
+    export interface StatOptions {
+        offset: number;
+        length: number;
+    }
+
+    export interface ServerStreamFileResponseOptions {
+        statCheck?: (stats: fs.Stats, headers: IncomingHttpHeaders, statOptions: StatOptions) => void;
+        getTrailers?: (trailers: IncomingHttpHeaders) => void;
+        offset?: number;
+        length?: number;
+    }
+
+    export interface Http2Stream extends stream.Duplex {
+        readonly aborted: boolean;
+        readonly destroyed: boolean;
+        priority(options: StreamPriorityOptions): void;
+        readonly rstCode: number;
+        rstStream(code: number): void;
+        rstWithNoError(): void;
+        rstWithProtocolError(): void;
+        rstWithCancel(): void;
+        rstWithRefuse(): void;
+        rstWithInternalError(): void;
+        readonly session: Http2Session;
+        setTimeout(msecs: number, callback?: () => void): void;
+        readonly state: StreamState;
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "aborted", listener: () => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        addListener(event: "drain", listener: () => void): this;
+        addListener(event: "end", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "finish", listener: () => void): this;
+        addListener(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        addListener(event: "pipe", listener: (src: stream.Readable) => void): this;
+        addListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
+        addListener(event: "streamClosed", listener: (code: number) => void): this;
+        addListener(event: "timeout", listener: () => void): this;
+        addListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "aborted"): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "data", chunk: Buffer | string): boolean;
+        emit(event: "drain"): boolean;
+        emit(event: "end"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "finish"): boolean;
+        emit(event: "frameError", frameType: number, errorCode: number): boolean;
+        emit(event: "pipe", src: stream.Readable): boolean;
+        emit(event: "unpipe", src: stream.Readable): boolean;
+        emit(event: "streamClosed", code: number): boolean;
+        emit(event: "timeout"): boolean;
+        emit(event: "trailers", trailers: IncomingHttpHeaders, flags: number): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "aborted", listener: () => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "data", listener: (chunk: Buffer | string) => void): this;
+        on(event: "drain", listener: () => void): this;
+        on(event: "end", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "finish", listener: () => void): this;
+        on(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        on(event: "pipe", listener: (src: stream.Readable) => void): this;
+        on(event: "unpipe", listener: (src: stream.Readable) => void): this;
+        on(event: "streamClosed", listener: (code: number) => void): this;
+        on(event: "timeout", listener: () => void): this;
+        on(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "aborted", listener: () => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "data", listener: (chunk: Buffer | string) => void): this;
+        once(event: "drain", listener: () => void): this;
+        once(event: "end", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "finish", listener: () => void): this;
+        once(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        once(event: "pipe", listener: (src: stream.Readable) => void): this;
+        once(event: "unpipe", listener: (src: stream.Readable) => void): this;
+        once(event: "streamClosed", listener: (code: number) => void): this;
+        once(event: "timeout", listener: () => void): this;
+        once(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "aborted", listener: () => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        prependListener(event: "drain", listener: () => void): this;
+        prependListener(event: "end", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "finish", listener: () => void): this;
+        prependListener(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        prependListener(event: "pipe", listener: (src: stream.Readable) => void): this;
+        prependListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
+        prependListener(event: "streamClosed", listener: (code: number) => void): this;
+        prependListener(event: "timeout", listener: () => void): this;
+        prependListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "aborted", listener: () => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        prependOnceListener(event: "drain", listener: () => void): this;
+        prependOnceListener(event: "end", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "finish", listener: () => void): this;
+        prependOnceListener(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        prependOnceListener(event: "pipe", listener: (src: stream.Readable) => void): this;
+        prependOnceListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
+        prependOnceListener(event: "streamClosed", listener: (code: number) => void): this;
+        prependOnceListener(event: "timeout", listener: () => void): this;
+        prependOnceListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
+    }
+
+    export interface ClientHttp2Stream extends Http2Stream {
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "headers", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        addListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        addListener(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "headers", headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(event: "push", headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(event: "response", headers: IncomingHttpHeaders, flags: number): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "headers", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        on(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        on(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "headers", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        once(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        once(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "headers", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependListener(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "headers", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependOnceListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependOnceListener(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
+    }
+
+    export interface ServerHttp2Stream extends Http2Stream {
+        additionalHeaders(headers: OutgoingHttpHeaders): void;
+        readonly headersSent: boolean;
+        readonly pushAllowed: boolean;
+        pushStream(headers: OutgoingHttpHeaders, callback?: (pushStream: ServerHttp2Stream) => void): void;
+        pushStream(headers: OutgoingHttpHeaders, options?: StreamPriorityOptions, callback?: (pushStream: ServerHttp2Stream) => void): void;
+        respond(headers?: OutgoingHttpHeaders, options?: ServerStreamResponseOptions): void;
+        respondWithFD(fd: number, headers?: OutgoingHttpHeaders, options?: ServerStreamFileResponseOptions): void;
+        respondWithFile(path: string, headers?: OutgoingHttpHeaders, options?: ServerStreamFileResponseOptions): void;
+    }
+
+    // Http2Session
+
+    export interface Settings {
+        headerTableSize?: number;
+        enablePush?: boolean;
+        initialWindowSize?: number;
+        maxFrameSize?: number;
+        maxConcurrentStreams?: number;
+        maxHeaderListSize?: number;
+    }
+
+    export interface ClientSessionRequestOptions {
+        endStream?: boolean;
+        exclusive?: boolean;
+        parent?: number;
+        weight?: number;
+        getTrailers?: (trailers: IncomingHttpHeaders, flags: number) => void;
+    }
+
+    export interface SessionShutdownOptions {
+        graceful?: boolean;
+        errorCode?: number;
+        lastStreamID?: number;
+        opaqueData?: Buffer | Uint8Array;
+    }
+
+    export interface SessionState {
+        effectiveLocalWindowSize?: number;
+        effectiveRecvDataLength?: number;
+        nextStreamID?: number;
+        localWindowSize?: number;
+        lastProcStreamID?: number;
+        remoteWindowSize?: number;
+        outboundQueueSize?: number;
+        deflateDynamicTableSize?: number;
+        inflateDynamicTableSize?: number;
+    }
+
+    export interface Http2Session extends events.EventEmitter {
+        destroy(): void;
+        readonly destroyed: boolean;
+        readonly localSettings: Settings;
+        readonly pendingSettingsAck: boolean;
+        readonly remoteSettings: Settings;
+        rstStream(stream: Http2Stream, code?: number): void;
+        setTimeout(msecs: number, callback?: () => void): void;
+        shutdown(callback?: () => void): void;
+        shutdown(options: SessionShutdownOptions, callback?: () => void): void;
+        readonly socket: net.Socket | tls.TLSSocket;
+        readonly state: SessionState;
+        priority(stream: Http2Stream, options: StreamPriorityOptions): void;
+        settings(settings: Settings): void;
+        readonly type: number;
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
+        addListener(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this;
+        addListener(event: "localSettings", listener: (settings: Settings) => void): this;
+        addListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
+        addListener(event: "socketError", listener: (err: Error) => void): this;
+        addListener(event: "timeout", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "frameError", frameType: number, errorCode: number, streamID: number): boolean;
+        emit(event: "goaway", errorCode: number, lastStreamID: number, opaqueData: Buffer): boolean;
+        emit(event: "localSettings", settings: Settings): boolean;
+        emit(event: "remoteSettings", settings: Settings): boolean;
+        emit(event: "socketError", err: Error): boolean;
+        emit(event: "timeout"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
+        on(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this;
+        on(event: "localSettings", listener: (settings: Settings) => void): this;
+        on(event: "remoteSettings", listener: (settings: Settings) => void): this;
+        on(event: "socketError", listener: (err: Error) => void): this;
+        on(event: "timeout", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
+        once(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this;
+        once(event: "localSettings", listener: (settings: Settings) => void): this;
+        once(event: "remoteSettings", listener: (settings: Settings) => void): this;
+        once(event: "socketError", listener: (err: Error) => void): this;
+        once(event: "timeout", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
+        prependListener(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this;
+        prependListener(event: "localSettings", listener: (settings: Settings) => void): this;
+        prependListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
+        prependListener(event: "socketError", listener: (err: Error) => void): this;
+        prependListener(event: "timeout", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
+        prependOnceListener(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData: Buffer) => void): this;
+        prependOnceListener(event: "localSettings", listener: (settings: Settings) => void): this;
+        prependOnceListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
+        prependOnceListener(event: "socketError", listener: (err: Error) => void): this;
+        prependOnceListener(event: "timeout", listener: () => void): this;
+    }
+
+    export interface ClientHttp2Session extends Http2Session {
+        request(headers?: OutgoingHttpHeaders, options?: ClientSessionRequestOptions): ClientHttp2Stream;
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "connect", listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        addListener(event: "stream", listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "connect", session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket): boolean;
+        emit(event: "stream", stream: ClientHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "connect", listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        on(event: "stream", listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "connect", listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        once(event: "stream", listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "connect", listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        prependListener(event: "stream", listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "connect", listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        prependOnceListener(event: "stream", listener: (stream: ClientHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+    }
+
+    export interface ServerHttp2Session extends Http2Session {
+        readonly server: Http2Server | Http2SecureServer;
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "connect", listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        addListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "connect", session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket): boolean;
+        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "connect", listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        on(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "connect", listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        once(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "connect", listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        prependListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "connect", listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        prependOnceListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+    }
+
+    // Http2Server
+
+    export interface SessionOptions {
+        maxDeflateDynamicTableSize?: number;
+        maxReservedRemoteStreams?: number;
+        maxSendHeaderBlockLength?: number;
+        paddingStrategy?: number;
+        peerMaxConcurrentStreams?: number;
+        selectPadding?: (frameLen: number, maxFrameLen: number) => number;
+        settings?: Settings;
+    }
+
+    export type ClientSessionOptions = SessionOptions;
+    export type ServerSessionOptions = SessionOptions;
+
+    export interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions {}
+    export interface SecureServerSessionOptions extends ServerSessionOptions, tls.TlsOptions {}
+
+    export interface ServerOptions extends ServerSessionOptions {
+        allowHTTP1?: boolean;
+    }
+
+    export interface SecureServerOptions extends SecureServerSessionOptions {
+        allowHTTP1?: boolean;
+    }
+
+    export interface Http2Server extends net.Server {
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        addListener(event: "sessionError", listener: (err: Error) => void): this;
+        addListener(event: "socketError", listener: (err: Error) => void): this;
+        addListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        addListener(event: "timeout", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "request", request: Http2ServerRequest, response: Http2ServerResponse): boolean;
+        emit(event: "sessionError", err: Error): boolean;
+        emit(event: "socketError", err: Error): boolean;
+        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(event: "timeout"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        on(event: "sessionError", listener: (err: Error) => void): this;
+        on(event: "socketError", listener: (err: Error) => void): this;
+        on(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        on(event: "timeout", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        once(event: "sessionError", listener: (err: Error) => void): this;
+        once(event: "socketError", listener: (err: Error) => void): this;
+        once(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        once(event: "timeout", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        prependListener(event: "sessionError", listener: (err: Error) => void): this;
+        prependListener(event: "socketError", listener: (err: Error) => void): this;
+        prependListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependListener(event: "timeout", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
+        prependOnceListener(event: "socketError", listener: (err: Error) => void): this;
+        prependOnceListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependOnceListener(event: "timeout", listener: () => void): this;
+    }
+
+    export interface Http2SecureServer extends tls.Server {
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        addListener(event: "sessionError", listener: (err: Error) => void): this;
+        addListener(event: "socketError", listener: (err: Error) => void): this;
+        addListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        addListener(event: "timeout", listener: () => void): this;
+        addListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "request", request: Http2ServerRequest, response: Http2ServerResponse): boolean;
+        emit(event: "sessionError", err: Error): boolean;
+        emit(event: "socketError", err: Error): boolean;
+        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(event: "timeout"): boolean;
+        emit(event: "unknownProtocol", socket: tls.TLSSocket): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        on(event: "sessionError", listener: (err: Error) => void): this;
+        on(event: "socketError", listener: (err: Error) => void): this;
+        on(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        on(event: "timeout", listener: () => void): this;
+        on(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        once(event: "sessionError", listener: (err: Error) => void): this;
+        once(event: "socketError", listener: (err: Error) => void): this;
+        once(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        once(event: "timeout", listener: () => void): this;
+        once(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        prependListener(event: "sessionError", listener: (err: Error) => void): this;
+        prependListener(event: "socketError", listener: (err: Error) => void): this;
+        prependListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependListener(event: "timeout", listener: () => void): this;
+        prependListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
+        prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
+        prependOnceListener(event: "socketError", listener: (err: Error) => void): this;
+        prependOnceListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
+        prependOnceListener(event: "timeout", listener: () => void): this;
+        prependOnceListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
+    }
+
+    export interface Http2ServerRequest extends stream.Readable {
+        headers: IncomingHttpHeaders;
+        httpVersion: string;
+        method: string;
+        rawHeaders: string[];
+        rawTrailers: string[];
+        setTimeout(msecs: number, callback?: () => void): void;
+        socket: net.Socket | tls.TLSSocket;
+        stream: ServerHttp2Stream;
+        trailers: IncomingHttpHeaders;
+        url: string;
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "aborted", hadError: boolean, code: number): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+    }
+
+    export interface Http2ServerResponse extends events.EventEmitter {
+        addTrailers(trailers: OutgoingHttpHeaders): void;
+        connection: net.Socket | tls.TLSSocket;
+        end(callback?: () => void): void;
+        end(data?: string | Buffer, callback?: () => void): void;
+        end(data?: string | Buffer, encoding?: string, callback?: () => void): void;
+        readonly finished: boolean;
+        getHeader(name: string): string;
+        getHeaderNames(): string[];
+        getHeaders(): OutgoingHttpHeaders;
+        hasHeader(name: string): boolean;
+        readonly headersSent: boolean;
+        removeHeader(name: string): void;
+        sendDate: boolean;
+        setHeader(name: string, value: number | string | string[]): void;
+        setTimeout(msecs: number, callback?: () => void): void;
+        socket: net.Socket | tls.TLSSocket;
+        statusCode: number;
+        statusMessage: '';
+        stream: ServerHttp2Stream;
+        write(chunk: string | Buffer, callback?: (err: Error) => void): boolean;
+        write(chunk: string | Buffer, encoding?: string, callback?: (err: Error) => void): boolean;
+        writeContinue(): void;
+        writeHead(statusCode: number, headers?: OutgoingHttpHeaders): void;
+        writeHead(statusCode: number, statusMessage?: string, headers?: OutgoingHttpHeaders): void;
+        createPushResponse(headers: OutgoingHttpHeaders, callback?: (err: Error) => void): void;
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "drain", listener: () => void): this;
+        addListener(event: "error", listener: (error: Error) => void): this;
+        addListener(event: "finish", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "aborted", hadError: boolean, code: number): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "drain"): boolean;
+        emit(event: "error", error: Error): boolean;
+        emit(event: "finish"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "drain", listener: () => void): this;
+        on(event: "error", listener: (error: Error) => void): this;
+        on(event: "finish", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "drain", listener: () => void): this;
+        once(event: "error", listener: (error: Error) => void): this;
+        once(event: "finish", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "drain", listener: () => void): this;
+        prependListener(event: "error", listener: (error: Error) => void): this;
+        prependListener(event: "finish", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "drain", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (error: Error) => void): this;
+        prependOnceListener(event: "finish", listener: () => void): this;
+    }
+
+    // Public API
+
+    export const constants: {
+        NGHTTP2_SESSION_SERVER: number;
+        NGHTTP2_SESSION_CLIENT: number;
+        NGHTTP2_STREAM_STATE_IDLE: number;
+        NGHTTP2_STREAM_STATE_OPEN: number;
+        NGHTTP2_STREAM_STATE_RESERVED_LOCAL: number;
+        NGHTTP2_STREAM_STATE_RESERVED_REMOTE: number;
+        NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL: number;
+        NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE: number;
+        NGHTTP2_STREAM_STATE_CLOSED: number;
+        NGHTTP2_NO_ERROR: number;
+        NGHTTP2_PROTOCOL_ERROR: number;
+        NGHTTP2_INTERNAL_ERROR: number;
+        NGHTTP2_FLOW_CONTROL_ERROR: number;
+        NGHTTP2_SETTINGS_TIMEOUT: number;
+        NGHTTP2_STREAM_CLOSED: number;
+        NGHTTP2_FRAME_SIZE_ERROR: number;
+        NGHTTP2_REFUSED_STREAM: number;
+        NGHTTP2_CANCEL: number;
+        NGHTTP2_COMPRESSION_ERROR: number;
+        NGHTTP2_CONNECT_ERROR: number;
+        NGHTTP2_ENHANCE_YOUR_CALM: number;
+        NGHTTP2_INADEQUATE_SECURITY: number;
+        NGHTTP2_HTTP_1_1_REQUIRED: number;
+        NGHTTP2_ERR_FRAME_SIZE_ERROR: number;
+        NGHTTP2_FLAG_NONE: number;
+        NGHTTP2_FLAG_END_STREAM: number;
+        NGHTTP2_FLAG_END_HEADERS: number;
+        NGHTTP2_FLAG_ACK: number;
+        NGHTTP2_FLAG_PADDED: number;
+        NGHTTP2_FLAG_PRIORITY: number;
+        DEFAULT_SETTINGS_HEADER_TABLE_SIZE: number;
+        DEFAULT_SETTINGS_ENABLE_PUSH: number;
+        DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE: number;
+        DEFAULT_SETTINGS_MAX_FRAME_SIZE: number;
+        MAX_MAX_FRAME_SIZE: number;
+        MIN_MAX_FRAME_SIZE: number;
+        MAX_INITIAL_WINDOW_SIZE: number;
+        NGHTTP2_DEFAULT_WEIGHT: number;
+        NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: number;
+        NGHTTP2_SETTINGS_ENABLE_PUSH: number;
+        NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: number;
+        NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: number;
+        NGHTTP2_SETTINGS_MAX_FRAME_SIZE: number;
+        NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: number;
+        PADDING_STRATEGY_NONE: number;
+        PADDING_STRATEGY_MAX: number;
+        PADDING_STRATEGY_CALLBACK: number;
+        HTTP2_HEADER_STATUS: string;
+        HTTP2_HEADER_METHOD: string;
+        HTTP2_HEADER_AUTHORITY: string;
+        HTTP2_HEADER_SCHEME: string;
+        HTTP2_HEADER_PATH: string;
+        HTTP2_HEADER_ACCEPT_CHARSET: string;
+        HTTP2_HEADER_ACCEPT_ENCODING: string;
+        HTTP2_HEADER_ACCEPT_LANGUAGE: string;
+        HTTP2_HEADER_ACCEPT_RANGES: string;
+        HTTP2_HEADER_ACCEPT: string;
+        HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: string;
+        HTTP2_HEADER_AGE: string;
+        HTTP2_HEADER_ALLOW: string;
+        HTTP2_HEADER_AUTHORIZATION: string;
+        HTTP2_HEADER_CACHE_CONTROL: string;
+        HTTP2_HEADER_CONNECTION: string;
+        HTTP2_HEADER_CONTENT_DISPOSITION: string;
+        HTTP2_HEADER_CONTENT_ENCODING: string;
+        HTTP2_HEADER_CONTENT_LANGUAGE: string;
+        HTTP2_HEADER_CONTENT_LENGTH: string;
+        HTTP2_HEADER_CONTENT_LOCATION: string;
+        HTTP2_HEADER_CONTENT_MD5: string;
+        HTTP2_HEADER_CONTENT_RANGE: string;
+        HTTP2_HEADER_CONTENT_TYPE: string;
+        HTTP2_HEADER_COOKIE: string;
+        HTTP2_HEADER_DATE: string;
+        HTTP2_HEADER_ETAG: string;
+        HTTP2_HEADER_EXPECT: string;
+        HTTP2_HEADER_EXPIRES: string;
+        HTTP2_HEADER_FROM: string;
+        HTTP2_HEADER_HOST: string;
+        HTTP2_HEADER_IF_MATCH: string;
+        HTTP2_HEADER_IF_MODIFIED_SINCE: string;
+        HTTP2_HEADER_IF_NONE_MATCH: string;
+        HTTP2_HEADER_IF_RANGE: string;
+        HTTP2_HEADER_IF_UNMODIFIED_SINCE: string;
+        HTTP2_HEADER_LAST_MODIFIED: string;
+        HTTP2_HEADER_LINK: string;
+        HTTP2_HEADER_LOCATION: string;
+        HTTP2_HEADER_MAX_FORWARDS: string;
+        HTTP2_HEADER_PREFER: string;
+        HTTP2_HEADER_PROXY_AUTHENTICATE: string;
+        HTTP2_HEADER_PROXY_AUTHORIZATION: string;
+        HTTP2_HEADER_RANGE: string;
+        HTTP2_HEADER_REFERER: string;
+        HTTP2_HEADER_REFRESH: string;
+        HTTP2_HEADER_RETRY_AFTER: string;
+        HTTP2_HEADER_SERVER: string;
+        HTTP2_HEADER_SET_COOKIE: string;
+        HTTP2_HEADER_STRICT_TRANSPORT_SECURITY: string;
+        HTTP2_HEADER_TRANSFER_ENCODING: string;
+        HTTP2_HEADER_TE: string;
+        HTTP2_HEADER_UPGRADE: string;
+        HTTP2_HEADER_USER_AGENT: string;
+        HTTP2_HEADER_VARY: string;
+        HTTP2_HEADER_VIA: string;
+        HTTP2_HEADER_WWW_AUTHENTICATE: string;
+        HTTP2_HEADER_HTTP2_SETTINGS: string;
+        HTTP2_HEADER_KEEP_ALIVE: string;
+        HTTP2_HEADER_PROXY_CONNECTION: string;
+        HTTP2_METHOD_ACL: string;
+        HTTP2_METHOD_BASELINE_CONTROL: string;
+        HTTP2_METHOD_BIND: string;
+        HTTP2_METHOD_CHECKIN: string;
+        HTTP2_METHOD_CHECKOUT: string;
+        HTTP2_METHOD_CONNECT: string;
+        HTTP2_METHOD_COPY: string;
+        HTTP2_METHOD_DELETE: string;
+        HTTP2_METHOD_GET: string;
+        HTTP2_METHOD_HEAD: string;
+        HTTP2_METHOD_LABEL: string;
+        HTTP2_METHOD_LINK: string;
+        HTTP2_METHOD_LOCK: string;
+        HTTP2_METHOD_MERGE: string;
+        HTTP2_METHOD_MKACTIVITY: string;
+        HTTP2_METHOD_MKCALENDAR: string;
+        HTTP2_METHOD_MKCOL: string;
+        HTTP2_METHOD_MKREDIRECTREF: string;
+        HTTP2_METHOD_MKWORKSPACE: string;
+        HTTP2_METHOD_MOVE: string;
+        HTTP2_METHOD_OPTIONS: string;
+        HTTP2_METHOD_ORDERPATCH: string;
+        HTTP2_METHOD_PATCH: string;
+        HTTP2_METHOD_POST: string;
+        HTTP2_METHOD_PRI: string;
+        HTTP2_METHOD_PROPFIND: string;
+        HTTP2_METHOD_PROPPATCH: string;
+        HTTP2_METHOD_PUT: string;
+        HTTP2_METHOD_REBIND: string;
+        HTTP2_METHOD_REPORT: string;
+        HTTP2_METHOD_SEARCH: string;
+        HTTP2_METHOD_TRACE: string;
+        HTTP2_METHOD_UNBIND: string;
+        HTTP2_METHOD_UNCHECKOUT: string;
+        HTTP2_METHOD_UNLINK: string;
+        HTTP2_METHOD_UNLOCK: string;
+        HTTP2_METHOD_UPDATE: string;
+        HTTP2_METHOD_UPDATEREDIRECTREF: string;
+        HTTP2_METHOD_VERSION_CONTROL: string;
+        HTTP_STATUS_CONTINUE: number;
+        HTTP_STATUS_SWITCHING_PROTOCOLS: number;
+        HTTP_STATUS_PROCESSING: number;
+        HTTP_STATUS_OK: number;
+        HTTP_STATUS_CREATED: number;
+        HTTP_STATUS_ACCEPTED: number;
+        HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION: number;
+        HTTP_STATUS_NO_CONTENT: number;
+        HTTP_STATUS_RESET_CONTENT: number;
+        HTTP_STATUS_PARTIAL_CONTENT: number;
+        HTTP_STATUS_MULTI_STATUS: number;
+        HTTP_STATUS_ALREADY_REPORTED: number;
+        HTTP_STATUS_IM_USED: number;
+        HTTP_STATUS_MULTIPLE_CHOICES: number;
+        HTTP_STATUS_MOVED_PERMANENTLY: number;
+        HTTP_STATUS_FOUND: number;
+        HTTP_STATUS_SEE_OTHER: number;
+        HTTP_STATUS_NOT_MODIFIED: number;
+        HTTP_STATUS_USE_PROXY: number;
+        HTTP_STATUS_TEMPORARY_REDIRECT: number;
+        HTTP_STATUS_PERMANENT_REDIRECT: number;
+        HTTP_STATUS_BAD_REQUEST: number;
+        HTTP_STATUS_UNAUTHORIZED: number;
+        HTTP_STATUS_PAYMENT_REQUIRED: number;
+        HTTP_STATUS_FORBIDDEN: number;
+        HTTP_STATUS_NOT_FOUND: number;
+        HTTP_STATUS_METHOD_NOT_ALLOWED: number;
+        HTTP_STATUS_NOT_ACCEPTABLE: number;
+        HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED: number;
+        HTTP_STATUS_REQUEST_TIMEOUT: number;
+        HTTP_STATUS_CONFLICT: number;
+        HTTP_STATUS_GONE: number;
+        HTTP_STATUS_LENGTH_REQUIRED: number;
+        HTTP_STATUS_PRECONDITION_FAILED: number;
+        HTTP_STATUS_PAYLOAD_TOO_LARGE: number;
+        HTTP_STATUS_URI_TOO_LONG: number;
+        HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE: number;
+        HTTP_STATUS_RANGE_NOT_SATISFIABLE: number;
+        HTTP_STATUS_EXPECTATION_FAILED: number;
+        HTTP_STATUS_TEAPOT: number;
+        HTTP_STATUS_MISDIRECTED_REQUEST: number;
+        HTTP_STATUS_UNPROCESSABLE_ENTITY: number;
+        HTTP_STATUS_LOCKED: number;
+        HTTP_STATUS_FAILED_DEPENDENCY: number;
+        HTTP_STATUS_UNORDERED_COLLECTION: number;
+        HTTP_STATUS_UPGRADE_REQUIRED: number;
+        HTTP_STATUS_PRECONDITION_REQUIRED: number;
+        HTTP_STATUS_TOO_MANY_REQUESTS: number;
+        HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE: number;
+        HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS: number;
+        HTTP_STATUS_INTERNAL_SERVER_ERROR: number;
+        HTTP_STATUS_NOT_IMPLEMENTED: number;
+        HTTP_STATUS_BAD_GATEWAY: number;
+        HTTP_STATUS_SERVICE_UNAVAILABLE: number;
+        HTTP_STATUS_GATEWAY_TIMEOUT: number;
+        HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED: number;
+        HTTP_STATUS_VARIANT_ALSO_NEGOTIATES: number;
+        HTTP_STATUS_INSUFFICIENT_STORAGE: number;
+        HTTP_STATUS_LOOP_DETECTED: number;
+        HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED: number;
+        HTTP_STATUS_NOT_EXTENDED: number;
+        HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED: number;
+    };
+
+    export function getDefaultSettings(): Settings;
+    export function getPackedSettings(settings: Settings): Settings;
+    export function getUnpackedSettings(buf: Buffer | Uint8Array): Settings;
+
+    export function createServer(onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2Server;
+    export function createServer(options: ServerOptions, onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2Server;
+
+    export function createSecureServer(onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2SecureServer;
+    export function createSecureServer(options: SecureServerOptions, onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2SecureServer;
+
+    export function connect(authority: string | url.URL, listener?: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): ClientHttp2Session;
+    export function connect(authority: string | url.URL, options?: ClientSessionOptions | SecureClientSessionOptions, listener?: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): ClientHttp2Session;
+}

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "8.0.22",
+    "version": "8.0.26",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -14,47 +14,63 @@
         },
         {
             "name": "Parambir Singh",
-            "url": "https://github.com/parambirs"
+            "url": "https://github.com/parambirs",
+            "githubUsername": "parambirs"
         },
         {
             "name": "Roberto Desideri",
-            "url": "https://github.com/RobDesideri"
+            "url": "https://github.com/RobDesideri",
+            "githubUsername": "RobDesideri"
         },
         {
             "name": "Christian Vaagland Tellnes",
-            "url": "https://github.com/tellnes"
+            "url": "https://github.com/tellnes",
+            "githubUsername": "tellnes"
         },
         {
             "name": "Wilco Bakker",
-            "url": "https://github.com/WilcoBakker"
+            "url": "https://github.com/WilcoBakker",
+            "githubUsername": "WilcoBakker"
         },
         {
             "name": "Nicolas Voigt",
-            "url": "https://github.com/octo-sniffle"
+            "url": "https://github.com/octo-sniffle",
+            "githubUsername": "octo-sniffle"
         },
         {
             "name": "Chigozirim C.",
-            "url": "https://github.com/smac89"
+            "url": "https://github.com/smac89",
+            "githubUsername": "smac89"
         },
         {
             "name": "Flarna",
-            "url": "https://github.com/Flarna"
+            "url": "https://github.com/Flarna",
+            "githubUsername": "Flarna"
         },
         {
             "name": "Mariusz Wiktorczyk",
-            "url": "https://github.com/mwiktorczyk"
+            "url": "https://github.com/mwiktorczyk",
+            "githubUsername": "mwiktorczyk"
         },
         {
             "name": "wwwy3y3",
-            "url": "https://github.com/wwwy3y3"
+            "url": "https://github.com/wwwy3y3",
+            "githubUsername": "wwwy3y3"
         },
         {
             "name": "Daniel Imms",
-            "url": "https://github.com/Tyriar"
+            "url": "https://github.com/Tyriar",
+            "githubUsername": "Tyriar"
         },
         {
             "name": "Deividas Bakanas",
-            "url": "https://github.com/DeividasBakanas"
+            "url": "https://github.com/DeividasBakanas",
+            "githubUsername": "DeividasBakanas"
+        },
+        {
+            "name": "Kelvin Jin",
+            "url": "https://github.com/kjin",
+            "githubUsername": "kjin"
         }
     ],
     "main": "",
@@ -64,7 +80,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "peerDependencies": {},
-    "typesPublisherContentHash": "4aee6926317d01e6fa3487f61da5431aef3d4ff2ce236d5b08ad1eb6c7435185",
+    "typesPublisherContentHash": "d58897114d5b8a61202a375762d0439e38ee2561924fe0907100ad241214937c",
     "typeScriptVersion": "2.2"
 }