@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/crypto.d.ts

@@ -0,0 +1,847 @@
+declare module "node:crypto" {
+    import { NonSharedBuffer } from "node:buffer";
+    import * as stream from "node:stream";
+    import { PeerCertificate } from "node:tls";
+    class Certificate {
+        static exportChallenge(spkac: BinaryLike): NonSharedBuffer;
+        static exportPublicKey(spkac: BinaryLike, encoding?: string): NonSharedBuffer;
+        static verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
+        exportChallenge(spkac: BinaryLike): NonSharedBuffer;
+        exportPublicKey(spkac: BinaryLike, encoding?: string): NonSharedBuffer;
+        verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
+    }
+    namespace constants {
+        const OPENSSL_VERSION_NUMBER: number;
+        const SSL_OP_ALL: number;
+        const SSL_OP_ALLOW_NO_DHE_KEX: number;
+        const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
+        const SSL_OP_CIPHER_SERVER_PREFERENCE: number;
+        const SSL_OP_CISCO_ANYCONNECT: number;
+        const SSL_OP_COOKIE_EXCHANGE: number;
+        const SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;
+        const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;
+        const SSL_OP_LEGACY_SERVER_CONNECT: number;
+        const SSL_OP_NO_COMPRESSION: number;
+        const SSL_OP_NO_ENCRYPT_THEN_MAC: number;
+        const SSL_OP_NO_QUERY_MTU: number;
+        const SSL_OP_NO_RENEGOTIATION: number;
+        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_NO_TLSv1_3: number;
+        const SSL_OP_PRIORITIZE_CHACHA: number;
+        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 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;
+        const RSA_PSS_SALTLEN_DIGEST: number;
+        const RSA_PSS_SALTLEN_MAX_SIGN: number;
+        const RSA_PSS_SALTLEN_AUTO: number;
+        const POINT_CONVERSION_COMPRESSED: number;
+        const POINT_CONVERSION_UNCOMPRESSED: number;
+        const POINT_CONVERSION_HYBRID: number;
+        const defaultCoreCipherList: string;
+        const defaultCipherList: string;
+    }
+    interface HashOptions extends stream.TransformOptions {
+        outputLength?: number | undefined;
+    }
+    const fips: boolean;
+    function createHash(algorithm: string, options?: HashOptions): Hash;
+    function createHmac(algorithm: string, key: BinaryLike | KeyObject, options?: stream.TransformOptions): Hmac;
+    type BinaryToTextEncoding = "base64" | "base64url" | "hex" | "binary";
+    type CharacterEncoding = "utf8" | "utf-8" | "utf16le" | "utf-16le" | "latin1";
+    type LegacyCharacterEncoding = "ascii" | "binary" | "ucs2" | "ucs-2";
+    type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
+    type ECDHKeyFormat = "compressed" | "uncompressed" | "hybrid";
+    class Hash extends stream.Transform {
+        private constructor();
+        copy(options?: HashOptions): Hash;
+        update(data: BinaryLike): Hash;
+        update(data: string, inputEncoding: Encoding): Hash;
+        digest(): NonSharedBuffer;
+        digest(encoding: BinaryToTextEncoding): string;
+    }
+    class Hmac extends stream.Transform {
+        private constructor();
+        update(data: BinaryLike): Hmac;
+        update(data: string, inputEncoding: Encoding): Hmac;
+        digest(): NonSharedBuffer;
+        digest(encoding: BinaryToTextEncoding): string;
+    }
+    type KeyFormat = "pem" | "der" | "jwk";
+    type KeyObjectType = "secret" | "public" | "private";
+    type PublicKeyExportType = "pkcs1" | "spki";
+    type PrivateKeyExportType = "pkcs1" | "pkcs8" | "sec1";
+    type KeyExportOptions = SymmetricKeyExportOptions | PublicKeyExportOptions | PrivateKeyExportOptions | JwkKeyExportOptions;
+    interface SymmetricKeyExportOptions {
+        format?: "buffer" | undefined;
+    }
+    interface PublicKeyExportOptions<T extends PublicKeyExportType = PublicKeyExportType> {
+        type: T;
+        format: Exclude<KeyFormat, "jwk">;
+    }
+    interface PrivateKeyExportOptions<T extends PrivateKeyExportType = PrivateKeyExportType> {
+        type: T;
+        format: Exclude<KeyFormat, "jwk">;
+        cipher?: string | undefined;
+        passphrase?: string | Buffer | undefined;
+    }
+    interface JwkKeyExportOptions {
+        format: "jwk";
+    }
+    interface KeyPairExportOptions<TPublic extends PublicKeyExportType = PublicKeyExportType, TPrivate extends PrivateKeyExportType = PrivateKeyExportType> {
+        publicKeyEncoding?: PublicKeyExportOptions<TPublic> | JwkKeyExportOptions | undefined;
+        privateKeyEncoding?: PrivateKeyExportOptions<TPrivate> | JwkKeyExportOptions | undefined;
+    }
+    type KeyExportResult<T, Default> = T extends {
+        format: infer F extends KeyFormat;
+    } ? {
+        der: NonSharedBuffer;
+        jwk: webcrypto.JsonWebKey;
+        pem: string;
+    }[F] : Default;
+    interface KeyPairExportResult<T extends KeyPairExportOptions> {
+        publicKey: KeyExportResult<T["publicKeyEncoding"], KeyObject>;
+        privateKey: KeyExportResult<T["privateKeyEncoding"], KeyObject>;
+    }
+    type KeyPairExportCallback<T extends KeyPairExportOptions> = (err: Error | null, publicKey: KeyExportResult<T["publicKeyEncoding"], KeyObject>, privateKey: KeyExportResult<T["privateKeyEncoding"], KeyObject>) => void;
+    type MLDSAKeyType = `ml-dsa-${44 | 65 | 87}`;
+    type MLKEMKeyType = `ml-kem-${1024 | 512 | 768}`;
+    type SLHDSAKeyType = `slh-dsa-${"sha2" | "shake"}-${128 | 192 | 256}${"f" | "s"}`;
+    type AsymmetricKeyType = "dh" | "dsa" | "ec" | "ed25519" | "ed448" | MLDSAKeyType | MLKEMKeyType | "rsa-pss" | "rsa" | SLHDSAKeyType | "x25519" | "x448";
+    interface AsymmetricKeyDetails {
+        modulusLength?: number;
+        publicExponent?: bigint;
+        hashAlgorithm?: string;
+        mgf1HashAlgorithm?: string;
+        saltLength?: number;
+        divisorLength?: number;
+        namedCurve?: string;
+    }
+    class KeyObject {
+        private constructor();
+        static from(key: webcrypto.CryptoKey): KeyObject;
+        asymmetricKeyType?: AsymmetricKeyType;
+        asymmetricKeyDetails?: AsymmetricKeyDetails;
+        export<T extends KeyExportOptions = {}>(options?: T): KeyExportResult<T, NonSharedBuffer>;
+        equals(otherKeyObject: KeyObject): boolean;
+        symmetricKeySize?: number;
+        toCryptoKey(algorithm: webcrypto.AlgorithmIdentifier | webcrypto.RsaHashedImportParams | webcrypto.EcKeyImportParams | webcrypto.HmacImportParams, extractable: boolean, keyUsages: readonly webcrypto.KeyUsage[]): webcrypto.CryptoKey;
+        type: KeyObjectType;
+    }
+    type CipherCCMTypes = "aes-128-ccm" | "aes-192-ccm" | "aes-256-ccm";
+    type CipherGCMTypes = "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm";
+    type CipherOCBTypes = "aes-128-ocb" | "aes-192-ocb" | "aes-256-ocb";
+    type CipherChaCha20Poly1305Types = "chacha20-poly1305";
+    type BinaryLike = string | NodeJS.ArrayBufferView;
+    type CipherKey = BinaryLike | KeyObject;
+    interface CipherCCMOptions extends stream.TransformOptions {
+        authTagLength: number;
+    }
+    interface CipherGCMOptions extends stream.TransformOptions {
+        authTagLength?: number | undefined;
+    }
+    interface CipherOCBOptions extends stream.TransformOptions {
+        authTagLength: number;
+    }
+    interface CipherChaCha20Poly1305Options extends stream.TransformOptions {
+        authTagLength?: number | undefined;
+    }
+    function createCipheriv(algorithm: CipherCCMTypes, key: CipherKey, iv: BinaryLike, options: CipherCCMOptions): CipherCCM;
+    function createCipheriv(algorithm: CipherOCBTypes, key: CipherKey, iv: BinaryLike, options: CipherOCBOptions): CipherOCB;
+    function createCipheriv(algorithm: CipherGCMTypes, key: CipherKey, iv: BinaryLike, options?: CipherGCMOptions): CipherGCM;
+    function createCipheriv(algorithm: CipherChaCha20Poly1305Types, key: CipherKey, iv: BinaryLike, options?: CipherChaCha20Poly1305Options): CipherChaCha20Poly1305;
+    function createCipheriv(algorithm: string, key: CipherKey, iv: BinaryLike | null, options?: stream.TransformOptions): Cipheriv;
+    class Cipheriv extends stream.Transform {
+        private constructor();
+        update(data: BinaryLike): NonSharedBuffer;
+        update(data: string, inputEncoding: Encoding): NonSharedBuffer;
+        update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
+        update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
+        final(): NonSharedBuffer;
+        final(outputEncoding: BufferEncoding): string;
+        setAutoPadding(autoPadding?: boolean): this;
+    }
+    interface CipherCCM extends Cipheriv {
+        setAAD(buffer: NodeJS.ArrayBufferView, options: {
+            plaintextLength: number;
+        }): this;
+        getAuthTag(): NonSharedBuffer;
+    }
+    interface CipherGCM extends Cipheriv {
+        setAAD(buffer: NodeJS.ArrayBufferView, options?: {
+            plaintextLength: number;
+        }): this;
+        getAuthTag(): NonSharedBuffer;
+    }
+    interface CipherOCB extends Cipheriv {
+        setAAD(buffer: NodeJS.ArrayBufferView, options?: {
+            plaintextLength: number;
+        }): this;
+        getAuthTag(): NonSharedBuffer;
+    }
+    interface CipherChaCha20Poly1305 extends Cipheriv {
+        setAAD(buffer: NodeJS.ArrayBufferView, options: {
+            plaintextLength: number;
+        }): this;
+        getAuthTag(): NonSharedBuffer;
+    }
+    function createDecipheriv(algorithm: CipherCCMTypes, key: CipherKey, iv: BinaryLike, options: CipherCCMOptions): DecipherCCM;
+    function createDecipheriv(algorithm: CipherOCBTypes, key: CipherKey, iv: BinaryLike, options: CipherOCBOptions): DecipherOCB;
+    function createDecipheriv(algorithm: CipherGCMTypes, key: CipherKey, iv: BinaryLike, options?: CipherGCMOptions): DecipherGCM;
+    function createDecipheriv(algorithm: CipherChaCha20Poly1305Types, key: CipherKey, iv: BinaryLike, options?: CipherChaCha20Poly1305Options): DecipherChaCha20Poly1305;
+    function createDecipheriv(algorithm: string, key: CipherKey, iv: BinaryLike | null, options?: stream.TransformOptions): Decipheriv;
+    class Decipheriv extends stream.Transform {
+        private constructor();
+        update(data: NodeJS.ArrayBufferView): NonSharedBuffer;
+        update(data: string, inputEncoding: Encoding): NonSharedBuffer;
+        update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
+        update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
+        final(): NonSharedBuffer;
+        final(outputEncoding: BufferEncoding): string;
+        setAutoPadding(auto_padding?: boolean): this;
+    }
+    interface DecipherCCM extends Decipheriv {
+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
+        setAAD(buffer: NodeJS.ArrayBufferView, options: {
+            plaintextLength: number;
+        }): this;
+    }
+    interface DecipherGCM extends Decipheriv {
+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
+        setAAD(buffer: NodeJS.ArrayBufferView, options?: {
+            plaintextLength: number;
+        }): this;
+    }
+    interface DecipherOCB extends Decipheriv {
+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
+        setAAD(buffer: NodeJS.ArrayBufferView, options?: {
+            plaintextLength: number;
+        }): this;
+    }
+    interface DecipherChaCha20Poly1305 extends Decipheriv {
+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
+        setAAD(buffer: NodeJS.ArrayBufferView, options: {
+            plaintextLength: number;
+        }): this;
+    }
+    interface PrivateKeyInput {
+        key: string | Buffer;
+        format?: KeyFormat | undefined;
+        type?: PrivateKeyExportType | undefined;
+        passphrase?: string | Buffer | undefined;
+        encoding?: string | undefined;
+    }
+    interface PublicKeyInput {
+        key: string | Buffer;
+        format?: KeyFormat | undefined;
+        type?: PublicKeyExportType | undefined;
+        encoding?: string | undefined;
+    }
+    function generateKey(type: "hmac" | "aes", options: {
+        length: number;
+    }, callback: (err: Error | null, key: KeyObject) => void): void;
+    function generateKeySync(type: "hmac" | "aes", options: {
+        length: number;
+    }): KeyObject;
+    interface JsonWebKeyInput {
+        key: webcrypto.JsonWebKey;
+        format: "jwk";
+    }
+    function createPrivateKey(key: PrivateKeyInput | string | Buffer | JsonWebKeyInput): KeyObject;
+    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput): KeyObject;
+    function createSecretKey(key: NodeJS.ArrayBufferView): KeyObject;
+    function createSecretKey(key: string, encoding: BufferEncoding): KeyObject;
+    function createSign(algorithm: string, options?: stream.WritableOptions): Sign;
+    type DSAEncoding = "der" | "ieee-p1363";
+    interface SigningOptions {
+        padding?: number | undefined;
+        saltLength?: number | undefined;
+        dsaEncoding?: DSAEncoding | undefined;
+        context?: ArrayBuffer | NodeJS.ArrayBufferView | undefined;
+    }
+    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {
+    }
+    interface SignKeyObjectInput extends SigningOptions {
+        key: KeyObject;
+    }
+    interface SignJsonWebKeyInput extends JsonWebKeyInput, SigningOptions {
+    }
+    interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {
+    }
+    interface VerifyKeyObjectInput extends SigningOptions {
+        key: KeyObject;
+    }
+    interface VerifyJsonWebKeyInput extends JsonWebKeyInput, SigningOptions {
+    }
+    type KeyLike = string | Buffer | KeyObject;
+    class Sign extends stream.Writable {
+        private constructor();
+        update(data: BinaryLike): this;
+        update(data: string, inputEncoding: Encoding): this;
+        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput): NonSharedBuffer;
+        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput, outputFormat: BinaryToTextEncoding): string;
+    }
+    function createVerify(algorithm: string, options?: stream.WritableOptions): Verify;
+    class Verify extends stream.Writable {
+        private constructor();
+        update(data: BinaryLike): Verify;
+        update(data: string, inputEncoding: Encoding): Verify;
+        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput, signature: NodeJS.ArrayBufferView): boolean;
+        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput, signature: string, signature_format?: BinaryToTextEncoding): boolean;
+    }
+    function createDiffieHellman(primeLength: number, generator?: number): DiffieHellman;
+    function createDiffieHellman(prime: ArrayBuffer | NodeJS.ArrayBufferView, generator?: number | ArrayBuffer | NodeJS.ArrayBufferView): DiffieHellman;
+    function createDiffieHellman(prime: ArrayBuffer | NodeJS.ArrayBufferView, generator: string, generatorEncoding: BinaryToTextEncoding): DiffieHellman;
+    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator?: number | ArrayBuffer | NodeJS.ArrayBufferView): DiffieHellman;
+    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator: string, generatorEncoding: BinaryToTextEncoding): DiffieHellman;
+    class DiffieHellman {
+        private constructor();
+        generateKeys(): NonSharedBuffer;
+        generateKeys(encoding: BinaryToTextEncoding): string;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding?: null, outputEncoding?: null): NonSharedBuffer;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding?: null): NonSharedBuffer;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding: null, outputEncoding: BinaryToTextEncoding): string;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding: BinaryToTextEncoding): string;
+        getPrime(): NonSharedBuffer;
+        getPrime(encoding: BinaryToTextEncoding): string;
+        getGenerator(): NonSharedBuffer;
+        getGenerator(encoding: BinaryToTextEncoding): string;
+        getPublicKey(): NonSharedBuffer;
+        getPublicKey(encoding: BinaryToTextEncoding): string;
+        getPrivateKey(): NonSharedBuffer;
+        getPrivateKey(encoding: BinaryToTextEncoding): string;
+        setPublicKey(publicKey: NodeJS.ArrayBufferView): void;
+        setPublicKey(publicKey: string, encoding: BufferEncoding): void;
+        setPrivateKey(privateKey: NodeJS.ArrayBufferView): void;
+        setPrivateKey(privateKey: string, encoding: BufferEncoding): void;
+        verifyError: number;
+    }
+    const DiffieHellmanGroup: DiffieHellmanGroupConstructor;
+    interface DiffieHellmanGroupConstructor {
+        new (name: string): DiffieHellmanGroup;
+        (name: string): DiffieHellmanGroup;
+        readonly prototype: DiffieHellmanGroup;
+    }
+    type DiffieHellmanGroup = Omit<DiffieHellman, "setPublicKey" | "setPrivateKey">;
+    function getDiffieHellman(groupName: string): DiffieHellmanGroup;
+    function createDiffieHellmanGroup(name: string): DiffieHellmanGroup;
+    function pbkdf2(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey: NonSharedBuffer) => void): void;
+    function pbkdf2Sync(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string): NonSharedBuffer;
+    function randomBytes(size: number): NonSharedBuffer;
+    function randomBytes(size: number, callback: (err: Error | null, buf: NonSharedBuffer) => void): void;
+    function pseudoRandomBytes(size: number): NonSharedBuffer;
+    function pseudoRandomBytes(size: number, callback: (err: Error | null, buf: NonSharedBuffer) => void): void;
+    function randomInt(max: number): number;
+    function randomInt(min: number, max: number): number;
+    function randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
+    function randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
+    function randomFillSync<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number, size?: number): T;
+    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
+    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, offset: number, callback: (err: Error | null, buf: T) => void): void;
+    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, offset: number, size: number, callback: (err: Error | null, buf: T) => void): void;
+    interface ScryptOptions {
+        cost?: number | undefined;
+        blockSize?: number | undefined;
+        parallelization?: number | undefined;
+        N?: number | undefined;
+        r?: number | undefined;
+        p?: number | undefined;
+        maxmem?: number | undefined;
+    }
+    function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: NonSharedBuffer) => void): void;
+    function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, options: ScryptOptions, callback: (err: Error | null, derivedKey: NonSharedBuffer) => void): void;
+    function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): NonSharedBuffer;
+    interface RsaPublicKey {
+        key: KeyLike;
+        padding?: number | undefined;
+    }
+    interface RsaPrivateKey {
+        key: KeyLike;
+        passphrase?: string | undefined;
+        oaepHash?: string | undefined;
+        oaepLabel?: NodeJS.TypedArray | undefined;
+        padding?: number | undefined;
+    }
+    function publicEncrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): NonSharedBuffer;
+    function publicDecrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): NonSharedBuffer;
+    function privateDecrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): NonSharedBuffer;
+    function privateEncrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): NonSharedBuffer;
+    function getCiphers(): string[];
+    function getCurves(): string[];
+    function getFips(): 1 | 0;
+    function setFips(bool: boolean): void;
+    function getHashes(): string[];
+    class ECDH {
+        private constructor();
+        static convertKey(key: BinaryLike, curve: string, inputEncoding?: BinaryToTextEncoding, outputEncoding?: "latin1" | "hex" | "base64" | "base64url", format?: "uncompressed" | "compressed" | "hybrid"): NonSharedBuffer | string;
+        generateKeys(): NonSharedBuffer;
+        generateKeys(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView): NonSharedBuffer;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding): NonSharedBuffer;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, outputEncoding: BinaryToTextEncoding): string;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding: BinaryToTextEncoding): string;
+        getPrivateKey(): NonSharedBuffer;
+        getPrivateKey(encoding: BinaryToTextEncoding): string;
+        getPublicKey(encoding?: null, format?: ECDHKeyFormat): NonSharedBuffer;
+        getPublicKey(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
+        setPrivateKey(privateKey: NodeJS.ArrayBufferView): void;
+        setPrivateKey(privateKey: string, encoding: BinaryToTextEncoding): void;
+    }
+    function createECDH(curveName: string): ECDH;
+    function timingSafeEqual(a: NodeJS.ArrayBufferView, b: NodeJS.ArrayBufferView): boolean;
+    interface DHKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+        prime?: Buffer | undefined;
+        primeLength?: number | undefined;
+        generator?: number | undefined;
+        groupName?: string | undefined;
+    }
+    interface DSAKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+        modulusLength: number;
+        divisorLength: number;
+    }
+    interface ECKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8" | "sec1"> {
+        namedCurve: string;
+        paramEncoding?: "explicit" | "named" | undefined;
+    }
+    interface ED25519KeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    interface ED448KeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    interface MLDSAKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    interface MLKEMKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    interface RSAPSSKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+        modulusLength: number;
+        publicExponent?: number | undefined;
+        hashAlgorithm?: string | undefined;
+        mgf1HashAlgorithm?: string | undefined;
+        saltLength?: string | undefined;
+    }
+    interface RSAKeyPairOptions extends KeyPairExportOptions<"pkcs1" | "spki", "pkcs1" | "pkcs8"> {
+        modulusLength: number;
+        publicExponent?: number | undefined;
+    }
+    interface SLHDSAKeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    interface X25519KeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    interface X448KeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {
+    }
+    function generateKeyPairSync<T extends DHKeyPairOptions>(type: "dh", options: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends DSAKeyPairOptions>(type: "dsa", options: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends ECKeyPairOptions>(type: "ec", options: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends ED25519KeyPairOptions = {}>(type: "ed25519", options?: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends ED448KeyPairOptions = {}>(type: "ed448", options?: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends MLDSAKeyPairOptions = {}>(type: MLDSAKeyType, options?: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends MLKEMKeyPairOptions = {}>(type: MLKEMKeyType, options?: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends RSAPSSKeyPairOptions>(type: "rsa-pss", options: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends RSAKeyPairOptions>(type: "rsa", options: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends SLHDSAKeyPairOptions = {}>(type: SLHDSAKeyType, options?: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends X25519KeyPairOptions = {}>(type: "x25519", options?: T): KeyPairExportResult<T>;
+    function generateKeyPairSync<T extends X448KeyPairOptions = {}>(type: "x448", options?: T): KeyPairExportResult<T>;
+    function generateKeyPair<T extends DHKeyPairOptions>(type: "dh", options: T, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends DSAKeyPairOptions>(type: "dsa", options: T, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends ECKeyPairOptions>(type: "ec", options: T, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends ED25519KeyPairOptions = {}>(type: "ed25519", options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends ED448KeyPairOptions = {}>(type: "ed448", options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends MLDSAKeyPairOptions = {}>(type: MLDSAKeyType, options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends MLKEMKeyPairOptions = {}>(type: MLKEMKeyType, options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends RSAPSSKeyPairOptions>(type: "rsa-pss", options: T, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends RSAKeyPairOptions>(type: "rsa", options: T, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends SLHDSAKeyPairOptions = {}>(type: SLHDSAKeyType, options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends X25519KeyPairOptions = {}>(type: "x25519", options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    function generateKeyPair<T extends X448KeyPairOptions = {}>(type: "x448", options: T | undefined, callback: KeyPairExportCallback<T>): void;
+    namespace generateKeyPair {
+        function __promisify__<T extends DHKeyPairOptions>(type: "dh", options: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends DSAKeyPairOptions>(type: "dsa", options: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends ECKeyPairOptions>(type: "ec", options: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends ED25519KeyPairOptions = {}>(type: "ed25519", options?: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends ED448KeyPairOptions = {}>(type: "ed448", options?: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends MLDSAKeyPairOptions = {}>(type: MLDSAKeyType, options?: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends MLKEMKeyPairOptions = {}>(type: MLKEMKeyType, options?: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends RSAPSSKeyPairOptions>(type: "rsa-pss", options: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends RSAKeyPairOptions>(type: "rsa", options: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends SLHDSAKeyPairOptions = {}>(type: SLHDSAKeyType, options?: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends X25519KeyPairOptions = {}>(type: "x25519", options?: T): Promise<KeyPairExportResult<T>>;
+        function __promisify__<T extends X448KeyPairOptions = {}>(type: "x448", options?: T): Promise<KeyPairExportResult<T>>;
+    }
+    function sign(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput): NonSharedBuffer;
+    function sign(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput, callback: (error: Error | null, data: NonSharedBuffer) => void): void;
+    function verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput, signature: NodeJS.ArrayBufferView): boolean;
+    function verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput, signature: NodeJS.ArrayBufferView, callback: (error: Error | null, result: boolean) => void): void;
+    function decapsulate(key: KeyLike | PrivateKeyInput | JsonWebKeyInput, ciphertext: ArrayBuffer | NodeJS.ArrayBufferView): NonSharedBuffer;
+    function decapsulate(key: KeyLike | PrivateKeyInput | JsonWebKeyInput, ciphertext: ArrayBuffer | NodeJS.ArrayBufferView, callback: (err: Error, sharedKey: NonSharedBuffer) => void): void;
+    function diffieHellman(options: {
+        privateKey: KeyObject;
+        publicKey: KeyObject;
+    }): NonSharedBuffer;
+    function diffieHellman(options: {
+        privateKey: KeyObject;
+        publicKey: KeyObject;
+    }, callback: (err: Error | null, secret: NonSharedBuffer) => void): void;
+    function encapsulate(key: KeyLike | PublicKeyInput | JsonWebKeyInput): {
+        sharedKey: NonSharedBuffer;
+        ciphertext: NonSharedBuffer;
+    };
+    function encapsulate(key: KeyLike | PublicKeyInput | JsonWebKeyInput, callback: (err: Error, result: {
+        sharedKey: NonSharedBuffer;
+        ciphertext: NonSharedBuffer;
+    }) => void): void;
+    interface OneShotDigestOptions {
+        outputEncoding?: BinaryToTextEncoding | "buffer" | undefined;
+        outputLength?: number | undefined;
+    }
+    interface OneShotDigestOptionsWithStringEncoding extends OneShotDigestOptions {
+        outputEncoding?: BinaryToTextEncoding | undefined;
+    }
+    interface OneShotDigestOptionsWithBufferEncoding extends OneShotDigestOptions {
+        outputEncoding: "buffer";
+    }
+    function hash(algorithm: string, data: BinaryLike, options?: OneShotDigestOptionsWithStringEncoding | BinaryToTextEncoding): string;
+    function hash(algorithm: string, data: BinaryLike, options: OneShotDigestOptionsWithBufferEncoding | "buffer"): NonSharedBuffer;
+    function hash(algorithm: string, data: BinaryLike, options: OneShotDigestOptions | BinaryToTextEncoding | "buffer"): string | NonSharedBuffer;
+    type CipherMode = "cbc" | "ccm" | "cfb" | "ctr" | "ecb" | "gcm" | "ocb" | "ofb" | "stream" | "wrap" | "xts";
+    interface CipherInfoOptions {
+        keyLength?: number | undefined;
+        ivLength?: number | undefined;
+    }
+    interface CipherInfo {
+        name: string;
+        nid: number;
+        blockSize?: number | undefined;
+        ivLength?: number | undefined;
+        keyLength: number;
+        mode: CipherMode;
+    }
+    function getCipherInfo(nameOrNid: string | number, options?: CipherInfoOptions): CipherInfo | undefined;
+    function hkdf(digest: string, irm: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => void): void;
+    function hkdfSync(digest: string, ikm: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
+    interface SecureHeapUsage {
+        total: number;
+        min: number;
+        used: number;
+        utilization: number;
+    }
+    function secureHeapUsed(): SecureHeapUsage;
+    interface RandomUUIDOptions {
+        disableEntropyCache?: boolean | undefined;
+    }
+    type UUID = `${string}-${string}-${string}-${string}-${string}`;
+    function randomUUID(options?: RandomUUIDOptions): UUID;
+    interface X509CheckOptions {
+        subject?: "always" | "default" | "never" | undefined;
+        wildcards?: boolean | undefined;
+        partialWildcards?: boolean | undefined;
+        multiLabelWildcards?: boolean | undefined;
+        singleLabelSubdomains?: boolean | undefined;
+    }
+    class X509Certificate {
+        readonly ca: boolean;
+        readonly fingerprint: string;
+        readonly fingerprint256: string;
+        readonly fingerprint512: string;
+        readonly subject: string;
+        readonly subjectAltName: string | undefined;
+        readonly infoAccess: string | undefined;
+        readonly keyUsage: string[];
+        readonly issuer: string;
+        readonly issuerCertificate: X509Certificate | undefined;
+        readonly publicKey: KeyObject;
+        readonly raw: NonSharedBuffer;
+        readonly serialNumber: string;
+        readonly signatureAlgorithm: string | undefined;
+        readonly signatureAlgorithmOid: string;
+        readonly validFrom: string;
+        readonly validFromDate: Date;
+        readonly validTo: string;
+        readonly validToDate: Date;
+        constructor(buffer: BinaryLike);
+        checkEmail(email: string, options?: Pick<X509CheckOptions, "subject">): string | undefined;
+        checkHost(name: string, options?: X509CheckOptions): string | undefined;
+        checkIP(ip: string): string | undefined;
+        checkIssued(otherCert: X509Certificate): boolean;
+        checkPrivateKey(privateKey: KeyObject): boolean;
+        toJSON(): string;
+        toLegacyObject(): PeerCertificate;
+        toString(): string;
+        verify(publicKey: KeyObject): boolean;
+    }
+    type LargeNumberLike = NodeJS.ArrayBufferView | SharedArrayBuffer | ArrayBuffer | bigint;
+    interface GeneratePrimeOptions {
+        add?: LargeNumberLike | undefined;
+        rem?: LargeNumberLike | undefined;
+        safe?: boolean | undefined;
+        bigint?: boolean | undefined;
+    }
+    interface GeneratePrimeOptionsBigInt extends GeneratePrimeOptions {
+        bigint: true;
+    }
+    interface GeneratePrimeOptionsArrayBuffer extends GeneratePrimeOptions {
+        bigint?: false | undefined;
+    }
+    function generatePrime(size: number, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
+    function generatePrime(size: number, options: GeneratePrimeOptionsBigInt, callback: (err: Error | null, prime: bigint) => void): void;
+    function generatePrime(size: number, options: GeneratePrimeOptionsArrayBuffer, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
+    function generatePrime(size: number, options: GeneratePrimeOptions, callback: (err: Error | null, prime: ArrayBuffer | bigint) => void): void;
+    function generatePrimeSync(size: number): ArrayBuffer;
+    function generatePrimeSync(size: number, options: GeneratePrimeOptionsBigInt): bigint;
+    function generatePrimeSync(size: number, options: GeneratePrimeOptionsArrayBuffer): ArrayBuffer;
+    function generatePrimeSync(size: number, options: GeneratePrimeOptions): ArrayBuffer | bigint;
+    interface CheckPrimeOptions {
+        checks?: number | undefined;
+    }
+    function checkPrime(value: LargeNumberLike, callback: (err: Error | null, result: boolean) => void): void;
+    function checkPrime(value: LargeNumberLike, options: CheckPrimeOptions, callback: (err: Error | null, result: boolean) => void): void;
+    function checkPrimeSync(candidate: LargeNumberLike, options?: CheckPrimeOptions): boolean;
+    function setEngine(engine: string, flags?: number): void;
+    function getRandomValues<T extends Exclude<NodeJS.NonSharedTypedArray, NodeJS.NonSharedFloat16Array | NodeJS.NonSharedFloat32Array | NodeJS.NonSharedFloat64Array>>(typedArray: T): T;
+    type Argon2Algorithm = "argon2d" | "argon2i" | "argon2id";
+    interface Argon2Parameters {
+        message: string | ArrayBuffer | NodeJS.ArrayBufferView;
+        nonce: string | ArrayBuffer | NodeJS.ArrayBufferView;
+        parallelism: number;
+        tagLength: number;
+        memory: number;
+        passes: number;
+        secret?: string | ArrayBuffer | NodeJS.ArrayBufferView | undefined;
+        associatedData?: string | ArrayBuffer | NodeJS.ArrayBufferView | undefined;
+    }
+    function argon2(algorithm: Argon2Algorithm, parameters: Argon2Parameters, callback: (err: Error | null, derivedKey: NonSharedBuffer) => void): void;
+    function argon2Sync(algorithm: Argon2Algorithm, parameters: Argon2Parameters): NonSharedBuffer;
+    const subtle: webcrypto.SubtleCrypto;
+    const webcrypto: webcrypto.Crypto;
+    namespace webcrypto {
+        type AlgorithmIdentifier = Algorithm | string;
+        type BigInteger = NodeJS.NonSharedUint8Array;
+        type KeyFormat = "jwk" | "pkcs8" | "raw" | "raw-public" | "raw-secret" | "raw-seed" | "spki";
+        type KeyType = "private" | "public" | "secret";
+        type KeyUsage = "decapsulateBits" | "decapsulateKey" | "decrypt" | "deriveBits" | "deriveKey" | "encapsulateBits" | "encapsulateKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
+        type HashAlgorithmIdentifier = AlgorithmIdentifier;
+        type NamedCurve = string;
+        interface AeadParams extends Algorithm {
+            additionalData?: NodeJS.BufferSource;
+            iv: NodeJS.BufferSource;
+            tagLength: number;
+        }
+        interface AesCbcParams extends Algorithm {
+            iv: NodeJS.BufferSource;
+        }
+        interface AesCtrParams extends Algorithm {
+            counter: NodeJS.BufferSource;
+            length: number;
+        }
+        interface AesDerivedKeyParams extends Algorithm {
+            length: number;
+        }
+        interface AesKeyAlgorithm extends KeyAlgorithm {
+            length: number;
+        }
+        interface AesKeyGenParams extends Algorithm {
+            length: number;
+        }
+        interface Algorithm {
+            name: string;
+        }
+        interface Argon2Params extends Algorithm {
+            associatedData?: NodeJS.BufferSource;
+            memory: number;
+            nonce: NodeJS.BufferSource;
+            parallelism: number;
+            passes: number;
+            secretValue?: NodeJS.BufferSource;
+            version?: number;
+        }
+        interface CShakeParams extends Algorithm {
+            customization?: NodeJS.BufferSource;
+            functionName?: NodeJS.BufferSource;
+            outputLength: number;
+        }
+        interface ContextParams extends Algorithm {
+            context?: NodeJS.BufferSource;
+        }
+        interface EcKeyAlgorithm extends KeyAlgorithm {
+            namedCurve: NamedCurve;
+        }
+        interface EcKeyGenParams extends Algorithm {
+            namedCurve: NamedCurve;
+        }
+        interface EcKeyImportParams extends Algorithm {
+            namedCurve: NamedCurve;
+        }
+        interface EcdhKeyDeriveParams extends Algorithm {
+            public: CryptoKey;
+        }
+        interface EcdsaParams extends Algorithm {
+            hash: HashAlgorithmIdentifier;
+        }
+        interface HkdfParams extends Algorithm {
+            hash: HashAlgorithmIdentifier;
+            info: NodeJS.BufferSource;
+            salt: NodeJS.BufferSource;
+        }
+        interface HmacImportParams extends Algorithm {
+            hash: HashAlgorithmIdentifier;
+            length?: number;
+        }
+        interface HmacKeyAlgorithm extends KeyAlgorithm {
+            hash: KeyAlgorithm;
+            length: number;
+        }
+        interface HmacKeyGenParams extends Algorithm {
+            hash: HashAlgorithmIdentifier;
+            length?: number;
+        }
+        interface KangarooTwelveParams {
+            customization?: NodeJS.BufferSource;
+            outputLength: number;
+        }
+        interface JsonWebKey {
+            alg?: string;
+            crv?: string;
+            d?: string;
+            dp?: string;
+            dq?: string;
+            e?: string;
+            ext?: boolean;
+            k?: string;
+            key_ops?: string[];
+            kty?: string;
+            n?: string;
+            oth?: RsaOtherPrimesInfo[];
+            p?: string;
+            q?: string;
+            qi?: string;
+            use?: string;
+            x?: string;
+            y?: string;
+        }
+        interface KeyAlgorithm {
+            name: string;
+        }
+        interface KmacImportParams extends Algorithm {
+            length?: number;
+        }
+        interface KmacKeyAlgorithm extends KeyAlgorithm {
+            length: number;
+        }
+        interface KmacKeyGenParams extends Algorithm {
+            length?: number;
+        }
+        interface KmacParams extends Algorithm {
+            customization?: NodeJS.BufferSource;
+            outputLength: number;
+        }
+        interface Pbkdf2Params extends Algorithm {
+            hash: HashAlgorithmIdentifier;
+            iterations: number;
+            salt: NodeJS.BufferSource;
+        }
+        interface RsaHashedImportParams extends Algorithm {
+            hash: HashAlgorithmIdentifier;
+        }
+        interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
+            hash: KeyAlgorithm;
+        }
+        interface RsaHashedKeyGenParams extends RsaKeyGenParams {
+            hash: HashAlgorithmIdentifier;
+        }
+        interface RsaKeyAlgorithm extends KeyAlgorithm {
+            modulusLength: number;
+            publicExponent: BigInteger;
+        }
+        interface RsaKeyGenParams extends Algorithm {
+            modulusLength: number;
+            publicExponent: BigInteger;
+        }
+        interface RsaOaepParams extends Algorithm {
+            label?: NodeJS.BufferSource;
+        }
+        interface RsaOtherPrimesInfo {
+            d?: string;
+            r?: string;
+            t?: string;
+        }
+        interface RsaPssParams extends Algorithm {
+            saltLength: number;
+        }
+        interface TurboShakeParams {
+            domainSeparation?: number;
+            outputLength: number;
+        }
+        interface Crypto {
+            readonly subtle: SubtleCrypto;
+            getRandomValues<T extends Exclude<NodeJS.NonSharedTypedArray, NodeJS.NonSharedFloat16Array | NodeJS.NonSharedFloat32Array | NodeJS.NonSharedFloat64Array>>(typedArray: T): T;
+            randomUUID(): UUID;
+        }
+        interface CryptoKey {
+            readonly algorithm: KeyAlgorithm;
+            readonly extractable: boolean;
+            readonly type: KeyType;
+            readonly usages: KeyUsage[];
+        }
+        interface CryptoKeyPair {
+            privateKey: CryptoKey;
+            publicKey: CryptoKey;
+        }
+        interface EncapsulatedBits {
+            sharedKey: ArrayBuffer;
+            ciphertext: ArrayBuffer;
+        }
+        interface EncapsulatedKey {
+            sharedKey: CryptoKey;
+            ciphertext: ArrayBuffer;
+        }
+        interface SubtleCrypto {
+            decapsulateBits(decapsulationAlgorithm: AlgorithmIdentifier, decapsulationKey: CryptoKey, ciphertext: NodeJS.BufferSource): Promise<ArrayBuffer>;
+            decapsulateKey(decapsulationAlgorithm: AlgorithmIdentifier, decapsulationKey: CryptoKey, ciphertext: NodeJS.BufferSource, sharedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams | AesDerivedKeyParams | KmacImportParams, extractable: boolean, usages: KeyUsage[]): Promise<CryptoKey>;
+            decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AeadParams, key: CryptoKey, data: NodeJS.BufferSource): Promise<ArrayBuffer>;
+            deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params | Argon2Params, baseKey: CryptoKey, length?: number | null): Promise<ArrayBuffer>;
+            deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params | Argon2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | KmacImportParams, extractable: boolean, keyUsages: readonly KeyUsage[]): Promise<CryptoKey>;
+            digest(algorithm: AlgorithmIdentifier | CShakeParams | TurboShakeParams | KangarooTwelveParams, data: NodeJS.BufferSource): Promise<ArrayBuffer>;
+            encapsulateBits(encapsulationAlgorithm: AlgorithmIdentifier, encapsulationKey: CryptoKey): Promise<EncapsulatedBits>;
+            encapsulateKey(encapsulationAlgorithm: AlgorithmIdentifier, encapsulationKey: CryptoKey, sharedKeyAlgorithm: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | KmacImportParams, extractable: boolean, usages: KeyUsage[]): Promise<EncapsulatedKey>;
+            encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AeadParams, key: CryptoKey, data: NodeJS.BufferSource): Promise<ArrayBuffer>;
+            exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
+            exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
+            exportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
+            generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+            generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params | KmacKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+            generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
+            getPublicKey(key: CryptoKey, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+            importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm | KmacImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+            importKey(format: Exclude<KeyFormat, "jwk">, keyData: NodeJS.BufferSource, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm | KmacImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+            sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | ContextParams | KmacParams, key: CryptoKey, data: NodeJS.BufferSource): Promise<ArrayBuffer>;
+            unwrapKey(format: KeyFormat, wrappedKey: NodeJS.BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AeadParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm | KmacImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+            verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | ContextParams | KmacParams, key: CryptoKey, signature: NodeJS.BufferSource, data: NodeJS.BufferSource): Promise<boolean>;
+            wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AeadParams): Promise<ArrayBuffer>;
+        }
+    }
+}
+declare module "crypto" {
+    export * from "node:crypto";
+}