dimaslanjaka / universal-framework

declare module "crypto" {

    import * as stream from "stream";

    interface Certificate {

        exportChallenge(spkac: BinaryLike): Buffer;

        exportPublicKey(spkac: BinaryLike): Buffer;

        verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;

    }

    const Certificate: {

        new(): Certificate;

        (): Certificate;

    };

    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. */

        const SSL_OP_ALL: number;

        /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */

        const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;

        /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */

        const SSL_OP_CIPHER_SERVER_PREFERENCE: number;

        /** Instructs OpenSSL to use Cisco's "speshul" version of DTLS_BAD_VER. */

        const SSL_OP_CISCO_ANYCONNECT: number;

        /** Instructs OpenSSL to turn on cookie exchange. */

        const SSL_OP_COOKIE_EXCHANGE: number;

        /** Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft. */

        const SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;

        /** Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d. */

        const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;

        /** Instructs OpenSSL to always use the tmp_rsa key when performing RSA operations. */

        const SSL_OP_EPHEMERAL_RSA: number;

        /** Allows initial connection to servers that do not support RI. */

        const SSL_OP_LEGACY_SERVER_CONNECT: number;

        const SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;

        const SSL_OP_MICROSOFT_SESS_ID_BUG: number;

        /** Instructs OpenSSL to disable the workaround for a man-in-the-middle protocol-version vulnerability in the SSL 2.0 server implementation. */

        const SSL_OP_MSIE_SSLV2_RSA_PADDING: number;

        const SSL_OP_NETSCAPE_CA_DN_BUG: number;

        const SSL_OP_NETSCAPE_CHALLENGE_BUG: number;

        const SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;

        const SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;

        /** Instructs OpenSSL to disable support for SSL/TLS compression. */

        const SSL_OP_NO_COMPRESSION: number;

        const SSL_OP_NO_QUERY_MTU: number;

        /** Instructs OpenSSL to always start a new session when performing renegotiation. */

        const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;

        const SSL_OP_NO_SSLv2: number;

        const SSL_OP_NO_SSLv3: number;

        const SSL_OP_NO_TICKET: number;

        const SSL_OP_NO_TLSv1: number;

        const SSL_OP_NO_TLSv1_1: number;

        const SSL_OP_NO_TLSv1_2: number;

        const SSL_OP_PKCS1_CHECK_1: number;

        const SSL_OP_PKCS1_CHECK_2: number;

        /** Instructs OpenSSL to always create a new key when using temporary/ephemeral DH parameters. */

        const SSL_OP_SINGLE_DH_USE: number;

        /** Instructs OpenSSL to always create a new key when using temporary/ephemeral ECDH parameters. */

        const SSL_OP_SINGLE_ECDH_USE: number;

        const SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;

        const SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;

        const SSL_OP_TLS_BLOCK_PADDING_BUG: number;

        const SSL_OP_TLS_D5_BUG: number;

        /** Instructs OpenSSL to disable version rollback attack detection. */

        const SSL_OP_TLS_ROLLBACK_BUG: number;

        const ENGINE_METHOD_RSA: number;

        const ENGINE_METHOD_DSA: number;

        const ENGINE_METHOD_DH: number;

        const ENGINE_METHOD_RAND: number;

        const ENGINE_METHOD_EC: number;

        const ENGINE_METHOD_CIPHERS: number;

        const ENGINE_METHOD_DIGESTS: number;

        const ENGINE_METHOD_PKEY_METHS: number;

        const ENGINE_METHOD_PKEY_ASN1_METHS: number;

        const ENGINE_METHOD_ALL: number;

        const ENGINE_METHOD_NONE: number;

        const DH_CHECK_P_NOT_SAFE_PRIME: number;

        const DH_CHECK_P_NOT_PRIME: number;

        const DH_UNABLE_TO_CHECK_GENERATOR: number;

        const DH_NOT_SUITABLE_GENERATOR: number;

        const ALPN_ENABLED: number;

        const RSA_PKCS1_PADDING: number;

        const RSA_SSLV23_PADDING: number;

        const RSA_NO_PADDING: number;

        const RSA_PKCS1_OAEP_PADDING: number;

        const RSA_X931_PADDING: number;

        const RSA_PKCS1_PSS_PADDING: number;

        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying. */

