@sentry/browser-utils 10.58.0

package/build/types-ts3.8/metrics/web-vitals/types/base.d.ts

@@ -0,0 +1,106 @@
+import { CLSMetric, CLSMetricWithAttribution } from './cls';
+import { FCPMetric, FCPMetricWithAttribution } from './fcp';
+import { INPMetric, INPMetricWithAttribution } from './inp';
+import { LCPMetric, LCPMetricWithAttribution } from './lcp';
+import { TTFBMetric, TTFBMetricWithAttribution } from './ttfb';
+export interface Metric {
+    /**
+     * The name of the metric (in acronym form).
+     */
+    name: 'CLS' | 'FCP' | 'INP' | 'LCP' | 'TTFB';
+    /**
+     * The current value of the metric.
+     */
+    value: number;
+    /**
+     * The rating as to whether the metric value is within the "good",
+     * "needs improvement", or "poor" thresholds of the metric.
+     */
+    rating: 'good' | 'needs-improvement' | 'poor';
+    /**
+     * The delta between the current value and the last-reported value.
+     * On the first report, `delta` and `value` will always be the same.
+     */
+    delta: number;
+    /**
+     * A unique ID representing this particular metric instance. This ID can
+     * be used by an analytics tool to dedupe multiple values sent for the same
+     * metric instance, or to group multiple deltas together and calculate a
+     * total. It can also be used to differentiate multiple different metric
+     * instances sent from the same page, which can happen if the page is
+     * restored from the back/forward cache (in that case new metrics object
+     * get created).
+     */
+    id: string;
+    /**
+     * Any performance entries relevant to the metric value calculation.
+     * The array may also be empty if the metric value was not based on any
+     * entries (e.g. a CLS value of 0 given no layout shifts).
+     */
+    entries: PerformanceEntry[];
+    /**
+     * The type of navigation.
+     *
+     * This will be the value returned by the Navigation Timing API (or
+     * `undefined` if the browser doesn't support that API), with the following
+     * exceptions:
+     * - 'back-forward-cache': for pages that are restored from the bfcache.
+     * - 'back_forward' is renamed to 'back-forward' for consistency.
+     * - 'prerender': for pages that were prerendered.
+     * - 'restore': for pages that were discarded by the browser and then
+     * restored by the user.
+     */
+    navigationType: 'navigate' | 'reload' | 'back-forward' | 'back-forward-cache' | 'prerender' | 'restore';
+}
+/** The union of supported metric types. */
+export type MetricType = CLSMetric | FCPMetric | INPMetric | LCPMetric | TTFBMetric;
+/** The union of supported metric attribution types. */
+export type MetricWithAttribution = CLSMetricWithAttribution | FCPMetricWithAttribution | INPMetricWithAttribution | LCPMetricWithAttribution | TTFBMetricWithAttribution;
+/**
+ * The thresholds of metric's "good", "needs improvement", and "poor" ratings.
+ *
+ * - Metric values up to and including [0] are rated "good"
+ * - Metric values up to and including [1] are rated "needs improvement"
+ * - Metric values above [1] are "poor"
+ *
+ * | Metric value    | Rating              |
+ * | --------------- | ------------------- |
+ * | ≦ [0]           | "good"              |
+ * | > [0] and ≦ [1] | "needs improvement" |
+ * | > [1]           | "poor"              |
+ */
+export type MetricRatingThresholds = [
+    number,
+    number
+];
+/**
+ * @deprecated Use metric-specific function types instead, such as:
+ * `(metric: LCPMetric) => void`. If a single callback type is needed for
+ * multiple metrics, use `(metric: MetricType) => void`.
+ */
+export interface ReportCallback {
+    (metric: MetricType): void;
+}
+export interface ReportOpts {
+    reportAllChanges?: boolean;
+}
+export interface AttributionReportOpts extends ReportOpts {
+    generateTarget?: (el: Node | null) => string | undefined;
+}
+/**
+ * The loading state of the document. Note: this value is similar to
+ * `document.readyState` but it subdivides the "interactive" state into the
+ * time before and after the DOMContentLoaded event fires.
+ *
+ * State descriptions:
+ * - `loading`: the initial document response has not yet been fully downloaded
+ *   and parsed. This is equivalent to the corresponding `readyState` value.
+ * - `dom-interactive`: the document has been fully loaded and parsed, but
+ *   scripts may not have yet finished loading and executing.
+ * - `dom-content-loaded`: the document is fully loaded and parsed, and all
+ *   scripts (except `async` scripts) have loaded and finished executing.
+ * - `complete`: the document and all of its sub-resources have finished
+ *   loading. This is equivalent to the corresponding `readyState` value.
+ */
+export type LoadState = 'loading' | 'dom-interactive' | 'dom-content-loaded' | 'complete';
+//# sourceMappingURL=base.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/types/cls.d.ts

