/**
 * The `v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
 *
 * ```js
 * const v8 = require('v8');
 * ```
 * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/v8.js)
 */
declare module 'v8' {
  import { Readable } from 'node:stream';

  interface HeapSpaceInfo {
    space_name: string;
    space_size: number;
    space_used_size: number;
    space_available_size: number;
    physical_space_size: number;
  }
  // ** Signifies if the --zap_code_space option is enabled or not.  1 == enabled, 0 == disabled. */
  type DoesZapCodeSpaceFlag = 0 | 1;
  interface HeapInfo {
    total_heap_size: number;
    total_heap_size_executable: number;
    total_physical_size: number;
    total_available_size: number;
    used_heap_size: number;
    heap_size_limit: number;
    malloced_memory: number;
    peak_malloced_memory: number;
    does_zap_garbage: DoesZapCodeSpaceFlag;
    number_of_native_contexts: number;
    number_of_detached_contexts: number;
  }
  interface HeapCodeStatistics {
    code_and_metadata_size: number;
    bytecode_and_metadata_size: number;
    external_script_source_size: number;
  }
  /**
   * Returns an integer representing a version tag derived from the V8 version,
   * command-line flags, and detected CPU features. This is useful for determining
   * whether a `vm.Script` `cachedData` buffer is compatible with this instance
   * of V8.
   *
   * ```js
   * console.log(v8.cachedDataVersionTag()); // 3947234607
   * // The value returned by v8.cachedDataVersionTag() is derived from the V8
   * // version, command-line flags, and detected CPU features. Test that the value
   * // does indeed update when flags are toggled.
   * v8.setFlagsFromString('--allow_natives_syntax');
   * console.log(v8.cachedDataVersionTag()); // 183726201
   * ```
   * @since v8.0.0
   */
  function cachedDataVersionTag(): number;
  /**
   * Returns an object with the following properties:
   *
   * `does_zap_garbage` is a 0/1 boolean, which signifies whether the`--zap_code_space` option is enabled or not. This makes V8 overwrite heap
   * garbage with a bit pattern. The RSS footprint (resident set size) gets bigger
   * because it continuously touches all heap pages and that makes them less likely
   * to get swapped out by the operating system.
   *
   * `number_of_native_contexts` The value of native\_context is the number of the
   * top-level contexts currently active. Increase of this number over time indicates
   * a memory leak.
   *
   * `number_of_detached_contexts` The value of detached\_context is the number
   * of contexts that were detached and not yet garbage collected. This number
   * being non-zero indicates a potential memory leak.
   *
   * ```js
   * {
   *   total_heap_size: 7326976,
   *   total_heap_size_executable: 4194304,
   *   total_physical_size: 7326976,
   *   total_available_size: 1152656,
   *   used_heap_size: 3476208,
   *   heap_size_limit: 1535115264,
   *   malloced_memory: 16384,
   *   peak_malloced_memory: 1127496,
   *   does_zap_garbage: 0,
   *   number_of_native_contexts: 1,
   *   number_of_detached_contexts: 0
   * }
   * ```
   * @since v1.0.0
   */
  function getHeapStatistics(): HeapInfo;
  /**
   * Returns statistics about the V8 heap spaces, i.e. the segments which make up
   * the V8 heap. Neither the ordering of heap spaces, nor the availability of a
   * heap space can be guaranteed as the statistics are provided via the
   * V8[`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the
   * next.
   *
   * The value returned is an array of objects containing the following properties:
   *
   * ```json
   * [
   *   {
   *     "space_name": "new_space",
   *     "space_size": 2063872,
   *     "space_used_size": 951112,
   *     "space_available_size": 80824,
   *     "physical_space_size": 2063872
   *   },
   *   {
   *     "space_name": "old_space",
   *     "space_size": 3090560,
   *     "space_used_size": 2493792,
   *     "space_available_size": 0,
   *     "physical_space_size": 3090560
   *   },
   *   {
   *     "space_name": "code_space",
   *     "space_size": 1260160,
   *     "space_used_size": 644256,
   *     "space_available_size": 960,
   *     "physical_space_size": 1260160
   *   },
   *   {
   *     "space_name": "map_space",
   *     "space_size": 1094160,
   *     "space_used_size": 201608,
   *     "space_available_size": 0,
   *     "physical_space_size": 1094160
   *   },
   *   {
   *     "space_name": "large_object_space",
   *     "space_size": 0,
   *     "space_used_size": 0,
   *     "space_available_size": 1490980608,
   *     "physical_space_size": 0
   *   }
   * ]
   * ```
   * @since v6.0.0
   */
  function getHeapSpaceStatistics(): HeapSpaceInfo[];
  /**
   * The `v8.setFlagsFromString()` method can be used to programmatically set
   * V8 command-line flags. This method should be used with care. Changing settings
   * after the VM has started may result in unpredictable behavior, including
   * crashes and data loss; or it may simply do nothing.
   *
   * The V8 options available for a version of Node.js may be determined by running`node --v8-options`.
   *
   * Usage:
   *
   * ```js
   * // Print GC events to stdout for one minute.
   * const v8 = require('v8');
   * v8.setFlagsFromString('--trace_gc');
   * setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
   * ```
   * @since v1.0.0
   */
  function setFlagsFromString(flags: string): void;
  /**
   * Generates a snapshot of the current V8 heap and returns a Readable
   * Stream that may be used to read the JSON serialized representation.
   * This JSON stream format is intended to be used with tools such as
   * Chrome DevTools. The JSON schema is undocumented and specific to the
   * V8 engine. Therefore, the schema may change from one version of V8 to the next.
   *
   * Creating a heap snapshot requires memory about twice the size of the heap at
   * the time the snapshot is created. This results in the risk of OOM killers
   * terminating the process.
   *
   * Generating a snapshot is a synchronous operation which blocks the event loop
   * for a duration depending on the heap size.
   *
   * ```js
   * // Print heap snapshot to the console
   * const v8 = require('v8');
   * const stream = v8.getHeapSnapshot();
   * stream.pipe(process.stdout);
   * ```
   * @since v11.13.0
   * @return A Readable Stream containing the V8 heap snapshot
   */
  function getHeapSnapshot(): Readable;
  /**
   * Generates a snapshot of the current V8 heap and writes it to a JSON
   * file. This file is intended to be used with tools such as Chrome
   * DevTools. The JSON schema is undocumented and specific to the V8
   * engine, and may change from one version of V8 to the next.
   *
   * A heap snapshot is specific to a single V8 isolate. When using `worker threads`, a heap snapshot generated from the main thread will
   * not contain any information about the workers, and vice versa.
   *
   * Creating a heap snapshot requires memory about twice the size of the heap at
   * the time the snapshot is created. This results in the risk of OOM killers
   * terminating the process.
   *
   * Generating a snapshot is a synchronous operation which blocks the event loop
   * for a duration depending on the heap size.
   *
   * ```js
   * const { writeHeapSnapshot } = require('v8');
   * const {
   *   Worker,
   *   isMainThread,
   *   parentPort
   * } = require('worker_threads');
   *
   * if (isMainThread) {
   *   const worker = new Worker(__filename);
   *
   *   worker.once('message', (filename) => {
   *     console.log(`worker heapdump: ${filename}`);
   *     // Now get a heapdump for the main thread.
   *     console.log(`main thread heapdump: ${writeHeapSnapshot()}`);
   *   });
   *
   *   // Tell the worker to create a heapdump.
   *   worker.postMessage('heapdump');
   * } else {
   *   parentPort.once('message', (message) => {
   *     if (message === 'heapdump') {
   *       // Generate a heapdump for the worker
   *       // and return the filename to the parent.
   *       parentPort.postMessage(writeHeapSnapshot());
   *     }
   *   });
   * }
   * ```
   * @since v11.13.0
   * @param filename The file path where the V8 heap snapshot is to be saved. If not specified, a file name with the pattern `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
   * generated, where `{pid}` will be the PID of the Node.js process, `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from the main Node.js thread or the id of a
   * worker thread.
   * @return The filename where the snapshot was saved.
   */
  function writeHeapSnapshot(filename?: string): string;
  /**
   * Returns an object with the following properties:
   *
   * ```js
   * {
   *   code_and_metadata_size: 212208,
   *   bytecode_and_metadata_size: 161368,
   *   external_script_source_size: 1410794
   * }
   * ```
   * @since v12.8.0
   */
  function getHeapCodeStatistics(): HeapCodeStatistics;
  /**
   * @since v8.0.0
   */
  class Serializer {
    /**
     * Writes out a header, which includes the serialization format version.
     */
    writeHeader(): void;
    /**
     * Serializes a JavaScript value and adds the serialized representation to the
     * internal buffer.
     *
     * This throws an error if `value` cannot be serialized.
     */
    writeValue(val: any): boolean;
    /**
     * Returns the stored internal buffer. This serializer should not be used once
     * the buffer is released. Calling this method results in undefined behavior
     * if a previous write has failed.
     */
    releaseBuffer(): Buffer;
    /**
     * Marks an `ArrayBuffer` as having its contents transferred out of band.
     * Pass the corresponding `ArrayBuffer` in the deserializing context to `deserializer.transferArrayBuffer()`.
     * @param id A 32-bit unsigned integer.
     * @param arrayBuffer An `ArrayBuffer` instance.
     */
    transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
    /**
     * Write a raw 32-bit unsigned integer.
     * For use inside of a custom `serializer._writeHostObject()`.
     */
    writeUint32(value: number): void;
    /**
     * Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
     * For use inside of a custom `serializer._writeHostObject()`.
     */
    writeUint64(hi: number, lo: number): void;
    /**
     * Write a JS `number` value.
     * For use inside of a custom `serializer._writeHostObject()`.
     */
    writeDouble(value: number): void;
    /**
     * Write raw bytes into the serializer’s internal buffer. The deserializer
     * will require a way to compute the length of the buffer.
     * For use inside of a custom `serializer._writeHostObject()`.
     */
    writeRawBytes(buffer: NodeJS.TypedArray): void;
  }
  /**
   * A subclass of `Serializer` that serializes `TypedArray`(in particular `Buffer`) and `DataView` objects as host objects, and only
   * stores the part of their underlying `ArrayBuffer`s that they are referring to.
   * @since v8.0.0
   */
  class DefaultSerializer extends Serializer {}
  /**
   * @since v8.0.0
   */
  class Deserializer {
    constructor(data: NodeJS.TypedArray);
    /**
     * Reads and validates a header (including the format version).
     * May, for example, reject an invalid or unsupported wire format. In that case,
     * an `Error` is thrown.
     */
    readHeader(): boolean;
    /**
     * Deserializes a JavaScript value from the buffer and returns it.
     */
    readValue(): any;
    /**
     * Marks an `ArrayBuffer` as having its contents transferred out of band.
     * Pass the corresponding `ArrayBuffer` in the serializing context to `serializer.transferArrayBuffer()` (or return the `id` from `serializer._getSharedArrayBufferId()` in the case of
     * `SharedArrayBuffer`s).
     * @param id A 32-bit unsigned integer.
     * @param arrayBuffer An `ArrayBuffer` instance.
     */
    transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
    /**
     * Reads the underlying wire format version. Likely mostly to be useful to
     * legacy code reading old wire format versions. May not be called before`.readHeader()`.
     */
    getWireFormatVersion(): number;
    /**
     * Read a raw 32-bit unsigned integer and return it.
     * For use inside of a custom `deserializer._readHostObject()`.
     */
    readUint32(): number;
    /**
     * Read a raw 64-bit unsigned integer and return it as an array `[hi, lo]`with two 32-bit unsigned integer entries.
     * For use inside of a custom `deserializer._readHostObject()`.
     */
    readUint64(): [number, number];
    /**
     * Read a JS `number` value.
     * For use inside of a custom `deserializer._readHostObject()`.
     */
    readDouble(): number;
    /**
     * Read raw bytes from the deserializer’s internal buffer. The `length` parameter
     * must correspond to the length of the buffer that was passed to `serializer.writeRawBytes()`.
     * For use inside of a custom `deserializer._readHostObject()`.
     */
    readRawBytes(length: number): Buffer;
  }
  /**
   * A subclass of `Deserializer` corresponding to the format written by `DefaultSerializer`.
   * @since v8.0.0
   */
  class DefaultDeserializer extends Deserializer {}
  /**
   * Uses a `DefaultSerializer` to serialize `value` into a buffer.
   *
   * `ERR_BUFFER_TOO_LARGE` will be thrown when trying to
   * serialize a huge object which requires buffer
   * larger than `buffer.constants.MAX_LENGTH`.
   * @since v8.0.0
   */
  function serialize(value: any): Buffer;
  /**
   * Uses a `DefaultDeserializer` with default options to read a JS value
   * from a buffer.
   * @since v8.0.0
   * @param buffer A buffer returned by {@link serialize}.
   */
  function deserialize(buffer: NodeJS.TypedArray): any;
  /**
   * The `v8.takeCoverage()` method allows the user to write the coverage started by `NODE_V8_COVERAGE` to disk on demand. This method can be invoked multiple
   * times during the lifetime of the process. Each time the execution counter will
   * be reset and a new coverage report will be written to the directory specified
   * by `NODE_V8_COVERAGE`.
   *
   * When the process is about to exit, one last coverage will still be written to
   * disk unless {@link stopCoverage} is invoked before the process exits.
   * @since v15.1.0, v14.18.0, v12.22.0
   */
  function takeCoverage(): void;
  /**
   * The `v8.stopCoverage()` method allows the user to stop the coverage collection
   * started by `NODE_V8_COVERAGE`, so that V8 can release the execution count
   * records and optimize code. This can be used in conjunction with {@link takeCoverage} if the user wants to collect the coverage on demand.
   * @since v15.1.0, v14.18.0, v12.22.0
   */
  function stopCoverage(): void;
}
declare module 'node:v8' {
    export * from 'v8';
}
