@types/node 12.6.4 → 12.6.8

node/README.md

@@ -8,9 +8,9 @@ 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: Tue, 16 Jul 2019 17:19:16 GMT
+ * Last updated: Wed, 17 Jul 2019 19:14:44 GMT
  * Dependencies: none
  * Global values: Buffer, NodeJS, Symbol, __dirname, __filename, clearImmediate, clearInterval, clearTimeout, console, exports, global, module, process, queueMicrotask, require, setImmediate, setInterval, setTimeout
 
 # Credits
-These definitions were written by Microsoft TypeScript <https://github.com/Microsoft>, DefinitelyTyped <https://github.com/DefinitelyTyped>, Alberto Schiabel <https://github.com/jkomyno>, Alexander T. <https://github.com/a-tarasyuk>, Alvis HT Tang <https://github.com/alvis>, Andrew Makarov <https://github.com/r3nya>, Benjamin Toueg <https://github.com/btoueg>, Bruno Scheufler <https://github.com/brunoscheufler>, Chigozirim C. <https://github.com/smac89>, Christian Vaagland Tellnes <https://github.com/tellnes>, David Junger <https://github.com/touffy>, Deividas Bakanas <https://github.com/DeividasBakanas>, Eugene Y. Q. Shen <https://github.com/eyqs>, Flarna <https://github.com/Flarna>, Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>, Hoàng Văn Khải <https://github.com/KSXGitHub>, Huw <https://github.com/hoo29>, Kelvin Jin <https://github.com/kjin>, Klaus Meinhardt <https://github.com/ajafff>, Lishude <https://github.com/islishude>, Mariusz Wiktorczyk <https://github.com/mwiktorczyk>, Matthieu Sieben <https://github.com/matthieusieben>, Mohsen Azimi <https://github.com/mohsen1>, Nicolas Even <https://github.com/n-e>, Nicolas Voigt <https://github.com/octo-sniffle>, Parambir Singh <https://github.com/parambirs>, Sebastian Silbermann <https://github.com/eps1lon>, Simon Schick <https://github.com/SimonSchick>, Thomas den Hollander <https://github.com/ThomasdenH>, Wilco Bakker <https://github.com/WilcoBakker>, wwwy3y3 <https://github.com/wwwy3y3>, Zane Hannan AU <https://github.com/ZaneHannanAU>, Jeremie Rodriguez <https://github.com/jeremiergz>, Samuel Ainsworth <https://github.com/samuela>, Kyle Uehlein <https://github.com/kuehlein>, Jordi Oliveras Rovira <https://github.com/j-oliveras>, and Thanik Bhongbhibhat <https://github.com/bhongy>.
+These definitions were written by Microsoft TypeScript <https://github.com/Microsoft>, DefinitelyTyped <https://github.com/DefinitelyTyped>, Alberto Schiabel <https://github.com/jkomyno>, Alexander T. <https://github.com/a-tarasyuk>, Alvis HT Tang <https://github.com/alvis>, Andrew Makarov <https://github.com/r3nya>, Benjamin Toueg <https://github.com/btoueg>, Bruno Scheufler <https://github.com/brunoscheufler>, Chigozirim C. <https://github.com/smac89>, Christian Vaagland Tellnes <https://github.com/tellnes>, David Junger <https://github.com/touffy>, Deividas Bakanas <https://github.com/DeividasBakanas>, Eugene Y. Q. Shen <https://github.com/eyqs>, Flarna <https://github.com/Flarna>, Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>, Hoàng Văn Khải <https://github.com/KSXGitHub>, Huw <https://github.com/hoo29>, Kelvin Jin <https://github.com/kjin>, Klaus Meinhardt <https://github.com/ajafff>, Lishude <https://github.com/islishude>, Mariusz Wiktorczyk <https://github.com/mwiktorczyk>, Matthieu Sieben <https://github.com/matthieusieben>, Mohsen Azimi <https://github.com/mohsen1>, Nicolas Even <https://github.com/n-e>, Nicolas Voigt <https://github.com/octo-sniffle>, Parambir Singh <https://github.com/parambirs>, Sebastian Silbermann <https://github.com/eps1lon>, Simon Schick <https://github.com/SimonSchick>, Thomas den Hollander <https://github.com/ThomasdenH>, Wilco Bakker <https://github.com/WilcoBakker>, wwwy3y3 <https://github.com/wwwy3y3>, Zane Hannan AU <https://github.com/ZaneHannanAU>, Samuel Ainsworth <https://github.com/samuela>, Kyle Uehlein <https://github.com/kuehlein>, Jordi Oliveras Rovira <https://github.com/j-oliveras>, and Thanik Bhongbhibhat <https://github.com/bhongy>.

