@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/@types/node/crypto.d.ts

@@ -14,10 +14,9 @@
  * // Prints:
  * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/crypto.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/crypto.js)
  */
 declare module "crypto" {
-    import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";
     import { PeerCertificate } from "node:tls";
     /**
@@ -45,7 +44,7 @@ declare module "crypto" {
          * @param encoding The `encoding` of the `spkac` string.
          * @return The challenge component of the `spkac` data structure, which includes a public key and a challenge.
          */
-        static exportChallenge(spkac: BinaryLike): NonSharedBuffer;
+        static exportChallenge(spkac: BinaryLike): Buffer;
         /**
          * ```js
          * const { Certificate } = await import('node:crypto');
@@ -58,7 +57,7 @@ declare module "crypto" {
          * @param encoding The `encoding` of the `spkac` string.
          * @return The public key component of the `spkac` data structure, which includes a public key and a challenge.
          */
-        static exportPublicKey(spkac: BinaryLike, encoding?: string): NonSharedBuffer;
+        static exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
         /**
          * ```js
          * import { Buffer } from 'node:buffer';
@@ -79,7 +78,7 @@ declare module "crypto" {
          * @returns The challenge component of the `spkac` data structure,
          * which includes a public key and a challenge.
          */
-        exportChallenge(spkac: BinaryLike): NonSharedBuffer;
+        exportChallenge(spkac: BinaryLike): Buffer;
         /**
          * @deprecated
          * @param spkac
@@ -87,7 +86,7 @@ declare module "crypto" {
          * @returns The public key component of the `spkac` data structure,
          * which includes a public key and a challenge.
          */
-        exportPublicKey(spkac: BinaryLike, encoding?: string): NonSharedBuffer;
+        exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
         /**
          * @deprecated
          * @param spkac
@@ -97,7 +96,7 @@ declare module "crypto" {
         verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
     }
     namespace constants {
-        // https://nodejs.org/dist/latest-v22.x/docs/api/crypto.html#crypto-constants
+        // https://nodejs.org/dist/latest-v20.x/docs/api/crypto.html#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;
@@ -403,7 +402,7 @@ declare module "crypto" {
          * @since v0.1.92
          * @param encoding The `encoding` of the return value.
          */
-        digest(): NonSharedBuffer;
+        digest(): Buffer;
         digest(encoding: BinaryToTextEncoding): string;
     }
     /**
@@ -497,7 +496,7 @@ declare module "crypto" {
          * @since v0.1.94
          * @param encoding The `encoding` of the return value.
          */
-        digest(): NonSharedBuffer;
+        digest(): Buffer;
         digest(encoding: BinaryToTextEncoding): string;
     }
     type KeyObjectType = "secret" | "public" | "private";
@@ -511,50 +510,50 @@ declare module "crypto" {
         format: "jwk";
     }
     interface JsonWebKey {
-        crv?: string;
-        d?: string;
-        dp?: string;
-        dq?: string;
-        e?: string;
-        k?: string;
-        kty?: string;
-        n?: string;
-        p?: string;
-        q?: string;
-        qi?: string;
-        x?: string;
-        y?: string;
+        crv?: string | undefined;
+        d?: string | undefined;
+        dp?: string | undefined;
+        dq?: string | undefined;
+        e?: string | undefined;
+        k?: string | undefined;
+        kty?: string | undefined;
+        n?: string | undefined;
+        p?: string | undefined;
+        q?: string | undefined;
+        qi?: string | undefined;
+        x?: string | undefined;
+        y?: string | undefined;
         [key: string]: unknown;
     }
     interface AsymmetricKeyDetails {
         /**
          * Key size in bits (RSA, DSA).
          */
-        modulusLength?: number;
+        modulusLength?: number | undefined;
         /**
          * Public exponent (RSA).
          */
-        publicExponent?: bigint;
+        publicExponent?: bigint | undefined;
         /**
          * Name of the message digest (RSA-PSS).
          */
-        hashAlgorithm?: string;
+        hashAlgorithm?: string | undefined;
         /**
          * Name of the message digest used by MGF1 (RSA-PSS).
          */
-        mgf1HashAlgorithm?: string;
+        mgf1HashAlgorithm?: string | undefined;
         /**
          * Minimal salt length in bytes (RSA-PSS).
          */
-        saltLength?: number;
+        saltLength?: number | undefined;
         /**
          * Size of q in bits (DSA).
          */
-        divisorLength?: number;
+        divisorLength?: number | undefined;
         /**
          * Name of the curve (EC).
          */
-        namedCurve?: string;
+        namedCurve?: string | undefined;
     }
     /**
      * Node.js uses a `KeyObject` class to represent a symmetric or asymmetric key,
@@ -609,7 +608,12 @@ declare module "crypto" {
          * keys.
          * @since v11.6.0
          */
-        asymmetricKeyType?: KeyType;
+        asymmetricKeyType?: KeyType | undefined;
+        /**
+         * For asymmetric keys, this property represents the size of the embedded key in
+         * bytes. This property is `undefined` for symmetric keys.
+         */
+        asymmetricKeySize?: number | undefined;
         /**
          * This property exists only on asymmetric keys. Depending on the type of the key,
          * this object contains information about the key. None of the information obtained
@@ -623,7 +627,7 @@ declare module "crypto" {
          * Other key details might be exposed via this API using additional attributes.
          * @since v15.7.0
          */
