cloudstructs 0.6.32 → 0.6.34

package/node_modules/@types/responselike/node_modules/@types/node/v8.d.ts

@@ -1,10 +1,10 @@
 /**
- * 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:
+ * The `node: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');
+ * const v8 = require('node:v8');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/v8.js)
  */
 declare module 'v8' {
     import { Readable } from 'node:stream';
@@ -29,6 +29,9 @@ declare module 'v8' {
         does_zap_garbage: DoesZapCodeSpaceFlag;
         number_of_native_contexts: number;
         number_of_detached_contexts: number;
+        total_global_handles_size: number;
+        used_global_handles_size: number;
+        external_memory: number;
     }
     interface HeapCodeStatistics {
         code_and_metadata_size: number;
@@ -68,6 +71,15 @@ declare module 'v8' {
      * of contexts that were detached and not yet garbage collected. This number
      * being non-zero indicates a potential memory leak.
      *
+     * `total_global_handles_size` The value of total\_global\_handles\_size is the
+     * total memory size of V8 global handles.
+     *
+     * `used_global_handles_size` The value of used\_global\_handles\_size is the
+     * used memory size of V8 global handles.
+     *
+     * `external_memory` The value of external\_memory is the memory size of array
+     * buffers and external strings.
+     *
      * ```js
      * {
      *   total_heap_size: 7326976,
@@ -80,7 +92,10 @@ declare module 'v8' {
      *   peak_malloced_memory: 1127496,
      *   does_zap_garbage: 0,
      *   number_of_native_contexts: 1,
-     *   number_of_detached_contexts: 0
+     *   number_of_detached_contexts: 0,
+     *   total_global_handles_size: 8192,
+     *   used_global_handles_size: 3296,
+     *   external_memory: 318824
      * }
      * ```
      * @since v1.0.0
@@ -149,7 +164,7 @@ declare module 'v8' {
      *
      * ```js
      * // Print GC events to stdout for one minute.
-     * const v8 = require('v8');
+     * const v8 = require('node:v8');
      * v8.setFlagsFromString('--trace_gc');
      * setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
      * ```
@@ -172,12 +187,12 @@ declare module 'v8' {
      *
      * ```js
      * // Print heap snapshot to the console
-     * const v8 = require('v8');
+     * const v8 = require('node:v8');
      * const stream = v8.getHeapSnapshot();
      * stream.pipe(process.stdout);
      * ```
      * @since v11.13.0
-     * @return A Readable Stream containing the V8 heap snapshot
+     * @return A Readable containing the V8 heap snapshot.
      */
     function getHeapSnapshot(): Readable;
     /**
@@ -197,12 +212,12 @@ declare module 'v8' {
      * for a duration depending on the heap size.
      *
      * ```js
-     * const { writeHeapSnapshot } = require('v8');
+     * const { writeHeapSnapshot } = require('node:v8');
      * const {
      *   Worker,
      *   isMainThread,
-     *   parentPort
-     * } = require('worker_threads');
+     *   parentPort,
+     * } = require('node:worker_threads');
      *
      * if (isMainThread) {
      *   const worker = new Worker(__filename);
@@ -233,13 +248,16 @@ declare module 'v8' {
      */
     function writeHeapSnapshot(filename?: string): string;
     /**
-     * Returns an object with the following properties:
+     * Get statistics about code and its metadata in the heap, see
+     * V8[`GetHeapCodeAndMetadataStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#a6079122af17612ef54ef3348ce170866) API. Returns an object with the
+     * following properties:
      *
      * ```js
      * {
      *   code_and_metadata_size: 212208,
      *   bytecode_and_metadata_size: 161368,
-     *   external_script_source_size: 1410794
+     *   external_script_source_size: 1410794,
+     *   cpu_profiler_metadata_size: 0,
      * }
      * ```
      * @since v12.8.0
@@ -289,7 +307,7 @@ declare module 'v8' {
          */
         writeDouble(value: number): void;
         /**
-         * Write raw bytes into the serializer’s internal buffer. The deserializer
+         * 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()`.
          */
@@ -345,7 +363,7 @@ declare module 'v8' {
          */
         readDouble(): number;
         /**
-         * Read raw bytes from the deserializer’s internal buffer. The `length` parameter
+         * 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()`.
          */
@@ -390,17 +408,93 @@ declare module 'v8' {
      * @since v15.1.0, v14.18.0, v12.22.0
      */
     function stopCoverage(): void;
-
     /**
      * This API collects GC data in current thread.
+     * @since v19.6.0, v18.15.0
      */
     class GCProfiler {
         /**
          * Start collecting GC data.
+         * @since v19.6.0, v18.15.0
          */
         start(): void;
         /**
-         * Stop collecting GC data and return a object.
+         * Stop collecting GC data and return an object.The content of object
+         * is as follows.
+         *
+         * ```json
+         * {
+         *   "version": 1,
+         *   "startTime": 1674059033862,
+         *   "statistics": [
+         *     {
+         *       "gcType": "Scavenge",
+         *       "beforeGC": {
+         *         "heapStatistics": {
+         *           "totalHeapSize": 5005312,
+         *           "totalHeapSizeExecutable": 524288,
+         *           "totalPhysicalSize": 5226496,
+         *           "totalAvailableSize": 4341325216,
+         *           "totalGlobalHandlesSize": 8192,
+         *           "usedGlobalHandlesSize": 2112,
+         *           "usedHeapSize": 4883840,
+         *           "heapSizeLimit": 4345298944,
+         *           "mallocedMemory": 254128,
+         *           "externalMemory": 225138,
+         *           "peakMallocedMemory": 181760
+         *         },
+         *         "heapSpaceStatistics": [
+         *           {
+         *             "spaceName": "read_only_space",
+         *             "spaceSize": 0,
+         *             "spaceUsedSize": 0,
+         *             "spaceAvailableSize": 0,
+         *             "physicalSpaceSize": 0
+         *           }
+         *         ]
+         *       },
+         *       "cost": 1574.14,
+         *       "afterGC": {
+         *         "heapStatistics": {
+         *           "totalHeapSize": 6053888,
+         *           "totalHeapSizeExecutable": 524288,
+         *           "totalPhysicalSize": 5500928,
+         *           "totalAvailableSize": 4341101384,
+         *           "totalGlobalHandlesSize": 8192,
+         *           "usedGlobalHandlesSize": 2112,
+         *           "usedHeapSize": 4059096,
+         *           "heapSizeLimit": 4345298944,
+         *           "mallocedMemory": 254128,
+         *           "externalMemory": 225138,
+         *           "peakMallocedMemory": 181760
+         *         },
+         *         "heapSpaceStatistics": [
+         *           {
+         *             "spaceName": "read_only_space",
+         *             "spaceSize": 0,
+         *             "spaceUsedSize": 0,
+         *             "spaceAvailableSize": 0,
+         *             "physicalSpaceSize": 0
+         *           }
+         *         ]
+         *       }
+         *     }
+         *   ],
+         *   "endTime": 1674059036865
+         * }
+         * ```
+         *
+         * Here's an example.
+         *
+         * ```js
+         * const { GCProfiler } = require('v8');
+         * const profiler = new GCProfiler();
+         * profiler.start();
+         * setTimeout(() => {
+         *   console.log(profiler.stop());
+         * }, 1000);
+         * ```
+         * @since v19.6.0, v18.15.0
          */
         stop(): GCProfilerResult;
     }
@@ -441,6 +535,100 @@ declare module 'v8' {
         spaceAvailableSize: number;
         physicalSpaceSize: number;
     }
+    /**
+     * Called when a promise is constructed. This does not mean that corresponding before/after events will occur, only that the possibility exists. This will
+     * happen if a promise is created without ever getting a continuation.
+     * @since v17.1.0, v16.14.0
+     * @param promise The promise being created.
+     * @param parent The promise continued from, if applicable.
+     */
+    interface Init {
+        (promise: Promise<unknown>, parent: Promise<unknown>): void;
+    }
+    /**
+     * Called before a promise continuation executes. This can be in the form of `then()`, `catch()`, or `finally()` handlers or an await resuming.
+     *
+     * The before callback will be called 0 to N times. The before callback will typically be called 0 times if no continuation was ever made for the promise.
+     * The before callback may be called many times in the case where many continuations have been made from the same promise.
+     * @since v17.1.0, v16.14.0
+     */
+    interface Before {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Called immediately after a promise continuation executes. This may be after a `then()`, `catch()`, or `finally()` handler or before an await after another await.
+     * @since v17.1.0, v16.14.0
+     */
+    interface After {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Called when the promise receives a resolution or rejection value. This may occur synchronously in the case of {@link Promise.resolve()} or
+     * {@link Promise.reject()}.
+     * @since v17.1.0, v16.14.0
+     */
+    interface Settled {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Key events in the lifetime of a promise have been categorized into four areas: creation of a promise, before/after a continuation handler is called or
+     * around an await, and when the promise resolves or rejects.
+     *
+     * Because promises are asynchronous resources whose lifecycle is tracked via the promise hooks mechanism, the `init()`, `before()`, `after()`, and
+     * `settled()` callbacks must not be async functions as they create more promises which would produce an infinite loop.
+     * @since v17.1.0, v16.14.0
+     */
+    interface HookCallbacks {
+        init?: Init;
+        before?: Before;
+        after?: After;
+        settled?: Settled;
+    }
+    interface PromiseHooks {
+        /**
+         * The `init` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param init The {@link Init | `init` callback} to call when a promise is created.
+         * @return Call to stop the hook.
+         */
+        onInit: (init: Init) => Function;
+        /**
+         * The `settled` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param settled The {@link Settled | `settled` callback} to call when a promise is created.
+         * @return Call to stop the hook.
+         */
+        onSettled: (settled: Settled) => Function;
+        /**
+         * The `before` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param before The {@link Before | `before` callback} to call before a promise continuation executes.
+         * @return Call to stop the hook.
+         */
+        onBefore: (before: Before) => Function;
+        /**
+         * The `after` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param after The {@link After | `after` callback} to call after a promise continuation executes.
+         * @return Call to stop the hook.
+         */
+        onAfter: (after: After) => Function;
+        /**
+         * Registers functions to be called for different lifetime events of each promise.
+         * The callbacks `init()`/`before()`/`after()`/`settled()` are called for the respective events during a promise's lifetime.
+         * All callbacks are optional. For example, if only promise creation needs to be tracked, then only the init callback needs to be passed.
+         * The hook callbacks must be plain functions. Providing async functions will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param callbacks The {@link HookCallbacks | Hook Callbacks} to register
+         * @return Used for disabling hooks
+         */
+        createHook: (callbacks: HookCallbacks) => Function;
+    }
+    /**
+     * The `promiseHooks` interface can be used to track promise lifecycle events.
+     * @since v17.1.0, v16.14.0
+     */
+    const promiseHooks: PromiseHooks;
 }
 declare module 'node:v8' {
     export * from 'v8';