lighthouse 11.6.0-dev.20240302 → 11.6.0-dev.20240304

package/core/lib/{dependency-graph → lantern}/base-node.d.ts

@@ -2,7 +2,7 @@
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  */
-export type Node = import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode;
+export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>;
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -11,7 +11,8 @@ export type Node = import('./cpu-node.js').CPUNode | import('./network-node.js')
 /**
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
- * @typedef {import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode} Node
+ * @template [T=any]
+ * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
  */
 /**
  * @fileoverview This class encapsulates logic for handling resources and tasks used to model the
@@ -25,7 +26,10 @@ export type Node = import('./cpu-node.js').CPUNode | import('./network-node.js')
  * This allows particular optimizations in this class so that we do no need to check for cycles as
  * these methods are called and we can always start traversal at the root node.
  */
-export class BaseNode {
+/**
+ * @template [T=any]
+ */
+export class BaseNode<T = any> {
     /**
      * Returns whether the given node has a cycle in its dependent graph by performing a DFS.
      * @param {Node} node
@@ -134,17 +138,17 @@ export class BaseNode {
      *
      * The `getNextNodes` function takes a visited node and returns which nodes to
      * visit next. It defaults to returning the node's dependents.
-     * @param {(node: Node, traversalPath: Node[]) => void} callback
-     * @param {function(Node): Node[]} [getNextNodes]
+     * @param {(node: Node<T>, traversalPath: Node<T>[]) => void} callback
+     * @param {function(Node<T>): Node<T>[]} [getNextNodes]
      */
-    traverse(callback: (node: Node, traversalPath: Node[]) => void, getNextNodes?: ((arg0: Node) => Node[]) | undefined): void;
+    traverse(callback: (node: Node<T>, traversalPath: Node<T>[]) => void, getNextNodes?: ((arg0: Node<T>) => Node<T>[]) | undefined): void;
     /**
      * @see BaseNode.traverse
      * @param {function(Node): Node[]} [getNextNodes]
      */
     traverseGenerator(getNextNodes?: ((arg0: Node) => Node[]) | undefined): Generator<{
-        node: Node;
-        traversalPath: Node[];
+        node: Node<any>;
+        traversalPath: Node<any>[];
     }, void, unknown>;
     /**
      * @param {Node} node

package/core/lib/{dependency-graph → lantern}/base-node.js

@@ -7,7 +7,8 @@
 /**
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
- * @typedef {import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode} Node
+ * @template [T=any]
+ * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
  */
 
 /**
@@ -22,6 +23,10 @@
  * This allows particular optimizations in this class so that we do no need to check for cycles as
  * these methods are called and we can always start traversal at the root node.
  */
+
+/**
+ * @template [T=any]
+ */
 class BaseNode {
   /**
    * @param {string} id
@@ -256,8 +261,8 @@ class BaseNode {
    *
    * The `getNextNodes` function takes a visited node and returns which nodes to
    * visit next. It defaults to returning the node's dependents.
-   * @param {(node: Node, traversalPath: Node[]) => void} callback
-   * @param {function(Node): Node[]} [getNextNodes]
+   * @param {(node: Node<T>, traversalPath: Node<T>[]) => void} callback
+   * @param {function(Node<T>): Node<T>[]} [getNextNodes]
    */
   traverse(callback, getNextNodes) {
     for (const {node, traversalPath} of this.traverseGenerator(getNextNodes)) {

package/core/lib/{dependency-graph → lantern}/cpu-node.d.ts

@@ -1,4 +1,8 @@
-export class CPUNode extends BaseNode {
+/**
+ * @template [T=any]
+ * @extends {BaseNode<T>}
+ */
+export class CPUNode<T = any> extends BaseNode<T> {
     /**
      * @param {LH.TraceEvent} parentEvent
      * @param {LH.TraceEvent[]=} childEvents

package/core/lib/{dependency-graph → lantern}/cpu-node.js

@@ -7,6 +7,10 @@
 import * as LH from '../../../types/lh.js';
 import {BaseNode} from './base-node.js';
 
+/**
+ * @template [T=any]
+ * @extends {BaseNode<T>}
+ */
 class CPUNode extends BaseNode {
   /**
    * @param {LH.TraceEvent} parentEvent

package/core/lib/lantern/lantern.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export const NetworkRequest: import("../../../types/internal/lantern").NetworkRequest<any>;
+/** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
+export const NetworkRequestTypes: LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
+//# sourceMappingURL=lantern.d.ts.map

package/core/lib/lantern/lantern.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const NetworkRequest = /** @type {import('../../../types/internal/lantern').NetworkRequest} */({});
+
+/** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
+const NetworkRequestTypes = {
+  XHR: 'XHR',
+  Fetch: 'Fetch',
+  EventSource: 'EventSource',
+  Script: 'Script',
+  Stylesheet: 'Stylesheet',
+  Image: 'Image',
+  Media: 'Media',
+  Font: 'Font',
+  Document: 'Document',
+  TextTrack: 'TextTrack',
+  WebSocket: 'WebSocket',
+  Other: 'Other',
+  Manifest: 'Manifest',
+  SignedExchange: 'SignedExchange',
+  Ping: 'Ping',
+  Preflight: 'Preflight',
+  CSPViolationReport: 'CSPViolationReport',
+  Prefetch: 'Prefetch',
+};
+
+export {
+  NetworkRequest,
+  NetworkRequestTypes,
+};

package/core/lib/{dependency-graph → lantern}/network-node.d.ts

@@ -1,15 +1,23 @@
-export class NetworkNode extends BaseNode {
+/**
+ * @template [T=any]
+ * @extends {BaseNode<T>}
+ */
+export class NetworkNode<T = any> extends BaseNode<T> {
     /**
-     * @param {LH.Artifacts.NetworkRequest} networkRecord
+     * @param {Lantern.NetworkRequest<T>} networkRequest
      */
-    constructor(networkRecord: LH.Artifacts.NetworkRequest);
+    constructor(networkRequest: import("../../../types/internal/lantern.js").NetworkRequest<any>);
     /** @private */
-    private _record;
+    private _request;
     get type(): "network";
     /**
-     * @return {LH.Artifacts.NetworkRequest}
+     * @return {Readonly<T>}
      */
-    get record(): NetworkRequest;
+    get record(): Readonly<T>;
+    /**
+     * @return {Lantern.NetworkRequest<T>}
+     */
+    get request(): import("../../../types/internal/lantern.js").NetworkRequest<any>;
     /**
      * @return {string}
      */
@@ -33,11 +41,9 @@ export class NetworkNode extends BaseNode {
      */
     hasRenderBlockingPriority(): boolean;
     /**
-     * @return {NetworkNode}
+     * @return {NetworkNode<T>}
      */
-    cloneWithoutRelationships(): NetworkNode;
+    cloneWithoutRelationships(): NetworkNode<T>;
 }
 import { BaseNode } from './base-node.js';
-import { NetworkRequest } from '../network-request.js';
-import * as LH from '../../../types/lh.js';
 //# sourceMappingURL=network-node.d.ts.map

package/core/lib/lantern/network-node.js

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from './lantern.js';
+import {BaseNode} from './base-node.js';
+// TODO(15841): bring impl of isNonNetworkRequest inside lantern and remove this.
+import UrlUtils from '../url-utils.js';
+
+/**
+ * @template [T=any]
+ * @extends {BaseNode<T>}
+ */
+class NetworkNode extends BaseNode {
+  /**
+   * @param {Lantern.NetworkRequest<T>} networkRequest
+   */
+  constructor(networkRequest) {
+    super(networkRequest.requestId);
+    /** @private */
+    this._request = networkRequest;
+  }
+
+  get type() {
+    return BaseNode.TYPES.NETWORK;
+  }
+
+  /**
+   * @return {number}
+   */
+  get startTime() {
+    return this._request.rendererStartTime * 1000;
+  }
+
+  /**
+   * @return {number}
+   */
+  get endTime() {
+    return this._request.networkEndTime * 1000;
+  }
+
+  /**
+   * @return {Readonly<T>}
+   */
+  get record() {
+    return /** @type {Required<T>} */ (this._request.record);
+  }
+
+  /**
+   * @return {Lantern.NetworkRequest<T>}
+   */
+  get request() {
+    return this._request;
+  }
+
+  /**
+   * @return {string}
+   */
+  get initiatorType() {
+    return this._request.initiator && this._request.initiator.type;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  get fromDiskCache() {
+    return !!this._request.fromDiskCache;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  get isNonNetworkProtocol() {
+    // The 'protocol' field in devtools a string more like a `scheme`
+    return UrlUtils.isNonNetworkProtocol(this.request.protocol) ||
+      // But `protocol` can fail to be populated if the request fails, so fallback to scheme.
+      UrlUtils.isNonNetworkProtocol(this.request.parsedURL.scheme);
+  }
+
+  /**
+   * Returns whether this network record can be downloaded without a TCP connection.
+   * During simulation we treat data coming in over a network connection separately from on-device data.
+   * @return {boolean}
+   */
+  get isConnectionless() {
+    return this.fromDiskCache || this.isNonNetworkProtocol;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  hasRenderBlockingPriority() {
+    const priority = this._request.priority;
+    const isScript = this._request.resourceType === Lantern.NetworkRequestTypes.Script;
+    const isDocument = this._request.resourceType === Lantern.NetworkRequestTypes.Document;
+    const isBlockingScript = priority === 'High' && isScript;
+    const isBlockingHtmlImport = priority === 'High' && isDocument;
+    return priority === 'VeryHigh' || isBlockingScript || isBlockingHtmlImport;
+  }
+
+  /**
+   * @return {NetworkNode<T>}
+   */
+  cloneWithoutRelationships() {
+    const node = new NetworkNode(this._request);
+    node.setIsMainDocument(this._isMainDocument);
+    return node;
+  }
+}
+
+export {NetworkNode};

package/core/lib/{dependency-graph → lantern}/simulator/connection-pool.d.ts

@@ -1,15 +1,15 @@
 export class ConnectionPool {
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {Required<LH.Gatherer.Simulation.Options>} options
      */
-    constructor(records: LH.Artifacts.NetworkRequest[], options: Required<LH.Gatherer.Simulation.Options>);
+    constructor(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[], options: Required<LH.Gatherer.Simulation.Options>);
     _options: Required<LH.Gatherer.Simulation.Options>;
-    _records: import("../../network-request.js").NetworkRequest[];
+    _records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[];
     /** @type {Map<string, TcpConnection[]>} */
     _connectionsByOrigin: Map<string, TcpConnection[]>;
-    /** @type {Map<LH.Artifacts.NetworkRequest, TcpConnection>} */
-    _connectionsByRecord: Map<LH.Artifacts.NetworkRequest, TcpConnection>;
+    /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
+    _connectionsByRecord: Map<import("../../../../types/internal/lantern.js").NetworkRequest<any>, TcpConnection>;
     _connectionsInUse: Set<any>;
     _connectionReusedByRequestId: Map<string, boolean>;
     /**
@@ -33,25 +33,25 @@ export class ConnectionPool {
      * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
      * Otherwise, only connections that have matching "warmth" are considered available.
      *
-     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      * @param {{ignoreConnectionReused?: boolean}} options
      * @return {?TcpConnection}
      */
-    acquire(record: LH.Artifacts.NetworkRequest, options?: {
+    acquire(record: import("../../../../types/internal/lantern.js").NetworkRequest<any>, options?: {
         ignoreConnectionReused?: boolean;
     }): TcpConnection | null;
     /**
      * Return the connection currently being used to fetch a record. If no connection
      * currently being used for this record, an error will be thrown.
      *
-     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      * @return {TcpConnection}
      */
-    acquireActiveConnectionFromRecord(record: LH.Artifacts.NetworkRequest): TcpConnection;
+    acquireActiveConnectionFromRecord(record: import("../../../../types/internal/lantern.js").NetworkRequest<any>): TcpConnection;
     /**
-     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      */
-    release(record: LH.Artifacts.NetworkRequest): void;
+    release(record: import("../../../../types/internal/lantern.js").NetworkRequest<any>): void;
 }
 import * as LH from '../../../../types/lh.js';
 import { TcpConnection } from './tcp-connection.js';

package/core/lib/{dependency-graph → lantern}/simulator/connection-pool.js

@@ -5,6 +5,7 @@
  */
 
 import * as LH from '../../../../types/lh.js';
+import * as Lantern from '../lantern.js';
 import {NetworkAnalyzer} from './network-analyzer.js';
 import {TcpConnection} from './tcp-connection.js';
 
@@ -17,7 +18,7 @@ const CONNECTIONS_PER_ORIGIN = 6;
 
 export class ConnectionPool {
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} records
    * @param {Required<LH.Gatherer.Simulation.Options>} options
    */
   constructor(records, options) {
@@ -26,7 +27,7 @@ export class ConnectionPool {
     this._records = records;
     /** @type {Map<string, TcpConnection[]>} */
     this._connectionsByOrigin = new Map();
-    /** @type {Map<LH.Artifacts.NetworkRequest, TcpConnection>} */
+    /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
     this._connectionsByRecord = new Map();
     this._connectionsInUse = new Set();
     this._connectionReusedByRequestId = NetworkAnalyzer.estimateIfConnectionWasReused(records, {
@@ -124,7 +125,7 @@ export class ConnectionPool {
    * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
    * Otherwise, only connections that have matching "warmth" are considered available.
    *
-   * @param {LH.Artifacts.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    * @param {{ignoreConnectionReused?: boolean}} options
    * @return {?TcpConnection}
    */
@@ -150,7 +151,7 @@ export class ConnectionPool {
    * Return the connection currently being used to fetch a record. If no connection
    * currently being used for this record, an error will be thrown.
    *
-   * @param {LH.Artifacts.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    * @return {TcpConnection}
    */
   acquireActiveConnectionFromRecord(record) {
@@ -161,7 +162,7 @@ export class ConnectionPool {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    */
   release(record) {
     const connection = this._connectionsByRecord.get(record);

package/core/lib/{dependency-graph → lantern}/simulator/dns-cache.d.ts

@@ -11,19 +11,19 @@ export class DNSCache {
         resolvedAt: number;
     }>;
     /**
-     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {Lantern.NetworkRequest} request
      * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
      * @return {number}
      */
-    getTimeUntilResolution(request: LH.Artifacts.NetworkRequest, options?: {
+    getTimeUntilResolution(request: import("../../../../types/internal/lantern.js").NetworkRequest<any>, options?: {
         requestedAt: number;
         shouldUpdateCache: boolean;
     } | undefined): number;
     /**
-     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {Lantern.NetworkRequest} request
      * @param {number} resolvedAt
      */
-    _updateCacheResolvedAtIfNeeded(request: LH.Artifacts.NetworkRequest, resolvedAt: number): void;
+    _updateCacheResolvedAtIfNeeded(request: import("../../../../types/internal/lantern.js").NetworkRequest<any>, resolvedAt: number): void;
     /**
      * Forcefully sets the DNS resolution time for a record.
      * Useful for testing and alternate execution simulations.
@@ -36,7 +36,6 @@ export class DNSCache {
 export namespace DNSCache {
     export { DNS_RESOLUTION_RTT_MULTIPLIER as RTT_MULTIPLIER };
 }
-import * as LH from '../../../../types/lh.js';
 declare const DNS_RESOLUTION_RTT_MULTIPLIER: 2;
 export {};
 //# sourceMappingURL=dns-cache.d.ts.map

package/core/lib/{dependency-graph → lantern}/simulator/dns-cache.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as LH from '../../../../types/lh.js';
+import * as Lantern from '../lantern.js';
 
 // A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.
 // Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1
@@ -25,7 +25,7 @@ class DNSCache {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest} request
+   * @param {Lantern.NetworkRequest} request
    * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
    * @return {number}
    */
@@ -47,7 +47,7 @@ class DNSCache {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest} request
+   * @param {Lantern.NetworkRequest} request
    * @param {number} resolvedAt
    */
   _updateCacheResolvedAtIfNeeded(request, resolvedAt) {

package/core/lib/{dependency-graph → lantern}/simulator/network-analyzer.d.ts

@@ -32,10 +32,10 @@ export class NetworkAnalyzer {
      */
     static get SUMMARY(): string;
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, LH.Artifacts.NetworkRequest[]>}
+     * @param {Lantern.NetworkRequest[]} records
+     * @return {Map<string, Lantern.NetworkRequest[]>}
      */
-    static groupByOrigin(records: LH.Artifacts.NetworkRequest[]): Map<string, LH.Artifacts.NetworkRequest[]>;
+    static groupByOrigin(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[]): Map<string, import("../../../../types/internal/lantern.js").NetworkRequest<any>[]>;
     /**
      * @param {number[]} values
      * @return {Summary}
@@ -46,14 +46,14 @@ export class NetworkAnalyzer {
      * @return {Map<string, Summary>}
      */
     static summarize(values: Map<string, number[]>): Map<string, Summary>;
-    /** @typedef {{record: LH.Artifacts.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+    /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
      * @return {Map<string, number[]>}
      */
-    static _estimateValueByOrigin(records: LH.Artifacts.NetworkRequest[], iteratee: (e: {
-        record: LH.Artifacts.NetworkRequest;
+    static _estimateValueByOrigin(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[], iteratee: (e: {
+        record: import("../../../../types/internal/lantern.js").NetworkRequest<any>;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }) => number | number[] | undefined): Map<string, number[]>;
@@ -69,7 +69,7 @@ export class NetworkAnalyzer {
      * @return {number[]|number|undefined}
      */
     static _estimateRTTViaConnectionTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: import("../../../../types/internal/lantern.js").NetworkRequest<any>;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number[] | number | undefined;
@@ -82,7 +82,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaDownloadTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: import("../../../../types/internal/lantern.js").NetworkRequest<any>;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -96,7 +96,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaSendStartTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: import("../../../../types/internal/lantern.js").NetworkRequest<any>;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -110,32 +110,32 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaHeadersEndTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: import("../../../../types/internal/lantern.js").NetworkRequest<any>;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
     /**
      * Given the RTT to each origin, estimates the observed server response times.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {Map<string, number>} rttByOrigin
      * @return {Map<string, number[]>}
      */
-    static _estimateResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    static _estimateResponseTimeByOrigin(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[], rttByOrigin: Map<string, number>): Map<string, number[]>;
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @return {boolean}
      */
-    static canTrustConnectionInformation(records: LH.Artifacts.NetworkRequest[]): boolean;
+    static canTrustConnectionInformation(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[]): boolean;
     /**
      * Returns a map of requestId -> connectionReused, estimating the information if the information
      * available in the records themselves appears untrustworthy.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {{forceCoarseEstimates: boolean}} [options]
      * @return {Map<string, boolean>}
      */
-    static estimateIfConnectionWasReused(records: LH.Artifacts.NetworkRequest[], options?: {
+    static estimateIfConnectionWasReused(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[], options?: {
         forceCoarseEstimates: boolean;
     } | undefined): Map<string, boolean>;
     /**
@@ -143,20 +143,20 @@ export class NetworkAnalyzer {
      * Attempts to use the most accurate information first and falls back to coarser estimates when it
      * is unavailable.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {RTTEstimateOptions} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateRTTByOrigin(records: LH.Artifacts.NetworkRequest[], options?: RTTEstimateOptions | undefined): Map<string, Summary>;
+    static estimateRTTByOrigin(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[], options?: RTTEstimateOptions | undefined): Map<string, Summary>;
     /**
      * Estimates the server response time of each origin. RTT times can be passed in or will be
      * estimated automatically if not provided.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateServerResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], options?: (RTTEstimateOptions & {
+    static estimateServerResponseTimeByOrigin(records: import("../../../../types/internal/lantern.js").NetworkRequest<any>[], options?: (RTTEstimateOptions & {
         rttByOrigin?: Map<string, number> | undefined;
     }) | undefined): Map<string, Summary>;
     /**
@@ -164,29 +164,32 @@ export class NetworkAnalyzer {
      * Excludes data URI, failed or otherwise incomplete, and cached requests.
      * Returns Infinity if there were no analyzable network records.
      *
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {Array<Lantern.NetworkRequest>} networkRecords
      * @return {number}
      */
-    static estimateThroughput(networkRecords: Array<LH.Artifacts.NetworkRequest>): number;
+    static estimateThroughput(networkRecords: Array<import("../../../../types/internal/lantern.js").NetworkRequest<any>>): number;
     /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @template {Lantern.NetworkRequest} T
+     * @param {Array<T>} records
      * @param {string} resourceUrl
-     * @return {LH.Artifacts.NetworkRequest|undefined}
+     * @return {T|undefined}
      */
-    static findResourceForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    static findResourceForUrl<T extends import("../../../../types/internal/lantern.js").NetworkRequest<any>>(records: T[], resourceUrl: string): T | undefined;
     /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @template {Lantern.NetworkRequest} T
+     * @param {Array<T>} records
      * @param {string} resourceUrl
-     * @return {LH.Artifacts.NetworkRequest|undefined}
+     * @return {T|undefined}
      */
-    static findLastDocumentForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    static findLastDocumentForUrl<T_1 extends import("../../../../types/internal/lantern.js").NetworkRequest<any>>(records: T_1[], resourceUrl: string): T_1 | undefined;
     /**
      * Resolves redirect chain given a main document.
      * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
      *
-     * @param {LH.Artifacts.NetworkRequest} request
-     * @return {LH.Artifacts.NetworkRequest}
+     * @template {Lantern.NetworkRequest} T
+     * @param {T} request
+     * @return {T}
      */
-    static resolveRedirects(request: LH.Artifacts.NetworkRequest): LH.Artifacts.NetworkRequest;
+    static resolveRedirects<T_2 extends import("../../../../types/internal/lantern.js").NetworkRequest<any>>(request: T_2): T_2;
 }
 //# sourceMappingURL=network-analyzer.d.ts.map