@types/node 16.4.14 → 16.7.0

node/crypto.d.ts

@@ -3,7 +3,7 @@
  * wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.
  *
  * ```js
- * import { createHmac } from 'crypto';
+ * const { createHmac } = await import('crypto');
  *
  * const secret = 'abcdefg';
  * const hash = createHmac('sha256', secret)
@@ -13,19 +13,7 @@
  * // Prints:
  * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
  * ```
- *
- * ```js
- * const crypto = require('crypto');
- *
- * const secret = 'abcdefg';
- * const hash = crypto.createHmac('sha256', secret)
- *                    .update('I love cupcakes')
- *                    .digest('hex');
- * console.log(hash);
- * // Prints:
- * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/crypto.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/crypto.js)
  */
 declare module 'crypto' {
     import * as stream from 'node:stream';
@@ -193,38 +181,12 @@ declare module 'crypto' {
      * import {
      *   createReadStream
      * } from 'fs';
-     *
+     * import { argv } from 'process';
      * const {
-     *   createHash,
+     *   createHash
      * } = await import('crypto');
      *
-     * const filename = process.argv[2];
-     *
-     * const hash = createHash('sha256');
-     *
-     * const input = createReadStream(filename);
-     * input.on('readable', () => {
-     *   // Only one element is going to be produced by the
-     *   // hash stream.
-     *   const data = input.read();
-     *   if (data)
-     *     hash.update(data);
-     *   else {
-     *     console.log(`${hash.digest('hex')} ${filename}`);
-     *   }
-     * });
-     * ```
-     *
-     * ```js
-     * const {
-     *   createReadStream,
-     * } = require('fs');
-     *
-     * const {
-     *   createHash,
-     * } = require('crypto');
-     *
-     * const filename = process.argv[2];
+     * const filename = argv[2];
      *
      * const hash = createHash('sha256');
      *
@@ -262,38 +224,12 @@ declare module 'crypto' {
      * import {
      *   createReadStream
      * } from 'fs';
-     *
+     * import { argv } from 'process';
      * const {
-     *   createHmac,
+     *   createHmac
      * } = await import('crypto');
      *
-     * const filename = process.argv[2];
-     *
-     * const hmac = createHmac('sha256', 'a secret');
-     *
-     * const input = createReadStream(filename);
-     * input.on('readable', () => {
-     *   // Only one element is going to be produced by the
-     *   // hash stream.
-     *   const data = input.read();
-     *   if (data)
-     *     hmac.update(data);
-     *   else {
-     *     console.log(`${hmac.digest('hex')} ${filename}`);
-     *   }
-     * });
-     * ```
-     *
-     * ```js
-     * const {
-     *   createReadStream,
-     * } = require('fs');
-     *
-     * const {
-     *   createHmac,
-     * } = require('crypto');
-     *
-     * const filename = process.argv[2];
+     * const filename = argv[2];
      *
      * const hmac = createHmac('sha256', 'a secret');
      *
@@ -334,7 +270,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   createHash,
+     *   createHash
      * } = await import('crypto');
      *
      * const hash = createHash('sha256');
@@ -354,62 +290,24 @@ declare module 'crypto' {
      * hash.end();
      * ```
      *
-     * ```js
-     * const {
-     *   createHash,
-     * } = require('crypto');
-     *
-     * const hash = createHash('sha256');
-     *
-     * hash.on('readable', () => {
-     *   // Only one element is going to be produced by the
-     *   // hash stream.
-     *   const data = hash.read();
-     *   if (data) {
-     *     console.log(data.toString('hex'));
-     *     // Prints:
-     *     //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
-     *   }
-     * });
-     *
-     * hash.write('some data to hash');
-     * hash.end();
-     * ```
-     *
      * Example: Using `Hash` and piped streams:
      *
      * ```js
      * import { createReadStream } from 'fs';
-     *
-     * const {
-     *   createHash,
-     * } = await import('crypto');
-     * const hash = createHash('sha256');
-     *
-     * const input = createReadStream('test.js');
-     * input.pipe(hash).setEncoding('hex').pipe(process.stdout);
-     * ```
-     *
-     * ```js
-     * const {
-     *   createReadStream,
-     * } = require('fs');
-     *
-     * const {
-     *   createHash,
-     * } = require('crypto');
+     * import { stdout } from 'process';
+     * const { createHash } = await import('crypto');
      *
      * const hash = createHash('sha256');
      *
      * const input = createReadStream('test.js');
-     * input.pipe(hash).setEncoding('hex').pipe(process.stdout);
+     * input.pipe(hash).setEncoding('hex').pipe(stdout);
      * ```
      *
      * Example: Using the `hash.update()` and `hash.digest()` methods:
      *
      * ```js
      * const {
-     *   createHash,
+     *   createHash
      * } = await import('crypto');
      *
      * const hash = createHash('sha256');
@@ -419,19 +317,6 @@ declare module 'crypto' {
      * // Prints:
      * //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
      * ```
