omegon 0.6.8 → 0.6.10

package/node_modules/@types/node/perf_hooks.d.ts

@@ -27,10 +27,11 @@
  *   performance.measure('A to B', 'A', 'B');
  * });
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/perf_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/perf_hooks.js)
  */
-declare module "perf_hooks" {
-    import { AsyncResource } from "node:async_hooks";
+declare module "node:perf_hooks" {
+    import { InternalEventTargetEventProperties } from "node:events";
+    // #region web types
     type EntryType =
         | "dns" // Node.js only
         | "function" // Node.js only
@@ -42,76 +43,212 @@ declare module "perf_hooks" {
         | "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;
-        /**
-         * 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;
+    interface ConnectionTimingInfo {
+        domainLookupStartTime: number;
+        domainLookupEndTime: number;
+        connectionStartTime: number;
+        connectionEndTime: number;
+        secureConnectionStartTime: number;
+        ALPNNegotiatedProtocol: string;
     }
-    /**
-     * The constructor of this class is not exposed to users directly.
-     * @since v8.5.0
-     */
-    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
-         */
-        readonly duration: number;
-        /**
-         * The name of the performance entry.
-         * @since v8.5.0
-         */
-        readonly name: string;
+    interface FetchTimingInfo {
+        startTime: number;
+        redirectStartTime: number;
+        redirectEndTime: number;
+        postRedirectStartTime: number;
+        finalServiceWorkerStartTime: number;
+        finalNetworkRequestStartTime: number;
+        finalNetworkResponseStartTime: number;
+        endTime: number;
+        finalConnectionTimingInfo: ConnectionTimingInfo | null;
+        encodedBodySize: number;
+        decodedBodySize: number;
+    }
+    type PerformanceEntryList = PerformanceEntry[];
+    interface PerformanceMarkOptions {
+        detail?: any;
+        startTime?: number;
+    }
+    interface PerformanceMeasureOptions {
+        detail?: any;
+        duration?: number;
+        end?: string | number;
+        start?: string | number;
+    }
+    interface PerformanceObserverCallback {
+        (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
+    }
+    interface PerformanceObserverInit {
+        buffered?: boolean;
+        entryTypes?: EntryType[];
+        type?: EntryType;
+    }
+    // TODO: remove in next major
+    /** @deprecated Use `TimerifyOptions` instead. */
+    interface PerformanceTimerifyOptions extends TimerifyOptions {}
+    interface PerformanceEventMap {
+        "resourcetimingbufferfull": Event;
+    }
+    interface Performance extends EventTarget, InternalEventTargetEventProperties<PerformanceEventMap> {
+        readonly nodeTiming: PerformanceNodeTiming;
+        readonly timeOrigin: number;
+        clearMarks(markName?: string): void;
+        clearMeasures(measureName?: string): void;
+        clearResourceTimings(resourceTimingName?: string): void;
+        getEntries(): PerformanceEntryList;
+        getEntriesByName(name: string, type?: EntryType): PerformanceEntryList;
+        getEntriesByType(type: EntryType): PerformanceEntryList;
+        mark(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
+        markResourceTiming(
+            timingInfo: FetchTimingInfo,
+            requestedUrl: string,
+            initiatorType: string,
+            global: unknown,
+            cacheMode: string,
+            bodyInfo: unknown,
+            responseStatus: number,
+            deliveryType?: string,
+        ): PerformanceResourceTiming;
+        measure(measureName: string, startMark?: string, endMark?: string): PerformanceMeasure;
+        measure(measureName: string, options: PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
+        now(): number;
+        setResourceTimingBufferSize(maxSize: number): void;
+        toJSON(): any;
+        addEventListener<K extends keyof PerformanceEventMap>(
+            type: K,
+            listener: (ev: PerformanceEventMap[K]) => void,
+            options?: AddEventListenerOptions | boolean,
+        ): void;
+        addEventListener(
+            type: string,
+            listener: EventListener | EventListenerObject,
+            options?: AddEventListenerOptions | boolean,
+        ): void;
+        removeEventListener<K extends keyof PerformanceEventMap>(
+            type: K,
+            listener: (ev: PerformanceEventMap[K]) => void,
+            options?: EventListenerOptions | boolean,
+        ): void;
+        removeEventListener(
+            type: string,
+            listener: EventListener | EventListenerObject,
+            options?: EventListenerOptions | boolean,
+        ): void;
         /**
-         * The high resolution millisecond timestamp marking the starting time of the
-         * Performance Entry.
-         * @since v8.5.0
+         * This is an alias of `perf_hooks.eventLoopUtilization()`.
+         *
+         * _This property is an extension by Node.js. It is not available in Web browsers._
+         * @since v14.10.0, v12.19.0
+         * @param utilization1 The result of a previous call to
+         * `eventLoopUtilization()`.
+         * @param utilization2 The result of a previous call to
+         * `eventLoopUtilization()` prior to `utilization1`.
          */
-        readonly startTime: number;
+        eventLoopUtilization(
+            utilization1?: EventLoopUtilization,
+            utilization2?: EventLoopUtilization,
+        ): EventLoopUtilization;
         /**
-         * The type of the performance entry. It may be one of:
+         * This is an alias of `perf_hooks.timerify()`.
          *
-         * * `'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)
+         * _This property is an extension by Node.js. It is not available in Web browsers._
          * @since v8.5.0
          */
+        timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+    }
+    var Performance: {
+        prototype: Performance;
+        new(): Performance;
+    };
+    interface PerformanceEntry {
+        readonly duration: number;
         readonly entryType: EntryType;
+        readonly name: string;
+        readonly startTime: number;
         toJSON(): any;
     }
-    /**
-     * Exposes marks created via the `Performance.mark()` method.
-     * @since v18.2.0, v16.17.0
-     */
-    class PerformanceMark extends PerformanceEntry {
+    var PerformanceEntry: {
+        prototype: PerformanceEntry;
+        new(): PerformanceEntry;
+    };
+    interface PerformanceMark extends PerformanceEntry {
         readonly detail: any;
-        readonly duration: 0;
         readonly entryType: "mark";
     }
+    var PerformanceMark: {
+        prototype: PerformanceMark;
+        new(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
+    };
+    interface PerformanceMeasure extends PerformanceEntry {
+        readonly detail: any;
+        readonly entryType: "measure";
+    }
+    var PerformanceMeasure: {
+        prototype: PerformanceMeasure;
+        new(): PerformanceMeasure;
+    };
+    interface PerformanceObserver {
+        disconnect(): void;
+        observe(options: PerformanceObserverInit): void;
+        takeRecords(): PerformanceEntryList;
+    }
+    var PerformanceObserver: {
+        prototype: PerformanceObserver;
+        new(callback: PerformanceObserverCallback): PerformanceObserver;
+        readonly supportedEntryTypes: readonly EntryType[];
+    };
+    interface PerformanceObserverEntryList {
+        getEntries(): PerformanceEntryList;
+        getEntriesByName(name: string, type?: EntryType): PerformanceEntryList;
+        getEntriesByType(type: EntryType): PerformanceEntryList;
+    }
+    var PerformanceObserverEntryList: {
+        prototype: PerformanceObserverEntryList;
+        new(): PerformanceObserverEntryList;
+    };
+    interface PerformanceResourceTiming extends PerformanceEntry {
+        readonly connectEnd: number;
+        readonly connectStart: number;
+        readonly decodedBodySize: number;
+        readonly domainLookupEnd: number;
+        readonly domainLookupStart: number;
+        readonly encodedBodySize: number;
+        readonly entryType: "resource";
+        readonly fetchStart: number;
+        readonly initiatorType: string;
+        readonly nextHopProtocol: string;
+        readonly redirectEnd: number;
+        readonly redirectStart: number;
+        readonly requestStart: number;
+        readonly responseEnd: number;
+        readonly responseStart: number;
+        readonly responseStatus: number;
+        readonly secureConnectionStart: number;
+        readonly transferSize: number;
+        readonly workerStart: number;
+        toJSON(): any;
+    }
+    var PerformanceResourceTiming: {
+        prototype: PerformanceResourceTiming;
+        new(): PerformanceResourceTiming;
+    };
+    var performance: Performance;
+    // #endregion
     /**
-     * Exposes measures created via the `Performance.measure()` method.
+     * _This class is an extension by Node.js. It is not available in Web browsers._
+     *
+     * Provides detailed Node.js timing data.
      *
      * The constructor of this class is not exposed to users directly.
-     * @since v18.2.0, v16.17.0
+     * @since v19.0.0
      */
-    class PerformanceMeasure extends PerformanceEntry {
+    class PerformanceNodeEntry extends PerformanceEntry {
+        /**
+         * Additional detail specific to the `entryType`.
+         * @since v16.0.0
+         */
         readonly detail: any;
-        readonly entryType: "measure";
+        readonly entryType: "dns" | "function" | "gc" | "http2" | "http" | "net" | "node";
     }
     interface UVMetrics {
         /**
@@ -127,7 +264,6 @@ declare module "perf_hooks" {
          */
         readonly eventsWaiting: number;
     }
-    // TODO: PerformanceNodeEntry is missing
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
@@ -135,8 +271,7 @@ declare module "perf_hooks" {
      * is not exposed to users.
      * @since v8.5.0
      */
-    class PerformanceNodeTiming extends PerformanceEntry {
-        readonly entryType: "node";
+    interface PerformanceNodeTiming extends PerformanceEntry {
         /**
          * The high resolution millisecond timestamp at which the Node.js process
          * completed bootstrapping. If bootstrapping has not yet finished, the property
@@ -144,6 +279,7 @@ declare module "perf_hooks" {
          * @since v8.5.0
          */
         readonly bootstrapComplete: number;
+        readonly entryType: "node";
         /**
          * The high resolution millisecond timestamp at which the Node.js environment was
          * initialized.
@@ -195,478 +331,6 @@ declare module "perf_hooks" {
          */
         readonly v8Start: number;
     }
-    interface EventLoopUtilization {
-        idle: number;
-        active: number;
-        utilization: number;
-    }
-    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;
-        /**
-         * 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;
-        /**
-         * This is an alias of `perf_hooks.eventLoopUtilization()`.
-         *
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         * @since v14.10.0, v12.19.0
-         * @param utilization1 The result of a previous call to
-         * `eventLoopUtilization()`.
-         * @param utilization2 The result of a previous call to
-         * `eventLoopUtilization()` prior to `utilization1`.
-         */
-        eventLoopUtilization(
-            utilization1?: EventLoopUtilization,
-            utilization2?: EventLoopUtilization,
-        ): EventLoopUtilization;
-        /**
-         * 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`.
-         * @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[];
-        /**
-         * 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;
-        /**
-         * Creates a new PerformanceMeasure entry in the Performance Timeline.
-         * A PerformanceMeasure is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'measure',
-         * and whose performanceEntry.duration measures the number of milliseconds elapsed since startMark and endMark.
-         *
-         * The startMark argument may identify any existing PerformanceMark in the the Performance Timeline, or may identify
-         * any of the timestamp properties provided by the PerformanceNodeTiming class. If the named startMark does not exist,
-         * then startMark is set to timeOrigin by default.
-         *
-         * The endMark argument must identify any existing PerformanceMark in the the Performance Timeline or any of the timestamp
-         * properties provided by the PerformanceNodeTiming class. If the named endMark does not exist, an error will be thrown.
-         * @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;
-        /**
-         * _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
-         */
-        readonly nodeTiming: PerformanceNodeTiming;
-        /**
-         * Returns the current high resolution millisecond timestamp, where 0 represents the start of the current `node` process.
-         * @since v8.5.0
-         */
-        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
-         */
-        readonly timeOrigin: number;
-        /**
-         * This is an alias of `perf_hooks.timerify()`.
-         *
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         * @since v8.5.0
-         */
-        timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): 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
-         */
-        toJSON(): any;
-    }
-    class 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
-         */
-        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
-         */
-        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
-         */
-        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
-         */
-        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
-         */
-        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;
-    }
     namespace constants {
         const NODE_PERFORMANCE_GC_MAJOR: number;
         const NODE_PERFORMANCE_GC_MINOR: number;
@@ -680,7 +344,6 @@ 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.
@@ -815,29 +478,11 @@ declare module "perf_hooks" {
          */
         add(other: RecordableHistogram): void;
     }
-    interface CreateHistogramOptions {
-        /**
-         * The lowest discernible value. Must be an integer value greater than 0.
-         * @default 1
-         */
-        lowest?: number | bigint | undefined;
-        /**
-         * The highest recordable value. Must be an integer value that is equal to
-         * or greater than two times `lowest`.
-         * @default Number.MAX_SAFE_INTEGER
-         */
-        highest?: number | bigint | undefined;
-        /**
-         * The number of accuracy digits. Must be a number between `1` and `5`.
-         * @default 3
-         */
-        figures?: number | undefined;
+    interface EventLoopUtilization {
+        idle: number;
+        active: number;
+        utilization: number;
     }
-    /**
-     * Returns a {@link RecordableHistogram `RecordableHistogram`}.
-     * @since v15.9.0, v14.18.0
-     */
-    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
     /**
      * The `eventLoopUtilization()` function returns an object that contains the
      * cumulative duration of time the event loop has been both idle and active as a
@@ -845,9 +490,8 @@ declare module "perf_hooks" {
      * Event Loop Utilization (ELU).
      *
      * If bootstrapping has not yet finished on the main thread the properties have
-     * the value of `0`. The ELU is immediately available on
-     * [Worker threads](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html#worker-threads)
-     * since bootstrap happens within the event loop.
+     * the value of `0`. The ELU is immediately available on [Worker threads](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html#worker-threads) since
+     * bootstrap happens within the event loop.
      *
      * Both `utilization1` and `utilization2` are optional parameters.
      *
@@ -877,16 +521,18 @@ declare module "perf_hooks" {
      * });
      * ```
      *
-     * Although the CPU is mostly idle while running this script, the value of `utilization`
-     * is `1`. This is because the call to `child_process.spawnSync()` blocks the event loop
-     * from proceeding.
+     * Although the CPU is mostly idle while running this script, the value of
+     * `utilization` is `1`. This is because the call to
+     * `child_process.spawnSync()` blocks the event loop from proceeding.
      *
      * Passing in a user-defined object instead of the result of a previous call to
-     * `eventLoopUtilization()` will lead to undefined behavior. The return values are not
-     * guaranteed to reflect any correct state of the event loop.
-     * @since v24.12.0
-     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
-     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
+     * `eventLoopUtilization()` will lead to undefined behavior. The return values
+     * are not guaranteed to reflect any correct state of the event loop.
+     * @since v25.2.0
+     * @param utilization1 The result of a previous call to
+     * `eventLoopUtilization()`.
+     * @param utilization2 The result of a previous call to
+     * `eventLoopUtilization()` prior to `utilization1`.
      */
     function eventLoopUtilization(
         utilization1?: EventLoopUtilization,
@@ -921,6 +567,14 @@ declare module "perf_hooks" {
      * @since v11.10.0
      */
     function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
+    interface TimerifyOptions {
+        /**
+         * A histogram object created using
+         * `perf_hooks.createHistogram()` that will record runtime durations in
+         * nanoseconds.
+         */
+        histogram?: RecordableHistogram | undefined;
+    }
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
@@ -951,92 +605,39 @@ declare module "perf_hooks" {
      * ```
      *
      * 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.
-     * @since v24.12.0
+     * to the promise and the duration will be reported once the finally handler is
+     * invoked.
+     * @since v25.2.0
      */
-    function timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
-    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-v24.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-v24.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-v24.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-v24.x/api/globals.html#performanceobserver
-         * @since v19.0.0
-         */
-        var PerformanceObserver: typeof globalThis extends {
-            onmessage: any;
-            PerformanceObserver: infer T;
-        } ? T
-            : typeof _PerformanceObserver;
+    function timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+    interface CreateHistogramOptions {
         /**
-         * `PerformanceObserverEntryList` is a global reference for `import { PerformanceObserverEntryList } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v24.x/api/globals.html#performanceobserverentrylist
-         * @since v19.0.0
+         * The minimum recordable value. Must be an integer value greater than 0.
+         * @default 1
          */
-        var PerformanceObserverEntryList: typeof globalThis extends {
-            onmessage: any;
-            PerformanceObserverEntryList: infer T;
-        } ? T
-            : typeof _PerformanceObserverEntryList;
+        lowest?: number | bigint | undefined;
         /**
-         * `PerformanceResourceTiming` is a global reference for `import { PerformanceResourceTiming } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v24.x/api/globals.html#performanceresourcetiming
-         * @since v19.0.0
+         * The maximum recordable value. Must be an integer value greater than min.
+         * @default Number.MAX_SAFE_INTEGER
          */
-        var PerformanceResourceTiming: typeof globalThis extends {
-            onmessage: any;
-            PerformanceResourceTiming: infer T;
-        } ? T
-            : typeof _PerformanceResourceTiming;
+        highest?: number | bigint | undefined;
         /**
-         * `performance` is a global reference for `import { performance } from 'node:perf_hooks'`
-         * @see https://nodejs.org/docs/latest-v24.x/api/globals.html#performance
-         * @since v16.0.0
+         * The number of accuracy digits. Must be a number between 1 and 5.
+         * @default 3
          */
-        var performance: typeof globalThis extends {
-            onmessage: any;
-            performance: infer T;
-        } ? T
-            : typeof _performance;
+        figures?: number | undefined;
     }
+    /**
+     * Returns a `RecordableHistogram`.
+     * @since v15.9.0, v14.18.0
+     */
+    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+    // TODO: remove these in a future major
+    /** @deprecated Use the canonical `PerformanceMarkOptions` instead. */
+    interface MarkOptions extends PerformanceMarkOptions {}
+    /** @deprecated Use the canonical `PerformanceMeasureOptions` instead. */
+    interface MeasureOptions extends PerformanceMeasureOptions {}
 }
-declare module "node:perf_hooks" {
-    export * from "perf_hooks";
+declare module "perf_hooks" {
+    export * from "node:perf_hooks";
 }