@@ -0,0 +1,58 @@
+import { LoadState, Metric } from './base';
+/**
+ * A CLS-specific version of the Metric object.
+ */
+export interface CLSMetric extends Metric {
+    name: 'CLS';
+    entries: LayoutShift[];
+}
+/**
+ * An object containing potentially-helpful debugging information that
+ * can be sent along with the CLS value for the current page visit in order
+ * to help identify issues happening to real-users in the field.
+ */
+export interface CLSAttribution {
+    /**
+     * By default, a selector identifying the first element (in document order)
+     * that shifted when the single largest layout shift that contributed to the
+     * page's CLS score occurred. If the `generateTarget` configuration option
+     * was passed, then this will instead be the return value of that function,
+     * falling back to the default if that returns null or undefined.
+     */
+    largestShiftTarget?: string;
+    /**
+     * The time when the single largest layout shift contributing to the page's
+     * CLS score occurred.
+     */
+    largestShiftTime?: DOMHighResTimeStamp;
+    /**
+     * The layout shift score of the single largest layout shift contributing to
+     * the page's CLS score.
+     */
+    largestShiftValue?: number;
+    /**
+     * The `LayoutShiftEntry` representing the single largest layout shift
+     * contributing to the page's CLS score. (Useful when you need more than just
+     * `largestShiftTarget`, `largestShiftTime`, and `largestShiftValue`).
+     */
+    largestShiftEntry?: LayoutShift;
+    /**
+     * The first element source (in document order) among the `sources` list
+     * of the `largestShiftEntry` object. (Also useful when you need more than
+     * just `largestShiftTarget`, `largestShiftTime`, and `largestShiftValue`).
+     */
+    largestShiftSource?: LayoutShiftAttribution;
+    /**
+     * The loading state of the document at the time when the largest layout
+     * shift contribution to the page's CLS score occurred (see `LoadState`
+     * for details).
+     */
+    loadState?: LoadState;
+}
+/**
+ * A CLS-specific version of the Metric object with attribution.
+ */
+export interface CLSMetricWithAttribution extends CLSMetric {
+    attribution: CLSAttribution;
+}
+//# sourceMappingURL=cls.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/types/fcp.d.ts

@@ -0,0 +1,47 @@
+import { LoadState, Metric } from './base';
+/**
+ * An FCP-specific version of the Metric object.
+ */
+export interface FCPMetric extends Metric {
+    name: 'FCP';
+    entries: PerformancePaintTiming[];
+}
+/**
+ * An object containing potentially-helpful debugging information that
+ * can be sent along with the FCP value for the current page visit in order
+ * to help identify issues happening to real-users in the field.
+ */
+export interface FCPAttribution {
+    /**
+     * The time from when the user initiates loading the page until when the
+     * browser receives the first byte of the response (a.k.a. TTFB).
+     */
+    timeToFirstByte: number;
+    /**
+     * The delta between TTFB and the first contentful paint (FCP).
+     */
+    firstByteToFCP: number;
+    /**
+     * The loading state of the document at the time when FCP `occurred (see
+     * `LoadState` for details). Ideally, documents can paint before they finish
+     * loading (e.g. the `loading` or `dom-interactive` phases).
+     */
+    loadState: LoadState;
+    /**
+     * The `PerformancePaintTiming` entry corresponding to FCP.
+     */
+    fcpEntry?: PerformancePaintTiming;
+    /**
+     * The `navigation` entry of the current page, which is useful for diagnosing
+     * general page load issues. This can be used to access `serverTiming` for example:
+     * navigationEntry?.serverTiming
+     */
+    navigationEntry?: PerformanceNavigationTiming;
+}
+/**
+ * An FCP-specific version of the Metric object with attribution.
+ */
+export interface FCPMetricWithAttribution extends FCPMetric {
+    attribution: FCPAttribution;
+}
+//# sourceMappingURL=fcp.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/types/inp.d.ts