-     *
-     * ```js
-     * const {
-     *   createHash,
-     * } = require('crypto');
-     *
-     * const hash = createHash('sha256');
-     *
-     * hash.update('some data to hash');
-     * console.log(hash.digest('hex'));
-     * // Prints:
-     * //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
-     * ```
      * @since v0.1.92
      */
     class Hash extends stream.Transform {
@@ -450,7 +335,7 @@ declare module 'crypto' {
          * ```js
          * // Calculate a rolling hash.
          * const {
-         *   createHash,
+         *   createHash
          * } = await import('crypto');
          *
          * const hash = createHash('sha256');
@@ -466,26 +351,6 @@ declare module 'crypto' {
          *
          * // Etc.
          * ```
-         *
-         * ```js
-         * // Calculate a rolling hash.
-         * const {
-         *   createHash,
-         * } = require('crypto');
-         *
-         * const hash = createHash('sha256');
-         *
-         * hash.update('one');
-         * console.log(hash.copy().digest('hex'));
-         *
-         * hash.update('two');
-         * console.log(hash.copy().digest('hex'));
-         *
-         * hash.update('three');
-         * console.log(hash.copy().digest('hex'));
-         *
-         * // Etc.
-         * ```
          * @since v13.1.0
          * @param options `stream.transform` options
          */
@@ -530,7 +395,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   createHmac,
+     *   createHmac
      * } = await import('crypto');
      *
      * const hmac = createHmac('sha256', 'a secret');
@@ -550,63 +415,26 @@ declare module 'crypto' {
      * hmac.end();
      * ```
      *
-     * ```js
-     * const {
-     *   createHmac,
-     * } = require('crypto');
-     *
-     * const hmac = createHmac('sha256', 'a secret');
-     *
-     * hmac.on('readable', () => {
-     *   // Only one element is going to be produced by the
-     *   // hash stream.
-     *   const data = hmac.read();
-     *   if (data) {
-     *     console.log(data.toString('hex'));
-     *     // Prints:
-     *     //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
-     *   }
-     * });
-     *
-     * hmac.write('some data to hash');
-     * hmac.end();
-     * ```
-     *
      * Example: Using `Hmac` and piped streams:
      *
      * ```js
      * import { createReadStream } from 'fs';
-     *
+     * import { stdout } from 'process';
      * const {
-     *   createHmac,
+     *   createHmac
      * } = await import('crypto');
      *
      * const hmac = createHmac('sha256', 'a secret');
      *
      * const input = createReadStream('test.js');
-     * input.pipe(hmac).pipe(process.stdout);
-     * ```
-     *
-     * ```js
-     * const {
-     *   createReadStream,
-     * } = require('fs');
-     *
-     * const {
-     *   createHmac,
-     * } = require('crypto');
-     *
-     * const hmac = createHmac('sha256', 'a secret');
-     *
-     * const input = createReadStream('test.js');
-     * input.pipe(hmac).pipe(process.stdout);
+     * input.pipe(hmac).pipe(stdout);
      * ```
      *
      * Example: Using the `hmac.update()` and `hmac.digest()` methods:
      *
      * ```js
      * const {
-     *   createHmac,
+     *   createHmac
      * } = await import('crypto');
      *
      * const hmac = createHmac('sha256', 'a secret');
@@ -616,19 +444,6 @@ declare module 'crypto' {
      * // Prints:
      * //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
      * ```
-     *
-     * ```js
-     * const {
-     *   createHmac,
-     * } = require('crypto');
-     *
-     * const hmac = createHmac('sha256', 'a secret');
-     *
-     * hmac.update('some data to hash');
-     * console.log(hmac.digest('hex'));
-     * // Prints:
-     * //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
-     * ```
      * @since v0.1.94
      */
     class Hmac extends stream.Transform {
@@ -921,39 +736,6 @@ declare module 'crypto' {
      * });
      * ```
      *
-     * ```js
-     * const {
-     *   scrypt,
-     *   randomFill,
-     *   createCipheriv
-     * } = require('crypto');
-     *
-     * const algorithm = 'aes-192-cbc';
-     * const password = 'Password used to generate key';
-     *
-     * // First, we'll generate the key. The key length is dependent on the algorithm.
-     * // In this case for aes192, it is 24 bytes (192 bits).
-     * scrypt(password, 'salt', 24, (err, key) => {
-     *   if (err) throw err;
-     *   // Then, we'll generate a random initialization vector
-     *   randomFill(new Uint8Array(16), (err, iv) => {
-     *     if (err) throw err;
-     *
-     *     // Once we have the key and iv, we can create and use the cipher...
-     *     const cipher = createCipheriv(algorithm, key, iv);
-     *
-     *     let encrypted = '';
-     *     cipher.setEncoding('hex');
-     *
-     *     cipher.on('data', (chunk) => encrypted += chunk);
-     *     cipher.on('end', () => console.log(encrypted));
-     *
-     *     cipher.write('some clear text data');
-     *     cipher.end();
-     *   });
-     * });
-     * ```
-     *
      * Example: Using `Cipher` and piped streams:
      *
      * ```js
@@ -969,7 +751,7 @@ declare module 'crypto' {
      * const {
      *   scrypt,
      *   randomFill,
-     *   createCipheriv,
+     *   createCipheriv
      * } = await import('crypto');
      *
      * const algorithm = 'aes-192-cbc';
@@ -995,52 +777,13 @@ declare module 'crypto' {
      * });
      * ```
      *
-     * ```js
-     * const {
-     *   createReadStream,
-     *   createWriteStream,
-     * } = require('fs');
-     *
-     * const {
-     *   pipeline
-     * } = require('stream');
-     *
-     * const {
-     *   scrypt,
-     *   randomFill,
-     *   createCipheriv,
-     * } = require('crypto');
-     *
-     * const algorithm = 'aes-192-cbc';
-     * const password = 'Password used to generate key';
-     *
-     * // First, we'll generate the key. The key length is dependent on the algorithm.
-     * // In this case for aes192, it is 24 bytes (192 bits).
-     * scrypt(password, 'salt', 24, (err, key) => {
-     *   if (err) throw err;
-     *   // Then, we'll generate a random initialization vector
-     *   randomFill(new Uint8Array(16), (err, iv) => {
-     *     if (err) throw err;
-     *
-     *     const cipher = createCipheriv(algorithm, key, iv);
-     *
-     *     const input = createReadStream('test.js');
-     *     const output = createWriteStream('test.enc');
-     *
-     *     pipeline(input, cipher, output, (err) => {
-     *       if (err) throw err;
-     *     });
-     *   });
-     * });
-     * ```
-     *
      * Example: Using the `cipher.update()` and `cipher.final()` methods:
      *
      * ```js
      * const {
      *   scrypt,
      *   randomFill,
-     *   createCipheriv,
+     *   createCipheriv
      * } = await import('crypto');
      *
      * const algorithm = 'aes-192-cbc';
@@ -1062,33 +805,6 @@ declare module 'crypto' {
      *   });
      * });
      * ```
-     *
-     * ```js
-     * const {
-     *   scrypt,
-     *   randomFill,
-     *   createCipheriv,
-     * } = require('crypto');
-     *
-     * const algorithm = 'aes-192-cbc';
-     * const password = 'Password used to generate key';
-     *
-     * // First, we'll generate the key. The key length is dependent on the algorithm.
-     * // In this case for aes192, it is 24 bytes (192 bits).
-     * scrypt(password, 'salt', 24, (err, key) => {
-     *   if (err) throw err;
-     *   // Then, we'll generate a random initialization vector
-     *   randomFill(new Uint8Array(16), (err, iv) => {
-     *     if (err) throw err;
-     *
-     *     const cipher = createCipheriv(algorithm, key, iv);
-     *
-     *     let encrypted = cipher.update('some clear text data', 'utf8', 'hex');
-     *     encrypted += cipher.final('hex');
-     *     console.log(encrypted);
-     *   });
-     * });
-     * ```
      * @since v0.1.94
      */
     class Cipher extends stream.Transform {
@@ -1229,9 +945,10 @@ declare module 'crypto' {
      * Example: Using `Decipher` objects as streams:
      *
      * ```js
+     * import { Buffer } from 'buffer';
      * const {
      *   scryptSync,
-     *   createDecipheriv,
+     *   createDecipheriv
      * } = await import('crypto');
      *
      * const algorithm = 'aes-192-cbc';
@@ -1263,41 +980,6 @@ declare module 'crypto' {
      * decipher.end();
      * ```
      *
-     * ```js
-     * const {
-     *   scryptSync,
-     *   createDecipheriv,
-     * } = require('crypto');
-     *
-     * const algorithm = 'aes-192-cbc';
-     * const password = 'Password used to generate key';
-     * // Key length is dependent on the algorithm. In this case for aes192, it is
-     * // 24 bytes (192 bits).
-     * // Use the async `crypto.scrypt()` instead.
-     * const key = scryptSync(password, 'salt', 24);
-     * // The IV is usually passed along with the ciphertext.
-     * const iv = Buffer.alloc(16, 0); // Initialization vector.
-     *
-     * const decipher = createDecipheriv(algorithm, key, iv);
-     *
-     * let decrypted = '';
-     * decipher.on('readable', () => {
-     *   while (null !== (chunk = decipher.read())) {
-     *     decrypted += chunk.toString('utf8');
-     *   }
-     * });
-     * decipher.on('end', () => {
-     *   console.log(decrypted);
-     *   // Prints: some clear text data
-     * });
-     *
-     * // Encrypted with same algorithm, key and iv.
-     * const encrypted =
-     *   'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
-     * decipher.write(encrypted, 'hex');
-     * decipher.end();
-     * ```
-     *
      * Example: Using `Decipher` and piped streams:
      *
      * ```js
@@ -1305,10 +987,10 @@ declare module 'crypto' {
      *   createReadStream,
      *   createWriteStream,
      * } from 'fs';
-     *
+     * import { Buffer } from 'buffer';
      * const {
      *   scryptSync,
-     *   createDecipheriv,
+     *   createDecipheriv
      * } = await import('crypto');
      *
      * const algorithm = 'aes-192-cbc';
@@ -1326,38 +1008,13 @@ declare module 'crypto' {
      * input.pipe(decipher).pipe(output);
      * ```
      *
-     * ```js
-     * const {
-     *   createReadStream,
-     *   createWriteStream,
-     * } = require('fs');
-     *
-     * const {
-     *   scryptSync,
-     *   createDecipheriv,
-     * } = require('crypto');
-     *
-     * const algorithm = 'aes-192-cbc';
-     * const password = 'Password used to generate key';
-     * // Use the async `crypto.scrypt()` instead.
-     * const key = scryptSync(password, 'salt', 24);
-     * // The IV is usually passed along with the ciphertext.
-     * const iv = Buffer.alloc(16, 0); // Initialization vector.
-     *
-     * const decipher = createDecipheriv(algorithm, key, iv);
-     *
-     * const input = createReadStream('test.enc');
-     * const output = createWriteStream('test.js');
-     *
-     * input.pipe(decipher).pipe(output);
-     * ```
-     *
      * Example: Using the `decipher.update()` and `decipher.final()` methods:
      *
      * ```js
+     * import { Buffer } from 'buffer';
      * const {
      *   scryptSync,
-     *   createDecipheriv,
+     *   createDecipheriv
      * } = await import('crypto');
      *
      * const algorithm = 'aes-192-cbc';
@@ -1377,30 +1034,6 @@ declare module 'crypto' {
      * console.log(decrypted);
      * // Prints: some clear text data
      * ```
-     *
-     * ```js
-     * const {
-     *   scryptSync,
-     *   createDecipheriv,
-     * } = require('crypto');
-     *
-     * const algorithm = 'aes-192-cbc';
-     * const password = 'Password used to generate key';
-     * // Use the async `crypto.scrypt()` instead.
-     * const key = scryptSync(password, 'salt', 24);
-     * // The IV is usually passed along with the ciphertext.
-     * const iv = Buffer.alloc(16, 0); // Initialization vector.
-     *
-     * const decipher = createDecipheriv(algorithm, key, iv);
-     *
-     * // Encrypted using same algorithm, key and iv.
-     * const encrypted =
-     *   'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
-     * let decrypted = decipher.update(encrypted, 'hex', 'utf8');
-     * decrypted += decipher.final('utf8');
-     * console.log(decrypted);
-     * // Prints: some clear text data
-     * ```
      * @since v0.1.94
      */
     class Decipher extends stream.Transform {
@@ -1481,7 +1114,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   generateKey,
+     *   generateKey
      * } = await import('crypto');
      *
      * generateKey('hmac', { length: 64 }, (err, key) => {
@@ -1489,17 +1122,6 @@ declare module 'crypto' {
      *   console.log(key.export().toString('hex'));  // 46e..........620
      * });
      * ```
-     *
-     * ```js
-     * const {
-     *   generateKey,
-     * } = require('crypto');
-     *
-     * generateKey('hmac', { length: 64 }, (err, key) => {
-     *   if (err) throw err;
-     *   console.log(key.export().toString('hex'));  // 46e..........620
-     * });
-     * ```
      * @since v15.0.0
      * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
      */
@@ -1595,7 +1217,7 @@ declare module 'crypto' {
      * const {
      *   generateKeyPairSync,
      *   createSign,
-     *   createVerify,
+     *   createVerify
      * } = await import('crypto');
      *
      * const { privateKey, publicKey } = generateKeyPairSync('ec', {
@@ -1614,36 +1236,13 @@ declare module 'crypto' {
      * // Prints: true
      * ```
      *
-     * ```js
-     * const {
-     *   generateKeyPairSync,
-     *   createSign,
-     *   createVerify,
-     * } = require('crypto');
-     *
-     * const { privateKey, publicKey } = generateKeyPairSync('ec', {
-     *   namedCurve: 'sect239k1'
-     * });
-     *
-     * const sign = createSign('SHA256');
-     * sign.write('some data to sign');
-     * sign.end();
-     * const signature = sign.sign(privateKey, 'hex');
-     *
-     * const verify = createVerify('SHA256');
-     * verify.write('some data to sign');
-     * verify.end();
-     * console.log(verify.verify(publicKey, signature, 'hex'));
-     * // Prints: true
-     * ```
-     *
      * Example: Using the `sign.update()` and `verify.update()` methods:
      *
      * ```js
      * const {
      *   generateKeyPairSync,
      *   createSign,
-     *   createVerify,
+     *   createVerify
      * } = await import('crypto');
      *
      * const { privateKey, publicKey } = generateKeyPairSync('rsa', {
@@ -1661,29 +1260,6 @@ declare module 'crypto' {
      * console.log(verify.verify(publicKey, signature));
      * // Prints: true
      * ```
-     *
-     * ```js
-     * const {
-     *   generateKeyPairSync,
-     *   createSign,
-     *   createVerify,
-     * } = require('crypto');
-     *
-     * const { privateKey, publicKey } = generateKeyPairSync('rsa', {
-     *   modulusLength: 2048,
-     * });
-     *
-     * const sign = createSign('SHA256');
-     * sign.update('some data to sign');
-     * sign.end();
-     * const signature = sign.sign(privateKey);
-     *
-     * const verify = createVerify('SHA256');
-     * verify.update('some data to sign');
-     * verify.end();
-     * console.log(verify.verify(publicKey, signature));
-     * // Prints: true
-     * ```
      * @since v0.1.92
      */
     class Sign extends stream.Writable {
@@ -1810,7 +1386,7 @@ declare module 'crypto' {
      * import assert from 'assert';
      *
      * const {
-     *   createDiffieHellman,
+     *   createDiffieHellman
      * } = await import('crypto');
      *
      * // Generate Alice's keys...
@@ -1828,29 +1404,6 @@ declare module 'crypto' {
      * // OK
      * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
      * ```
-     *
-     * ```js
-     * const assert = require('assert');
-     *
-     * const {
-     *   createDiffieHellman,
-     * } = require('crypto');
-     *
-     * // Generate Alice's keys...
-     * const alice = createDiffieHellman(2048);
-     * const aliceKey = alice.generateKeys();
-     *
-     * // Generate Bob's keys...
-     * const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
-     * const bobKey = bob.generateKeys();
-     *
-     * // Exchange and generate the secret...
-     * const aliceSecret = alice.computeSecret(bobKey);
-     * const bobSecret = bob.computeSecret(aliceKey);
-     *
-     * // OK
-     * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
-     * ```
      * @since v0.5.0
      */
     class DiffieHellman {
@@ -1964,7 +1517,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   getDiffieHellman,
+     *   getDiffieHellman
      * } = await import('crypto');
      * const alice = getDiffieHellman('modp14');
      * const bob = getDiffieHellman('modp14');
@@ -1978,24 +1531,6 @@ declare module 'crypto' {
      * // aliceSecret and bobSecret should be the same
      * console.log(aliceSecret === bobSecret);
      * ```
-     *
-     * ```js
-     * const {
-     *   getDiffieHellman,
-     * } = require('crypto');
-     *
-     * const alice = getDiffieHellman('modp14');
-     * const bob = getDiffieHellman('modp14');
-     *
-     * alice.generateKeys();
-     * bob.generateKeys();
-     *
-     * const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
-     * const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
-     *
-     * // aliceSecret and bobSecret should be the same
-     * console.log(aliceSecret === bobSecret);
-     * ```
      * @since v0.7.5
      */
     function getDiffieHellman(groupName: string): DiffieHellman;
@@ -2022,7 +1557,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   pbkdf2,
+     *   pbkdf2
      * } = await import('crypto');
      *
      * pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
@@ -2031,31 +1566,11 @@ declare module 'crypto' {
      * });
      * ```
      *
-     * ```js
-     * const {
-     *   pbkdf2,
-     * } = require('crypto');
-     *
-     * pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
-     *   if (err) throw err;
-     *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
-     * });
-     * ```
-     *
      * The `crypto.DEFAULT_ENCODING` property can be used to change the way the`derivedKey` is passed to the callback. This property, however, has been
      * deprecated and use should be avoided.
      *
      * ```js
-     * const crypto = await import('crypto');
-     * crypto.DEFAULT_ENCODING = 'hex';
-     * crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, derivedKey) => {
-     *   if (err) throw err;
-     *   console.log(derivedKey);  // '3745e48...aa39b34'
-     * });
-     * ```
-     *
-     * ```js
-     * const crypto = require('crypto');
+     * import crypto from 'crypto';
      * crypto.DEFAULT_ENCODING = 'hex';
      * crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, derivedKey) => {
      *   if (err) throw err;
@@ -2092,34 +1607,18 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   pbkdf2Sync,
+     *   pbkdf2Sync
      * } = await import('crypto');
      *
      * const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
      * console.log(key.toString('hex'));  // '3745e48...08d59ae'
      * ```
      *
-     * ```js
-     * const {
-     *   pbkdf2Sync,
-     * } = require('crypto');
-     *
-     * const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
-     * console.log(key.toString('hex'));  // '3745e48...08d59ae'
-     * ```
-     *
      * The `crypto.DEFAULT_ENCODING` property may be used to change the way the`derivedKey` is returned. This property, however, is deprecated and use
      * should be avoided.
      *
      * ```js
-     * const crypto = await import('crypto');
-     * crypto.DEFAULT_ENCODING = 'hex';
-     * const key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512');
-     * console.log(key);  // '3745e48...aa39b34'
-     * ```
-     *
-     * ```js
-     * const crypto = require('crypto');
+     * import crypto from 'crypto';
      * crypto.DEFAULT_ENCODING = 'hex';
      * const key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512');
      * console.log(key);  // '3745e48...aa39b34'
@@ -2140,7 +1639,7 @@ declare module 'crypto' {
      * ```js
      * // Asynchronous
      * const {
-     *   randomBytes,
+     *   randomBytes
      * } = await import('crypto');
      *
      * randomBytes(256, (err, buf) => {
@@ -2149,18 +1648,6 @@ declare module 'crypto' {
      * });
      * ```
      *
-     * ```js
-     * // Asynchronous
-     * const {
-     *   randomBytes,
-     * } = require('crypto');
-     *
-     * randomBytes(256, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
-     * });
-     * ```
-     *
      * If the `callback` function is not provided, the random bytes are generated
      * synchronously and returned as a `Buffer`. An error will be thrown if
      * there is a problem generating the bytes.
@@ -2168,7 +1655,7 @@ declare module 'crypto' {
      * ```js
      * // Synchronous
      * const {
-     *   randomBytes,
+     *   randomBytes
      * } = await import('crypto');
      *
      * const buf = randomBytes(256);
@@ -2176,17 +1663,6 @@ declare module 'crypto' {
      *   `${buf.length} bytes of random data: ${buf.toString('hex')}`);
      * ```
      *
-     * ```js
-     * // Synchronous
-     * const {
-     *   randomBytes,
-     * } = require('crypto');
-     *
-     * const buf = randomBytes(256);
-     * console.log(
-     *   `${buf.length} bytes of random data: ${buf.toString('hex')}`);
-     * ```
-     *
      * The `crypto.randomBytes()` method will not complete until there is
      * sufficient entropy available.
      * This should normally never take longer than a few milliseconds. The only time
@@ -2221,20 +1697,8 @@ declare module 'crypto' {
      * ```js
      * // Asynchronous
      * const {
-     *   randomInt,
-     * } = await import('crypto');
-     *
-     * randomInt(3, (err, n) => {
-     *   if (err) throw err;
-     *   console.log(`Random number chosen from (0, 1, 2): ${n}`);
-     * });
-     * ```
-     *
-     * ```js
-     * // Asynchronous
-     * const {
-     *   randomInt,
-     * } = require('crypto');
+     *   randomInt
+     * } = await import('crypto');
      *
      * randomInt(3, (err, n) => {
      *   if (err) throw err;
@@ -2245,7 +1709,7 @@ declare module 'crypto' {
      * ```js
      * // Synchronous
      * const {
-     *   randomInt,
+     *   randomInt
      * } = await import('crypto');
      *
      * const n = randomInt(3);
@@ -2253,34 +1717,14 @@ declare module 'crypto' {
      * ```
      *
      * ```js
-     * // Synchronous
-     * const {
-     *   randomInt,
-     * } = require('crypto');
-     *
-     * const n = randomInt(3);
-     * console.log(`Random number chosen from (0, 1, 2): ${n}`);
-     * ```
-     *
-     * ```js
      * // With `min` argument
      * const {
-     *   randomInt,
+     *   randomInt
      * } = await import('crypto');
      *
      * const n = randomInt(1, 7);
      * console.log(`The dice rolled: ${n}`);
      * ```
-     *
-     * ```js
-     * // With `min` argument
-     * const {
-     *   randomInt,
-     * } = require('crypto');
-     *
-     * const n = randomInt(1, 7);
-     * console.log(`The dice rolled: ${n}`);
-     * ```
      * @since v14.10.0, v12.19.0
      * @param [min=0] Start of random range (inclusive).
      * @param max End of random range (exclusive).
@@ -2294,25 +1738,8 @@ declare module 'crypto' {
      * Synchronous version of {@link randomFill}.
      *
      * ```js
-     * const {
-     *   randomFillSync,
-     * } = await import('crypto');
-     *
-     * const buf = Buffer.alloc(10);
-     * console.log(randomFillSync(buf).toString('hex'));
-     *
-     * randomFillSync(buf, 5);
-     * console.log(buf.toString('hex'));
-     *
-     * // The above is equivalent to the following:
-     * randomFillSync(buf, 5, 5);
-     * console.log(buf.toString('hex'));
-     * ```
-     *
-     * ```js
-     * const {
-     *   randomFillSync,
-     * } = require('crypto');
+     * import { Buffer } from 'buffer';
+     * const { randomFillSync } = await import('crypto');
      *
      * const buf = Buffer.alloc(10);
      * console.log(randomFillSync(buf).toString('hex'));
@@ -2328,26 +1755,8 @@ declare module 'crypto' {
      * Any `ArrayBuffer`, `TypedArray` or `DataView` instance may be passed as`buffer`.
      *
      * ```js
-     * const {
-     *   randomFillSync,
-     * } = await import('crypto');
-     *
-     * const a = new Uint32Array(10);
-     * console.log(Buffer.from(randomFillSync(a).buffer,
-     *                         a.byteOffset, a.byteLength).toString('hex'));
-     *
-     * const b = new DataView(new ArrayBuffer(10));
-     * console.log(Buffer.from(randomFillSync(b).buffer,
-     *                         b.byteOffset, b.byteLength).toString('hex'));
-     *
-     * const c = new ArrayBuffer(10);
-     * console.log(Buffer.from(randomFillSync(c)).toString('hex'));
-     * ```
-     *
-     * ```js
-     * const {
-     *   randomFillSync,
-     * } = require('crypto');
+     * import { Buffer } from 'buffer';
+     * const { randomFillSync } = await import('crypto');
      *
      * const a = new Uint32Array(10);
      * console.log(Buffer.from(randomFillSync(a).buffer,
@@ -2375,32 +1784,8 @@ declare module 'crypto' {
      * If the `callback` function is not provided, an error will be thrown.
      *
      * ```js
-     * const {
-     *   randomFill,
-     * } = await import('crypto');
-     *
-     * const buf = Buffer.alloc(10);
-     * randomFill(buf, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(buf.toString('hex'));
-     * });
-     *
-     * randomFill(buf, 5, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(buf.toString('hex'));
-     * });
-     *
-     * // The above is equivalent to the following:
-     * randomFill(buf, 5, 5, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(buf.toString('hex'));
-     * });
-     * ```
-     *
-     * ```js
-     * const {
-     *   randomFill,
-     * } = require('crypto');
+     * import { Buffer } from 'buffer';
+     * const { randomFill } = await import('crypto');
      *
      * const buf = Buffer.alloc(10);
      * randomFill(buf, (err, buf) => {
@@ -2429,35 +1814,8 @@ declare module 'crypto' {
      * distribution and have no meaningful lower or upper bounds.
      *
      * ```js
-     * const {
-     *   randomFill,
-     * } = await import('crypto');
-     *
-     * const a = new Uint32Array(10);
-     * randomFill(a, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-     *     .toString('hex'));
-     * });
-     *
-     * const b = new DataView(new ArrayBuffer(10));
-     * randomFill(b, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-     *     .toString('hex'));
-     * });
-     *
-     * const c = new ArrayBuffer(10);
-     * randomFill(c, (err, buf) => {
-     *   if (err) throw err;
-     *   console.log(Buffer.from(buf).toString('hex'));
-     * });
-     * ```
-     *
-     * ```js
-     * const {
-     *   randomFill,
-     * } = require('crypto');
+     * import { Buffer } from 'buffer';
+     * const { randomFill } = await import('crypto');
      *
      * const a = new Uint32Array(10);
      * randomFill(a, (err, buf) => {
@@ -2523,7 +1881,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   scrypt,
+     *   scrypt
      * } = await import('crypto');
      *
      * // Using the factory defaults.
@@ -2537,23 +1895,6 @@ declare module 'crypto' {
      *   console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
      * });
      * ```
-     *
-     * ```js
-     * const {
-     *   scrypt,
-     * } = require('crypto');
-     *
-     * // Using the factory defaults.
-     * scrypt('password', 'salt', 64, (err, derivedKey) => {
-     *   if (err) throw err;
-     *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
-     * });
-     * // Using a custom N parameter. Must be a power of two.
-     * scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
-     *   if (err) throw err;
-     *   console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
-     * });
-     * ```
      * @since v10.5.0
      */
     function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: Buffer) => void): void;
@@ -2576,7 +1917,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   scryptSync,
+     *   scryptSync
      * } = await import('crypto');
      * // Using the factory defaults.
      *
@@ -2586,19 +1927,6 @@ declare module 'crypto' {
      * const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
      * console.log(key2.toString('hex'));  // '3745e48...aa39b34'
      * ```
-     *
-     * ```js
-     * const {
-     *   scryptSync,
-     * } = require('crypto');
-     * // Using the factory defaults.
-     *
-     * const key1 = scryptSync('password', 'salt', 64);
-     * console.log(key1.toString('hex'));  // '3745e48...08d59ae'
-     * // Using a custom N parameter. Must be a power of two.
-     * const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
-     * console.log(key2.toString('hex'));  // '3745e48...aa39b34'
-     * ```
      * @since v10.5.0
      */
     function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;
@@ -2661,19 +1989,11 @@ declare module 'crypto' {
     /**
      * ```js
      * const {
-     *   getCiphers,
+     *   getCiphers
      * } = await import('crypto');
      *
      * console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
      * ```
-     *
-     * ```js
-     * const {
-     *   getCiphers,
-     * } = require('crypto');
-     *
-     * console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
-     * ```
      * @since v0.9.3
      * @return An array with the names of the supported cipher algorithms.
      */
@@ -2681,19 +2001,11 @@ declare module 'crypto' {
     /**
      * ```js
      * const {
-     *   getCurves,
+     *   getCurves
      * } = await import('crypto');
      *
      * console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
      * ```
-     *
-     * ```js
-     * const {
-     *   getCurves,
-     * } = require('crypto');
-     *
-     * console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
-     * ```
      * @since v2.3.0
      * @return An array with the names of the supported elliptic curves.
      */
@@ -2706,19 +2018,11 @@ declare module 'crypto' {
     /**
      * ```js
      * const {
-     *   getHashes,
+     *   getHashes
      * } = await import('crypto');
      *
      * console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
      * ```
-     *
-     * ```js
-     * const {
-     *   getHashes,
-     * } = require('crypto');
-     *
-     * console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
-     * ```
      * @since v0.9.3
      * @return An array of the names of the supported hash algorithms, such as `'RSA-SHA256'`. Hash algorithms are also called "digest" algorithms.
      */
@@ -2733,7 +2037,7 @@ declare module 'crypto' {
      * import assert from 'assert';
      *
      * const {
-     *   createECDH,
+     *   createECDH
      * } = await import('crypto');
      *
      * // Generate Alice's keys...
@@ -2751,29 +2055,6 @@ declare module 'crypto' {
      * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
      * // OK
      * ```
-     *
-     * ```js
-     * const assert = require('assert');
-     *
-     * const {
-     *   createECDH,
-     * } = require('crypto');
-     *
-     * // Generate Alice's keys...
-     * const alice = createECDH('secp521r1');
-     * const aliceKey = alice.generateKeys();
-     *
-     * // Generate Bob's keys...
-     * const bob = createECDH('secp521r1');
-     * const bobKey = bob.generateKeys();
-     *
-     * // Exchange and generate the secret...
-     * const aliceSecret = alice.computeSecret(bobKey);
-     * const bobSecret = bob.computeSecret(aliceKey);
-     *
-     * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
-     * // OK
-     * ```
      * @since v0.11.14
      */
     class ECDH {
@@ -2798,7 +2079,7 @@ declare module 'crypto' {
          * ```js
          * const {
          *   createECDH,
-         *   ECDH,
+         *   ECDH
          * } = await import('crypto');
          *
          * const ecdh = createECDH('secp256k1');
@@ -2815,27 +2096,6 @@ declare module 'crypto' {
          * // The converted key and the uncompressed public key should be the same
          * console.log(uncompressedKey === ecdh.getPublicKey('hex'));
          * ```
-         *
-         * ```js
-         * const {
-         *   createECDH,
-         *   ECDH,
-         * } = require('crypto');
-         *
-         * const ecdh = createECDH('secp256k1');
-         * ecdh.generateKeys();
-         *
-         * const compressedKey = ecdh.getPublicKey('hex', 'compressed');
-         *
-         * const uncompressedKey = ECDH.convertKey(compressedKey,
-         *                                         'secp256k1',
-         *                                         'hex',
-         *                                         'hex',
-         *                                         'uncompressed');
-         *
-         * // The converted key and the uncompressed public key should be the same
-         * console.log(uncompressedKey === ecdh.getPublicKey('hex'));
-         * ```
          * @since v10.0.0
          * @param inputEncoding The `encoding` of the `key` string.
          * @param outputEncoding The `encoding` of the return value.
@@ -3089,7 +2349,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   generateKeyPairSync,
+     *   generateKeyPairSync
      * } = await import('crypto');
      *
      * const {
@@ -3110,29 +2370,6 @@ declare module 'crypto' {
      * });
      * ```
      *
-     * ```js
-     * const {
-     *   generateKeyPairSync,
-     * } = require('crypto');
-     *
-     * const {
-     *   publicKey,
-     *   privateKey,
-     * } = generateKeyPairSync('rsa', {
-     *   modulusLength: 4096,
-     *   publicKeyEncoding: {
-     *     type: 'spki',
-     *     format: 'pem'
-     *   },
-     *   privateKeyEncoding: {
-     *     type: 'pkcs8',
-     *     format: 'pem',
-     *     cipher: 'aes-256-cbc',
-     *     passphrase: 'top secret'
-     *   }
-     * });
-     * ```
-     *
      * The return value `{ publicKey, privateKey }` represents the generated key pair.
      * When PEM encoding was selected, the respective key will be a string, otherwise
      * it will be a buffer containing the data encoded as DER.
@@ -3186,7 +2423,7 @@ declare module 'crypto' {
      *
      * ```js
      * const {
-     *   generateKeyPair,
+     *   generateKeyPair
      * } = await import('crypto');
      *
      * generateKeyPair('rsa', {
@@ -3206,28 +2443,6 @@ declare module 'crypto' {
      * });
      * ```
      *
-     * ```js
-     * const {
-     *   generateKeyPair,
-     * } = require('crypto');
-     *
-     * generateKeyPair('rsa', {
-     *   modulusLength: 4096,
-     *   publicKeyEncoding: {
-     *     type: 'spki',
-     *     format: 'pem'
-     *   },
-     *   privateKeyEncoding: {
-     *     type: 'pkcs8',
-     *     format: 'pem',
-     *     cipher: 'aes-256-cbc',
-     *     passphrase: 'top secret'
-     *   }
-     * }, (err, publicKey, privateKey) => {
-     *   // Handle errors and use the generated key pair.
-     * });
-     * ```
-     *
      * On completion, `callback` will be called with `err` set to `undefined` and`publicKey` / `privateKey` representing the generated key pair.
      *
      * If this method is invoked as its `util.promisify()` ed version, it returns
@@ -3576,7 +2791,7 @@ declare module 'crypto' {
      */
     function getCipherInfo(nameOrNid: string | number, options?: CipherInfoOptions): CipherInfo | undefined;
     /**
-     * HKDF is a simple key derivation function defined in RFC 5869\. The given `key`,`salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
+     * HKDF is a simple key derivation function defined in RFC 5869\. The given `ikm`,`salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
      *
      * The supplied `callback` function is called with two arguments: `err` and`derivedKey`. If an errors occurs while deriving the key, `err` will be set;
      * otherwise `err` will be `null`. The successfully generated `derivedKey` will
@@ -3584,8 +2799,9 @@ declare module 'crypto' {
      * of the input arguments specify invalid values or types.
      *
      * ```js
+     * import { Buffer } from 'buffer';
      * const {
-     *   hkdf,
+     *   hkdf
      * } = await import('crypto');
      *
      * hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
@@ -3593,29 +2809,18 @@ declare module 'crypto' {
      *   console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
      * });
      * ```
-     *
-     * ```js
-     * const {
-     *   hkdf,
-     * } = require('crypto');
-     *
-     * hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
-     *   if (err) throw err;
-     *   console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
-     * });
-     * ```
      * @since v15.0.0
      * @param digest The digest algorithm to use.
-     * @param key The secret key. It must be at least one byte in length.
+     * @param ikm The input keying material. It must be at least one byte in length.
      * @param salt The salt value. Must be provided but can be zero-length.
      * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
      * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512`
      * generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
      */
-    function hkdf(digest: string, key: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => void): void;
+    function hkdf(digest: string, irm: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => void): void;
     /**
      * Provides a synchronous HKDF key derivation function as defined in RFC 5869\. The
-     * given `key`, `salt` and `info` are used with the `digest` to derive a key of`keylen` bytes.
+     * given `ikm`, `salt` and `info` are used with the `digest` to derive a key of`keylen` bytes.
      *
      * The successfully generated `derivedKey` will be returned as an [<ArrayBuffer>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
      *
@@ -3623,31 +2828,23 @@ declare module 'crypto' {
      * types, or if the derived key cannot be generated.
      *
      * ```js
+     * import { Buffer } from 'buffer';
      * const {
-     *   hkdfSync,
+     *   hkdfSync
      * } = await import('crypto');
      *
      * const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
      * console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
      * ```
-     *
-     * ```js
-     * const {
-     *   hkdfSync,
-     * } = require('crypto');
-     *
-     * const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
-     * console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
-     * ```
      * @since v15.0.0
      * @param digest The digest algorithm to use.
-     * @param key The secret key. It must be at least one byte in length.
+     * @param ikm The input keying material. It must be at least one byte in length.
      * @param salt The salt value. Must be provided but can be zero-length.
      * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
      * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512`
      * generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
      */
-    function hkdfSync(digest: string, key: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
+    function hkdfSync(digest: string, ikm: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
     interface SecureHeapUsage {
         /**
          * The total allocated secure heap size as specified using the `--secure-heap=n` command-line flag.
@@ -3682,7 +2879,7 @@ declare module 'crypto' {
         disableEntropyCache?: boolean | undefined;
     }
     /**
-     * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) Version 4 UUID. The UUID is generated using a
+     * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) version 4 UUID. The UUID is generated using a
      * cryptographic pseudorandom number generator.
      * @since v15.6.0
      */
@@ -3720,14 +2917,6 @@ declare module 'crypto' {
      *
      * console.log(x509.subject);
      * ```
-     *
-     * ```js
-     * const { X509Certificate } = require('crypto');
-     *
-     * const x509 = new X509Certificate('{... pem encoded cert ...}');
-     *
-     * console.log(x509.subject);
-     * ```
      * @since v15.6.0
      */
     class X509Certificate {
@@ -3778,7 +2967,7 @@ declare module 'crypto' {
          */
         readonly issuerCertificate?: X509Certificate | undefined;
         /**
-         * The public key `<KeyObject>` for this certificate.
+         * The public key `KeyObject` for this certificate.
          * @since v15.6.0
          */
         readonly publicKey: KeyObject;