@types/node 13.13.35 → 13.13.39

node v13.13/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/v13.
 
 ### Additional Details
- * Last updated: Tue, 08 Dec 2020 16:56:27 GMT
+ * Last updated: Mon, 04 Jan 2021 20:50:29 GMT
  * Dependencies: none
  * Global values: `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

node v13.13/assert.d.ts

@@ -15,6 +15,7 @@ declare module 'assert' {
                 actual?: any;
                 expected?: any;
                 operator?: string;
+                // tslint:disable-next-line:ban-types
                 stackStartFn?: Function;
             });
         }
@@ -28,6 +29,7 @@ declare module 'assert' {
             expected: any,
             message?: string | Error,
             operator?: string,
+            // tslint:disable-next-line:ban-types
             stackStartFn?: Function,
         ): never;
         function ok(value: any, message?: string | Error): asserts value;
@@ -47,7 +49,7 @@ declare module 'assert' {
         function throws(block: () => any, message?: string | Error): void;
         function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
         function doesNotThrow(block: () => any, message?: string | Error): void;
-        function doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: AssertPredicate, message?: string | Error): void;
 
         function ifError(value: any): asserts value is null | undefined;
 
@@ -60,7 +62,7 @@ declare module 'assert' {
         function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
         function doesNotReject(
             block: (() => Promise<any>) | Promise<any>,
-            error: RegExp | Function,
+            error: AssertPredicate,
             message?: string | Error,
         ): Promise<void>;
 

node v13.13/crypto.d.ts

@@ -1,5 +1,5 @@
-declare module "crypto" {
-    import * as stream from "stream";
+declare module 'crypto' {
+    import * as stream from 'stream';
 
     interface Certificate {
         exportChallenge(spkac: BinaryLike): Buffer;
@@ -7,11 +7,12 @@ declare module "crypto" {
         verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
     }
     const Certificate: {
-        new(): Certificate;
+        new (): Certificate;
         (): Certificate;
     };
 
-    namespace constants { // https://nodejs.org/dist/latest-v10.x/docs/api/crypto.html#crypto_crypto_constants
+    namespace constants {
+        // https://nodejs.org/dist/latest-v10.x/docs/api/crypto.html#crypto_crypto_constants
         const OPENSSL_VERSION_NUMBER: number;
 
         /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */
@@ -120,11 +121,11 @@ declare module "crypto" {
     function createHash(algorithm: string, options?: HashOptions): Hash;
     function createHmac(algorithm: string, key: BinaryLike | KeyObject, options?: stream.TransformOptions): Hmac;
 
-    type Utf8AsciiLatin1Encoding = "utf8" | "ascii" | "latin1";
-    type HexBase64Latin1Encoding = "latin1" | "hex" | "base64";
-    type Utf8AsciiBinaryEncoding = "utf8" | "ascii" | "binary";
-    type HexBase64BinaryEncoding = "binary" | "base64" | "hex";
-    type ECDHKeyFormat = "compressed" | "uncompressed" | "hybrid";
+    type Utf8AsciiLatin1Encoding = 'utf8' | 'ascii' | 'latin1';
+    type HexBase64Latin1Encoding = 'latin1' | 'hex' | 'base64';
+    type Utf8AsciiBinaryEncoding = 'utf8' | 'ascii' | 'binary';
+    type HexBase64BinaryEncoding = 'binary' | 'base64' | 'hex';
+    type ECDHKeyFormat = 'compressed' | 'uncompressed' | 'hybrid';
 
     class Hash extends stream.Transform {
         private constructor();
@@ -189,24 +190,35 @@ declare module "crypto" {
         algorithm: CipherCCMTypes,
         key: CipherKey,
         iv: BinaryLike | null,
-        options: CipherCCMOptions
+        options: CipherCCMOptions,
     ): CipherCCM;
     function createCipheriv(
         algorithm: CipherGCMTypes,
         key: CipherKey,
         iv: BinaryLike | null,
-        options?: CipherGCMOptions
+        options?: CipherGCMOptions,
     ): CipherGCM;
     function createCipheriv(
-        algorithm: string, key: CipherKey, iv: BinaryLike | null, options?: stream.TransformOptions
+        algorithm: string,
+        key: CipherKey,
+        iv: BinaryLike | null,
+        options?: stream.TransformOptions,
     ): Cipher;
 
     class Cipher extends stream.Transform {
         private constructor();
         update(data: BinaryLike): Buffer;
         update(data: string, input_encoding: Utf8AsciiBinaryEncoding): Buffer;
-        update(data: NodeJS.ArrayBufferView, input_encoding: undefined, output_encoding: HexBase64BinaryEncoding): string;
-        update(data: string, input_encoding: Utf8AsciiBinaryEncoding | undefined, output_encoding: HexBase64BinaryEncoding): string;
+        update(
+            data: NodeJS.ArrayBufferView,
+            input_encoding: undefined,
+            output_encoding: HexBase64BinaryEncoding,
+        ): string;
+        update(
+            data: string,
+            input_encoding: Utf8AsciiBinaryEncoding | undefined,
+            output_encoding: HexBase64BinaryEncoding,
+        ): string;
         final(): Buffer;
         final(output_encoding: string): string;
         setAutoPadding(auto_padding?: boolean): this;
@@ -240,14 +252,27 @@ declare module "crypto" {
         iv: BinaryLike | null,
         options?: CipherGCMOptions,
     ): DecipherGCM;
-    function createDecipheriv(algorithm: string, key: CipherKey, iv: BinaryLike | null, options?: stream.TransformOptions): Decipher;
+    function createDecipheriv(
+        algorithm: string,
+        key: CipherKey,
+        iv: BinaryLike | null,
+        options?: stream.TransformOptions,
+    ): Decipher;
 
     class Decipher extends stream.Transform {
         private constructor();
         update(data: NodeJS.ArrayBufferView): Buffer;
         update(data: string, input_encoding: HexBase64BinaryEncoding): Buffer;
-        update(data: NodeJS.ArrayBufferView, input_encoding: HexBase64BinaryEncoding | undefined, output_encoding: Utf8AsciiBinaryEncoding): string;
-        update(data: string, input_encoding: HexBase64BinaryEncoding | undefined, output_encoding: Utf8AsciiBinaryEncoding): string;
+        update(
+            data: NodeJS.ArrayBufferView,
+            input_encoding: HexBase64BinaryEncoding | undefined,
+            output_encoding: Utf8AsciiBinaryEncoding,
+        ): string;
+        update(
+            data: string,
+            input_encoding: HexBase64BinaryEncoding | undefined,
+            output_encoding: Utf8AsciiBinaryEncoding,
+        ): string;
         final(): Buffer;
         final(output_encoding: string): string;
         setAutoPadding(auto_padding?: boolean): this;
@@ -290,8 +315,7 @@ declare module "crypto" {
         saltLength?: number;
     }
 
-    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {
-    }
+    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {}
 
     type KeyLike = string | Buffer | KeyObject;
 
@@ -318,8 +342,17 @@ declare module "crypto" {
     function createDiffieHellman(prime_length: number, generator?: number | NodeJS.ArrayBufferView): DiffieHellman;
     function createDiffieHellman(prime: NodeJS.ArrayBufferView): DiffieHellman;
     function createDiffieHellman(prime: string, prime_encoding: HexBase64Latin1Encoding): DiffieHellman;
-    function createDiffieHellman(prime: string, prime_encoding: HexBase64Latin1Encoding, generator: number | NodeJS.ArrayBufferView): DiffieHellman;
-    function createDiffieHellman(prime: string, prime_encoding: HexBase64Latin1Encoding, generator: string, generator_encoding: HexBase64Latin1Encoding): DiffieHellman;
+    function createDiffieHellman(
+        prime: string,
+        prime_encoding: HexBase64Latin1Encoding,
+        generator: number | NodeJS.ArrayBufferView,
+    ): DiffieHellman;
+    function createDiffieHellman(
+        prime: string,
+        prime_encoding: HexBase64Latin1Encoding,
+        generator: string,
+        generator_encoding: HexBase64Latin1Encoding,
+    ): DiffieHellman;
     class DiffieHellman {
         private constructor();
         generateKeys(): Buffer;
@@ -327,7 +360,11 @@ declare module "crypto" {
         computeSecret(other_public_key: NodeJS.ArrayBufferView): Buffer;
         computeSecret(other_public_key: string, input_encoding: HexBase64Latin1Encoding): Buffer;
         computeSecret(other_public_key: NodeJS.ArrayBufferView, output_encoding: HexBase64Latin1Encoding): string;
-        computeSecret(other_public_key: string, input_encoding: HexBase64Latin1Encoding, output_encoding: HexBase64Latin1Encoding): string;
+        computeSecret(
+            other_public_key: string,
+            input_encoding: HexBase64Latin1Encoding,
+            output_encoding: HexBase64Latin1Encoding,
+        ): string;
         getPrime(): Buffer;
         getPrime(encoding: HexBase64Latin1Encoding): string;
         getGenerator(): Buffer;
@@ -351,7 +388,13 @@ declare module "crypto" {
         digest: string,
         callback: (err: Error | null, derivedKey: Buffer) => any,
     ): void;
-    function pbkdf2Sync(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string): Buffer;
+    function pbkdf2Sync(
+        password: BinaryLike,
+        salt: BinaryLike,
+        iterations: number,
+        keylen: number,
+        digest: string,
+    ): Buffer;
 
     function randomBytes(size: number): Buffer;
     function randomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
@@ -359,11 +402,26 @@ declare module "crypto" {
     function pseudoRandomBytes(size: number, callback: (err: Error | null, buf: Buffer) => 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;
-    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, offset: number, size: number, callback: (err: Error | null, buf: T) => void): void;
+    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;
+    function randomFill<T extends NodeJS.ArrayBufferView>(
+        buffer: T,
+        offset: number,
+        size: number,
+        callback: (err: Error | null, buf: T) => void,
+    ): void;
 
     interface ScryptOptions {
+        cost?: number;
+        blockSize?: number;
+        parallelization?: number;
         N?: number;
         r?: number;
         p?: number;
@@ -372,7 +430,8 @@ declare module "crypto" {
     function scrypt(
         password: BinaryLike,
         salt: BinaryLike,
-        keylen: number, callback: (err: Error | null, derivedKey: Buffer) => void,
+        keylen: number,
+        callback: (err: Error | null, derivedKey: Buffer) => void,
     ): void;
     function scrypt(
         password: BinaryLike,
@@ -411,15 +470,19 @@ declare module "crypto" {
             key: BinaryLike,
             curve: string,
             inputEncoding?: HexBase64Latin1Encoding,
-            outputEncoding?: "latin1" | "hex" | "base64",
-            format?: "uncompressed" | "compressed" | "hybrid",
+            outputEncoding?: 'latin1' | 'hex' | 'base64',
+            format?: 'uncompressed' | 'compressed' | 'hybrid',
         ): Buffer | string;
         generateKeys(): Buffer;
         generateKeys(encoding: HexBase64Latin1Encoding, format?: ECDHKeyFormat): string;
         computeSecret(other_public_key: NodeJS.ArrayBufferView): Buffer;
         computeSecret(other_public_key: string, input_encoding: HexBase64Latin1Encoding): Buffer;
         computeSecret(other_public_key: NodeJS.ArrayBufferView, output_encoding: HexBase64Latin1Encoding): string;
-        computeSecret(other_public_key: string, input_encoding: HexBase64Latin1Encoding, output_encoding: HexBase64Latin1Encoding): string;
+        computeSecret(
+            other_public_key: string,
+            input_encoding: HexBase64Latin1Encoding,
+            output_encoding: HexBase64Latin1Encoding,
+        ): string;
         getPrivateKey(): Buffer;
         getPrivateKey(encoding: HexBase64Latin1Encoding): string;
         getPublicKey(): Buffer;
@@ -535,60 +598,192 @@ declare module "crypto" {
         privateKey: T2;
     }
 
-    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
-    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
-    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
-    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+    function generateKeyPairSync(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'pem', 'pem'>,
+    ): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'pem', 'der'>,
+    ): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'der', 'pem'>,
+    ): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'der', 'der'>,
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: 'rsa', options: RSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
 
-    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
-    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
-    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
-    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+    function generateKeyPairSync(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'pem', 'pem'>,
+    ): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'pem', 'der'>,
+    ): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'der', 'pem'>,
+    ): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'der', 'der'>,
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: 'dsa', options: DSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
 
-    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
-    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
-    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
-    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+    function generateKeyPairSync(
+        type: 'ec',
+        options: ECKeyPairOptions<'pem', 'pem'>,
+    ): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(
+        type: 'ec',
+        options: ECKeyPairOptions<'pem', 'der'>,
+    ): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(
+        type: 'ec',
+        options: ECKeyPairOptions<'der', 'pem'>,
+    ): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(
+        type: 'ec',
+        options: ECKeyPairOptions<'der', 'der'>,
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: 'ec', options: ECKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
 
-    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
-    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
-    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'rsa', options: RSAKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+    function generateKeyPair(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'pem', 'pem'>,
+        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'pem', 'der'>,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'der', 'pem'>,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'rsa',
+        options: RSAKeyPairOptions<'der', 'der'>,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'rsa',
+        options: RSAKeyPairKeyObjectOptions,
+        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
+    ): void;
 
-    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
-    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
-    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'dsa', options: DSAKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+    function generateKeyPair(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'pem', 'pem'>,
+        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'pem', 'der'>,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'der', 'pem'>,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'dsa',
+        options: DSAKeyPairOptions<'der', 'der'>,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'dsa',
+        options: DSAKeyPairKeyObjectOptions,
+        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
+    ): void;
 
-    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
-    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
-    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
-    function generateKeyPair(type: 'ec', options: ECKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+    function generateKeyPair(
+        type: 'ec',
+        options: ECKeyPairOptions<'pem', 'pem'>,
+        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'ec',
+        options: ECKeyPairOptions<'pem', 'der'>,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'ec',
+        options: ECKeyPairOptions<'der', 'pem'>,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'ec',
+        options: ECKeyPairOptions<'der', 'der'>,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
+    ): void;
+    function generateKeyPair(
+        type: 'ec',
+        options: ECKeyPairKeyObjectOptions,
+        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
+    ): void;
 
     namespace generateKeyPair {
-        function __promisify__(type: "rsa", options: RSAKeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
-        function __promisify__(type: "rsa", options: RSAKeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
-        function __promisify__(type: "rsa", options: RSAKeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
-        function __promisify__(type: "rsa", options: RSAKeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
-        function __promisify__(type: "rsa", options: RSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
-
-        function __promisify__(type: "dsa", options: DSAKeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
-        function __promisify__(type: "dsa", options: DSAKeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
-        function __promisify__(type: "dsa", options: DSAKeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
-        function __promisify__(type: "dsa", options: DSAKeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
-        function __promisify__(type: "dsa", options: DSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
-
-        function __promisify__(type: "ec", options: ECKeyPairOptions<'pem', 'pem'>): Promise<{ publicKey: string, privateKey: string }>;
-        function __promisify__(type: "ec", options: ECKeyPairOptions<'pem', 'der'>): Promise<{ publicKey: string, privateKey: Buffer }>;
-        function __promisify__(type: "ec", options: ECKeyPairOptions<'der', 'pem'>): Promise<{ publicKey: Buffer, privateKey: string }>;
-        function __promisify__(type: "ec", options: ECKeyPairOptions<'der', 'der'>): Promise<{ publicKey: Buffer, privateKey: Buffer }>;
-        function __promisify__(type: "ec", options: ECKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+        function __promisify__(
+            type: 'rsa',
+            options: RSAKeyPairOptions<'pem', 'pem'>,
+        ): Promise<{ publicKey: string; privateKey: string }>;
+        function __promisify__(
+            type: 'rsa',
+            options: RSAKeyPairOptions<'pem', 'der'>,
+        ): Promise<{ publicKey: string; privateKey: Buffer }>;
+        function __promisify__(
+            type: 'rsa',
+            options: RSAKeyPairOptions<'der', 'pem'>,
+        ): Promise<{ publicKey: Buffer; privateKey: string }>;
+        function __promisify__(
+            type: 'rsa',
+            options: RSAKeyPairOptions<'der', 'der'>,
+        ): Promise<{ publicKey: Buffer; privateKey: Buffer }>;
+        function __promisify__(type: 'rsa', options: RSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+
+        function __promisify__(
+            type: 'dsa',
+            options: DSAKeyPairOptions<'pem', 'pem'>,
+        ): Promise<{ publicKey: string; privateKey: string }>;
+        function __promisify__(
+            type: 'dsa',
+            options: DSAKeyPairOptions<'pem', 'der'>,
+        ): Promise<{ publicKey: string; privateKey: Buffer }>;
+        function __promisify__(
+            type: 'dsa',
+            options: DSAKeyPairOptions<'der', 'pem'>,
+        ): Promise<{ publicKey: Buffer; privateKey: string }>;
+        function __promisify__(
+            type: 'dsa',
+            options: DSAKeyPairOptions<'der', 'der'>,
+        ): Promise<{ publicKey: Buffer; privateKey: Buffer }>;
+        function __promisify__(type: 'dsa', options: DSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
+
+        function __promisify__(
+            type: 'ec',
+            options: ECKeyPairOptions<'pem', 'pem'>,
+        ): Promise<{ publicKey: string; privateKey: string }>;
+        function __promisify__(
+            type: 'ec',
+            options: ECKeyPairOptions<'pem', 'der'>,
+        ): Promise<{ publicKey: string; privateKey: Buffer }>;
+        function __promisify__(
+            type: 'ec',
+            options: ECKeyPairOptions<'der', 'pem'>,
+        ): Promise<{ publicKey: Buffer; privateKey: string }>;
+        function __promisify__(
+            type: 'ec',
+            options: ECKeyPairOptions<'der', 'der'>,
+        ): Promise<{ publicKey: Buffer; privateKey: Buffer }>;
+        function __promisify__(type: 'ec', options: ECKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
     }
 
     /**
@@ -599,10 +794,13 @@ declare module "crypto" {
      * If `key` is not a [`KeyObject`][], this function behaves as if `key` had been
      * passed to [`crypto.createPrivateKey()`][].
      */
-    function sign(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | SignPrivateKeyInput): Buffer;
+    function sign(
+        algorithm: string | null | undefined,
+        data: NodeJS.ArrayBufferView,
+        key: KeyLike | SignPrivateKeyInput,
+    ): Buffer;
 
-    interface VerifyKeyWithOptions extends KeyObject, SigningOptions {
-    }
+    interface VerifyKeyWithOptions extends KeyObject, SigningOptions {}
 
     /**
      * Calculates and returns the signature for `data` using the given private key and
@@ -612,5 +810,10 @@ declare module "crypto" {
      * If `key` is not a [`KeyObject`][], this function behaves as if `key` had been
      * passed to [`crypto.createPublicKey()`][].
      */
-    function verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | VerifyKeyWithOptions, signature: NodeJS.ArrayBufferView): boolean;
+    function verify(
+        algorithm: string | null | undefined,
+        data: NodeJS.ArrayBufferView,
+        key: KeyLike | VerifyKeyWithOptions,
+        signature: NodeJS.ArrayBufferView,
+    ): boolean;
 }

node v13.13/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "13.13.35",
+    "version": "13.13.39",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -241,6 +241,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "eb4667f716c2f1ff652d701ddb90bfe5f77bd7bf14e8c56ce4157328b255f4f1",
+    "typesPublisherContentHash": "157c97c0c8cf6e9afa4b150dfd82763637d000c3503595d3e1b60290ea4209ce",
     "typeScriptVersion": "3.3"
 }

node v13.13/ts3.4/assert.d.ts

@@ -15,6 +15,7 @@ declare module 'assert' {
                 actual?: any;
                 expected?: any;
                 operator?: string;
+                // tslint:disable-next-line:ban-types
                 stackStartFn?: Function;
             });
         }
@@ -28,6 +29,7 @@ declare module 'assert' {
             expected: any,
             message?: string | Error,
             operator?: string,
+            // tslint:disable-next-line:ban-types
             stackStartFn?: Function,
         ): never;
         function ok(value: any, message?: string | Error): void;
@@ -47,7 +49,7 @@ declare module 'assert' {
         function throws(block: () => any, message?: string | Error): void;
         function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
         function doesNotThrow(block: () => any, message?: string | Error): void;
-        function doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: AssertPredicate, message?: string | Error): void;
 
         function ifError(value: any): void;
 
@@ -60,7 +62,7 @@ declare module 'assert' {
         function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
         function doesNotReject(
             block: (() => Promise<any>) | Promise<any>,
-            error: RegExp | Function,
+            error: AssertPredicate,
             message?: string | Error,
         ): Promise<void>;
 

node v13.13/url.d.ts

@@ -40,13 +40,19 @@ declare module "url" {
         query: string | null;
     }
 
+    /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function parse(urlStr: string): UrlWithStringQuery;
+    /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function parse(urlStr: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
+    /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function parse(urlStr: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
+    /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function parse(urlStr: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
 
     function format(URL: URL, options?: URLFormatOptions): string;
+    /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function format(urlObject: UrlObject | string): string;
+    /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function resolve(from: string, to: string): string;
 
     function domainToASCII(domain: string): string;

node v13.13/util.d.ts

@@ -5,8 +5,8 @@ declare module "util" {
     interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
-    function format(format: any, ...param: any[]): string;
-    function formatWithOptions(inspectOptions: InspectOptions, format: string, ...param: any[]): string;
+    function format(format?: any, ...param: any[]): string;
+    function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
     /** @deprecated since v0.11.3 - use a third party module instead. */
     function log(string: string): void;
     function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;