@types/node 13.13.50 → 14.0.1

node v13.13/crypto.d.ts → node/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,12 +7,11 @@ 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. */
@@ -121,11 +120,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();
@@ -190,37 +189,26 @@ 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;
+        final(output_encoding: BufferEncoding): string;
         setAutoPadding(auto_padding?: boolean): this;
         // getAuthTag(): Buffer;
         // setAAD(buffer: Buffer): this; // docs only say buffer
@@ -252,29 +240,16 @@ 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;
+        final(output_encoding: BufferEncoding): string;
         setAutoPadding(auto_padding?: boolean): this;
         // setAuthTag(tag: NodeJS.ArrayBufferView): this;
         // setAAD(buffer: NodeJS.ArrayBufferView): this;
@@ -315,7 +290,8 @@ declare module 'crypto' {
         saltLength?: number;
     }
 
-    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {}
+    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {
+    }
 
     type KeyLike = string | Buffer | KeyObject;
 
@@ -342,17 +318,8 @@ 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;
@@ -360,11 +327,7 @@ 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;
@@ -374,9 +337,9 @@ declare module 'crypto' {
         getPrivateKey(): Buffer;
         getPrivateKey(encoding: HexBase64Latin1Encoding): string;
         setPublicKey(public_key: NodeJS.ArrayBufferView): void;
-        setPublicKey(public_key: string, encoding: string): void;
+        setPublicKey(public_key: string, encoding: BufferEncoding): void;
         setPrivateKey(private_key: NodeJS.ArrayBufferView): void;
-        setPrivateKey(private_key: string, encoding: string): void;
+        setPrivateKey(private_key: string, encoding: BufferEncoding): void;
         verifyError: number;
     }
     function getDiffieHellman(group_name: string): DiffieHellman;
@@ -388,13 +351,7 @@ 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;
@@ -402,26 +359,11 @@ 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;
@@ -430,8 +372,7 @@ 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,
@@ -462,7 +403,6 @@ declare module 'crypto' {
     function privateEncrypt(private_key: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     function getCiphers(): string[];
     function getCurves(): string[];
-    function getFips(): 1 | 0;
     function getHashes(): string[];
     class ECDH {
         private constructor();
@@ -470,19 +410,15 @@ 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;
@@ -493,7 +429,7 @@ declare module 'crypto' {
     function createECDH(curve_name: string): ECDH;
     function timingSafeEqual(a: NodeJS.ArrayBufferView, b: NodeJS.ArrayBufferView): boolean;
     /** @deprecated since v10.0.0 */
-    const DEFAULT_ENCODING: string;
+    const DEFAULT_ENCODING: BufferEncoding;
 
     type KeyType = 'rsa' | 'dsa' | 'ec';
     type KeyFormat = 'pem' | 'der';
@@ -598,192 +534,60 @@ 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>;
     }
 
     /**
@@ -794,13 +598,10 @@ 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
@@ -810,10 +611,5 @@ 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/dgram.d.ts → node/dgram.d.ts

@@ -50,9 +50,9 @@ declare module "dgram" {
         getSendBufferSize(): number;
         ref(): this;
         remoteAddress(): AddressInfo;
-        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
-        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
-        send(msg: string | Uint8Array | ReadonlyArray<any>, 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 | any[], port?: number, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | any[], 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;
         send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
         send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;

node v13.13/domain.d.ts → node/domain.d.ts

@@ -1,5 +1,5 @@
-declare module 'domain' {
-    import EventEmitter = require('events');
+declare module "domain" {
+    import { EventEmitter } from "events";
 
     class Domain extends EventEmitter implements NodeJS.Domain {
         run<T>(fn: (...args: any[]) => T, ...args: any[]): T;

node v13.13/events.d.ts → node/events.d.ts

@@ -1,4 +1,4 @@
-declare module 'events' {
+declare module "events" {
     interface EventEmitterOptions {
         /**
          * Enables automatic capturing of promise rejection.
@@ -14,16 +14,11 @@ declare module 'events' {
         addEventListener(event: string, listener: (...args: any[]) => void, opts?: { once: boolean }): any;
     }
 
-    interface EventEmitter extends NodeJS.EventEmitter {}
-    class EventEmitter {
-        constructor(options?: EventEmitterOptions);
-
-        static once(emitter: NodeEventTarget, event: string | symbol): Promise<any[]>;
-        static once(emitter: DOMEventTarget, event: string): Promise<any[]>;
-        static on(emitter: NodeJS.EventEmitter, event: string): AsyncIterableIterator<any>;
-
-        /** @deprecated since v4.0.0 */
-        static listenerCount(emitter: NodeJS.EventEmitter, event: string | symbol): number;
+    namespace EventEmitter {
+        function once(emitter: NodeEventTarget, event: string | symbol): Promise<any[]>;
+        function once(emitter: DOMEventTarget, event: string): Promise<any[]>;
+        function on(emitter: EventEmitter, event: string): AsyncIterableIterator<any>;
+        const captureRejectionSymbol: unique symbol;
 
         /**
          * This symbol shall be used to install a listener for only monitoring `'error'`
@@ -34,21 +29,21 @@ declare module 'events' {
          * `'error'` event is emitted, therefore the process will still crash if no
          * regular `'error'` listener is installed.
          */
-        static readonly errorMonitor: unique symbol;
-        static readonly captureRejectionSymbol: unique symbol;
-
+        const errorMonitor: unique symbol;
         /**
          * Sets or gets the default captureRejection value for all emitters.
          */
-        // TODO: These should be described using static getter/setter pairs:
-        static captureRejections: boolean;
-        static defaultMaxListeners: number;
-    }
+        let captureRejections: boolean;
 
-    import internal = require('events');
-    namespace EventEmitter {
-        // Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
-        export { internal as EventEmitter };
+        interface EventEmitter extends NodeJS.EventEmitter {
+        }
+
+        class EventEmitter {
+            constructor(options?: EventEmitterOptions);
+            /** @deprecated since v4.0.0 */
+            static listenerCount(emitter: EventEmitter, event: string | symbol): number;
+            static defaultMaxListeners: number;
+        }
     }
 
     export = EventEmitter;