@@ -0,0 +1,150 @@
+import { AttributionReportOpts, LoadState, Metric, ReportOpts } from './base';
+export interface INPReportOpts extends ReportOpts {
+    durationThreshold?: number;
+}
+export interface INPAttributionReportOpts extends AttributionReportOpts {
+    durationThreshold?: number;
+}
+/**
+ * An INP-specific version of the Metric object.
+ */
+export interface INPMetric extends Metric {
+    name: 'INP';
+    entries: PerformanceEventTiming[];
+}
+export interface INPLongestScriptSummary {
+    /**
+     * The longest Long Animation Frame script entry that intersects the INP
+     * interaction.
+     */
+    entry: PerformanceScriptTiming;
+    /**
+     * The INP subpart where the longest script ran.
+     */
+    subpart: 'input-delay' | 'processing-duration' | 'presentation-delay';
+    /**
+     * The amount of time the longest script intersected the INP duration.
+     */
+    intersectingDuration: number;
+}
+/**
+ * An object containing potentially-helpful debugging information that
+ * can be sent along with the INP value for the current page visit in order
+ * to help identify issues happening to real-users in the field.
+ */
+export interface INPAttribution {
+    /**
+     * By default, a selector identifying the element that the user first
+     * interacted with as part of the frame where the INP candidate interaction
+     * occurred. If this value is an empty string, that generally means the
+     * element was removed from the DOM after the interaction. If the
+     * `generateTarget` configuration option was passed, then this will instead
+     * be the return value of that function, falling back to the default if that
+     * returns null or undefined.
+     */
+    interactionTarget: string;
+    /**
+     * The time when the user first interacted during the frame where the INP
+     * candidate interaction occurred (if more than one interaction occurred
+     * within the frame, only the first time is reported).
+     */
+    interactionTime: DOMHighResTimeStamp;
+    /**
+     * The type of interaction, based on the event type of the `event` entry
+     * that corresponds to the interaction (i.e. the first `event` entry
+     * containing an `interactionId` dispatched in a given animation frame).
+     * For "pointerdown", "pointerup", or "click" events this will be "pointer",
+     * and for "keydown" or "keyup" events this will be "keyboard".
+     */
+    interactionType: 'pointer' | 'keyboard';
+    /**
+     * The best-guess timestamp of the next paint after the interaction.
+     * In general, this timestamp is the same as the `startTime + duration` of
+     * the event timing entry. However, since duration values are rounded to the
+     * nearest 8ms (and can be rounded down), this value is clamped to always be
+     * reported after the processing times.
+     */
+    nextPaintTime: DOMHighResTimeStamp;
+    /**
+     * An array of Event Timing entries that were processed within the same
+     * animation frame as the INP candidate interaction.
+     */
+    processedEventEntries: PerformanceEventTiming[];
+    /**
+     * The time from when the user interacted with the page until when the
+     * browser was first able to start processing event listeners for that
+     * interaction. This time captures the delay before event processing can
+     * begin due to the main thread being busy with other work.
+     */
+    inputDelay: number;
+    /**
+     * The time from when the first event listener started running in response to
+     * the user interaction until when all event listener processing has finished.
+     */
+    processingDuration: number;
+    /**
+     * The time from when the browser finished processing all event listeners for
+     * the user interaction until the next frame is presented on the screen and
+     * visible to the user. This time includes work on the main thread (such as
+     * `requestAnimationFrame()` callbacks, `ResizeObserver` and
+     * `IntersectionObserver` callbacks, and style/layout calculation) as well
+     * as off-main-thread work (such as compositor, GPU, and raster work).
+     */
+    presentationDelay: number;
+    /**
+     * The loading state of the document at the time when the interaction
+     * corresponding to INP occurred (see `LoadState` for details). If the
+     * interaction occurred while the document was loading and executing script
+     * (e.g. usually in the `dom-interactive` phase) it can result in long delays.
+     */
+    loadState: LoadState;
+    /**
+     * If the browser supports the Long Animation Frame API, this array will
+     * include any `long-animation-frame` entries that intersect with the INP
+     * candidate interaction's `startTime` and the `processingEnd` time of the
+     * last event processed within that animation frame. If the browser does not
+     * support the Long Animation Frame API or no `long-animation-frame` entries
+     * are detected, this array will be empty.
+     */
+    longAnimationFrameEntries: PerformanceLongAnimationFrameTiming[];
+    /**
+     * Summary information about the longest script entry intersecting the INP
+     * duration. Note, only script entries above 5 milliseconds are reported by
+     * the Long Animation Frame API.
+     */
+    longestScript?: INPLongestScriptSummary;
+    /**
+     * The total duration of Long Animation Frame scripts that intersect the INP
+     * duration excluding any forced style and layout (that is included in
+     * totalStyleAndLayout). Note, this is limited to scripts > 5 milliseconds.
+     */
+    totalScriptDuration?: number;
+    /**
+     * The total style and layout duration from any Long Animation Frames
+     * intersecting the INP interaction. This includes any end-of-frame style and
+     * layout duration + any forced style and layout duration.
+     */
+    totalStyleAndLayoutDuration?: number;
+    /**
+     * The off main-thread presentation delay from the end of the last Long
+     * Animation Frame (where available) until the INP end point.
+     */
+    totalPaintDuration?: number;
+    /**
+     * The total unattributed time not included in any of the previous totals.
+     * This includes scripts < 5 milliseconds and other timings not attributed
+     * by Long Animation Frame (including when a frame is < 50ms and so has no
+     * Long Animation Frame).
+     * When no Long Animation Frames are present this will be undefined, rather
+     * than everything being unattributed to make it clearer when it's expected
+     * to be small.
+     */
+    totalUnattributedDuration?: number;
+}
+/**
+ * An INP-specific version of the Metric object with attribution.
+ */
+export interface INPMetricWithAttribution extends INPMetric {
+    attribution: INPAttribution;
+}
+//# sourceMappingURL=inp.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/types/lcp.d.ts

