@types/node 12.12.69 → 12.19.2

{node v12.12 → node v12.19}/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (http://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v12.
 
 ### Additional Details
- * Last updated: Tue, 20 Oct 2020 12:09:03 GMT
+ * Last updated: Mon, 26 Oct 2020 22:58:17 GMT
  * Dependencies: none
  * Global values: `Buffer`, `NodeJS`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

{node v12.12 → node v12.19}/assert.d.ts

@@ -19,6 +19,24 @@ declare module 'assert' {
             });
         }
 
+        class CallTracker {
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            report(): CallTrackerReportInformation[];
+            verify(): void;
+        }
+        interface CallTrackerReportInformation {
+            message: string;
+            /** The actual number of times the function was called. */
+            actual: number;
+            /** The number of times the function was expected to be called. */
+            expected: number;
+            /** The name of the function that is wrapped. */
+            operator: string;
+            /** A stack trace of the function. */
+            stack: object;
+        }
+
         function fail(message?: string | Error): never;
         /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
         function fail(

{node v12.12 → node v12.19}/async_hooks.d.ts

@@ -115,6 +115,19 @@ declare module "async_hooks" {
          */
         constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
 
+        /**
+         * Binds the given function to the current execution context.
+         * @param fn The function to bind to the current execution context.
+         * @param type An optional name to associate with the underlying `AsyncResource`.
+         */
+        static bind<Func extends (...args: any[]) => any>(fn: Func, type?: string): Func & { asyncResource: AsyncResource };
+
+        /**
+         * Binds the given function to execute to this `AsyncResource`'s scope.
+         * @param fn The function to bind to the current `AsyncResource`.
+         */
+        bind<Func extends (...args: any[]) => any>(fn: Func): Func & { asyncResource: AsyncResource };
+
         /**
          * Call the provided function with the provided arguments in the
          * execution context of the async resource. This will establish the
@@ -209,20 +222,6 @@ declare module "async_hooks" {
          */
         exit(callback: (...args: any[]) => void, ...args: any[]): void;
 
-        /**
-         * This methods runs a function synchronously within a context and return its
-         * return value. The store is not accessible outside of the callback function or
-         * the asynchronous operations created within the callback.
-         *
-         * Optionally, arguments can be passed to the function. They will be passed to
-         * the callback function.
-         *
-         * If the callback function throws an error, it will be thrown by
-         * `runSyncAndReturn` too. The stacktrace will not be impacted by this call and
-         * the context will be exited.
-         */
-        runSyncAndReturn<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
-
         /**
          * This methods runs a function synchronously outside of a context and return its
          * return value. The store is not accessible within the callback function or

{node v12.12 → node v12.19}/crypto.d.ts

@@ -368,6 +368,11 @@ declare module "crypto" {
     function pseudoRandomBytes(size: number): Buffer;
     function pseudoRandomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
 
+    function randomInt(max: number): number;
+    function randomInt(min: number, max: number): number;
+    function randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
+    function randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
+
     function randomFillSync<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number, size?: number): T;
     function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
     function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, offset: number, callback: (err: Error | null, buf: T) => void): void;

{node v12.12 → node v12.19}/fs.d.ts

@@ -346,6 +346,39 @@ declare module "fs" {
      */
     function lchownSync(path: PathLike, uid: number, gid: number): void;
 
+    /**
+     * Changes the access and modification times of a file in the same way as `fs.utimes()`,
+     * with the difference that if the path refers to a symbolic link, then the link is not
+     * dereferenced: instead, the timestamps of the symbolic link itself are changed.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * @param atime The last access time. If a string is provided, it will be coerced to number.
+     * @param mtime The last modified time. If a string is provided, it will be coerced to number.
+     */
+    function lutimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date, callback: NoParamCallback): void;
+
+    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
+    namespace lutimes {
+        /**
+         * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`,
+         * with the difference that if the path refers to a symbolic link, then the link is not
+         * dereferenced: instead, the timestamps of the symbolic link itself are changed.
+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+         * @param atime The last access time. If a string is provided, it will be coerced to number.
+         * @param mtime The last modified time. If a string is provided, it will be coerced to number.
+         */
+        function __promisify__(path: PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    }
+
+    /**
+     * Change the file system timestamps of the symbolic link referenced by `path`. Returns `undefined`,
+     * or throws an exception when parameters are incorrect or the operation fails.
+     * This is the synchronous version of `fs.lutimes()`.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * @param atime The last access time. If a string is provided, it will be coerced to number.
+     * @param mtime The last modified time. If a string is provided, it will be coerced to number.
+     */
+    function lutimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void;
+
     /**
      * Asynchronous chmod(2) - Change permissions of a file.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -2324,6 +2357,16 @@ declare module "fs" {
          */
         function lchown(path: PathLike, uid: number, gid: number): Promise<void>;
 
+        /**
+         * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`,
+         * with the difference that if the path refers to a symbolic link, then the link is not
+         * dereferenced: instead, the timestamps of the symbolic link itself are changed.
+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+         * @param atime The last access time. If a string is provided, it will be coerced to number.
+         * @param mtime The last modified time. If a string is provided, it will be coerced to number.
+         */
+        function lutimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+
         /**
          * Asynchronous fchown(2) - Change ownership of a file.
          * @param handle A `FileHandle`.

{node v12.12 → node v12.19}/globals.d.ts

@@ -934,10 +934,16 @@ declare namespace NodeJS {
             tls_ocsp: boolean;
             tls: boolean;
         };
+        /**
+         * @deprecated since v12.19.0 - Calling process.umask() with no argument causes
+         * the process-wide umask to be written twice. This introduces a race condition between threads,
+         * and is a potential security vulnerability. There is no safe, cross-platform alternative API.
+         */
+        umask(): number;
         /**
          * Can only be set if not in worker thread.
          */
-        umask(mask?: number): number;
+        umask(mask: string | number): number;
         uptime(): number;
         hrtime: HRTime;
         domain: Domain;
@@ -1140,6 +1146,7 @@ declare namespace NodeJS {
         ref(): this;
         refresh(): this;
         unref(): this;
+        [Symbol.toPrimitive](): number;
     }
 
     class Immediate {
@@ -1154,6 +1161,7 @@ declare namespace NodeJS {
         ref(): this;
         refresh(): this;
         unref(): this;
+        [Symbol.toPrimitive](): number;
     }
 
     class Module {
@@ -1174,7 +1182,8 @@ declare namespace NodeJS {
         id: string;
         filename: string;
         loaded: boolean;
-        parent: Module | null;
+        /** @deprecated since 12.19.0 Please use `require.main` and `module.children` instead. */
+        parent: Module | null | undefined;
         children: Module[];
         /**
          * @since 11.14.0

{node v12.12 → node v12.19}/http.d.ts

@@ -177,7 +177,9 @@ declare module "http" {
     class ClientRequest extends OutgoingMessage {
         connection: Socket;
         socket: Socket;
-        aborted: number;
+        aborted: boolean;
+        host: string;
+        protocol: string;
 
         constructor(url: string | URL | ClientRequestArgs, cb?: (res: IncomingMessage) => void);
 
@@ -317,6 +319,10 @@ declare module "http" {
          * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
          */
         maxSockets?: number;
+        /**
+         * Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. Default: Infinity.
+         */
+        maxTotalSockets?: number;
         /**
          * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
          */
@@ -330,6 +336,7 @@ declare module "http" {
     class Agent {
         maxFreeSockets: number;
         maxSockets: number;
+        maxTotalSockets: number;
         readonly sockets: {
             readonly [key: string]: Socket[];
         };

{node v12.12 → node v12.19}/index.d.ts

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

{node v12.12 → node v12.19}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "12.12.69",
+    "version": "12.19.2",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -231,6 +231,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "61f7351a46af6aef73c34b6ed0d1789f50c9388d0eba62b56b8261433f176b58",
+    "typesPublisherContentHash": "1b26fba776dabe6181a3dbeafb1ab140da716d7a38c58f85a8915c13e0d805a6",
     "typeScriptVersion": "3.2"
 }

{node v12.12 → node v12.19}/perf_hooks.d.ts

@@ -45,6 +45,11 @@ declare module "perf_hooks" {
          */
         readonly environment: number;
 
+        /**
+         * The high resolution millisecond timestamp at which the Node.js environment was initialized.
+         */
+        readonly idleTime: number;
+
         /**
          * The high resolution millisecond timestamp at which the Node.js event loop exited.
          * If the event loop has not yet exited, the property has the value of -1.
@@ -69,6 +74,12 @@ declare module "perf_hooks" {
         readonly v8Start: number;
     }
 
+    interface EventLoopUtilization {
+        idle: number;
+        active: number;
+        utilization: number;
+    }
+
     interface Performance {
         /**
          * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
@@ -124,6 +135,16 @@ declare module "perf_hooks" {
          * @param fn
          */
         timerify<T extends (...optionalParams: any[]) => any>(fn: T): T;
+
+        /**
+         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
+         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
+         * No other CPU idle time is taken into consideration.
+         *
+         * @param util1 The result of a previous call to eventLoopUtilization()
+         * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
+         */
+        eventLoopUtilization(util1?: EventLoopUtilization, util2?: EventLoopUtilization): EventLoopUtilization;
     }
 
     interface PerformanceObserverEntryList {

{node v12.12 → node v12.19}/repl.d.ts

@@ -131,13 +131,21 @@ declare module "repl" {
          */
         readonly context: Context;
         /**
-         * The `Readable` stream from which REPL input will be read.
+         * Outdated alias for `input`.
          */
         readonly inputStream: NodeJS.ReadableStream;
         /**
-         * The `Writable` stream to which REPL output will be written.
+         * Outdated alias for `output`.
          */
         readonly outputStream: NodeJS.WritableStream;
+        /**
+         * The `Readable` stream from which REPL input will be read.
+         */
+        readonly input: NodeJS.ReadableStream;
+        /**
+         * The `Writable` stream to which REPL output will be written.
+         */
+        readonly output: NodeJS.WritableStream;
         /**
          * The commands registered via `replServer.defineCommand()`.
          */

{node v12.12 → node v12.19}/tls.d.ts

@@ -641,6 +641,17 @@ declare module "tls" {
          * shared between applications. Unused by clients.
          */
         sessionIdContext?: string;
+        /**
+         * 48-bytes of cryptographically strong pseudo-random data.
+         * See Session Resumption for more information.
+         */
+        ticketKeys?: Buffer;
+        /**
+         * The number of seconds after which a TLS session created by the
+         * server will no longer be resumable. See Session Resumption for more
+         * information. Default: 300.
+         */
+        sessionTimeout?: number;
     }
 
     interface SecureContext {
@@ -664,7 +675,7 @@ declare module "tls" {
      * @deprecated
      */
     function createSecurePair(credentials?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
-    function createSecureContext(details: SecureContextOptions): SecureContext;
+    function createSecureContext(options?: SecureContextOptions): SecureContext;
     function getCiphers(): string[];
 
     /**

{node v12.12 → node v12.19}/worker_threads.d.ts

@@ -2,6 +2,7 @@ declare module "worker_threads" {
     import { Context } from "vm";
     import { EventEmitter } from "events";
     import { Readable, Writable } from "stream";
+    import { promises } from "fs";
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -15,7 +16,7 @@ declare module "worker_threads" {
         readonly port2: MessagePort;
     }
 
-    type TransferListItem = ArrayBuffer | MessagePort;
+    type TransferListItem = ArrayBuffer | MessagePort | promises.FileHandle;
 
     class MessagePort extends EventEmitter {
         close(): void;
@@ -70,6 +71,7 @@ declare module "worker_threads" {
          * Additional data to send in the first worker message.
          */
         transferList?: TransferListItem[];
+        trackUnmanagedFds?: boolean;
     }
 
     interface ResourceLimits {
@@ -85,6 +87,11 @@ declare module "worker_threads" {
          * The size of a pre-allocated memory range used for generated code.
          */
         codeRangeSizeMb?: number;
+        /**
+         * The default maximum stack size for the thread. Small values may lead to unusable Worker instances.
+         * @default 4
+         */
+        stackSizeMb?: number;
     }
 
     class Worker extends EventEmitter {
@@ -92,6 +99,7 @@ declare module "worker_threads" {
         readonly stdout: Readable;
         readonly stderr: Readable;
         readonly threadId: number;
+        readonly resourceLimits?: ResourceLimits;
 
         constructor(filename: string, options?: WorkerOptions);
 
@@ -107,52 +115,72 @@ declare module "worker_threads" {
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (exitCode: number) => void): this;
         addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: "messageerror", listener: (error: Error) => void): this;
         addListener(event: "online", listener: () => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         emit(event: "error", err: Error): boolean;
         emit(event: "exit", exitCode: number): boolean;
         emit(event: "message", value: any): boolean;
+        emit(event: "messageerror", error: Error): boolean;
         emit(event: "online"): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
 
         on(event: "error", listener: (err: Error) => void): this;
         on(event: "exit", listener: (exitCode: number) => void): this;
         on(event: "message", listener: (value: any) => void): this;
+        on(event: "messageerror", listener: (error: Error) => void): this;
         on(event: "online", listener: () => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
 
         once(event: "error", listener: (err: Error) => void): this;
         once(event: "exit", listener: (exitCode: number) => void): this;
         once(event: "message", listener: (value: any) => void): this;
+        once(event: "messageerror", listener: (error: Error) => void): this;
         once(event: "online", listener: () => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
 
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(event: "exit", listener: (exitCode: number) => void): this;
         prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: "messageerror", listener: (error: Error) => void): this;
         prependListener(event: "online", listener: () => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
         prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
         prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
         prependOnceListener(event: "online", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         removeListener(event: "error", listener: (err: Error) => void): this;
         removeListener(event: "exit", listener: (exitCode: number) => void): this;
         removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: "messageerror", listener: (error: Error) => void): this;
         removeListener(event: "online", listener: () => void): this;
         removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
 
         off(event: "error", listener: (err: Error) => void): this;
         off(event: "exit", listener: (exitCode: number) => void): this;
         off(event: "message", listener: (value: any) => void): this;
+        off(event: "messageerror", listener: (error: Error) => void): this;
         off(event: "online", listener: () => void): this;
         off(event: string | symbol, listener: (...args: any[]) => void): this;
     }
 
+    /**
+     * Mark an object as not transferable.
+     * If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.
+     *
+     * In particular, this makes sense for objects that can be cloned, rather than transferred,
+     * and which are used by other objects on the sending side. For example, Node.js marks
+     * the `ArrayBuffer`s it uses for its Buffer pool with this.
+     *
+     * This operation cannot be undone.
+     */
+    function markAsUntransferable(object: object): void;
+
     /**
      * Transfer a `MessagePort` to a different `vm` Context. The original `port`
      * object will be rendered unusable, and the returned `MessagePort` instance will

{node v12.12 → node v12.19}/zlib.d.ts

@@ -20,6 +20,7 @@ declare module "zlib" {
         strategy?: number; // compression only
         dictionary?: NodeJS.ArrayBufferView | ArrayBuffer; // deflate/inflate only, empty dictionary by default
         info?: boolean;
+        maxOutputLength?: number;
     }
 
     interface BrotliOptions {
@@ -41,6 +42,7 @@ declare module "zlib" {
              */
             [key: number]: boolean | number;
         };
+        maxOutputLength?: number;
     }
 
     interface Zlib {
@@ -49,7 +51,8 @@ declare module "zlib" {
         readonly bytesWritten: number;
         shell?: boolean | string;
         close(callback?: () => void): void;
-        flush(kind?: number | (() => void), callback?: () => void): void;
+        flush(kind?: number, callback?: () => void): void;
+        flush(callback?: () => void): void;
     }
 
     interface ZlibParams {
@@ -86,69 +89,76 @@ declare module "zlib" {
 
     function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
     function brotliCompress(buf: InputType, callback: CompressCallback): void;
+    namespace brotliCompress {
+        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
+    }
+
     function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+
     function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
     function brotliDecompress(buf: InputType, callback: CompressCallback): void;
+    namespace brotliDecompress {
+        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
+    }
+
     function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+
     function deflate(buf: InputType, callback: CompressCallback): void;
     function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    namespace deflate {
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+    }
+
     function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     function deflateRaw(buf: InputType, callback: CompressCallback): void;
     function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    namespace deflateRaw {
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+    }
+
     function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     function gzip(buf: InputType, callback: CompressCallback): void;
     function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    namespace gzip {
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+    }
+
     function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     function gunzip(buf: InputType, callback: CompressCallback): void;
     function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    namespace gunzip {
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+    }
+
     function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     function inflate(buf: InputType, callback: CompressCallback): void;
     function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    namespace inflate {
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+    }
+
     function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     function inflateRaw(buf: InputType, callback: CompressCallback): void;
     function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    namespace inflateRaw {
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+    }
+
     function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     function unzip(buf: InputType, callback: CompressCallback): void;
     function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
-    function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
-
-    namespace brotliCompress {
-        function __promisify__(buffer: InputType, options: BrotliOptions): Promise<Buffer>;
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-    }
-    namespace brotliDecompress {
-        function __promisify__(buffer: InputType, options: BrotliOptions): Promise<Buffer>;
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-    }
-    namespace deflate {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
-    }
-    namespace deflateRaw {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
-    }
-    namespace gzip {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
-    }
-    namespace gunzip {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
-    }
-    namespace inflate {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
-    }
-    namespace inflateRaw {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
-    }
     namespace unzip {
-        function __promisify__(buffer: InputType): Promise<Buffer>;
-        function __promisify__(buffer: InputType, options: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
     }
 
+    function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+
     namespace constants {
         const BROTLI_DECODE: number;
         const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;
@@ -226,165 +236,121 @@ declare module "zlib" {
         const INFLATERAW: number;
         const UNZIP: number;
 
-        const Z_BEST_COMPRESSION: number;
-        const Z_BEST_SPEED: number;
+        const Z_NO_FLUSH: number;
+        const Z_PARTIAL_FLUSH: number;
+        const Z_SYNC_FLUSH: number;
+        const Z_FULL_FLUSH: number;
+        const Z_FINISH: number;
         const Z_BLOCK: number;
-        const Z_BUF_ERROR: number;
+        const Z_TREES: number;
+
+        const Z_OK: number;
+        const Z_STREAM_END: number;
+        const Z_NEED_DICT: number;
+        const Z_ERRNO: number;
+        const Z_STREAM_ERROR: number;
         const Z_DATA_ERROR: number;
+        const Z_MEM_ERROR: number;
+        const Z_BUF_ERROR: number;
+        const Z_VERSION_ERROR: number;
 
-        const Z_DEFAULT_CHUNK: number;
+        const Z_NO_COMPRESSION: number;
+        const Z_BEST_SPEED: number;
+        const Z_BEST_COMPRESSION: number;
         const Z_DEFAULT_COMPRESSION: number;
-        const Z_DEFAULT_LEVEL: number;
-        const Z_DEFAULT_MEMLEVEL: number;
-        const Z_DEFAULT_STRATEGY: number;
-        const Z_DEFAULT_WINDOWBITS: number;
 
-        const Z_ERRNO: number;
         const Z_FILTERED: number;
-        const Z_FINISH: number;
-        const Z_FIXED: number;
-        const Z_FULL_FLUSH: number;
         const Z_HUFFMAN_ONLY: number;
-        const Z_MAX_CHUNK: number;
-        const Z_MAX_LEVEL: number;
-        const Z_MAX_MEMLEVEL: number;
+        const Z_RLE: number;
+        const Z_FIXED: number;
+        const Z_DEFAULT_STRATEGY: number;
+
+        const Z_DEFAULT_WINDOWBITS: number;
+        const Z_MIN_WINDOWBITS: number;
         const Z_MAX_WINDOWBITS: number;
-        const Z_MEM_ERROR: number;
+
         const Z_MIN_CHUNK: number;
-        const Z_MIN_LEVEL: number;
+        const Z_MAX_CHUNK: number;
+        const Z_DEFAULT_CHUNK: number;
+
         const Z_MIN_MEMLEVEL: number;
-        const Z_MIN_WINDOWBITS: number;
-        const Z_NEED_DICT: number;
-        const Z_NO_COMPRESSION: number;
-        const Z_NO_FLUSH: number;
-        const Z_OK: number;
-        const Z_PARTIAL_FLUSH: number;
-        const Z_RLE: number;
-        const Z_STREAM_END: number;
-        const Z_STREAM_ERROR: number;
-        const Z_SYNC_FLUSH: number;
-        const Z_VERSION_ERROR: number;
+        const Z_MAX_MEMLEVEL: number;
+        const Z_DEFAULT_MEMLEVEL: number;
+
+        const Z_MIN_LEVEL: number;
+        const Z_MAX_LEVEL: number;
+        const Z_DEFAULT_LEVEL: number;
+
         const ZLIB_VERNUM: number;
     }
 
-    /**
-     * @deprecated
-     */
+    // Allowed flush values.
+    /** @deprecated Use `constants.Z_NO_FLUSH` */
     const Z_NO_FLUSH: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_PARTIAL_FLUSH` */
     const Z_PARTIAL_FLUSH: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_SYNC_FLUSH` */
     const Z_SYNC_FLUSH: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_FULL_FLUSH` */
     const Z_FULL_FLUSH: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_FINISH` */
     const Z_FINISH: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_BLOCK` */
     const Z_BLOCK: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_TREES` */
     const Z_TREES: number;
-    /**
-     * @deprecated
-     */
+
+    // Return codes for the compression/decompression functions.
+    // Negative values are errors, positive values are used for special but normal events.
+    /** @deprecated Use `constants.Z_OK` */
     const Z_OK: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_STREAM_END` */
     const Z_STREAM_END: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_NEED_DICT` */
     const Z_NEED_DICT: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_ERRNO` */
     const Z_ERRNO: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_STREAM_ERROR` */
     const Z_STREAM_ERROR: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_DATA_ERROR` */
     const Z_DATA_ERROR: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_MEM_ERROR` */
     const Z_MEM_ERROR: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_BUF_ERROR` */
     const Z_BUF_ERROR: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_VERSION_ERROR` */
     const Z_VERSION_ERROR: number;
-    /**
-     * @deprecated
-     */
+
+    // Compression levels.
+    /** @deprecated Use `constants.Z_NO_COMPRESSION` */
     const Z_NO_COMPRESSION: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_BEST_SPEED` */
     const Z_BEST_SPEED: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_BEST_COMPRESSION` */
     const Z_BEST_COMPRESSION: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_DEFAULT_COMPRESSION` */
     const Z_DEFAULT_COMPRESSION: number;
-    /**
-     * @deprecated
-     */
+
+    // Compression strategy.
+    /** @deprecated Use `constants.Z_FILTERED` */
     const Z_FILTERED: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_HUFFMAN_ONLY` */
     const Z_HUFFMAN_ONLY: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_RLE` */
     const Z_RLE: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_FIXED` */
     const Z_FIXED: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated Use `constants.Z_DEFAULT_STRATEGY` */
     const Z_DEFAULT_STRATEGY: number;
-    /**
-     * @deprecated
-     */
+
+    /** @deprecated */
     const Z_BINARY: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated */
     const Z_TEXT: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated */
     const Z_ASCII: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated  */
     const Z_UNKNOWN: number;
-    /**
-     * @deprecated
-     */
+    /** @deprecated */
     const Z_DEFLATED: number;
 }