rapid_stack 1.0.0 → 1.0.1

data/lib/rapid_stack/generators/generator-rapid/node_modules/@types/node/perf_hooks.d.ts

@@ -1,334 +1,116 @@
-/**
- * This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
- * Node.js-specific performance measurements.
- *
- * Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
- *
- * * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
- * * [Performance Timeline](https://w3c.github.io/performance-timeline/)
- * * [User Timing](https://www.w3.org/TR/user-timing/)
- * * [Resource Timing](https://www.w3.org/TR/resource-timing-2/)
- *
- * ```js
- * import { PerformanceObserver, performance } from 'node:perf_hooks';
- *
- * const obs = new PerformanceObserver((items) => {
- *   console.log(items.getEntries()[0].duration);
- *   performance.clearMarks();
- * });
- * obs.observe({ type: 'measure' });
- * performance.measure('Start to Now');
- *
- * performance.mark('A');
- * doSomeLongRunningProcess(() => {
- *   performance.measure('A to Now', 'A');
- *
- *   performance.mark('B');
- *   performance.measure('A to B', 'A', 'B');
- * });
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/perf_hooks.js)
- */
-declare module "perf_hooks" {
-    import { AsyncResource } from "node:async_hooks";
-    type EntryType =
-        | "dns" // Node.js only
-        | "function" // Node.js only
-        | "gc" // Node.js only
-        | "http2" // Node.js only
-        | "http" // Node.js only
-        | "mark" // available on the Web
-        | "measure" // available on the Web
-        | "net" // Node.js only
-        | "node" // Node.js only
-        | "resource"; // available on the Web
-    interface NodeGCPerformanceDetail {
-        /**
-         * When `performanceEntry.entryType` is equal to 'gc', the `performance.kind` property identifies
-         * the type of garbage collection operation that occurred.
-         * See perf_hooks.constants for valid values.
-         */
-        readonly kind?: number | undefined;
-        /**
-         * When `performanceEntry.entryType` is equal to 'gc', the `performance.flags`
-         * property contains additional information about garbage collection operation.
-         * See perf_hooks.constants for valid values.
-         */
-        readonly flags?: number | undefined;
-    }
-    /**
-     * The constructor of this class is not exposed to users directly.
-     * @since v8.5.0
-     */
+declare module 'perf_hooks' {
+    import { AsyncResource } from 'async_hooks';
+
+    type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
+
     class PerformanceEntry {
         protected constructor();
         /**
-         * The total number of milliseconds elapsed for this entry. This value will not
-         * be meaningful for all Performance Entry types.
-         * @since v8.5.0
+         * The total number of milliseconds elapsed for this entry.
+         * This value will not be meaningful for all Performance Entry types.
          */
         readonly duration: number;
+
         /**
          * The name of the performance entry.
-         * @since v8.5.0
          */
         readonly name: string;
+
         /**
-         * The high resolution millisecond timestamp marking the starting time of the
-         * Performance Entry.
-         * @since v8.5.0
+         * The high resolution millisecond timestamp marking the starting time of the Performance Entry.
          */
         readonly startTime: number;
+
         /**
-         * The type of the performance entry. It may be one of:
-         *
-         * * `'node'` (Node.js only)
-         * * `'mark'` (available on the Web)
-         * * `'measure'` (available on the Web)
-         * * `'gc'` (Node.js only)
-         * * `'function'` (Node.js only)
-         * * `'http2'` (Node.js only)
-         * * `'http'` (Node.js only)
-         * @since v8.5.0
+         * The type of the performance entry.
+         * Currently it may be one of: 'node', 'mark', 'measure', 'gc', or 'function'.
          */
         readonly entryType: EntryType;
+
         /**
-         * Additional detail specific to the `entryType`.
-         * @since v16.0.0
-         */
-        readonly detail?: NodeGCPerformanceDetail | unknown | undefined; // TODO: Narrow this based on entry type.
-        toJSON(): any;
-    }
-    /**
-     * Exposes marks created via the `Performance.mark()` method.
-     * @since v18.2.0, v16.17.0
-     */
-    class PerformanceMark extends PerformanceEntry {
-        readonly duration: 0;
-        readonly entryType: "mark";
-    }
-    /**
-     * Exposes measures created via the `Performance.measure()` method.
-     *
-     * The constructor of this class is not exposed to users directly.
-     * @since v18.2.0, v16.17.0
-     */
-    class PerformanceMeasure extends PerformanceEntry {
-        readonly entryType: "measure";
-    }
-    interface UVMetrics {
-        /**
-         * Number of event loop iterations.
-         */
-        readonly loopCount: number;
-        /**
-         * Number of events that have been processed by the event handler.
+         * When `performanceEntry.entryType` is equal to 'gc', `the performance.kind` property identifies
+         * the type of garbage collection operation that occurred.
+         * See perf_hooks.constants for valid values.
          */
-        readonly events: number;
+        readonly kind?: number;
+
         /**
-         * Number of events that were waiting to be processed when the event provider was called.
+         * When `performanceEntry.entryType` is equal to 'gc', the `performance.flags`
+         * property contains additional information about garbage collection operation.
+         * See perf_hooks.constants for valid values.
          */
-        readonly eventsWaiting: number;
+        readonly flags?: number;
     }
-    /**
-     * _This property is an extension by Node.js. It is not available in Web browsers._
-     *
-     * Provides timing details for Node.js itself. The constructor of this class
-     * is not exposed to users.
-     * @since v8.5.0
-     */
+
     class PerformanceNodeTiming extends PerformanceEntry {
-        readonly entryType: "node";
         /**
-         * The high resolution millisecond timestamp at which the Node.js process
-         * completed bootstrapping. If bootstrapping has not yet finished, the property
-         * has the value of -1.
-         * @since v8.5.0
+         * The high resolution millisecond timestamp at which the Node.js process completed bootstrap.
          */
         readonly bootstrapComplete: number;
+
         /**
-         * The high resolution millisecond timestamp at which the Node.js environment was
-         * initialized.
-         * @since v8.5.0
+         * The high resolution millisecond timestamp at which the Node.js process completed bootstrapping.
+         * If bootstrapping has not yet finished, the property has the value of -1.
          */
         readonly environment: number;
+
         /**
-         * The high resolution millisecond timestamp of the amount of time the event loop
-         * has been idle within the event loop's event provider (e.g. `epoll_wait`). This
-         * does not take CPU usage into consideration. If the event loop has not yet
-         * started (e.g., in the first tick of the main script), the property has the
-         * value of 0.
-         * @since v14.10.0, v12.19.0
+         * The high resolution millisecond timestamp at which the Node.js environment was initialized.
          */
         readonly idleTime: number;
+
         /**
-         * The high resolution millisecond timestamp at which the Node.js event loop
-         * exited. If the event loop has not yet exited, the property has the value of -1\.
-         * It can only have a value of not -1 in a handler of the `'exit'` event.
-         * @since v8.5.0
+         * The high resolution millisecond timestamp of the amount of time the event loop has been idle
+         *  within the event loop's event provider (e.g. `epoll_wait`). This does not take CPU usage
+         * into consideration. If the event loop has not yet started (e.g., in the first tick of the main script),
+         *  the property has the value of 0.
          */
         readonly loopExit: number;
+
         /**
-         * The high resolution millisecond timestamp at which the Node.js event loop
-         * started. If the event loop has not yet started (e.g., in the first tick of the
-         * main script), the property has the value of -1.
-         * @since v8.5.0
+         * The high resolution millisecond timestamp at which the Node.js event loop started.
+         * If the event loop has not yet started (e.g., in the first tick of the main script), the property has the value of -1.
          */
         readonly loopStart: number;
+
         /**
-         * The high resolution millisecond timestamp at which the Node.js process was initialized.
-         * @since v8.5.0
-         */
-        readonly nodeStart: number;
-        /**
-         * This is a wrapper to the `uv_metrics_info` function.
-         * It returns the current set of event loop metrics.
-         *
-         * It is recommended to use this property inside a function whose execution was
-         * scheduled using `setImmediate` to avoid collecting metrics before finishing all
-         * operations scheduled during the current loop iteration.
-         * @since v22.8.0, v20.18.0
-         */
-        readonly uvMetricsInfo: UVMetrics;
-        /**
-         * The high resolution millisecond timestamp at which the V8 platform was
-         * initialized.
-         * @since v8.5.0
+         * The high resolution millisecond timestamp at which the V8 platform was initialized.
          */
         readonly v8Start: number;
     }
+
     interface EventLoopUtilization {
         idle: number;
         active: number;
         utilization: number;
     }
+
     /**
-     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
-     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
+     * @param util1 The result of a previous call to eventLoopUtilization()
+     * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
      */
     type EventLoopUtilityFunction = (
-        utilization1?: EventLoopUtilization,
-        utilization2?: EventLoopUtilization,
+        util1?: EventLoopUtilization,
+        util2?: EventLoopUtilization,
     ) => EventLoopUtilization;
-    interface MarkOptions {
-        /**
-         * Additional optional detail to include with the mark.
-         */
-        detail?: unknown | undefined;
-        /**
-         * An optional timestamp to be used as the mark time.
-         * @default `performance.now()`
-         */
-        startTime?: number | undefined;
-    }
-    interface MeasureOptions {
-        /**
-         * Additional optional detail to include with the mark.
-         */
-        detail?: unknown | undefined;
-        /**
-         * Duration between start and end times.
-         */
-        duration?: number | undefined;
-        /**
-         * Timestamp to be used as the end time, or a string identifying a previously recorded mark.
-         */
-        end?: number | string | undefined;
-        /**
-         * Timestamp to be used as the start time, or a string identifying a previously recorded mark.
-         */
-        start?: number | string | undefined;
-    }
-    interface TimerifyOptions {
-        /**
-         * A histogram object created using `perf_hooks.createHistogram()` that will record runtime
-         * durations in nanoseconds.
-         */
-        histogram?: RecordableHistogram | undefined;
-    }
+
     interface Performance {
         /**
-         * If `name` is not provided, removes all `PerformanceMark` objects from the Performance Timeline.
-         * If `name` is provided, removes only the named mark.
-         * @since v8.5.0
-         */
-        clearMarks(name?: string): void;
-        /**
-         * If `name` is not provided, removes all `PerformanceMeasure` objects from the Performance Timeline.
-         * If `name` is provided, removes only the named measure.
-         * @since v16.7.0
-         */
-        clearMeasures(name?: string): void;
-        /**
-         * If `name` is not provided, removes all `PerformanceResourceTiming` objects from the Resource Timeline.
-         * If `name` is provided, removes only the named resource.
-         * @since v18.2.0, v16.17.0
-         */
-        clearResourceTimings(name?: string): void;
-        /**
-         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
-         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
-         * No other CPU idle time is taken into consideration.
-         */
-        eventLoopUtilization: EventLoopUtilityFunction;
-        /**
-         * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
-         * If you are only interested in performance entries of certain types or that have certain names, see
-         * `performance.getEntriesByType()` and `performance.getEntriesByName()`.
-         * @since v16.7.0
-         */
-        getEntries(): PerformanceEntry[];
-        /**
-         * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
-         * whose `performanceEntry.name` is equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to `type`.
+         * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
+         * If name is provided, removes only the named mark.
          * @param name
-         * @param type
-         * @since v16.7.0
-         */
-        getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
-        /**
-         * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
-         * whose `performanceEntry.entryType` is equal to `type`.
-         * @param type
-         * @since v16.7.0
          */
-        getEntriesByType(type: EntryType): PerformanceEntry[];
+        clearMarks(name?: string): void;
+
         /**
-         * Creates a new `PerformanceMark` entry in the Performance Timeline.
-         * A `PerformanceMark` is a subclass of `PerformanceEntry` whose `performanceEntry.entryType` is always `'mark'`,
-         * and whose `performanceEntry.duration` is always `0`.
+         * Creates a new PerformanceMark entry in the Performance Timeline.
+         * A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',
+         * and whose performanceEntry.duration is always 0.
          * Performance marks are used to mark specific significant moments in the Performance Timeline.
-         *
-         * The created `PerformanceMark` entry is put in the global Performance Timeline and can be queried with
-         * `performance.getEntries`, `performance.getEntriesByName`, and `performance.getEntriesByType`. When the observation is
-         * performed, the entries should be cleared from the global Performance Timeline manually with `performance.clearMarks`.
          * @param name
          */
-        mark(name: string, options?: MarkOptions): PerformanceMark;
-        /**
-         * Creates a new `PerformanceResourceTiming` entry in the Resource Timeline.
-         * A `PerformanceResourceTiming` is a subclass of `PerformanceEntry` whose `performanceEntry.entryType` is always `'resource'`.
-         * Performance resources are used to mark moments in the Resource Timeline.
-         * @param timingInfo [Fetch Timing Info](https://fetch.spec.whatwg.org/#fetch-timing-info)
-         * @param requestedUrl The resource url
-         * @param initiatorType The initiator name, e.g: 'fetch'
-         * @param global
-         * @param cacheMode The cache mode must be an empty string ('') or 'local'
-         * @param bodyInfo [Fetch Response Body Info](https://fetch.spec.whatwg.org/#response-body-info)
-         * @param responseStatus The response's status code
-         * @param deliveryType The delivery type. Default: ''.
-         * @since v18.2.0, v16.17.0
-         */
-        markResourceTiming(
-            timingInfo: object,
-            requestedUrl: string,
-            initiatorType: string,
-            global: object,
-            cacheMode: "" | "local",
-            bodyInfo: object,
-            responseStatus: number,
-            deliveryType?: string,
-        ): PerformanceResourceTiming;
+        mark(name?: string): void;
+
         /**
          * Creates a new PerformanceMeasure entry in the Performance Timeline.
          * A PerformanceMeasure is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'measure',
@@ -343,366 +125,83 @@ declare module "perf_hooks" {
          * @param name
          * @param startMark
          * @param endMark
-         * @return The PerformanceMeasure entry that was created
          */
-        measure(name: string, startMark?: string, endMark?: string): PerformanceMeasure;
-        measure(name: string, options: MeasureOptions): PerformanceMeasure;
+        measure(name: string, startMark?: string, endMark?: string): void;
+
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         *
-         * An instance of the `PerformanceNodeTiming` class that provides performance metrics for specific Node.js operational milestones.
-         * @since v8.5.0
+         * An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.
          */
         readonly nodeTiming: PerformanceNodeTiming;
+
         /**
-         * Returns the current high resolution millisecond timestamp, where 0 represents the start of the current `node` process.
-         * @since v8.5.0
+         * @return the current high resolution millisecond timestamp
          */
         now(): number;
+
         /**
-         * Sets the global performance resource timing buffer size to the specified number of "resource" type performance entry objects.
-         *
-         * By default the max buffer size is set to 250.
-         * @since v18.8.0
-         */
-        setResourceTimingBufferSize(maxSize: number): void;
-        /**
-         * The [`timeOrigin`](https://w3c.github.io/hr-time/#dom-performance-timeorigin) specifies the high resolution millisecond timestamp
-         * at which the current `node` process began, measured in Unix time.
-         * @since v8.5.0
+         * The timeOrigin specifies the high resolution millisecond timestamp from which all performance metric durations are measured.
          */
         readonly timeOrigin: number;
+
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         *
          * Wraps a function within a new function that measures the running time of the wrapped function.
-         * A `PerformanceObserver` must be subscribed to the `'function'` event type in order for the timing details to be accessed.
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * function someFunction() {
-         *   console.log('hello world');
-         * }
-         *
-         * const wrapped = performance.timerify(someFunction);
-         *
-         * const obs = new PerformanceObserver((list) => {
-         *   console.log(list.getEntries()[0].duration);
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   obs.disconnect();
-         * });
-         * obs.observe({ entryTypes: ['function'] });
-         *
-         * // A performance timeline entry will be created
-         * wrapped();
-         * ```
-         *
-         * If the wrapped function returns a promise, a finally handler will be attached to the promise and the duration will be reported
-         * once the finally handler is invoked.
+         * A PerformanceObserver must be subscribed to the 'function' event type in order for the timing details to be accessed.
          * @param fn
          */
-        timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+        timerify<T extends (...optionalParams: any[]) => any>(fn: T): T;
+
         /**
-         * An object which is JSON representation of the performance object. It is similar to
-         * [`window.performance.toJSON`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/toJSON) in browsers.
-         * @since v16.1.0
+         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
+         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
+         * No other CPU idle time is taken into consideration.
          */
-        toJSON(): any;
+        eventLoopUtilization: EventLoopUtilityFunction;
     }
-    class PerformanceObserverEntryList {
+
+    interface PerformanceObserverEntryList {
         /**
-         * Returns a list of `PerformanceEntry` objects in chronological order
-         * with respect to `performanceEntry.startTime`.
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * const obs = new PerformanceObserver((perfObserverList, observer) => {
-         *   console.log(perfObserverList.getEntries());
-         *
-         *    * [
-         *    *   PerformanceEntry {
-         *    *     name: 'test',
-         *    *     entryType: 'mark',
-         *    *     startTime: 81.465639,
-         *    *     duration: 0,
-         *    *     detail: null
-         *    *   },
-         *    *   PerformanceEntry {
-         *    *     name: 'meow',
-         *    *     entryType: 'mark',
-         *    *     startTime: 81.860064,
-         *    *     duration: 0,
-         *    *     detail: null
-         *    *   }
-         *    * ]
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   observer.disconnect();
-         * });
-         * obs.observe({ type: 'mark' });
-         *
-         * performance.mark('test');
-         * performance.mark('meow');
-         * ```
-         * @since v8.5.0
+         * @return a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime.
          */
         getEntries(): PerformanceEntry[];
+
         /**
-         * Returns a list of `PerformanceEntry` objects in chronological order
-         * with respect to `performanceEntry.startTime` whose `performanceEntry.name` is
-         * equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to`type`.
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * const obs = new PerformanceObserver((perfObserverList, observer) => {
-         *   console.log(perfObserverList.getEntriesByName('meow'));
-         *
-         *    * [
-         *    *   PerformanceEntry {
-         *    *     name: 'meow',
-         *    *     entryType: 'mark',
-         *    *     startTime: 98.545991,
-         *    *     duration: 0,
-         *    *     detail: null
-         *    *   }
-         *    * ]
-         *
-         *   console.log(perfObserverList.getEntriesByName('nope')); // []
-         *
-         *   console.log(perfObserverList.getEntriesByName('test', 'mark'));
-         *
-         *    * [
-         *    *   PerformanceEntry {
-         *    *     name: 'test',
-         *    *     entryType: 'mark',
-         *    *     startTime: 63.518931,
-         *    *     duration: 0,
-         *    *     detail: null
-         *    *   }
-         *    * ]
-         *
-         *   console.log(perfObserverList.getEntriesByName('test', 'measure')); // []
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   observer.disconnect();
-         * });
-         * obs.observe({ entryTypes: ['mark', 'measure'] });
-         *
-         * performance.mark('test');
-         * performance.mark('meow');
-         * ```
-         * @since v8.5.0
+         * @return a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
+         * whose performanceEntry.name is equal to name, and optionally, whose performanceEntry.entryType is equal to type.
          */
         getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
+
         /**
-         * Returns a list of `PerformanceEntry` objects in chronological order
-         * with respect to `performanceEntry.startTime` whose `performanceEntry.entryType` is equal to `type`.
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * const obs = new PerformanceObserver((perfObserverList, observer) => {
-         *   console.log(perfObserverList.getEntriesByType('mark'));
-         *
-         *    * [
-         *    *   PerformanceEntry {
-         *    *     name: 'test',
-         *    *     entryType: 'mark',
-         *    *     startTime: 55.897834,
-         *    *     duration: 0,
-         *    *     detail: null
-         *    *   },
-         *    *   PerformanceEntry {
-         *    *     name: 'meow',
-         *    *     entryType: 'mark',
-         *    *     startTime: 56.350146,
-         *    *     duration: 0,
-         *    *     detail: null
-         *    *   }
-         *    * ]
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   observer.disconnect();
-         * });
-         * obs.observe({ type: 'mark' });
-         *
-         * performance.mark('test');
-         * performance.mark('meow');
-         * ```
-         * @since v8.5.0
+         * @return Returns a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
+         * whose performanceEntry.entryType is equal to type.
          */
         getEntriesByType(type: EntryType): PerformanceEntry[];
     }
+
     type PerformanceObserverCallback = (list: PerformanceObserverEntryList, observer: PerformanceObserver) => void;
-    /**
-     * @since v8.5.0
-     */
+
     class PerformanceObserver extends AsyncResource {
         constructor(callback: PerformanceObserverCallback);
+
         /**
-         * Disconnects the `PerformanceObserver` instance from all notifications.
-         * @since v8.5.0
+         * Disconnects the PerformanceObserver instance from all notifications.
          */
         disconnect(): void;
+
         /**
-         * Subscribes the `PerformanceObserver` instance to notifications of new `PerformanceEntry` instances identified either by `options.entryTypes` or `options.type`:
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * const obs = new PerformanceObserver((list, observer) => {
-         *   // Called once asynchronously. `list` contains three items.
-         * });
-         * obs.observe({ type: 'mark' });
-         *
-         * for (let n = 0; n < 3; n++)
-         *   performance.mark(`test${n}`);
-         * ```
-         * @since v8.5.0
-         */
-        observe(
-            options:
-                | {
-                    entryTypes: readonly EntryType[];
-                    buffered?: boolean | undefined;
-                }
-                | {
-                    type: EntryType;
-                    buffered?: boolean | undefined;
-                },
-        ): void;
-        /**
-         * @since v16.0.0
-         * @returns Current list of entries stored in the performance observer, emptying it out.
-         */
-        takeRecords(): PerformanceEntry[];
-    }
-    /**
-     * Provides detailed network timing data regarding the loading of an application's resources.
-     *
-     * The constructor of this class is not exposed to users directly.
-     * @since v18.2.0, v16.17.0
-     */
-    class PerformanceResourceTiming extends PerformanceEntry {
-        readonly entryType: "resource";
-        protected constructor();
-        /**
-         * The high resolution millisecond timestamp at immediately before dispatching the `fetch`
-         * request. If the resource is not intercepted by a worker the property will always return 0.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly workerStart: number;
-        /**
-         * The high resolution millisecond timestamp that represents the start time of the fetch which
-         * initiates the redirect.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly redirectStart: number;
-        /**
-         * The high resolution millisecond timestamp that will be created immediately after receiving
-         * the last byte of the response of the last redirect.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly redirectEnd: number;
-        /**
-         * The high resolution millisecond timestamp immediately before the Node.js starts to fetch the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly fetchStart: number;
-        /**
-         * The high resolution millisecond timestamp immediately before the Node.js starts the domain name lookup
-         * for the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly domainLookupStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately after the Node.js finished
-         * the domain name lookup for the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly domainLookupEnd: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately before Node.js starts to
-         * establish the connection to the server to retrieve the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly connectStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately after Node.js finishes
-         * establishing the connection to the server to retrieve the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly connectEnd: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately before Node.js starts the
-         * handshake process to secure the current connection.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly secureConnectionStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately before Node.js receives the
-         * first byte of the response from the server.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly requestStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately after Node.js receives the
-         * last byte of the resource or immediately before the transport connection is closed, whichever comes first.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly responseEnd: number;
-        /**
-         * A number representing the size (in octets) of the fetched resource. The size includes the response header
-         * fields plus the response payload body.
-         * @since v18.2.0, v16.17.0
+         * Subscribes the PerformanceObserver instance to notifications of new PerformanceEntry instances identified by options.entryTypes.
+         * When options.buffered is false, the callback will be invoked once for every PerformanceEntry instance.
+         * Property buffered defaults to false.
+         * @param options
          */
-        readonly transferSize: number;
-        /**
-         * A number representing the size (in octets) received from the fetch (HTTP or cache), of the payload body, before
-         * removing any applied content-codings.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly encodedBodySize: number;
-        /**
-         * A number representing the size (in octets) received from the fetch (HTTP or cache), of the message body, after
-         * removing any applied content-codings.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly decodedBodySize: number;
-        /**
-         * Returns a `object` that is the JSON representation of the `PerformanceResourceTiming` object
-         * @since v18.2.0, v16.17.0
-         */
-        toJSON(): any;
+        observe(options: { entryTypes: ReadonlyArray<EntryType>; buffered?: boolean }): void;
     }
+
     namespace constants {
         const NODE_PERFORMANCE_GC_MAJOR: number;
         const NODE_PERFORMANCE_GC_MINOR: number;
         const NODE_PERFORMANCE_GC_INCREMENTAL: number;
         const NODE_PERFORMANCE_GC_WEAKCB: number;
+
         const NODE_PERFORMANCE_GC_FLAGS_NO: number;
         const NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: number;
         const NODE_PERFORMANCE_GC_FLAGS_FORCED: number;
@@ -711,260 +210,101 @@ declare module "perf_hooks" {
         const NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: number;
         const NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: number;
     }
+
     const performance: Performance;
+
     interface EventLoopMonitorOptions {
         /**
          * The sampling rate in milliseconds.
          * Must be greater than zero.
          * @default 10
          */
-        resolution?: number | undefined;
+        resolution?: number;
     }
+
     interface Histogram {
         /**
-         * The number of samples recorded by the histogram.
-         * @since v17.4.0, v16.14.0
+         * A `Map` object detailing the accumulated percentile distribution.
          */
-        readonly count: number;
-        /**
-         * The number of samples recorded by the histogram.
-         * v17.4.0, v16.14.0
-         */
-        readonly countBigInt: bigint;
+        readonly percentiles: Map<number, number>;
+
         /**
-         * The number of times the event loop delay exceeded the maximum 1 hour event
-         * loop delay threshold.
-         * @since v11.10.0
+         * The number of times the event loop delay exceeded the maximum 1 hour eventloop delay threshold.
          */
         readonly exceeds: number;
+
         /**
-         * The number of times the event loop delay exceeded the maximum 1 hour event loop delay threshold.
-         * @since v17.4.0, v16.14.0
+         * The minimum recorded event loop delay.
          */
-        readonly exceedsBigInt: bigint;
+        readonly min: number;
+
         /**
          * The maximum recorded event loop delay.
-         * @since v11.10.0
          */
         readonly max: number;
-        /**
-         * The maximum recorded event loop delay.
-         * v17.4.0, v16.14.0
-         */
-        readonly maxBigInt: number;
+
         /**
          * The mean of the recorded event loop delays.
-         * @since v11.10.0
          */
         readonly mean: number;
+
         /**
-         * The minimum recorded event loop delay.
-         * @since v11.10.0
-         */
-        readonly min: number;
-        /**
-         * The minimum recorded event loop delay.
-         * v17.4.0, v16.14.0
-         */
-        readonly minBigInt: bigint;
-        /**
-         * Returns the value at the given percentile.
-         * @since v11.10.0
-         * @param percentile A percentile value in the range (0, 100].
-         */
-        percentile(percentile: number): number;
-        /**
-         * Returns the value at the given percentile.
-         * @since v17.4.0, v16.14.0
-         * @param percentile A percentile value in the range (0, 100].
-         */
-        percentileBigInt(percentile: number): bigint;
-        /**
-         * Returns a `Map` object detailing the accumulated percentile distribution.
-         * @since v11.10.0
-         */
-        readonly percentiles: Map<number, number>;
-        /**
-         * Returns a `Map` object detailing the accumulated percentile distribution.
-         * @since v17.4.0, v16.14.0
+         * The standard deviation of the recorded event loop delays.
          */
-        readonly percentilesBigInt: Map<bigint, bigint>;
+        readonly stddev: number;
+
         /**
          * Resets the collected histogram data.
-         * @since v11.10.0
          */
         reset(): void;
+
         /**
-         * The standard deviation of the recorded event loop delays.
-         * @since v11.10.0
+         * Returns the value at the given percentile.
+         * @param percentile A percentile value between 1 and 100.
          */
-        readonly stddev: number;
+        percentile(percentile: number): number;
     }
+
     interface IntervalHistogram extends Histogram {
         /**
-         * Enables the update interval timer. Returns `true` if the timer was
-         * started, `false` if it was already started.
-         * @since v11.10.0
+         * Enables the event loop delay sample timer. Returns `true` if the timer was started, `false` if it was already started.
          */
         enable(): boolean;
         /**
-         * Disables the update interval timer. Returns `true` if the timer was
-         * stopped, `false` if it was already stopped.
-         * @since v11.10.0
+         * Disables the event loop delay sample timer. Returns `true` if the timer was stopped, `false` if it was already stopped.
          */
         disable(): boolean;
     }
+
     interface RecordableHistogram extends Histogram {
-        /**
-         * @since v15.9.0, v14.18.0
-         * @param val The amount to record in the histogram.
-         */
         record(val: number | bigint): void;
+
         /**
-         * Calculates the amount of time (in nanoseconds) that has passed since the
-         * previous call to `recordDelta()` and records that amount in the histogram.
-         * @since v15.9.0, v14.18.0
+         * Calculates the amount of time (in nanoseconds) that has passed since the previous call to recordDelta() and records that amount in the histogram.
          */
         recordDelta(): void;
-        /**
-         * Adds the values from `other` to this histogram.
-         * @since v17.4.0, v16.14.0
-         */
-        add(other: RecordableHistogram): void;
     }
-    /**
-     * _This property is an extension by Node.js. It is not available in Web browsers._
-     *
-     * Creates an `IntervalHistogram` object that samples and reports the event loop
-     * delay over time. The delays will be reported in nanoseconds.
-     *
-     * Using a timer to detect approximate event loop delay works because the
-     * execution of timers is tied specifically to the lifecycle of the libuv
-     * event loop. That is, a delay in the loop will cause a delay in the execution
-     * of the timer, and those delays are specifically what this API is intended to
-     * detect.
-     *
-     * ```js
-     * import { monitorEventLoopDelay } from 'node:perf_hooks';
-     * const h = monitorEventLoopDelay({ resolution: 20 });
-     * h.enable();
-     * // Do something.
-     * h.disable();
-     * console.log(h.min);
-     * console.log(h.max);
-     * console.log(h.mean);
-     * console.log(h.stddev);
-     * console.log(h.percentiles);
-     * console.log(h.percentile(50));
-     * console.log(h.percentile(99));
-     * ```
-     * @since v11.10.0
-     */
+
     function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
+
     interface CreateHistogramOptions {
         /**
          * The minimum recordable value. Must be an integer value greater than 0.
          * @default 1
          */
-        min?: number | bigint | undefined;
+        min?: number | bigint;
+
         /**
          * The maximum recordable value. Must be an integer value greater than min.
          * @default Number.MAX_SAFE_INTEGER
          */
-        max?: number | bigint | undefined;
+        max?: number | bigint;
         /**
          * The number of accuracy digits. Must be a number between 1 and 5.
          * @default 3
          */
-        figures?: number | undefined;
+        figures?: number;
     }
-    /**
-     * Returns a `RecordableHistogram`.
-     * @since v15.9.0, v14.18.0
-     */
+
     function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
-    import {
-        performance as _performance,
-        PerformanceEntry as _PerformanceEntry,
-        PerformanceMark as _PerformanceMark,
-        PerformanceMeasure as _PerformanceMeasure,
-        PerformanceObserver as _PerformanceObserver,
-        PerformanceObserverEntryList as _PerformanceObserverEntryList,
-        PerformanceResourceTiming as _PerformanceResourceTiming,
-    } from "perf_hooks";
-    global {
-        /**
-         * `PerformanceEntry` is a global reference for `import { PerformanceEntry } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performanceentry
-         * @since v19.0.0
-         */
-        var PerformanceEntry: typeof globalThis extends {
-            onmessage: any;
-            PerformanceEntry: infer T;
-        } ? T
-            : typeof _PerformanceEntry;
-        /**
-         * `PerformanceMark` is a global reference for `import { PerformanceMark } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performancemark
-         * @since v19.0.0
-         */
-        var PerformanceMark: typeof globalThis extends {
-            onmessage: any;
-            PerformanceMark: infer T;
-        } ? T
-            : typeof _PerformanceMark;
-        /**
-         * `PerformanceMeasure` is a global reference for `import { PerformanceMeasure } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performancemeasure
-         * @since v19.0.0
-         */
-        var PerformanceMeasure: typeof globalThis extends {
-            onmessage: any;
-            PerformanceMeasure: infer T;
-        } ? T
-            : typeof _PerformanceMeasure;
-        /**
-         * `PerformanceObserver` is a global reference for `import { PerformanceObserver } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performanceobserver
-         * @since v19.0.0
-         */
-        var PerformanceObserver: typeof globalThis extends {
-            onmessage: any;
-            PerformanceObserver: infer T;
-        } ? T
-            : typeof _PerformanceObserver;
-        /**
-         * `PerformanceObserverEntryList` is a global reference for `import { PerformanceObserverEntryList } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performanceobserverentrylist
-         * @since v19.0.0
-         */
-        var PerformanceObserverEntryList: typeof globalThis extends {
-            onmessage: any;
-            PerformanceObserverEntryList: infer T;
-        } ? T
-            : typeof _PerformanceObserverEntryList;
-        /**
-         * `PerformanceResourceTiming` is a global reference for `import { PerformanceResourceTiming } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performanceresourcetiming
-         * @since v19.0.0
-         */
-        var PerformanceResourceTiming: typeof globalThis extends {
-            onmessage: any;
-            PerformanceResourceTiming: infer T;
-        } ? T
-            : typeof _PerformanceResourceTiming;
-        /**
-         * `performance` is a global reference for `import { performance } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v22.x/api/globals.html#performance
-         * @since v16.0.0
-         */
-        var performance: typeof globalThis extends {
-            onmessage: any;
-            performance: infer T;
-        } ? T
-            : typeof _performance;
-    }
-}
-declare module "node:perf_hooks" {
-    export * from "perf_hooks";
 }