        const RSA_PSS_SALTLEN_DIGEST: number;

        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data. */

        const RSA_PSS_SALTLEN_MAX_SIGN: number;

        /** Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature. */

        const RSA_PSS_SALTLEN_AUTO: number;

        const POINT_CONVERSION_COMPRESSED: number;

        const POINT_CONVERSION_UNCOMPRESSED: number;

        const POINT_CONVERSION_HYBRID: number;

        /** Specifies the built-in default cipher list used by Node.js (colon-separated values). */

        const defaultCoreCipherList: string;

        /** Specifies the active default cipher list used by the current Node.js process  (colon-separated values). */

        const defaultCipherList: string;

    }

    interface HashOptions extends stream.TransformOptions {

        /**

         * For XOF hash functions such as `shake256`, the

         * outputLength option can be used to specify the desired output length in bytes.

         */

        outputLength?: number;

    }

    /** @deprecated since v10.0.0 */

    const fips: boolean;

    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";

    class Hash extends stream.Transform {

        private constructor();

        copy(): Hash;

        update(data: BinaryLike): Hash;

        update(data: string, input_encoding: Utf8AsciiLatin1Encoding): Hash;

        digest(): Buffer;

        digest(encoding: HexBase64Latin1Encoding): string;

    }

    class Hmac extends stream.Transform {

        private constructor();

        update(data: BinaryLike): Hmac;

        update(data: string, input_encoding: Utf8AsciiLatin1Encoding): Hmac;

        digest(): Buffer;

        digest(encoding: HexBase64Latin1Encoding): string;

    }

    type KeyObjectType = 'secret' | 'public' | 'private';

    interface KeyExportOptions<T extends KeyFormat> {

        type: 'pkcs1' | 'spki' | 'pkcs8' | 'sec1';

        format: T;

        cipher?: string;

        passphrase?: string | Buffer;

    }

    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;

        symmetricKeySize?: number;

        type: KeyObjectType;

    }

    type CipherCCMTypes = 'aes-128-ccm' | 'aes-192-ccm' | 'aes-256-ccm' | 'chacha20-poly1305';

    type CipherGCMTypes = 'aes-128-gcm' | 'aes-192-gcm' | 'aes-256-gcm';

    type BinaryLike = string | NodeJS.ArrayBufferView;

    type CipherKey = BinaryLike | KeyObject;

    interface CipherCCMOptions extends stream.TransformOptions {

        authTagLength: number;

    }

    interface CipherGCMOptions extends stream.TransformOptions {

        authTagLength?: number;

    }

    /** @deprecated since v10.0.0 use createCipheriv() */

    function createCipher(algorithm: CipherCCMTypes, password: BinaryLike, options: CipherCCMOptions): CipherCCM;

    /** @deprecated since v10.0.0 use createCipheriv() */

    function createCipher(algorithm: CipherGCMTypes, password: BinaryLike, options?: CipherGCMOptions): CipherGCM;

    /** @deprecated since v10.0.0 use createCipheriv() */

    function createCipher(algorithm: string, password: BinaryLike, options?: stream.TransformOptions): Cipher;

    function createCipheriv(

        algorithm: CipherCCMTypes,

        key: CipherKey,

        iv: BinaryLike | null,

        options: CipherCCMOptions

    ): CipherCCM;

    function createCipheriv(

        algorithm: CipherGCMTypes,

        key: CipherKey,

        iv: BinaryLike | null,

        options?: CipherGCMOptions

    ): CipherGCM;

    function createCipheriv(

        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;

        final(): Buffer;

        final(output_encoding: BufferEncoding): string;

        setAutoPadding(auto_padding?: boolean): this;

        // getAuthTag(): Buffer;

        // setAAD(buffer: Buffer): this; // docs only say buffer

    }

    interface CipherCCM extends Cipher {

        setAAD(buffer: Buffer, options: { plaintextLength: number }): this;

        getAuthTag(): Buffer;

    }

    interface CipherGCM extends Cipher {

        setAAD(buffer: Buffer, options?: { plaintextLength: number }): this;

        getAuthTag(): Buffer;

    }

    /** @deprecated since v10.0.0 use createDecipheriv() */

    function createDecipher(algorithm: CipherCCMTypes, password: BinaryLike, options: CipherCCMOptions): DecipherCCM;

    /** @deprecated since v10.0.0 use createDecipheriv() */

    function createDecipher(algorithm: CipherGCMTypes, password: BinaryLike, options?: CipherGCMOptions): DecipherGCM;

    /** @deprecated since v10.0.0 use createDecipheriv() */

    function createDecipher(algorithm: string, password: BinaryLike, options?: stream.TransformOptions): Decipher;

    function createDecipheriv(

        algorithm: CipherCCMTypes,

        key: CipherKey,

        iv: BinaryLike | null,

        options: CipherCCMOptions,

    ): DecipherCCM;

    function createDecipheriv(

        algorithm: CipherGCMTypes,

        key: CipherKey,

        iv: BinaryLike | null,

        options?: CipherGCMOptions,

    ): DecipherGCM;

    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;

        final(): Buffer;

        final(output_encoding: BufferEncoding): string;

        setAutoPadding(auto_padding?: boolean): this;

        // setAuthTag(tag: NodeJS.ArrayBufferView): this;

        // setAAD(buffer: NodeJS.ArrayBufferView): this;

    }

    interface DecipherCCM extends Decipher {

        setAuthTag(buffer: NodeJS.ArrayBufferView): this;

        setAAD(buffer: NodeJS.ArrayBufferView, options: { plaintextLength: number }): this;

    }

    interface DecipherGCM extends Decipher {

        setAuthTag(buffer: NodeJS.ArrayBufferView): this;

        setAAD(buffer: NodeJS.ArrayBufferView, options?: { plaintextLength: number }): this;

    }

    interface PrivateKeyInput {

        key: string | Buffer;

        format?: KeyFormat;

        type?: 'pkcs1' | 'pkcs8' | 'sec1';

        passphrase?: string | Buffer;

    }

    interface PublicKeyInput {

        key: string | Buffer;

        format?: KeyFormat;

        type?: 'pkcs1' | 'spki';

    }

    function createPrivateKey(key: PrivateKeyInput | string | Buffer): KeyObject;

    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject): KeyObject;

    function createSecretKey(key: Buffer): KeyObject;

    function createSign(algorithm: string, options?: stream.WritableOptions): Signer;

    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 {

        private constructor();

        update(data: BinaryLike): Signer;

        update(data: string, input_encoding: Utf8AsciiLatin1Encoding): Signer;

        sign(private_key: SignPrivateKeyInput | KeyLike): Buffer;

        sign(private_key: SignPrivateKeyInput | KeyLike, output_format: HexBase64Latin1Encoding): string;

    }

    function createVerify(algorithm: string, options?: stream.WritableOptions): Verify;

    class Verify extends stream.Writable {

        private constructor();

        update(data: BinaryLike): Verify;

        update(data: string, input_encoding: Utf8AsciiLatin1Encoding): Verify;

        verify(object: object | KeyLike, signature: NodeJS.ArrayBufferView): boolean;

        verify(object: object | KeyLike, signature: string, signature_format?: HexBase64Latin1Encoding): boolean;

        // https://nodejs.org/api/crypto.html#crypto_verifier_verify_object_signature_signature_format

        // The signature field accepts a TypedArray type, but it is only available starting ES2017

    }

    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;

    class DiffieHellman {

        private constructor();

        generateKeys(): Buffer;

        generateKeys(encoding: HexBase64Latin1Encoding): 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;

        getPrime(): Buffer;

        getPrime(encoding: HexBase64Latin1Encoding): string;

        getGenerator(): Buffer;

        getGenerator(encoding: HexBase64Latin1Encoding): string;

        getPublicKey(): Buffer;

        getPublicKey(encoding: HexBase64Latin1Encoding): string;

        getPrivateKey(): Buffer;

        getPrivateKey(encoding: HexBase64Latin1Encoding): string;

        setPublicKey(public_key: NodeJS.ArrayBufferView): void;

        setPublicKey(public_key: string, encoding: BufferEncoding): void;

        setPrivateKey(private_key: NodeJS.ArrayBufferView): void;

        setPrivateKey(private_key: string, encoding: BufferEncoding): void;

        verifyError: number;

    }

    function getDiffieHellman(group_name: string): DiffieHellman;

    function pbkdf2(

        password: BinaryLike,

        salt: BinaryLike,

        iterations: number,

        keylen: number,

        digest: string,

        callback: (err: Error | null, derivedKey: Buffer) => any,

    ): void;

    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;

    function pseudoRandomBytes(size: number): Buffer;

    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;

    interface ScryptOptions {

        N?: number;

        r?: number;

        p?: number;

        maxmem?: number;

    }

    function scrypt(

        password: BinaryLike,

        salt: BinaryLike,

        keylen: number, callback: (err: Error | null, derivedKey: Buffer) => void,

    ): void;

    function scrypt(

        password: BinaryLike,

        salt: BinaryLike,

        keylen: number,

        options: ScryptOptions,

        callback: (err: Error | null, derivedKey: Buffer) => void,

    ): void;

    function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;

    interface RsaPublicKey {

        key: KeyLike;

        padding?: number;

    }

    interface RsaPrivateKey {

        key: KeyLike;

        passphrase?: string;

        /**

         * @default 'sha1'

         */

        oaepHash?: string;

        oaepLabel?: NodeJS.TypedArray;

        padding?: number;

    }

    function publicEncrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;

    function publicDecrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;

    function privateDecrypt(private_key: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;

    function privateEncrypt(private_key: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;

    function getCiphers(): string[];

    function getCurves(): string[];

    function getHashes(): string[];

    class ECDH {

        private constructor();

        static convertKey(

            key: BinaryLike,

            curve: string,

            inputEncoding?: HexBase64Latin1Encoding,

            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;

        getPrivateKey(): Buffer;

        getPrivateKey(encoding: HexBase64Latin1Encoding): string;

        getPublicKey(): Buffer;

        getPublicKey(encoding: HexBase64Latin1Encoding, format?: ECDHKeyFormat): string;

        setPrivateKey(private_key: NodeJS.ArrayBufferView): void;

        setPrivateKey(private_key: string, encoding: HexBase64Latin1Encoding): void;

    }

    function createECDH(curve_name: string): ECDH;

    function timingSafeEqual(a: NodeJS.ArrayBufferView, b: NodeJS.ArrayBufferView): boolean;

    /** @deprecated since v10.0.0 */

    const DEFAULT_ENCODING: BufferEncoding;

    type KeyType = 'rsa' | 'dsa' | 'ec';

    type KeyFormat = 'pem' | 'der';

    interface BasePrivateKeyEncodingOptions<T extends KeyFormat> {

        format: T;

        cipher?: string;

        passphrase?: string;

    }

    interface KeyPairKeyObjectResult {

        publicKey: KeyObject;

        privateKey: KeyObject;

    }

    interface ECKeyPairKeyObjectOptions {

        /**

         * Name of the curve to use.

         */

        namedCurve: string;

    }

    interface RSAKeyPairKeyObjectOptions {

        /**

         * Key size in bits

         */

        modulusLength: number;

        /**

         * @default 0x10001

         */

        publicExponent?: number;

    }

    interface DSAKeyPairKeyObjectOptions {

        /**

         * Key size in bits

         */

        modulusLength: number;

        /**

         * Size of q in bits

         */

        divisorLength: number;

    }

    interface RSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {

        /**

         * Key size in bits

         */

        modulusLength: number;

        /**

         * @default 0x10001

         */

        publicExponent?: number;

        publicKeyEncoding: {

            type: 'pkcs1' | 'spki';

            format: PubF;

        };

        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {

            type: 'pkcs1' | 'pkcs8';

        };

    }

    interface DSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {

        /**

         * Key size in bits

         */

        modulusLength: number;

        /**

         * Size of q in bits

         */

        divisorLength: number;

        publicKeyEncoding: {

            type: 'spki';

            format: PubF;

        };

        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {

            type: 'pkcs8';

        };

    }

    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {

        /**

         * Name of the curve to use.

         */

        namedCurve: string;

        publicKeyEncoding: {

            type: 'pkcs1' | 'spki';

            format: PubF;

        };

        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {

            type: 'sec1' | 'pkcs8';

        };

    }

    interface KeyPairSyncResult<T1 extends string | Buffer, T2 extends string | Buffer> {

        publicKey: T1;

        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: 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: 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: 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: '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;

    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>;

    }

    /**

     * 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: NodeJS.ArrayBufferView, 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: NodeJS.ArrayBufferView, key: KeyLike | VerifyKeyWithOptions, signature: NodeJS.ArrayBufferView): boolean;

}