@@ -0,0 +1,74 @@
+import { Metric } from './base.js';
+/**
+ * An LCP-specific version of the Metric object.
+ */
+export interface LCPMetric extends Metric {
+    name: 'LCP';
+    entries: LargestContentfulPaint[];
+}
+/**
+ * An object containing potentially-helpful debugging information that
+ * can be sent along with the LCP value for the current page visit in order
+ * to help identify issues happening to real-users in the field.
+ */
+export interface LCPAttribution {
+    /**
+     * By default, a selector identifying the element corresponding to the
+     * largest contentful paint for the page. If the `generateTarget`
+     * configuration option was passed, then this will instead be the return
+     * value of that function, falling back to the default if that returns null
+     * or undefined.
+     */
+    target?: string;
+    /**
+     * The URL (if applicable) of the LCP image resource. If the LCP element
+     * is a text node, this value will not be set.
+     */
+    url?: string;
+    /**
+     * The time from when the user initiates loading the page until when the
+     * browser receives the first byte of the response (a.k.a. TTFB). See
+     * [Optimize LCP](https://web.dev/articles/optimize-lcp) for details.
+     */
+    timeToFirstByte: number;
+    /**
+     * The delta between TTFB and when the browser starts loading the LCP
+     * resource (if there is one, otherwise 0). See [Optimize
+     * LCP](https://web.dev/articles/optimize-lcp) for details.
+     */
+    resourceLoadDelay: number;
+    /**
+     * The total time it takes to load the LCP resource itself (if there is one,
+     * otherwise 0). See [Optimize LCP](https://web.dev/articles/optimize-lcp) for
+     * details.
+     */
+    resourceLoadDuration: number;
+    /**
+     * The delta between when the LCP resource finishes loading until the LCP
+     * element is fully rendered. See [Optimize
+     * LCP](https://web.dev/articles/optimize-lcp) for details.
+     */
+    elementRenderDelay: number;
+    /**
+     * The `navigation` entry of the current page, which is useful for diagnosing
+     * general page load issues. This can be used to access `serverTiming` for example:
+     * navigationEntry?.serverTiming
+     */
+    navigationEntry?: PerformanceNavigationTiming;
+    /**
+     * The `resource` entry for the LCP resource (if applicable), which is useful
+     * for diagnosing resource load issues.
+     */
+    lcpResourceEntry?: PerformanceResourceTiming;
+    /**
+     * The `LargestContentfulPaint` entry corresponding to LCP.
+     */
+    lcpEntry?: LargestContentfulPaint;
+}
+/**
+ * An LCP-specific version of the Metric object with attribution.
+ */
+export interface LCPMetricWithAttribution extends LCPMetric {
+    attribution: LCPAttribution;
+}
+//# sourceMappingURL=lcp.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/types/ttfb.d.ts