-        asymmetricKeyDetails?: AsymmetricKeyDetails;
+        asymmetricKeyDetails?: AsymmetricKeyDetails | undefined;
         /**
          * For symmetric keys, the following encoding options can be used:
          *
@@ -647,8 +651,8 @@ declare module "crypto" {
          * PKCS#1 and SEC1 encryption.
          * @since v11.6.0
          */
-        export(options: KeyExportOptions<"pem">): string | NonSharedBuffer;
-        export(options?: KeyExportOptions<"der">): NonSharedBuffer;
+        export(options: KeyExportOptions<"pem">): string | Buffer;
+        export(options?: KeyExportOptions<"der">): Buffer;
         export(options?: JwkKeyExportOptions): JsonWebKey;
         /**
          * Returns `true` or `false` depending on whether the keys have exactly the same
@@ -662,20 +666,7 @@ declare module "crypto" {
          * property is `undefined` for asymmetric keys.
          * @since v11.6.0
          */
-        symmetricKeySize?: number;
-        /**
-         * Converts a `KeyObject` instance to a `CryptoKey`.
-         * @since 22.10.0
-         */
-        toCryptoKey(
-            algorithm:
-                | webcrypto.AlgorithmIdentifier
-                | webcrypto.RsaHashedImportParams
-                | webcrypto.EcKeyImportParams
-                | webcrypto.HmacImportParams,
-            extractable: boolean,
-            keyUsages: readonly webcrypto.KeyUsage[],
-        ): webcrypto.CryptoKey;
+        symmetricKeySize?: number | undefined;
         /**
          * Depending on the type of this `KeyObject`, this property is either`'secret'` for secret (symmetric) keys, `'public'` for public (asymmetric) keys
          * or `'private'` for private (asymmetric) keys.
@@ -683,10 +674,9 @@ declare module "crypto" {
          */
         type: KeyObjectType;
     }
