lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230120

package/core/audits/script-treemap-data.d.ts

@@ -0,0 +1,42 @@
+export default ScriptTreemapDataAudit;
+export type SourceData = Omit<LH.Treemap.Node, 'name' | 'children'>;
+declare class ScriptTreemapDataAudit extends Audit {
+    /**
+     * Returns a tree data structure where leaf nodes are sources (ie. real files from source tree)
+     * from a source map, and non-leaf nodes are directories. Leaf nodes have data
+     * for bytes, coverage, etc., when available, and non-leaf nodes have the
+     * same data as the sum of all descendant leaf nodes.
+     * @param {string} src
+     * @param {string} sourceRoot
+     * @param {Record<string, SourceData>} sourcesData
+     * @return {LH.Treemap.Node}
+     */
+    static makeScriptNode(src: string, sourceRoot: string, sourcesData: Record<string, SourceData>): LH.Treemap.Node;
+    /**
+     * Returns nodes where the first level of nodes are URLs.
+     * Every external script has a node.
+     * All inline scripts are combined into a single node.
+     * If a script has a source map, that node will be created by makeScriptNode.
+     *
+     * Example return result:
+       - index.html (inline scripts)
+       - main.js
+       - - webpack://
+       - - - react.js
+       - - - app.js
+       - i-have-no-map.js
+     *
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Treemap.Node[]>}
+     */
+    static makeNodes(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Treemap.Node[]>;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=script-treemap-data.d.ts.map

package/core/audits/seo/canonical.d.ts

@@ -0,0 +1,51 @@
+export default Canonical;
+export type CanonicalURLData = {
+    uniqueCanonicalURLs: Set<string>;
+    hreflangURLs: Set<string>;
+    invalidCanonicalLink: LH.Artifacts.LinkElement | undefined;
+    relativeCanonicallink: LH.Artifacts.LinkElement | undefined;
+};
+/**
+ * @typedef CanonicalURLData
+ * @property {Set<string>} uniqueCanonicalURLs
+ * @property {Set<string>} hreflangURLs
+ * @property {LH.Artifacts.LinkElement|undefined} invalidCanonicalLink
+ * @property {LH.Artifacts.LinkElement|undefined} relativeCanonicallink
+ */
+declare class Canonical extends Audit {
+    /**
+     * @param {LH.Artifacts.LinkElement[]} linkElements
+     * @return {CanonicalURLData}
+     */
+    static collectCanonicalURLs(linkElements: LH.Artifacts.LinkElement[]): CanonicalURLData;
+    /**
+     * @param {CanonicalURLData} canonicalURLData
+     * @return {LH.Audit.Product|undefined}
+     */
+    static findInvalidCanonicalURLReason(canonicalURLData: CanonicalURLData): LH.Audit.Product | undefined;
+    /**
+     * @param {CanonicalURLData} canonicalURLData
+     * @param {URL} canonicalURL
+     * @param {URL} baseURL
+     * @return {LH.Audit.Product|undefined}
+     */
+    static findCommonCanonicalURLMistakes(canonicalURLData: CanonicalURLData, canonicalURL: URL, baseURL: URL): LH.Audit.Product | undefined;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const explanationConflict: string;
+    const explanationInvalid: string;
+    const explanationRelative: string;
+    const explanationPointsElsewhere: string;
+    const explanationRoot: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=canonical.d.ts.map

package/core/audits/seo/crawlable-anchors.d.ts

@@ -0,0 +1,16 @@
+export default CrawlableAnchors;
+declare class CrawlableAnchors extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit({ AnchorElements: anchorElements, URL: url }: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnFailingLink: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=crawlable-anchors.d.ts.map

package/core/audits/seo/font-size.d.ts

@@ -0,0 +1,24 @@
+export default FontSize;
+export type FailingNodeData = LH.Artifacts.FontSize['analyzedFailingNodesData'][0];
+declare class FontSize extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const displayValue: string;
+    const explanationViewport: string;
+    const additionalIllegibleText: string;
+    const legibleText: string;
+    const columnSelector: string;
+    const columnPercentPageText: string;
+    const columnFontSize: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=font-size.d.ts.map

package/core/audits/seo/hreflang.d.ts

@@ -0,0 +1,28 @@
+export default Hreflang;
+export type Source = string | LH.Audit.Details.NodeValue | undefined;
+export type InvalidHreflang = {
+    source: Source;
+    subItems: {
+        type: 'subitems';
+        items: SubItem[];
+    };
+};
+export type SubItem = {
+    reason: LH.IcuMessage;
+};
+declare class Hreflang extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit({ LinkElements }: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const unexpectedLanguage: string;
+    const notFullyQualified: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=hreflang.d.ts.map

package/core/audits/seo/http-status-code.d.ts

@@ -0,0 +1,16 @@
+export default HTTPStatusCode;
+declare class HTTPStatusCode extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=http-status-code.d.ts.map

package/core/audits/seo/is-crawlable.d.ts

@@ -0,0 +1,38 @@
+export default IsCrawlable;
+declare class IsCrawlable extends Audit {
+    /**
+     * @param {LH.Artifacts.MetaElement} metaElement
+     */
+    static handleMetaElement(metaElement: LH.Artifacts.MetaElement): {
+        source: {
+            snippet: string;
+            type: "node";
+            lhId?: string | undefined;
+            path?: string | undefined;
+            selector?: string | undefined;
+            boundingRect?: import("../../../types/lhr/audit-details.js").default.Rect | undefined;
+            nodeLabel?: string | undefined;
+        };
+    } | undefined;
+    /**
+     * @param {string|undefined} userAgent
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @param {LH.Artifacts.MetaElement[]} metaElements
+     * @param {import('robots-parser').Robot|undefined} parsedRobotsTxt
+     * @param {URL} robotsTxtUrl
+     */
+    static determineIfCrawlableForUserAgent(userAgent: string | undefined, mainResource: LH.Artifacts.NetworkRequest, metaElements: LH.Artifacts.MetaElement[], parsedRobotsTxt: import('robots-parser').Robot | undefined, robotsTxtUrl: URL): import("../../../types/lhr/audit-details.js").default.TableItem[];
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=is-crawlable.d.ts.map

package/core/audits/seo/link-text.d.ts

@@ -0,0 +1,16 @@
+export default LinkText;
+declare class LinkText extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const displayValue: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=link-text.d.ts.map

package/core/audits/seo/manual/structured-data.d.ts

@@ -0,0 +1,12 @@
+export default StructuredData;
+/**
+ * @fileoverview Manual SEO audit to check if structured data on page is valid.
+ */
+declare class StructuredData extends ManualAudit {
+}
+export namespace UIStrings {
+    const description: string;
+    const title: string;
+}
+import ManualAudit from "../../manual/manual-audit.js";
+//# sourceMappingURL=structured-data.d.ts.map

package/core/audits/seo/meta-description.d.ts

@@ -0,0 +1,16 @@
+export default Description;
+declare class Description extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const explanation: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=meta-description.d.ts.map

package/core/audits/seo/plugins.d.ts

@@ -0,0 +1,15 @@
+export default Plugins;
+declare class Plugins extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=plugins.d.ts.map

package/core/audits/seo/robots-txt.d.ts

@@ -0,0 +1,18 @@
+export default RobotsTxt;
+declare class RobotsTxt extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const displayValueHttpBadCode: string;
+    const displayValueValidationError: string;
+    const explanation: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=robots-txt.d.ts.map

package/core/audits/seo/tap-targets.d.ts

@@ -0,0 +1,50 @@
+export default TapTargets;
+export type ClientRectOverlapFailure = {
+    overlapScoreRatio: number;
+    tapTargetScore: number;
+    overlappingTargetScore: number;
+};
+export type TapTargetOverlapFailure = {
+    overlapScoreRatio: number;
+    tapTargetScore: number;
+    overlappingTargetScore: number;
+    tapTarget: LH.Artifacts.TapTarget;
+    overlappingTarget: LH.Artifacts.TapTarget;
+};
+export type BoundedTapTarget = {
+    paddedBoundsRect: LH.Artifacts.Rect;
+    tapTarget: LH.Artifacts.TapTarget;
+};
+export type TapTargetTableItem = {
+    tapTarget: LH.Audit.Details.NodeValue;
+    overlappingTarget: LH.Audit.Details.NodeValue;
+    size: string;
+    overlapScoreRatio: number;
+    height: number;
+    width: number;
+    tapTargetScore: number;
+    overlappingTargetScore: number;
+};
+declare class TapTargets extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+declare namespace TapTargets {
+    export { FINGER_SIZE_PX };
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const tapTargetHeader: string;
+    const overlappingTargetHeader: string;
+    const explanationViewportMetaNotOptimized: string;
+    const displayValue: string;
+}
+import { Audit } from "../audit.js";
+declare const FINGER_SIZE_PX: 48;
+//# sourceMappingURL=tap-targets.d.ts.map

package/core/audits/server-response-time.d.ts

@@ -0,0 +1,21 @@
+export default ServerResponseTime;
+declare class ServerResponseTime extends Audit {
+    /**
+     * @param {LH.Artifacts.NetworkRequest} record
+     */
+    static calculateResponseTime(record: LH.Artifacts.NetworkRequest): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const displayValue: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=server-response-time.d.ts.map

package/core/audits/service-worker.d.ts

@@ -0,0 +1,46 @@
+export default ServiceWorker;
+declare class ServiceWorker extends Audit {
+    /**
+     * Find active service workers for this origin.
+     * @param {Array<LH.Crdp.ServiceWorker.ServiceWorkerVersion>} versions
+     * @param {URL} pageUrl
+     * @return {Array<LH.Crdp.ServiceWorker.ServiceWorkerVersion>}
+     */
+    static getVersionsForOrigin(versions: Array<LH.Crdp.ServiceWorker.ServiceWorkerVersion>, pageUrl: URL): Array<LH.Crdp.ServiceWorker.ServiceWorkerVersion>;
+    /**
+     * From the set of active service workers for this origin, find the controlling SW (if any)
+     * and return its scope URL.
+     * @param {Array<LH.Crdp.ServiceWorker.ServiceWorkerVersion>} matchingSWVersions
+     * @param {Array<LH.Crdp.ServiceWorker.ServiceWorkerRegistration>} registrations
+     * @param {URL} pageUrl
+     * @return {{scopeUrl: string; scriptUrl: string} | undefined}
+     */
+    static getControllingServiceWorker(matchingSWVersions: Array<LH.Crdp.ServiceWorker.ServiceWorkerVersion>, registrations: Array<LH.Crdp.ServiceWorker.ServiceWorkerRegistration>, pageUrl: URL): {
+        scopeUrl: string;
+        scriptUrl: string;
+    } | undefined;
+    /**
+     * Returns a failure message if there is no start_url or if the start_url isn't
+     * contolled by the scopeUrl.
+     * @param {LH.Artifacts['WebAppManifest']} WebAppManifest
+     * @param {string} scopeUrl
+     * @return {LH.IcuMessage|undefined}
+     */
+    static checkStartUrl(WebAppManifest: LH.Artifacts['WebAppManifest'], scopeUrl: string): LH.IcuMessage | undefined;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const explanationOutOfScope: string;
+    const explanationNoManifest: string;
+    const explanationBadManifest: string;
+    const explanationBadStartUrl: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=service-worker.d.ts.map

package/core/audits/splash-screen.d.ts

@@ -0,0 +1,37 @@
+export default SplashScreen;
+/**
+ * @fileoverview
+ * Audits if a page is configured for a custom splash screen when launched
+ * https://github.com/GoogleChrome/lighthouse/issues/24
+ *
+ * Requirements:
+ *   * manifest is not empty
+ *   * manifest has a valid name
+ *   * manifest has a valid background_color
+ *   * manifest has a valid theme_color
+ *   * manifest contains icon that's a png and size >= 512px
+ */
+declare class SplashScreen extends MultiCheckAudit {
+    /**
+     * @param {LH.Artifacts.ManifestValues} manifestValues
+     * @param {Array<string>} failures
+     */
+    static assessManifest(manifestValues: LH.Artifacts.ManifestValues, failures: Array<string>): void;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<{failures: Array<string>, manifestValues: LH.Artifacts.ManifestValues}>}
+     */
+    static audit_(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
+        failures: Array<string>;
+        manifestValues: LH.Artifacts.ManifestValues;
+    }>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import MultiCheckAudit from "./multi-check-audit.js";
+import { ManifestValues } from "../computed/manifest-values.js";
+//# sourceMappingURL=splash-screen.d.ts.map

package/core/audits/themed-omnibox.d.ts

@@ -0,0 +1,42 @@
+export default ThemedOmnibox;
+/**
+ * @fileoverview
+ * Audits if a page is configured for a themed address bar
+ *
+ * Requirements:
+ *   * manifest is not empty
+ *   * manifest has a theme_color
+ *   * HTML has a theme-color meta
+ *
+ * Color validity is explicitly not checked.
+ */
+declare class ThemedOmnibox extends MultiCheckAudit {
+    /**
+     * @param {LH.Artifacts.MetaElement|undefined} themeColorMeta
+     * @param {Array<string>} failures
+     */
+    static assessMetaThemecolor(themeColorMeta: LH.Artifacts.MetaElement | undefined, failures: Array<string>): void;
+    /**
+     * @param {LH.Artifacts.ManifestValues} manifestValues
+     * @param {Array<string>} failures
+     */
+    static assessManifest(manifestValues: LH.Artifacts.ManifestValues, failures: Array<string>): void;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<{failures: Array<string>, manifestValues: LH.Artifacts.ManifestValues, themeColor: ?string}>}
+     */
+    static audit_(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
+        failures: Array<string>;
+        manifestValues: LH.Artifacts.ManifestValues;
+        themeColor: string | null;
+    }>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import MultiCheckAudit from "./multi-check-audit.js";
+import { ManifestValues } from "../computed/manifest-values.js";
+//# sourceMappingURL=themed-omnibox.d.ts.map

package/core/audits/third-party-facades.d.ts

@@ -0,0 +1,41 @@
+export default ThirdPartyFacades;
+export type ThirdPartyEntity = import("third-party-web").IEntity;
+export type ThirdPartyProduct = import("third-party-web").IProduct;
+export type ThirdPartyFacade = import("third-party-web").IFacade;
+export type FacadableProduct = {
+    product: ThirdPartyProduct;
+    entity: ThirdPartyEntity;
+};
+declare class ThirdPartyFacades extends Audit {
+    /**
+     * Sort items by transfer size and combine small items into a single row.
+     * Items will be mutated in place to a maximum of 6 rows.
+     * @param {import('./third-party-summary.js').URLSummary[]} items
+     */
+    static condenseItems(items: import('./third-party-summary.js').URLSummary[]): void;
+    /**
+     * @param {Map<string, import('./third-party-summary.js').Summary>} byURL
+     * @param {ThirdPartyEntity | undefined} mainEntity
+     * @return {FacadableProduct[]}
+     */
+    static getProductsWithFacade(byURL: Map<string, import('./third-party-summary.js').Summary>, mainEntity: ThirdPartyEntity | undefined): FacadableProduct[];
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const displayValue: string;
+    const columnProduct: string;
+    const categoryVideo: string;
+    const categoryCustomerSuccess: string;
+    const categoryMarketing: string;
+    const categorySocial: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=third-party-facades.d.ts.map

package/core/audits/third-party-summary.d.ts

@@ -0,0 +1,58 @@
+export default ThirdPartySummary;
+export type ThirdPartyEntity = import("third-party-web").IEntity;
+export type Summary = {
+    mainThreadTime: number;
+    transferSize: number;
+    blockingTime: number;
+};
+export type URLSummary = {
+    transferSize: number;
+    blockingTime: number;
+    url: string | LH.IcuMessage;
+};
+export type SummaryMaps = {
+    /**
+     * Map of impact summaries for each entity.
+     */
+    byEntity: Map<ThirdPartyEntity, Summary>;
+    /**
+     * Map of impact summaries for each URL.
+     */
+    byURL: Map<string, Summary>;
+    /**
+     * Map of URLs under each entity.
+     */
+    urls: Map<ThirdPartyEntity, string[]>;
+};
+declare class ThirdPartySummary extends Audit {
+    /**
+     *
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {Array<LH.Artifacts.TaskNode>} mainThreadTasks
+     * @param {number} cpuMultiplier
+     * @return {SummaryMaps}
+     */
+    static getSummaries(networkRecords: Array<LH.Artifacts.NetworkRequest>, mainThreadTasks: Array<LH.Artifacts.TaskNode>, cpuMultiplier: number): SummaryMaps;
+    /**
+     * @param {ThirdPartyEntity} entity
+     * @param {SummaryMaps} summaries
+     * @param {Summary} stats
+     * @return {Array<URLSummary>}
+     */
+    static makeSubItems(entity: ThirdPartyEntity, summaries: SummaryMaps, stats: Summary): Array<URLSummary>;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnThirdParty: string;
+    const displayValue: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=third-party-summary.d.ts.map

package/core/audits/timing-budget.d.ts

@@ -0,0 +1,43 @@
+export default TimingBudget;
+export type BudgetItem = {
+    metric: LH.Budget.TimingMetric;
+    label: LH.IcuMessage;
+    measurement?: LH.Audit.Details.NumericValue | number;
+    overBudget?: LH.Audit.Details.NumericValue | number;
+};
+/** @typedef {{metric: LH.Budget.TimingMetric, label: LH.IcuMessage, measurement?: LH.Audit.Details.NumericValue|number, overBudget?: LH.Audit.Details.NumericValue|number}} BudgetItem */
+declare class TimingBudget extends Audit {
+    /**
+     * @param {LH.Budget.TimingMetric} timingMetric
+     * @return {LH.IcuMessage}
+     */
+    static getRowLabel(timingMetric: LH.Budget.TimingMetric): LH.IcuMessage;
+    /**
+     * @param {LH.Budget.TimingMetric} timingMetric
+     * @param {LH.Artifacts.TimingSummary} summary
+     * @return {number|undefined}
+     */
+    static getMeasurement(timingMetric: LH.Budget.TimingMetric, summary: LH.Artifacts.TimingSummary): number | undefined;
+    /**
+     * @param {LH.Util.Immutable<LH.Budget>} budget
+     * @param {LH.Artifacts.TimingSummary} summary
+     * @return {Array<BudgetItem>}
+     */
+    static tableItems(budget: LH.Util.Immutable<LH.Budget>, summary: LH.Artifacts.TimingSummary): Array<BudgetItem>;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const columnTimingMetric: string;
+    const columnMeasurement: string;
+}
+import { Budget } from "../config/budget.js";
+import { Audit } from "./audit.js";
+import { TimingSummary } from "../computed/metrics/timing-summary.js";
+//# sourceMappingURL=timing-budget.d.ts.map