@types/node 11.15.51 → 12.0.0

node v11.15/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: Binary): 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. */
@@ -113,20 +112,20 @@ declare module 'crypto' {
     function createHash(algorithm: string, options?: stream.TransformOptions): Hash;
     function createHmac(algorithm: string, key: BinaryLike, 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 {
+    class Hash extends stream.Duplex {
         private constructor();
         update(data: BinaryLike): Hash;
         update(data: string, input_encoding: Utf8AsciiLatin1Encoding): Hash;
         digest(): Buffer;
         digest(encoding: HexBase64Latin1Encoding): string;
     }
-    class Hmac extends stream.Transform {
+    class Hmac extends stream.Duplex {
         private constructor();
         update(data: BinaryLike): Hmac;
         update(data: string, input_encoding: Utf8AsciiLatin1Encoding): Hmac;
@@ -146,6 +145,11 @@ declare module 'crypto' {
     class KeyObject {
         private constructor();
         asymmetricKeyType?: KeyType;
+        /**
+         * For asymmetric keys, this property represents the size of the embedded key in
+         * bytes. This property is `undefined` for symmetric keys.
+         */
+        asymmetricKeySize?: number;
         export(options: KeyExportOptions<'pem'>): string | Buffer;
         export(options?: KeyExportOptions<'der'>): Buffer;
         symmetricSize?: number;
@@ -177,31 +181,24 @@ 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 {
+    class Cipher extends stream.Duplex {
         private constructor();
         update(data: BinaryLike): Buffer;
         update(data: string, input_encoding: Utf8AsciiBinaryEncoding): Buffer;
         update(data: Binary, input_encoding: undefined, output_encoding: HexBase64BinaryEncoding): string;
-        update(
-            data: string,
-            input_encoding: Utf8AsciiBinaryEncoding | 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;
@@ -216,11 +213,11 @@ declare module 'crypto' {
         setAAD(buffer: Buffer, options?: { plaintextLength: number }): this;
         getAuthTag(): Buffer;
     }
-    /** @deprecated since v10.0.0 use createDecipheriv() */
+    /** @deprecated since v10.0.0 use createCipheriv() */
     function createDecipher(algorithm: CipherCCMTypes, password: BinaryLike, options: CipherCCMOptions): DecipherCCM;
-    /** @deprecated since v10.0.0 use createDecipheriv() */
+    /** @deprecated since v10.0.0 use createCipheriv() */
     function createDecipher(algorithm: CipherGCMTypes, password: BinaryLike, options?: CipherGCMOptions): DecipherGCM;
-    /** @deprecated since v10.0.0 use createDecipheriv() */
+    /** @deprecated since v10.0.0 use createCipheriv() */
     function createDecipher(algorithm: string, password: BinaryLike, options?: stream.TransformOptions): Decipher;
 
     function createDecipheriv(
@@ -235,23 +232,14 @@ declare module 'crypto' {
         iv: BinaryLike | null,
         options?: CipherGCMOptions,
     ): DecipherGCM;
-    function createDecipheriv(
-        algorithm: string,
-        key: BinaryLike,
-        iv: BinaryLike | null,
-        options?: stream.TransformOptions,
-    ): Decipher;
+    function createDecipheriv(algorithm: string, key: BinaryLike, iv: BinaryLike | null, options?: stream.TransformOptions): Decipher;
 
-    class Decipher extends stream.Transform {
+    class Decipher extends stream.Duplex {
         private constructor();
         update(data: Binary): Buffer;
         update(data: string, input_encoding: HexBase64BinaryEncoding): Buffer;
         update(data: Binary, input_encoding: undefined, output_encoding: Utf8AsciiBinaryEncoding): string;
-        update(
-            data: string,
-            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;
@@ -286,11 +274,17 @@ declare module 'crypto' {
 
     function createSign(algorithm: string, options?: stream.WritableOptions): Signer;
 
-    interface SignPrivateKeyInput extends PrivateKeyInput {
+    interface SigningOptions {
+        /**
+         * @See crypto.constants.RSA_PKCS1_PADDING
+         */
         padding?: number;
         saltLength?: number;
     }
 
+    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {
+    }
+
     type KeyLike = string | Buffer | KeyObject;
 
     class Signer extends stream.Writable {
@@ -316,17 +310,8 @@ declare module 'crypto' {
     function createDiffieHellman(prime_length: number, generator?: number | Binary): DiffieHellman;
     function createDiffieHellman(prime: Binary): DiffieHellman;
     function createDiffieHellman(prime: string, prime_encoding: HexBase64Latin1Encoding): DiffieHellman;
-    function createDiffieHellman(
-        prime: string,
-        prime_encoding: HexBase64Latin1Encoding,
-        generator: number | Binary,
-    ): DiffieHellman;
-    function createDiffieHellman(
-        prime: string,
-        prime_encoding: HexBase64Latin1Encoding,
-        generator: string,
-        generator_encoding: HexBase64Latin1Encoding,
-    ): DiffieHellman;
+    function createDiffieHellman(prime: string, prime_encoding: HexBase64Latin1Encoding, generator: number | Binary): DiffieHellman;
+    function createDiffieHellman(prime: string, prime_encoding: HexBase64Latin1Encoding, generator: string, generator_encoding: HexBase64Latin1Encoding): DiffieHellman;
     class DiffieHellman {
         private constructor();
         generateKeys(): Buffer;
@@ -334,11 +319,7 @@ declare module 'crypto' {
         computeSecret(other_public_key: Binary): Buffer;
         computeSecret(other_public_key: string, input_encoding: HexBase64Latin1Encoding): Buffer;
         computeSecret(other_public_key: Binary, 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;
@@ -362,13 +343,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;
@@ -377,22 +352,10 @@ declare module 'crypto' {
 
     function randomFillSync<T extends Binary>(buffer: T, offset?: number, size?: number): T;
     function randomFill<T extends Binary>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
-    function randomFill<T extends Binary>(
-        buffer: T,
-        offset: number,
-        callback: (err: Error | null, buf: T) => void,
-    ): void;
-    function randomFill<T extends Binary>(
-        buffer: T,
-        offset: number,
-        size: number,
-        callback: (err: Error | null, buf: T) => void,
-    ): void;
+    function randomFill<T extends Binary>(buffer: T, offset: number, callback: (err: Error | null, buf: T) => void): void;
+    function randomFill<T extends Binary>(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;
@@ -401,8 +364,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,
@@ -428,7 +390,6 @@ declare module 'crypto' {
     function publicDecrypt(public_key: RsaPublicKey | KeyLike, buffer: Binary): Buffer;
     function getCiphers(): string[];
     function getCurves(): string[];
-    function getFips(): 1 | 0;
     function getHashes(): string[];
     class ECDH {
         private constructor();
@@ -436,19 +397,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: Binary): Buffer;
         computeSecret(other_public_key: string, input_encoding: HexBase64Latin1Encoding): Buffer;
         computeSecret(other_public_key: Binary, 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;
@@ -564,191 +521,82 @@ 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>;
+    }
+
+    /**
+     * Calculates and returns the signature for `data` using the given private key and
+     * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is
+     * dependent upon the key type (especially Ed25519 and Ed448).
+     *
+     * 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: Binary, key: KeyLike | SignPrivateKeyInput): Buffer;
+
+    interface VerifyKeyWithOptions extends KeyObject, SigningOptions {
+    }
+
+    /**
+     * Calculates and returns the signature for `data` using the given private key and
+     * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is
+     * dependent upon the key type (especially Ed25519 and Ed448).
+     *
+     * 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: Binary, key: KeyLike | VerifyKeyWithOptions, signature: Binary): Buffer;
 }

node v11.15/dgram.d.ts → node/dgram.d.ts

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

node v11.15/dns.d.ts → node/dns.d.ts

@@ -242,7 +242,7 @@ declare module "dns" {
     }
 
     function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void;
-    function setServers(servers: ReadonlyArray<string>): void;
+    function setServers(servers: string[]): void;
     function getServers(): string[];
 
     // Error codes
@@ -289,78 +289,4 @@ declare module "dns" {
         reverse: typeof reverse;
         cancel(): void;
     }
-
-    namespace promises {
-        function getServers(): string[];
-
-        function lookup(hostname: string, family: number): Promise<LookupAddress>;
-        function lookup(hostname: string, options: LookupOneOptions): Promise<LookupAddress>;
-        function lookup(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
-        function lookup(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
-        function lookup(hostname: string): Promise<LookupAddress>;
-
-        function lookupService(address: string, port: number): Promise<{ hostname: string, service: string }>;
-
-        function resolve(hostname: string): Promise<string[]>;
-        function resolve(hostname: string, rrtype: "A"): Promise<string[]>;
-        function resolve(hostname: string, rrtype: "AAAA"): Promise<string[]>;
-        function resolve(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
-        function resolve(hostname: string, rrtype: "CNAME"): Promise<string[]>;
-        function resolve(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
-        function resolve(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
-        function resolve(hostname: string, rrtype: "NS"): Promise<string[]>;
-        function resolve(hostname: string, rrtype: "PTR"): Promise<string[]>;
-        function resolve(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
-        function resolve(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
-        function resolve(hostname: string, rrtype: "TXT"): Promise<string[][]>;
-        function resolve(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
-
-        function resolve4(hostname: string): Promise<string[]>;
-        function resolve4(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
-        function resolve4(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
-
-        function resolve6(hostname: string): Promise<string[]>;
-        function resolve6(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
-        function resolve6(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
-
-        function resolveAny(hostname: string): Promise<AnyRecord[]>;
-
-        function resolveCname(hostname: string): Promise<string[]>;
-
-        function resolveMx(hostname: string): Promise<MxRecord[]>;
-
-        function resolveNaptr(hostname: string): Promise<NaptrRecord[]>;
-
-        function resolveNs(hostname: string): Promise<string[]>;
-
-        function resolvePtr(hostname: string): Promise<string[]>;
-
-        function resolveSoa(hostname: string): Promise<SoaRecord>;
-
-        function resolveSrv(hostname: string): Promise<SrvRecord[]>;
-
-        function resolveTxt(hostname: string): Promise<string[][]>;
-
-        function reverse(ip: string): Promise<string[]>;
-
-        function setServers(servers: ReadonlyArray<string>): void;
-
-        class Resolver {
-            getServers: typeof getServers;
-            resolve: typeof resolve;
-            resolve4: typeof resolve4;
-            resolve6: typeof resolve6;
-            resolveAny: typeof resolveAny;
-            resolveCname: typeof resolveCname;
-            resolveMx: typeof resolveMx;
-            resolveNaptr: typeof resolveNaptr;
-            resolveNs: typeof resolveNs;
-            resolvePtr: typeof resolvePtr;
-            resolveSoa: typeof resolveSoa;
-            resolveSrv: typeof resolveSrv;
-            resolveTxt: typeof resolveTxt;
-            reverse: typeof reverse;
-            setServers: typeof setServers;
-        }
-    }
 }

node/domain.d.ts

@@ -0,0 +1,16 @@
+declare module "domain" {
+    import * as events from "events";
+
+    class Domain extends events.EventEmitter implements NodeJS.Domain {
+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+        add(emitter: events.EventEmitter | NodeJS.Timer): void;
+        remove(emitter: events.EventEmitter | NodeJS.Timer): void;
+        bind<T extends Function>(cb: T): T;
+        intercept<T extends Function>(cb: T): T;
+        members: Array<events.EventEmitter | NodeJS.Timer>;
+        enter(): void;
+        exit(): void;
+    }
+
+    function create(): Domain;
+}