node/buffer.d.ts

@@ -10,7 +10,7 @@ declare module "buffer" {
 
     export type TranscodeEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "latin1" | "binary";
 
-    export function transcode(source: Buffer | Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
+    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
 
     export const SlowBuffer: {
         /** @deprecated since v6.0.0, use Buffer.allocUnsafeSlow() */

node/child_process.d.ts

@@ -296,7 +296,7 @@ declare module "child_process" {
 
     interface SpawnSyncOptions extends CommonOptions {
         argv0?: string; // Not specified in the docs
-        input?: string | Buffer | NodeJS.TypedArray | DataView;
+        input?: string | NodeJS.TypedArray | DataView;
         stdio?: StdioOptions;
         killSignal?: string | number;
         maxBuffer?: number;
@@ -328,7 +328,7 @@ declare module "child_process" {
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
 
     interface ExecSyncOptions extends CommonOptions {
-        input?: string | Buffer | Uint8Array;
+        input?: string | Uint8Array;
         stdio?: StdioOptions;
         shell?: string;
         killSignal?: string | number;
@@ -347,7 +347,7 @@ declare module "child_process" {
     function execSync(command: string, options?: ExecSyncOptions): Buffer;
 
     interface ExecFileSyncOptions extends CommonOptions {
-        input?: string | Buffer | NodeJS.TypedArray | DataView;
+        input?: string | NodeJS.TypedArray | DataView;
         stdio?: StdioOptions;
         killSignal?: string | number;
         maxBuffer?: number;

node/crypto.d.ts

@@ -159,7 +159,7 @@ declare module "crypto" {
     type CipherCCMTypes = 'aes-128-ccm' | 'aes-192-ccm' | 'aes-256-ccm';
     type CipherGCMTypes = 'aes-128-gcm' | 'aes-192-gcm' | 'aes-256-gcm';
 
-    type Binary = Buffer | NodeJS.TypedArray | DataView;
+    type Binary = NodeJS.TypedArray | DataView;
     type BinaryLike = string | Binary;
 
     type CipherKey = BinaryLike | KeyObject;
@@ -296,7 +296,7 @@ declare module "crypto" {
         sign(private_key: SignPrivateKeyInput | KeyLike, output_format: HexBase64Latin1Encoding): string;
     }
 
-    function createVerify(algorith: string, options?: stream.WritableOptions): Verify;
+    function createVerify(algorithm: string, options?: stream.WritableOptions): Verify;
     class Verify extends stream.Writable {
         private constructor();
 

node/dgram.d.ts

@@ -34,8 +34,8 @@ declare module "dgram" {
     function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
 
     class Socket extends events.EventEmitter {
-        send(msg: Buffer | string | Uint8Array | any[], port: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
-        send(msg: Buffer | string | Uint8Array, offset: number, length: number, port: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | any[], port: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array, 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;

node/fs.d.ts

@@ -8,7 +8,7 @@ declare module "fs" {
      */
     type PathLike = string | Buffer | URL;
 
-    type BinaryData = Buffer | DataView | NodeJS.TypedArray;
+    type BinaryData = DataView | NodeJS.TypedArray;
     class Stats {
         isFile(): boolean;
         isDirectory(): boolean;
@@ -1724,6 +1724,7 @@ declare module "fs" {
         mode?: number;
         autoClose?: boolean;
         start?: number;
+        highWaterMark?: number;
     }): WriteStream;
 
     /**
@@ -1846,7 +1847,7 @@ declare module "fs" {
              * @param length The number of bytes to read.
              * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
              */
-            read<TBuffer extends Buffer | Uint8Array>(buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null): Promise<{ bytesRead: number, buffer: TBuffer }>;
+            read<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null): Promise<{ bytesRead: number, buffer: TBuffer }>;
 
             /**
              * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
@@ -1898,7 +1899,7 @@ declare module "fs" {
              * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
              * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
              */
-            write<TBuffer extends Buffer | Uint8Array>(buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null): Promise<{ bytesWritten: number, buffer: TBuffer }>;
+            write<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null): Promise<{ bytesWritten: number, buffer: TBuffer }>;
 
             /**
              * Asynchronously writes `string` to the file.
@@ -1967,7 +1968,7 @@ declare module "fs" {
          * @param position The offset from the beginning of the file from which data should be read. If
          * `null`, data will be read from the current position.
          */
-        function read<TBuffer extends Buffer | Uint8Array>(
+        function read<TBuffer extends Uint8Array>(
             handle: FileHandle,
             buffer: TBuffer,
             offset?: number | null,
@@ -1985,7 +1986,7 @@ declare module "fs" {
          * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
          * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
          */
-        function write<TBuffer extends Buffer | Uint8Array>(
+        function write<TBuffer extends Uint8Array>(
             handle: FileHandle,
             buffer: TBuffer,
             offset?: number | null,

node/globals.d.ts

@@ -238,81 +238,9 @@ declare var exports: any;
 
 // Buffer class
 type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
-interface Buffer extends Uint8Array {
+
+interface Buffer {
     constructor: typeof Buffer;
-    write(string: string, encoding?: BufferEncoding): number;
-    write(string: string, offset: number, encoding?: BufferEncoding): number;
-    write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
-    toString(encoding?: string, start?: number, end?: number): string;
-    toJSON(): { type: 'Buffer', data: number[] };
-    equals(otherBuffer: Uint8Array): boolean;
-    compare(otherBuffer: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
-    copy(targetBuffer: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
-    /**
-     * Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
-     *
-     * This method is incompatible with `Uint8Array#slice()`, which returns a copy of the original memory.
-     *
-     * @param begin Where the new `Buffer` will start. Default: `0`.
-     * @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
-     */
-    slice(begin?: number, end?: number): Buffer;
-    /**
-     * Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
-     *
-     * This method is compatible with `Uint8Array#subarray()`.
-     *
-     * @param begin Where the new `Buffer` will start. Default: `0`.
-     * @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
-     */
-    subarray(begin?: number, end?: number): Buffer;
-    writeUIntLE(value: number, offset: number, byteLength: number): number;
-    writeUIntBE(value: number, offset: number, byteLength: number): number;
-    writeIntLE(value: number, offset: number, byteLength: number): number;
-    writeIntBE(value: number, offset: number, byteLength: number): number;
-    readUIntLE(offset: number, byteLength: number): number;
-    readUIntBE(offset: number, byteLength: number): number;
-    readIntLE(offset: number, byteLength: number): number;
-    readIntBE(offset: number, byteLength: number): number;
-    readUInt8(offset: number): number;
-    readUInt16LE(offset: number): number;
-    readUInt16BE(offset: number): number;
-    readUInt32LE(offset: number): number;
-    readUInt32BE(offset: number): number;
-    readInt8(offset: number): number;
-    readInt16LE(offset: number): number;
-    readInt16BE(offset: number): number;
-    readInt32LE(offset: number): number;
-    readInt32BE(offset: number): number;
-    readFloatLE(offset: number): number;
-    readFloatBE(offset: number): number;
-    readDoubleLE(offset: number): number;
-    readDoubleBE(offset: number): number;
-    reverse(): this;
-    swap16(): Buffer;
-    swap32(): Buffer;
-    swap64(): Buffer;
-    writeUInt8(value: number, offset: number): number;
-    writeUInt16LE(value: number, offset: number): number;
-    writeUInt16BE(value: number, offset: number): number;
-    writeUInt32LE(value: number, offset: number): number;
-    writeUInt32BE(value: number, offset: number): number;
-    writeInt8(value: number, offset: number): number;
-    writeInt16LE(value: number, offset: number): number;
-    writeInt16BE(value: number, offset: number): number;
-    writeInt32LE(value: number, offset: number): number;
-    writeInt32BE(value: number, offset: number): number;
-    writeFloatLE(value: number, offset: number): number;
-    writeFloatBE(value: number, offset: number): number;
-    writeDoubleLE(value: number, offset: number): number;
-    writeDoubleBE(value: number, offset: number): number;
-    fill(value: any, offset?: number, end?: number): this;
-    indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
-    lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
-    entries(): IterableIterator<[number, number]>;
-    includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
-    keys(): IterableIterator<number>;
-    values(): IterableIterator<number>;
 }
 
 /**
@@ -320,7 +248,7 @@ interface Buffer extends Uint8Array {
  * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.  A Buffer cannot be resized.
  * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
  */
-declare const Buffer: {
+declare class Buffer extends Uint8Array {
     /**
      * Allocates a new buffer containing the given {str}.
      *
@@ -328,21 +256,21 @@ declare const Buffer: {
      * @param encoding encoding to use, optional.  Default is 'utf8'
      * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
      */
-    new (str: string, encoding?: BufferEncoding): Buffer;
+    constructor(str: string, encoding?: BufferEncoding);
     /**
      * Allocates a new buffer of {size} octets.
      *
      * @param size count of octets to allocate.
      * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
      */
-    new (size: number): Buffer;
+    constructor(size: number);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
      */
-    new (array: Uint8Array): Buffer;
+    constructor(array: Uint8Array);
     /**
      * Produces a Buffer backed by the same allocated memory as
      * the given {ArrayBuffer}/{SharedArrayBuffer}.
@@ -351,22 +279,21 @@ declare const Buffer: {
      * @param arrayBuffer The ArrayBuffer with which to share memory.
      * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
      */
-    new (arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
+    constructor(arrayBuffer: ArrayBuffer | SharedArrayBuffer);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
      */
-    new (array: any[]): Buffer;
+    constructor(array: any[]);
     /**
      * Copies the passed {buffer} data onto a new {Buffer} instance.
      *
      * @param buffer The buffer to copy.
      * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
      */
-    new (buffer: Buffer): Buffer;
-    prototype: Buffer;
+    constructor(buffer: Buffer);
     /**
      * When passed a reference to the .buffer property of a TypedArray instance,
      * the newly created Buffer will share the same allocated memory as the TypedArray.
@@ -375,37 +302,37 @@ declare const Buffer: {
      *
      * @param arrayBuffer The .buffer property of any TypedArray or a new ArrayBuffer()
      */
-    from(arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer;
+    static from(arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer;
     /**
      * Creates a new Buffer using the passed {data}
      * @param data data to create a new Buffer
      */
-    from(data: number[]): Buffer;
-    from(data: Uint8Array): Buffer;
+    static from(data: number[]): Buffer;
+    static from(data: Uint8Array): Buffer;
     /**
      * Creates a new Buffer containing the given JavaScript string {str}.
      * If provided, the {encoding} parameter identifies the character encoding.
      * If not provided, {encoding} defaults to 'utf8'.
      */
-    from(str: string, encoding?: BufferEncoding): Buffer;
+    static from(str: string, encoding?: BufferEncoding): Buffer;
     /**
      * Creates a new Buffer using the passed {data}
      * @param values to create a new Buffer
      */
-    of(...items: number[]): Buffer;
+    static of(...items: number[]): Buffer;
     /**
      * Returns true if {obj} is a Buffer
      *
      * @param obj object to test.
      */
-    isBuffer(obj: any): obj is Buffer;
+    static isBuffer(obj: any): obj is Buffer;
     /**
      * Returns true if {encoding} is a valid encoding argument.
      * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
      *
      * @param encoding string to test.
      */
-    isEncoding(encoding: string): encoding is BufferEncoding;
+    static isEncoding(encoding: string): encoding is BufferEncoding;
     /**
      * Gives the actual byte length of a string. encoding defaults to 'utf8'.
      * This is not the same as String.prototype.length since that returns the number of characters in a string.
@@ -413,7 +340,7 @@ declare const Buffer: {
      * @param string string to test.
      * @param encoding encoding used to evaluate (defaults to 'utf8')
      */
-    byteLength(
+    static byteLength(
         string: string | NodeJS.TypedArray | DataView | ArrayBuffer | SharedArrayBuffer,
         encoding?: BufferEncoding
     ): number;
@@ -428,11 +355,11 @@ declare const Buffer: {
      * @param totalLength Total length of the buffers when concatenated.
      *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
      */
-    concat(list: Uint8Array[], totalLength?: number): Buffer;
+    static concat(list: Uint8Array[], totalLength?: number): Buffer;
     /**
      * The same as buf1.compare(buf2).
      */
-    compare(buf1: Uint8Array, buf2: Uint8Array): number;
+    static compare(buf1: Uint8Array, buf2: Uint8Array): number;
     /**
      * Allocates a new buffer of {size} octets.
      *
@@ -441,26 +368,108 @@ declare const Buffer: {
      *    If parameter is omitted, buffer will be filled with zeros.
      * @param encoding encoding used for call to buf.fill while initalizing
      */
-    alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
+    static alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
     /**
      * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
      * of the newly created Buffer are unknown and may contain sensitive data.
      *
      * @param size count of octets to allocate
      */
-    allocUnsafe(size: number): Buffer;
+    static allocUnsafe(size: number): Buffer;
     /**
      * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
      * of the newly created Buffer are unknown and may contain sensitive data.
      *
      * @param size count of octets to allocate
      */
-    allocUnsafeSlow(size: number): Buffer;
+    static allocUnsafeSlow(size: number): Buffer;
     /**
      * This is the number of bytes used to determine the size of pre-allocated, internal Buffer instances used for pooling. This value may be modified.
      */
-    poolSize: number;
-};
+    static poolSize: number;
+
+    write(string: string, encoding?: BufferEncoding): number;
+    write(string: string, offset: number, encoding?: BufferEncoding): number;
+    write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    toJSON(): { type: 'Buffer'; data: number[] };
+    equals(otherBuffer: Uint8Array): boolean;
+    compare(
+        otherBuffer: Uint8Array,
+        targetStart?: number,
+        targetEnd?: number,
+        sourceStart?: number,
+        sourceEnd?: number
+    ): number;
+    copy(targetBuffer: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    /**
+     * Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
+     *
+     * This method is incompatible with `Uint8Array#slice()`, which returns a copy of the original memory.
+     *
+     * @param begin Where the new `Buffer` will start. Default: `0`.
+     * @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
+     */
+    slice(begin?: number, end?: number): Buffer;
+    /**
+     * Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
+     *
+     * This method is compatible with `Uint8Array#subarray()`.
+     *
+     * @param begin Where the new `Buffer` will start. Default: `0`.
+     * @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
+     */
+    subarray(begin?: number, end?: number): Buffer;
+    writeUIntLE(value: number, offset: number, byteLength: number): number;
+    writeUIntBE(value: number, offset: number, byteLength: number): number;
+    writeIntLE(value: number, offset: number, byteLength: number): number;
+    writeIntBE(value: number, offset: number, byteLength: number): number;
+    readUIntLE(offset: number, byteLength: number): number;
+    readUIntBE(offset: number, byteLength: number): number;
+    readIntLE(offset: number, byteLength: number): number;
+    readIntBE(offset: number, byteLength: number): number;
+    readUInt8(offset: number): number;
+    readUInt16LE(offset: number): number;
+    readUInt16BE(offset: number): number;
+    readUInt32LE(offset: number): number;
+    readUInt32BE(offset: number): number;
+    readInt8(offset: number): number;
+    readInt16LE(offset: number): number;
+    readInt16BE(offset: number): number;
+    readInt32LE(offset: number): number;
+    readInt32BE(offset: number): number;
+    readFloatLE(offset: number): number;
+    readFloatBE(offset: number): number;
+    readDoubleLE(offset: number): number;
+    readDoubleBE(offset: number): number;
+    reverse(): this;
+    swap16(): Buffer;
+    swap32(): Buffer;
+    swap64(): Buffer;
+    writeUInt8(value: number, offset: number): number;
+    writeUInt16LE(value: number, offset: number): number;
+    writeUInt16BE(value: number, offset: number): number;
+    writeUInt32LE(value: number, offset: number): number;
+    writeUInt32BE(value: number, offset: number): number;
+    writeInt8(value: number, offset: number): number;
+    writeInt16LE(value: number, offset: number): number;
+    writeInt16BE(value: number, offset: number): number;
+    writeInt32LE(value: number, offset: number): number;
+    writeInt32BE(value: number, offset: number): number;
+    writeFloatLE(value: number, offset: number): number;
+    writeFloatBE(value: number, offset: number): number;
+    writeDoubleLE(value: number, offset: number): number;
+    writeDoubleBE(value: number, offset: number): number;
+
+    fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
+
+    indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+    lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+    entries(): IterableIterator<[number, number]>;
+    includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<number>;
+}
 
 /*----------------------------------------------*
 *                                               *
@@ -626,17 +635,17 @@ declare namespace NodeJS {
         isPaused(): boolean;
         pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
         unpipe(destination?: WritableStream): this;
-        unshift(chunk: string | Buffer | Uint8Array, encoding?: BufferEncoding): void;
+        unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
         wrap(oldStream: ReadableStream): this;
         [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
     }
 
     interface WritableStream extends EventEmitter {
         writable: boolean;
-        write(buffer: Buffer | Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        write(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(data: string | Uint8Array, cb?: () => void): void;
         end(str: string, encoding?: string, cb?: () => void): void;
     }
 
@@ -863,7 +872,7 @@ declare namespace NodeJS {
         emitWarning(warning: string | Error, name?: string, ctor?: Function): void;
         env: ProcessEnv;
         exit(code?: number): never;
-        exitCode: number;
+        exitCode?: number;
         getgid(): number;
         setgid(id: number | string): void;
         getuid(): number;

node/http2.d.ts

@@ -656,8 +656,8 @@ declare module "http2" {
         addTrailers(trailers: OutgoingHttpHeaders): void;
         readonly connection: net.Socket | tls.TLSSocket;
         end(callback?: () => void): void;
-        end(data: string | Buffer | Uint8Array, callback?: () => void): void;
-        end(data: string | Buffer | Uint8Array, encoding: string, callback?: () => void): void;
+        end(data: string | Uint8Array, callback?: () => void): void;
+        end(data: string | Uint8Array, encoding: string, callback?: () => void): void;
         readonly finished: boolean;
         getHeader(name: string): string;
         getHeaderNames(): string[];
@@ -672,8 +672,8 @@ declare module "http2" {
         statusCode: number;
         statusMessage: '';
         readonly stream: ServerHttp2Stream;
-        write(chunk: string | Buffer | Uint8Array, callback?: (err: Error) => void): boolean;
-        write(chunk: string | Buffer | Uint8Array, encoding: string, callback?: (err: Error) => void): boolean;
+        write(chunk: string | Uint8Array, callback?: (err: Error) => void): boolean;
+        write(chunk: string | Uint8Array, encoding: string, callback?: (err: Error) => void): boolean;
         writeContinue(): void;
         writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this;
         writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders): this;
@@ -943,7 +943,7 @@ declare module "http2" {
 
     export function getDefaultSettings(): Settings;
     export function getPackedSettings(settings: Settings): Buffer;
-    export function getUnpackedSettings(buf: Buffer | Uint8Array): Settings;
+    export function getUnpackedSettings(buf: Uint8Array): Settings;
 
     export function createServer(onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2Server;
     export function createServer(options: ServerOptions, onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void): Http2Server;

node/index.d.ts

@@ -32,7 +32,6 @@
 //                 Wilco Bakker <https://github.com/WilcoBakker>
 //                 wwwy3y3 <https://github.com/wwwy3y3>
 //                 Zane Hannan AU <https://github.com/ZaneHannanAU>
-//                 Jeremie Rodriguez <https://github.com/jeremiergz>
 //                 Samuel Ainsworth <https://github.com/samuela>
 //                 Kyle Uehlein <https://github.com/kuehlein>
 //                 Jordi Oliveras Rovira <https://github.com/j-oliveras>

node/net.d.ts

@@ -38,8 +38,8 @@ declare module "net" {
         constructor(options?: SocketConstructorOpts);
 
         // Extended base methods
-        write(buffer: Buffer | Uint8Array | string, cb?: (err?: Error) => void): boolean;
-        write(str: Buffer | Uint8Array | string, encoding?: string, cb?: (err?: Error) => void): boolean;
+        write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+        write(str: Uint8Array | string, encoding?: string, cb?: (err?: Error) => void): boolean;
 
         connect(options: SocketConnectOpts, connectionListener?: () => void): this;
         connect(port: number, host: string, connectionListener?: () => void): this;
@@ -69,8 +69,8 @@ declare module "net" {
 
         // Extended base methods
         end(cb?: () => void): void;
-        end(buffer: Buffer | Uint8Array | string, cb?: () => void): void;
-        end(str: Buffer | Uint8Array | string, encoding?: string, cb?: () => void): void;
+        end(buffer: Uint8Array | string, cb?: () => void): void;
+        end(str: Uint8Array | string, encoding?: string, cb?: () => void): void;
 
         /**
          * events.EventEmitter

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "12.6.4",
+    "version": "12.6.8",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -164,11 +164,6 @@
             "url": "https://github.com/ZaneHannanAU",
             "githubUsername": "ZaneHannanAU"
         },
-        {
-            "name": "Jeremie Rodriguez",
-            "url": "https://github.com/jeremiergz",
-            "githubUsername": "jeremiergz"
-        },
         {
             "name": "Samuel Ainsworth",
             "url": "https://github.com/samuela",
@@ -206,6 +201,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "55e1dd2b48fbe58beb147b8157e825fd0074b7568f51f551ca1c7ada156dc083",
+    "typesPublisherContentHash": "8630266379794ffe5826422974749423e8d09e4d652e641cbf6ade81782c32af",
     "typeScriptVersion": "2.0"
 }

node/string_decoder.d.ts

@@ -1,9 +1,7 @@
 declare module "string_decoder" {
-    interface NodeStringDecoder {
+    class StringDecoder {
+        constructor(encoding?: string);
         write(buffer: Buffer): string;
         end(buffer?: Buffer): string;
     }
-    const StringDecoder: {
-        new(encoding?: string): NodeStringDecoder;
-    };
 }

node/tls.d.ts

@@ -245,7 +245,7 @@ declare module "tls" {
          * An array of strings or a Buffer naming possible ALPN protocols.
          * (Protocols should be ordered by their priority.)
          */
-        ALPNProtocols?: string[] | Buffer[] | Uint8Array[] | Buffer | Uint8Array;
+        ALPNProtocols?: string[] | Uint8Array[] | Uint8Array;
         /**
          * SNICallback(servername, cb) <Function> A function that will be
          * called if the client supports SNI TLS extension. Two arguments
@@ -262,7 +262,7 @@ declare module "tls" {
          * effect if requestCert is true.
          * @default true
          */
-        rejectUnauthorized?: boolean; // Defaults to true
+        rejectUnauthorized?: boolean;
     }
 
     interface TlsOptions extends SecureContextOptions, CommonConnectionOptions {

node/zlib.d.ts

@@ -18,7 +18,7 @@ declare module "zlib" {
         level?: number; // compression only
         memLevel?: number; // compression only
         strategy?: number; // compression only
-        dictionary?: Buffer | NodeJS.TypedArray | DataView | ArrayBuffer; // deflate/inflate only, empty dictionary by default
+        dictionary?: NodeJS.TypedArray | DataView | ArrayBuffer; // deflate/inflate only, empty dictionary by default
     }
 
     interface BrotliOptions {
@@ -79,7 +79,7 @@ declare module "zlib" {
     function createInflateRaw(options?: ZlibOptions): InflateRaw;
     function createUnzip(options?: ZlibOptions): Unzip;
 
-    type InputType = string | Buffer | DataView | ArrayBuffer | NodeJS.TypedArray;
+    type InputType = string | DataView | ArrayBuffer | NodeJS.TypedArray;
 
     type CompressCallback = (error: Error | null, result: Buffer) => void;