@@ -0,0 +1,60 @@
+import { Metric } from './base';
+/**
+ * A TTFB-specific version of the Metric object.
+ */
+export interface TTFBMetric extends Metric {
+    name: 'TTFB';
+    entries: PerformanceNavigationTiming[];
+}
+/**
+ * An object containing potentially-helpful debugging information that
+ * can be sent along with the TTFB value for the current page visit in order
+ * to help identify issues happening to real-users in the field.
+ *
+ * NOTE: these values are primarily useful for page loads not handled via
+ * service worker, as browsers differ in what they report when service worker
+ * is involved, see: https://github.com/w3c/navigation-timing/issues/199
+ */
+export interface TTFBAttribution {
+    /**
+     * The total time from when the user initiates loading the page to when the
+     * page starts to handle the request. Large values here are typically due
+     * to HTTP redirects, though other browser processing contributes to this
+     * duration as well (so even without redirect it's generally not zero).
+     */
+    waitingDuration: number;
+    /**
+     * The total time spent checking the HTTP cache for a match. For navigations
+     * handled via service worker, this duration usually includes service worker
+     * start-up time as well as time processing `fetch` event listeners, with
+     * some exceptions, see: https://github.com/w3c/navigation-timing/issues/199
+     */
+    cacheDuration: number;
+    /**
+     * The total time to resolve the DNS for the requested domain.
+     */
+    dnsDuration: number;
+    /**
+     * The total time to create the connection to the requested domain.
+     */
+    connectionDuration: number;
+    /**
+     * The total time from when the request was sent until the first byte of the
+     * response was received. This includes network time as well as server
+     * processing time.
+     */
+    requestDuration: number;
+    /**
+     * The `navigation` entry of the current page, which is useful for diagnosing
+     * general page load issues. This can be used to access `serverTiming` for
+     * example: navigationEntry?.serverTiming
+     */
+    navigationEntry?: PerformanceNavigationTiming;
+}
+/**
+ * A TTFB-specific version of the Metric object with attribution.
+ */
+export interface TTFBMetricWithAttribution extends TTFBMetric {
+    attribution: TTFBAttribution;
+}
+//# sourceMappingURL=ttfb.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/types.d.ts