-    type CipherCCMTypes = "aes-128-ccm" | "aes-192-ccm" | "aes-256-ccm";
+    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 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 {
@@ -698,10 +688,48 @@ declare module "crypto" {
     interface CipherOCBOptions extends stream.TransformOptions {
         authTagLength: number;
     }
-    interface CipherChaCha20Poly1305Options extends stream.TransformOptions {
-        /** @default 16 */
-        authTagLength?: number | undefined;
-    }
+    /**
+     * Creates and returns a `Cipher` object that uses the given `algorithm` and `password`.
+     *
+     * The `options` argument controls stream behavior and is optional except when a
+     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the
+     * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to set the length of the authentication
+     * tag that will be returned by `getAuthTag()` and defaults to 16 bytes.
+     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
+     *
+     * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
+     * recent OpenSSL releases, `openssl list -cipher-algorithms` will
+     * display the available cipher algorithms.
+     *
+     * The `password` is used to derive the cipher key and initialization vector (IV).
+     * The value must be either a `'latin1'` encoded string, a `Buffer`, a`TypedArray`, or a `DataView`.
+     *
+     * **This function is semantically insecure for all**
+     * **supported ciphers and fatally flawed for ciphers in counter mode (such as CTR,**
+     * **GCM, or CCM).**
+     *
+     * The implementation of `crypto.createCipher()` derives keys using the OpenSSL
+     * function [`EVP_BytesToKey`](https://www.openssl.org/docs/man3.0/man3/EVP_BytesToKey.html) with the digest algorithm set to MD5, one
+     * iteration, and no salt. The lack of salt allows dictionary attacks as the same
+     * password always creates the same key. The low iteration count and
+     * non-cryptographically secure hash algorithm allow passwords to be tested very
+     * rapidly.
+     *
+     * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man3.0/man3/EVP_BytesToKey.html) it is recommended that
+     * developers derive a key and IV on
+     * their own using {@link scrypt} and to use {@link createCipheriv} to create the `Cipher` object. Users should not use ciphers with counter mode
+     * (e.g. CTR, GCM, or CCM) in `crypto.createCipher()`. A warning is emitted when
+     * they are used in order to avoid the risk of IV reuse that causes
+     * vulnerabilities. For the case when IV is reused in GCM, see [Nonce-Disrespecting Adversaries](https://github.com/nonce-disrespect/nonce-disrespect) for details.
+     * @since v0.1.94
+     * @deprecated Since v10.0.0 - Use {@link createCipheriv} instead.
+     * @param options `stream.transform` options
+     */
+    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;
     /**
      * Creates and returns a `Cipher` object, with the given `algorithm`, `key` and
      * initialization vector (`iv`).
@@ -750,12 +778,6 @@ declare module "crypto" {
         iv: BinaryLike,
         options?: CipherGCMOptions,
     ): CipherGCM;
-    function createCipheriv(
-        algorithm: CipherChaCha20Poly1305Types,
-        key: CipherKey,
-        iv: BinaryLike,
-        options?: CipherChaCha20Poly1305Options,
-    ): CipherChaCha20Poly1305;
     function createCipheriv(
         algorithm: string,
         key: CipherKey,
@@ -771,7 +793,7 @@ declare module "crypto" {
      * * Using the `cipher.update()` and `cipher.final()` methods to produce
      * the encrypted data.
      *
-     * The {@link createCipheriv} method is
+     * The {@link createCipher} or {@link createCipheriv} methods are
      * used to create `Cipher` instances. `Cipher` objects are not to be created
      * directly using the `new` keyword.
      *
@@ -897,8 +919,8 @@ declare module "crypto" {
          * @param inputEncoding The `encoding` of the data.
          * @param outputEncoding The `encoding` of the return value.
          */
-        update(data: BinaryLike): NonSharedBuffer;
-        update(data: string, inputEncoding: Encoding): NonSharedBuffer;
+        update(data: BinaryLike): Buffer;
+        update(data: string, inputEncoding: Encoding): Buffer;
         update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
         update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
         /**
@@ -909,7 +931,7 @@ declare module "crypto" {
          * @param outputEncoding The `encoding` of the return value.
          * @return Any remaining enciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned.
          */
-        final(): NonSharedBuffer;
+        final(): Buffer;
         final(outputEncoding: BufferEncoding): string;
         /**
          * When using block encryption algorithms, the `Cipher` class will automatically
@@ -935,7 +957,7 @@ declare module "crypto" {
                 plaintextLength: number;
             },
         ): this;
-        getAuthTag(): NonSharedBuffer;
+        getAuthTag(): Buffer;
     }
     interface CipherGCM extends Cipher {
         setAAD(
@@ -944,7 +966,7 @@ declare module "crypto" {
                 plaintextLength: number;
             },
         ): this;
-        getAuthTag(): NonSharedBuffer;
+        getAuthTag(): Buffer;
     }
     interface CipherOCB extends Cipher {
         setAAD(
@@ -953,17 +975,39 @@ declare module "crypto" {
                 plaintextLength: number;
             },
         ): this;
-        getAuthTag(): NonSharedBuffer;
-    }
-    interface CipherChaCha20Poly1305 extends Cipher {
-        setAAD(
-            buffer: NodeJS.ArrayBufferView,
-            options: {
-                plaintextLength: number;
-            },
-        ): this;
-        getAuthTag(): NonSharedBuffer;
+        getAuthTag(): Buffer;
     }
+    /**
+     * Creates and returns a `Decipher` object that uses the given `algorithm` and `password` (key).
+     *
+     * The `options` argument controls stream behavior and is optional except when a
+     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the `authTagLength` option is required and specifies the length of the
+     * authentication tag in bytes, see `CCM mode`.
+     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
+     *
+     * **This function is semantically insecure for all**
+     * **supported ciphers and fatally flawed for ciphers in counter mode (such as CTR,**
+     * **GCM, or CCM).**
+     *
+     * The implementation of `crypto.createDecipher()` derives keys using the OpenSSL
+     * function [`EVP_BytesToKey`](https://www.openssl.org/docs/man3.0/man3/EVP_BytesToKey.html) with the digest algorithm set to MD5, one
+     * iteration, and no salt. The lack of salt allows dictionary attacks as the same
+     * password always creates the same key. The low iteration count and
+     * non-cryptographically secure hash algorithm allow passwords to be tested very
+     * rapidly.
+     *
+     * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man3.0/man3/EVP_BytesToKey.html) it is recommended that
+     * developers derive a key and IV on
+     * their own using {@link scrypt} and to use {@link createDecipheriv} to create the `Decipher` object.
+     * @since v0.1.94
+     * @deprecated Since v10.0.0 - Use {@link createDecipheriv} instead.
+     * @param options `stream.transform` options
+     */
+    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;
     /**
      * Creates and returns a `Decipher` object that uses the given `algorithm`, `key` and initialization vector (`iv`).
      *
@@ -1011,12 +1055,6 @@ declare module "crypto" {
         iv: BinaryLike,
         options?: CipherGCMOptions,
     ): DecipherGCM;
-    function createDecipheriv(
-        algorithm: CipherChaCha20Poly1305Types,
-        key: CipherKey,
-        iv: BinaryLike,
-        options?: CipherChaCha20Poly1305Options,
-    ): DecipherChaCha20Poly1305;
     function createDecipheriv(
         algorithm: string,
         key: CipherKey,
@@ -1032,7 +1070,7 @@ declare module "crypto" {
      * * Using the `decipher.update()` and `decipher.final()` methods to
      * produce the unencrypted data.
      *
-     * The {@link createDecipheriv} method is
+     * The {@link createDecipher} or {@link createDecipheriv} methods are
      * used to create `Decipher` instances. `Decipher` objects are not to be created
      * directly using the `new` keyword.
      *
@@ -1147,8 +1185,8 @@ declare module "crypto" {
          * @param inputEncoding The `encoding` of the `data` string.
          * @param outputEncoding The `encoding` of the return value.
          */
-        update(data: NodeJS.ArrayBufferView): NonSharedBuffer;
-        update(data: string, inputEncoding: Encoding): NonSharedBuffer;
+        update(data: NodeJS.ArrayBufferView): Buffer;
+        update(data: string, inputEncoding: Encoding): Buffer;
         update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
         update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
         /**
@@ -1159,7 +1197,7 @@ declare module "crypto" {
          * @param outputEncoding The `encoding` of the return value.
          * @return Any remaining deciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned.
          */
-        final(): NonSharedBuffer;
+        final(): Buffer;
         final(outputEncoding: BufferEncoding): string;
         /**
          * When data has been encrypted without standard block padding, calling `decipher.setAutoPadding(false)` will disable automatic padding to prevent `decipher.final()` from checking for and
@@ -1202,15 +1240,6 @@ declare module "crypto" {
             },
         ): this;
     }
-    interface DecipherChaCha20Poly1305 extends Decipher {
-        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
-        setAAD(
-            buffer: NodeJS.ArrayBufferView,
-            options: {
-                plaintextLength: number;
-            },
-        ): this;
-    }
     interface PrivateKeyInput {
         key: string | Buffer;
         format?: KeyFormat | undefined;
@@ -1335,7 +1364,6 @@ declare module "crypto" {
     interface SignKeyObjectInput extends SigningOptions {
         key: KeyObject;
     }
-    interface SignJsonWebKeyInput extends JsonWebKeyInput, SigningOptions {}
     interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {}
     interface VerifyKeyObjectInput extends SigningOptions {
         key: KeyObject;
@@ -1431,9 +1459,9 @@ declare module "crypto" {
          * called. Multiple calls to `sign.sign()` will result in an error being thrown.
          * @since v0.1.92
          */
-        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput): NonSharedBuffer;
+        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput): Buffer;
         sign(
-            privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput,
+            privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput,
             outputFormat: BinaryToTextEncoding,
         ): string;
     }
@@ -1590,7 +1618,7 @@ declare module "crypto" {
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
-        generateKeys(): NonSharedBuffer;
+        generateKeys(): Buffer;
         generateKeys(encoding: BinaryToTextEncoding): string;
         /**
          * Computes the shared secret using `otherPublicKey` as the other
@@ -1605,16 +1633,8 @@ declare module "crypto" {
          * @param inputEncoding The `encoding` of an `otherPublicKey` string.
          * @param outputEncoding The `encoding` of the return value.
          */
-        computeSecret(
-            otherPublicKey: NodeJS.ArrayBufferView,
-            inputEncoding?: null,
-            outputEncoding?: null,
-        ): NonSharedBuffer;
-        computeSecret(
-            otherPublicKey: string,
-            inputEncoding: BinaryToTextEncoding,
-            outputEncoding?: null,
-        ): NonSharedBuffer;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding?: null, outputEncoding?: null): Buffer;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding?: null): Buffer;
         computeSecret(
             otherPublicKey: NodeJS.ArrayBufferView,
             inputEncoding: null,
@@ -1632,7 +1652,7 @@ declare module "crypto" {
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
-        getPrime(): NonSharedBuffer;
+        getPrime(): Buffer;
         getPrime(encoding: BinaryToTextEncoding): string;
         /**
          * Returns the Diffie-Hellman generator in the specified `encoding`.
@@ -1641,7 +1661,7 @@ declare module "crypto" {
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
-        getGenerator(): NonSharedBuffer;
+        getGenerator(): Buffer;
         getGenerator(encoding: BinaryToTextEncoding): string;
         /**
          * Returns the Diffie-Hellman public key in the specified `encoding`.
@@ -1650,7 +1670,7 @@ declare module "crypto" {
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
-        getPublicKey(): NonSharedBuffer;
+        getPublicKey(): Buffer;
         getPublicKey(encoding: BinaryToTextEncoding): string;
         /**
          * Returns the Diffie-Hellman private key in the specified `encoding`.
@@ -1659,7 +1679,7 @@ declare module "crypto" {
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
-        getPrivateKey(): NonSharedBuffer;
+        getPrivateKey(): Buffer;
         getPrivateKey(encoding: BinaryToTextEncoding): string;
         /**
          * Sets the Diffie-Hellman public key. If the `encoding` argument is provided, `publicKey` is expected
@@ -1803,7 +1823,7 @@ declare module "crypto" {
         iterations: number,
         keylen: number,
         digest: string,
-        callback: (err: Error | null, derivedKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, derivedKey: Buffer) => void,
     ): void;
     /**
      * Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
@@ -1840,7 +1860,7 @@ declare module "crypto" {
         iterations: number,
         keylen: number,
         digest: string,
-    ): NonSharedBuffer;
+    ): Buffer;
     /**
      * Generates cryptographically strong pseudorandom data. The `size` argument
      * is a number indicating the number of bytes to generate.
@@ -1893,10 +1913,10 @@ declare module "crypto" {
      * @param size The number of bytes to generate. The `size` must not be larger than `2**31 - 1`.
      * @return if the `callback` function is not provided.
      */
-    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 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;
     /**
      * Return a random integer `n` such that `min <= n < max`.  This
      * implementation avoids [modulo bias](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias).
@@ -2126,14 +2146,14 @@ declare module "crypto" {
         password: BinaryLike,
         salt: BinaryLike,
         keylen: number,
-        callback: (err: Error | null, derivedKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, derivedKey: Buffer) => void,
     ): void;
     function scrypt(
         password: BinaryLike,
         salt: BinaryLike,
         keylen: number,
         options: ScryptOptions,
-        callback: (err: Error | null, derivedKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, derivedKey: Buffer) => void,
     ): void;
     /**
      * Provides a synchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based
@@ -2165,12 +2185,7 @@ declare module "crypto" {
      * ```
      * @since v10.5.0
      */
-    function scryptSync(
-        password: BinaryLike,
-        salt: BinaryLike,
-        keylen: number,
-        options?: ScryptOptions,
-    ): NonSharedBuffer;
+    function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;
     interface RsaPublicKey {
         key: KeyLike;
         padding?: number | undefined;
@@ -2196,10 +2211,7 @@ declare module "crypto" {
      * be passed instead of a public key.
      * @since v0.11.14
      */
-    function publicEncrypt(
-        key: RsaPublicKey | RsaPrivateKey | KeyLike,
-        buffer: NodeJS.ArrayBufferView | string,
-    ): NonSharedBuffer;
+    function publicEncrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     /**
      * Decrypts `buffer` with `key`.`buffer` was previously encrypted using
      * the corresponding private key, for example using {@link privateEncrypt}.
@@ -2211,10 +2223,7 @@ declare module "crypto" {
      * be passed instead of a public key.
      * @since v1.1.0
      */
-    function publicDecrypt(
-        key: RsaPublicKey | RsaPrivateKey | KeyLike,
-        buffer: NodeJS.ArrayBufferView | string,
-    ): NonSharedBuffer;
+    function publicDecrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     /**
      * Decrypts `buffer` with `privateKey`. `buffer` was previously encrypted using
      * the corresponding public key, for example using {@link publicEncrypt}.
@@ -2223,10 +2232,7 @@ declare module "crypto" {
      * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_OAEP_PADDING`.
      * @since v0.11.14
      */
-    function privateDecrypt(
-        privateKey: RsaPrivateKey | KeyLike,
-        buffer: NodeJS.ArrayBufferView | string,
-    ): NonSharedBuffer;
+    function privateDecrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     /**
      * Encrypts `buffer` with `privateKey`. The returned data can be decrypted using
      * the corresponding public key, for example using {@link publicDecrypt}.
@@ -2235,10 +2241,7 @@ declare module "crypto" {
      * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_PADDING`.
      * @since v1.1.0
      */
-    function privateEncrypt(
-        privateKey: RsaPrivateKey | KeyLike,
-        buffer: NodeJS.ArrayBufferView | string,
-    ): NonSharedBuffer;
+    function privateEncrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     /**
      * ```js
      * const {
@@ -2367,7 +2370,7 @@ declare module "crypto" {
             inputEncoding?: BinaryToTextEncoding,
             outputEncoding?: "latin1" | "hex" | "base64" | "base64url",
             format?: "uncompressed" | "compressed" | "hybrid",
-        ): NonSharedBuffer | string;
+        ): Buffer | string;
         /**
          * Generates private and public EC Diffie-Hellman key values, and returns
          * the public key in the specified `format` and `encoding`. This key should be
@@ -2380,7 +2383,7 @@ declare module "crypto" {
          * @param encoding The `encoding` of the return value.
          * @param [format='uncompressed']
          */
-        generateKeys(): NonSharedBuffer;
+        generateKeys(): Buffer;
         generateKeys(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
         /**
          * Computes the shared secret using `otherPublicKey` as the other
@@ -2399,8 +2402,8 @@ declare module "crypto" {
          * @param inputEncoding The `encoding` of the `otherPublicKey` string.
          * @param outputEncoding The `encoding` of the return value.
          */
-        computeSecret(otherPublicKey: NodeJS.ArrayBufferView): NonSharedBuffer;
-        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding): NonSharedBuffer;
+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView): Buffer;
+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding): Buffer;
         computeSecret(otherPublicKey: NodeJS.ArrayBufferView, outputEncoding: BinaryToTextEncoding): string;
         computeSecret(
             otherPublicKey: string,
@@ -2414,7 +2417,7 @@ declare module "crypto" {
          * @param encoding The `encoding` of the return value.
          * @return The EC Diffie-Hellman in the specified `encoding`.
          */
-        getPrivateKey(): NonSharedBuffer;
+        getPrivateKey(): Buffer;
         getPrivateKey(encoding: BinaryToTextEncoding): string;
         /**
          * The `format` argument specifies point encoding and can be `'compressed'` or `'uncompressed'`. If `format` is not specified the point will be returned in`'uncompressed'` format.
@@ -2426,7 +2429,7 @@ declare module "crypto" {
          * @param [format='uncompressed']
          * @return The EC Diffie-Hellman public key in the specified `encoding` and `format`.
          */
-        getPublicKey(encoding?: null, format?: ECDHKeyFormat): NonSharedBuffer;
+        getPublicKey(encoding?: null, format?: ECDHKeyFormat): Buffer;
         getPublicKey(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
         /**
          * Sets the EC Diffie-Hellman private key.
@@ -2525,15 +2528,15 @@ declare module "crypto" {
         /**
          * Name of the message digest
          */
-        hashAlgorithm?: string | undefined;
+        hashAlgorithm?: string;
         /**
          * Name of the message digest used by MGF1
          */
-        mgf1HashAlgorithm?: string | undefined;
+        mgf1HashAlgorithm?: string;
         /**
          * Minimal salt length in bytes
          */
-        saltLength?: string | undefined;
+        saltLength?: string;
     }
     interface DSAKeyPairKeyObjectOptions {
         /**
@@ -2576,15 +2579,15 @@ declare module "crypto" {
         /**
          * Name of the message digest
          */
-        hashAlgorithm?: string | undefined;
+        hashAlgorithm?: string;
         /**
          * Name of the message digest used by MGF1
          */
-        mgf1HashAlgorithm?: string | undefined;
+        mgf1HashAlgorithm?: string;
         /**
          * Minimal salt length in bytes
          */
-        saltLength?: string | undefined;
+        saltLength?: string;
         publicKeyEncoding: {
             type: "spki";
             format: PubF;
@@ -2707,15 +2710,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "rsa",
         options: RSAKeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "rsa",
         options: RSAKeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "rsa",
         options: RSAKeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "rsa", options: RSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "rsa-pss",
@@ -2724,15 +2727,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "rsa-pss",
         options: RSAPSSKeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "rsa-pss",
         options: RSAPSSKeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "rsa-pss",
         options: RSAPSSKeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "rsa-pss", options: RSAPSSKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "dsa",
@@ -2741,15 +2744,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "dsa",
         options: DSAKeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "dsa",
         options: DSAKeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "dsa",
         options: DSAKeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "dsa", options: DSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "ec",
@@ -2758,15 +2761,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "ec",
         options: ECKeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "ec",
         options: ECKeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "ec",
         options: ECKeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "ec", options: ECKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "ed25519",
@@ -2775,15 +2778,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "ed25519",
         options: ED25519KeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "ed25519",
         options: ED25519KeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "ed25519",
         options: ED25519KeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "ed25519", options?: ED25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "ed448",
@@ -2792,15 +2795,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "ed448",
         options: ED448KeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "ed448",
         options: ED448KeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "ed448",
         options: ED448KeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "ed448", options?: ED448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "x25519",
@@ -2809,15 +2812,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "x25519",
         options: X25519KeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "x25519",
         options: X25519KeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "x25519",
         options: X25519KeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "x25519", options?: X25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     function generateKeyPairSync(
         type: "x448",
@@ -2826,15 +2829,15 @@ declare module "crypto" {
     function generateKeyPairSync(
         type: "x448",
         options: X448KeyPairOptions<"pem", "der">,
-    ): KeyPairSyncResult<string, NonSharedBuffer>;
+    ): KeyPairSyncResult<string, Buffer>;
     function generateKeyPairSync(
         type: "x448",
         options: X448KeyPairOptions<"der", "pem">,
-    ): KeyPairSyncResult<NonSharedBuffer, string>;
+    ): KeyPairSyncResult<Buffer, string>;
     function generateKeyPairSync(
         type: "x448",
         options: X448KeyPairOptions<"der", "der">,
-    ): KeyPairSyncResult<NonSharedBuffer, NonSharedBuffer>;
+    ): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: "x448", options?: X448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     /**
      * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
@@ -2883,17 +2886,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "rsa",
         options: RSAKeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "rsa",
         options: RSAKeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "rsa",
         options: RSAKeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "rsa",
@@ -2908,17 +2911,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "rsa-pss",
         options: RSAPSSKeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "rsa-pss",
         options: RSAPSSKeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "rsa-pss",
         options: RSAPSSKeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "rsa-pss",
@@ -2933,17 +2936,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "dsa",
         options: DSAKeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "dsa",
         options: DSAKeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "dsa",
         options: DSAKeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "dsa",
@@ -2958,17 +2961,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "ec",
         options: ECKeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "ec",
         options: ECKeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "ec",
         options: ECKeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "ec",
@@ -2983,17 +2986,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "ed25519",
         options: ED25519KeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "ed25519",
         options: ED25519KeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "ed25519",
         options: ED25519KeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "ed25519",
@@ -3008,17 +3011,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "ed448",
         options: ED448KeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "ed448",
         options: ED448KeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "ed448",
         options: ED448KeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "ed448",
@@ -3033,17 +3036,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "x25519",
         options: X25519KeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "x25519",
         options: X25519KeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "x25519",
         options: X25519KeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "x25519",
@@ -3058,17 +3061,17 @@ declare module "crypto" {
     function generateKeyPair(
         type: "x448",
         options: X448KeyPairOptions<"pem", "der">,
-        callback: (err: Error | null, publicKey: string, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "x448",
         options: X448KeyPairOptions<"der", "pem">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: string) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
     ): void;
     function generateKeyPair(
         type: "x448",
         options: X448KeyPairOptions<"der", "der">,
-        callback: (err: Error | null, publicKey: NonSharedBuffer, privateKey: NonSharedBuffer) => void,
+        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
     ): void;
     function generateKeyPair(
         type: "x448",
@@ -3088,21 +3091,21 @@ declare module "crypto" {
             options: RSAKeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "rsa",
             options: RSAKeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "rsa",
             options: RSAKeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(type: "rsa", options: RSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
         function __promisify__(
@@ -3117,21 +3120,21 @@ declare module "crypto" {
             options: RSAPSSKeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "rsa-pss",
             options: RSAPSSKeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "rsa-pss",
             options: RSAPSSKeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "rsa-pss",
@@ -3149,21 +3152,21 @@ declare module "crypto" {
             options: DSAKeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "dsa",
             options: DSAKeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "dsa",
             options: DSAKeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(type: "dsa", options: DSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
         function __promisify__(
@@ -3178,21 +3181,21 @@ declare module "crypto" {
             options: ECKeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "ec",
             options: ECKeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "ec",
             options: ECKeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(type: "ec", options: ECKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
         function __promisify__(
@@ -3207,21 +3210,21 @@ declare module "crypto" {
             options: ED25519KeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "ed25519",
             options: ED25519KeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "ed25519",
             options: ED25519KeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "ed25519",
@@ -3239,21 +3242,21 @@ declare module "crypto" {
             options: ED448KeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "ed448",
             options: ED448KeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "ed448",
             options: ED448KeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(type: "ed448", options?: ED448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
         function __promisify__(
@@ -3268,21 +3271,21 @@ declare module "crypto" {
             options: X25519KeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "x25519",
             options: X25519KeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "x25519",
             options: X25519KeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "x25519",
@@ -3300,21 +3303,21 @@ declare module "crypto" {
             options: X448KeyPairOptions<"pem", "der">,
         ): Promise<{
             publicKey: string;
-            privateKey: NonSharedBuffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(
             type: "x448",
             options: X448KeyPairOptions<"der", "pem">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
+            publicKey: Buffer;
             privateKey: string;
         }>;
         function __promisify__(
             type: "x448",
             options: X448KeyPairOptions<"der", "der">,
         ): Promise<{
-            publicKey: NonSharedBuffer;
-            privateKey: NonSharedBuffer;
+            publicKey: Buffer;
+            privateKey: Buffer;
         }>;
         function __promisify__(type: "x448", options?: X448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
     }
@@ -3333,13 +3336,13 @@ declare module "crypto" {
     function sign(
         algorithm: string | null | undefined,
         data: NodeJS.ArrayBufferView,
-        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput,
-    ): NonSharedBuffer;
+        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput,
+    ): Buffer;
     function sign(
         algorithm: string | null | undefined,
         data: NodeJS.ArrayBufferView,
-        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput,
-        callback: (error: Error | null, data: NonSharedBuffer) => void,
+        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput,
+        callback: (error: Error | null, data: Buffer) => void,
     ): void;
     /**
      * Verifies the given signature for `data` using the given key and algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is dependent upon the
@@ -3375,7 +3378,7 @@ declare module "crypto" {
      * Both keys must have the same `asymmetricKeyType`, which must be one of `'dh'` (for Diffie-Hellman), `'ec'` (for ECDH), `'x448'`, or `'x25519'` (for ECDH-ES).
      * @since v13.9.0, v12.17.0
      */
-    function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): NonSharedBuffer;
+    function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
     /**
      * A utility for creating one-shot hash digests of data. It can be faster than the object-based `crypto.createHash()` when hashing a smaller amount of data
      * (<= 5MB) that's readily available. If the data can be big or if it is streamed, it's still recommended to use `crypto.createHash()` instead. The `algorithm`
@@ -3385,8 +3388,8 @@ declare module "crypto" {
      * Example:
      *
      * ```js
-     * import crypto from 'node:crypto';
-     * import { Buffer } from 'node:buffer';
+     * const crypto = require('node:crypto');
+     * const { Buffer } = require('node:buffer');
      *
      * // Hashing a string and return the result as a hex-encoded string.
      * const string = 'Node.js';
@@ -3402,15 +3405,15 @@ declare module "crypto" {
      * @since v21.7.0, v20.12.0
      * @param data When `data` is a string, it will be encoded as UTF-8 before being hashed. If a different input encoding is desired for a string input, user
      *             could encode the string into a `TypedArray` using either `TextEncoder` or `Buffer.from()` and passing the encoded `TypedArray` into this API instead.
-     * @param [outputEncoding='hex'] [Encoding](https://nodejs.org/docs/latest-v22.x/api/buffer.html#buffers-and-character-encodings) used to encode the returned digest.
+     * @param [outputEncoding='hex'] [Encoding](https://nodejs.org/docs/latest-v20.x/api/buffer.html#buffers-and-character-encodings) used to encode the returned digest.
      */
     function hash(algorithm: string, data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
-    function hash(algorithm: string, data: BinaryLike, outputEncoding: "buffer"): NonSharedBuffer;
+    function hash(algorithm: string, data: BinaryLike, outputEncoding: "buffer"): Buffer;
     function hash(
         algorithm: string,
         data: BinaryLike,
         outputEncoding?: BinaryToTextEncoding | "buffer",
-    ): string | NonSharedBuffer;
+    ): string | Buffer;
     type CipherMode = "cbc" | "ccm" | "cfb" | "ctr" | "ecb" | "gcm" | "ocb" | "ofb" | "stream" | "wrap" | "xts";
     interface CipherInfoOptions {
         /**
@@ -3574,23 +3577,23 @@ declare module "crypto" {
         /**
          * @default 'always'
          */
-        subject?: "always" | "default" | "never" | undefined;
+        subject?: "always" | "default" | "never";
         /**
          * @default true
          */
-        wildcards?: boolean | undefined;
+        wildcards?: boolean;
         /**
          * @default true
          */
-        partialWildcards?: boolean | undefined;
+        partialWildcards?: boolean;
         /**
          * @default false
          */
-        multiLabelWildcards?: boolean | undefined;
+        multiLabelWildcards?: boolean;
         /**
          * @default false
          */
-        singleLabelSubdomains?: boolean | undefined;
+        singleLabelSubdomains?: boolean;
     }
     /**
      * Encapsulates an X509 certificate and provides read-only access to
@@ -3692,7 +3695,7 @@ declare module "crypto" {
          * available.
          * @since v15.9.0
          */
-        readonly issuerCertificate: X509Certificate | undefined;
+        readonly issuerCertificate?: X509Certificate | undefined;
         /**
          * The public key `KeyObject` for this certificate.
          * @since v15.6.0
@@ -3702,7 +3705,7 @@ declare module "crypto" {
          * A `Buffer` containing the DER encoding of this certificate.
          * @since v15.6.0
          */
-        readonly raw: NonSharedBuffer;
+        readonly raw: Buffer;
         /**
          * The serial number of this certificate.
          *
@@ -3717,21 +3720,11 @@ declare module "crypto" {
          * @since v15.6.0
          */
         readonly validFrom: string;
-        /**
-         * The date/time from which this certificate is valid, encapsulated in a `Date` object.
-         * @since v22.10.0
-         */
-        readonly validFromDate: Date;
         /**
          * The date/time until which this certificate is considered valid.
          * @since v15.6.0
          */
         readonly validTo: string;
-        /**
-         * The date/time until which this certificate is valid, encapsulated in a `Date` object.
-         * @since v22.10.0
-         */
-        readonly validToDate: Date;
         constructor(buffer: BinaryLike);
         /**
          * Checks whether the certificate matches the given email address.
@@ -3784,23 +3777,7 @@ declare module "crypto" {
          */
         checkIP(ip: string): string | undefined;
         /**
-         * Checks whether this certificate was potentially issued by the given `otherCert`
-         * by comparing the certificate metadata.
-         *
-         * This is useful for pruning a list of possible issuer certificates which have been
-         * selected using a more rudimentary filtering routine, i.e. just based on subject
-         * and issuer names.
-         *
-         * Finally, to verify that this certificate's signature was produced by a private key
-         * corresponding to `otherCert`'s public key use `x509.verify(publicKey)`
-         * with `otherCert`'s public key represented as a `KeyObject`
-         * like so
-         *
-         * ```js
-         * if (!x509.verify(otherCert.publicKey)) {
-         *   throw new Error('otherCert did not issue x509');
-         * }
-         * ```
+         * Checks whether this certificate was issued by the given `otherCert`.
          * @since v15.6.0
          */
         checkIssued(otherCert: X509Certificate): boolean;
@@ -4129,7 +4106,7 @@ declare module "crypto" {
             saltLength: number;
         }
         /**
-         * Importing the `webcrypto` object (`import { webcrypto } from 'node:crypto'`) gives an instance of the `Crypto` class.
+         * Calling `require('node:crypto').webcrypto` returns an instance of the `Crypto` class.
          * `Crypto` is a singleton that provides access to the remainder of the crypto API.
          * @since v15.0.0
          */
@@ -4257,13 +4234,9 @@ declare module "crypto" {
              * - `'PBKDF2'`
              * @since v15.0.0
              */
+            deriveBits(algorithm: EcdhKeyDeriveParams, baseKey: CryptoKey, length: number | null): Promise<ArrayBuffer>;
             deriveBits(
-                algorithm: EcdhKeyDeriveParams,
-                baseKey: CryptoKey,
-                length?: number | null,
-            ): Promise<ArrayBuffer>;
-            deriveBits(
-                algorithm: EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params,
+                algorithm: AlgorithmIdentifier | HkdfParams | Pbkdf2Params,
                 baseKey: CryptoKey,
                 length: number,
             ): Promise<ArrayBuffer>;
@@ -4285,9 +4258,14 @@ declare module "crypto" {
              * @since v15.0.0
              */
             deriveKey(
-                algorithm: EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params,
+                algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params,
                 baseKey: CryptoKey,
-                derivedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams | AesDerivedKeyParams,
+                derivedKeyAlgorithm:
+                    | AlgorithmIdentifier
+                    | AesDerivedKeyParams
+                    | HmacImportParams
+                    | HkdfParams
+                    | Pbkdf2Params,
                 extractable: boolean,
                 keyUsages: readonly KeyUsage[],
             ): Promise<CryptoKey>;