@@ -0,0 +1,78 @@
+export * from './types/base';
+export * from './types/cls';
+export * from './types/fcp';
+export * from './types/inp';
+export * from './types/lcp';
+export * from './types/ttfb';
+interface PerformanceEntryMap {
+    navigation: PerformanceNavigationTiming;
+    resource: PerformanceResourceTiming;
+    paint: PerformancePaintTiming;
+}
+declare global {
+    interface Document {
+        prerendering?: boolean;
+        wasDiscarded?: boolean;
+    }
+    interface Performance {
+        getEntriesByType<K extends keyof PerformanceEntryMap>(type: K): PerformanceEntryMap[K][];
+    }
+    interface PerformanceObserverInit {
+        durationThreshold?: number;
+    }
+    interface PerformanceNavigationTiming {
+        activationStart?: number;
+    }
+    interface PerformanceEventTiming extends PerformanceEntry {
+        duration: DOMHighResTimeStamp;
+        interactionId: number;
+    }
+    interface LayoutShiftAttribution {
+        node: Node | null;
+        previousRect: DOMRectReadOnly;
+        currentRect: DOMRectReadOnly;
+    }
+    interface LayoutShift extends PerformanceEntry {
+        value: number;
+        sources: LayoutShiftAttribution[];
+        hadRecentInput: boolean;
+    }
+    interface LargestContentfulPaint extends PerformanceEntry {
+        readonly renderTime: DOMHighResTimeStamp;
+        readonly loadTime: DOMHighResTimeStamp;
+        readonly size: number;
+        readonly id: string;
+        readonly url: string;
+        readonly element: Element | null;
+    }
+    export type ScriptInvokerType = 'classic-script' | 'module-script' | 'event-listener' | 'user-callback' | 'resolve-promise' | 'reject-promise';
+    export type ScriptWindowAttribution = 'self' | 'descendant' | 'ancestor' | 'same-page' | 'other';
+    interface PerformanceScriptTiming extends PerformanceEntry {
+        readonly startTime: DOMHighResTimeStamp;
+        readonly duration: DOMHighResTimeStamp;
+        readonly name: string;
+        readonly entryType: string;
+        readonly invokerType: ScriptInvokerType;
+        readonly invoker: string;
+        readonly executionStart: DOMHighResTimeStamp;
+        readonly sourceURL: string;
+        readonly sourceFunctionName: string;
+        readonly sourceCharPosition: number;
+        readonly pauseDuration: DOMHighResTimeStamp;
+        readonly forcedStyleAndLayoutDuration: DOMHighResTimeStamp;
+        readonly window?: Window;
+        readonly windowAttribution: ScriptWindowAttribution;
+    }
+    interface PerformanceLongAnimationFrameTiming extends PerformanceEntry {
+        readonly startTime: DOMHighResTimeStamp;
+        readonly duration: DOMHighResTimeStamp;
+        readonly name: string;
+        readonly entryType: string;
+        readonly renderStart: DOMHighResTimeStamp;
+        readonly styleAndLayoutStart: DOMHighResTimeStamp;
+        readonly blockingDuration: DOMHighResTimeStamp;
+        readonly firstUIEventTimestamp: DOMHighResTimeStamp;
+        readonly scripts: PerformanceScriptTiming[];
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/metrics/webVitalSpans.d.ts

@@ -0,0 +1,65 @@
+import { Client, Span, SpanAttributes } from '@sentry/core';
+import { WebVitalReportEvent } from './utils';
+import { PerformanceEventTiming } from './instrument';
+export interface LayoutShift extends PerformanceEntry {
+    value: number;
+    sources: Array<{
+        node: Node | null;
+    }>;
+    hadRecentInput: boolean;
+}
+export interface LargestContentfulPaint extends PerformanceEntry {
+    readonly renderTime: DOMHighResTimeStamp;
+    readonly loadTime: DOMHighResTimeStamp;
+    readonly size: number;
+    readonly id: string;
+    readonly url: string;
+    readonly element: Element | null;
+}
+interface WebVitalSpanOptions {
+    name: string;
+    op: string;
+    origin: string;
+    metricName: 'lcp' | 'cls' | 'inp';
+    value: number;
+    attributes?: SpanAttributes;
+    parentSpan?: Span;
+    reportEvent?: WebVitalReportEvent;
+    startTime: number;
+    endTime?: number;
+}
+/**
+ * Emits a web vital span that flows through the span streaming pipeline.
+ */
+export declare function _emitWebVitalSpan(options: WebVitalSpanOptions): void;
+/**
+ * Tracks LCP as a streamed span.
+ */
+export declare function trackLcpAsSpan(client: Client): void;
+/**
+ * Exported only for testing.
+ */
+export declare function _sendLcpSpan(lcpValue: number, entry: LargestContentfulPaint | undefined, pageloadSpan?: Span, reportEvent?: WebVitalReportEvent): void;
+/**
+ * Tracks CLS as a streamed span.
+ */
+export declare function trackClsAsSpan(client: Client): void;
+/**
+ * Exported only for testing.
+ */
+export declare function _sendClsSpan(clsValue: number, entry: LayoutShift | undefined, pageloadSpan?: Span, reportEvent?: WebVitalReportEvent): void;
+/**
+ * Tracks INP as a streamed span.
+ *
+ * This mirrors the standalone INP tracking logic (`startTrackingINP`) but emits
+ * spans through the streaming pipeline instead of as standalone spans.
+ * Requires `registerInpInteractionListener()` to be called separately for
+ * cached element names and root spans per interaction.
+ */
+export declare function trackInpAsSpan(): void;
+/**
+ * Exported only for testing.
+ */
+export declare function _sendInpSpan(inpValue: number, entry: PerformanceEventTiming): void;
+export {};
+//# sourceMappingURL=webVitalSpans.d.ts.map

package/build/types-ts3.8/networkUtils.d.ts

@@ -0,0 +1,28 @@
+import { debug } from '@sentry/core';
+import { NetworkMetaWarning } from './types';
+export declare const ORIGINAL_REQ_BODY: unique symbol;
+/**
+ * Serializes FormData.
+ *
+ * This is a bit simplified, but gives us a decent estimate.
+ * This converts e.g. { name: 'Anne Smith', age: 13 } to 'name=Anne+Smith&age=13'.
+ *
+ */
+export declare function serializeFormData(formData: FormData): string;
+/** Get the string representation of a body. */
+export declare function getBodyString(body: unknown, _debug?: typeof debug): [
+    string | undefined,
+    NetworkMetaWarning?
+];
+/**
+ * Parses the fetch arguments to extract the request payload.
+ *
+ * In case of a Request object, this function attempts to retrieve the original body by looking for a Sentry-patched symbol.
+ */
+export declare function getFetchRequestArgBody(fetchArgs?: unknown[]): RequestInit['body'] | undefined;
+/**
+ * Parses XMLHttpRequest response headers into a Record.
+ * Extracted from replay internals to be reusable.
+ */
+export declare function parseXhrResponseHeaders(xhr: XMLHttpRequest): Record<string, string>;
+//# sourceMappingURL=networkUtils.d.ts.map