@atlaskit/react-ufo 1.1.0 → 2.0.1

package/dist/types/ssr/index.d.ts

@@ -0,0 +1,21 @@
+export type FeatureFlagValue = boolean | string | number | Record<any, any>;
+export type ReportedTiming = {
+    startTime: number;
+    duration: number;
+};
+export type ReportedTimings = {
+    [key: string]: ReportedTiming;
+};
+export type SSRFeatureFlags = {
+    [key: string]: FeatureFlagValue;
+};
+export type SSRConfig = {
+    getDoneMark: () => number | null;
+    getFeatureFlags: () => SSRFeatureFlags | null;
+    getTimings?: () => ReportedTimings | null;
+};
+export declare function configure(ssrConfig: SSRConfig): void;
+export declare function getSSRTimings(): ReportedTimings;
+export declare function getSSRSuccess(): boolean;
+export declare function getSSRDoneTime(): number | undefined;
+export declare function getSSRFeatureFlags(): SSRFeatureFlags | undefined;

package/dist/types/trace-interaction/index.d.ts

@@ -0,0 +1,2 @@
+import type { UIEvent } from 'react';
+export default function traceUFOInteraction(name: string, event: UIEvent): void;

package/dist/types/trace-pageload/index.d.ts

@@ -0,0 +1,2 @@
+export default function traceUFOPageLoad(ufoName?: string | null | undefined, routeName?: string | null | undefined): void;
+export declare function updatePageloadName(ufoName: string, routeName?: string | null | undefined): void;

package/dist/types/trace-press/index.d.ts

@@ -0,0 +1 @@
+export default function traceUFOPress(name: string, timestamp?: number): void;

package/dist/types/trace-redirect/index.d.ts

@@ -0,0 +1 @@
+export default function traceUFORedirect(fromUfoName: string, nextUfoName: string, nextRouteName: string, time: number): void;

package/dist/types/trace-transition/index.d.ts

@@ -0,0 +1,2 @@
+export default function traceUFOTransition(ufoName: string | null | undefined, routeName?: string | null | undefined): void;
+export declare function useUFOTransitionCompleter(): void;

package/dist/types/trace-transition/utils/generate-span-id/index.d.ts

@@ -0,0 +1 @@
+export declare const generateSpanId: () => string;

package/dist/types/trace-transition/utils/set-interaction-active-trace/index.d.ts

@@ -0,0 +1 @@
+export declare const setInteractionActiveTrace: (newId: string) => void;

package/dist/types/typing-performance-tracing/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function useUFOTypingPerformanceTracing<T extends HTMLElement>(name: string): import("react").RefObject<T>;

package/dist/types/use-press-tracing/index.d.ts

@@ -0,0 +1 @@
+export default function usePressTracing(name: string): (timeStamp?: number) => void;

package/dist/types/vc/index.d.ts

@@ -0,0 +1,2 @@
+import { VCObserver, type VCObserverOptions } from './vc-observer';
+export declare const getVCObserver: (opts?: VCObserverOptions) => VCObserver;

package/dist/types/vc/vc-observer/attachAbortListeners.d.ts

@@ -0,0 +1,6 @@
+import { type UnbindFn } from 'bind-event-listener';
+import { AbortEvent } from '../../common/vc/types';
+export declare const attachAbortListeners: (window: Window, initialViewPort: {
+    w: number;
+    h: number;
+}, callback: (key: keyof typeof AbortEvent, time: number) => void) => UnbindFn[];

package/dist/types/vc/vc-observer/getViewport.d.ts

@@ -0,0 +1,2 @@
+export declare function getViewportWidth(document?: Document): number;
+export declare function getViewportHeight(document?: Document): number;

package/dist/types/vc/vc-observer/index.d.ts

@@ -0,0 +1,98 @@
+import { type UnbindFn } from 'bind-event-listener';
+import type { ComponentsLogType, VCAbortReasonType, VCEntryType, VCIgnoreReason, VCRatioType, VCRawDataType, VCResult } from '../../common/vc/types';
+import { Observers, type SelectorConfig } from './observers';
+type GetVCResultType = {
+    start: number;
+    stop: number;
+    tti: number;
+    prefix?: string;
+    ssr?: number;
+    vc?: VCRawDataType | null;
+};
+export type VCObserverOptions = {
+    heatmapSize?: number | undefined;
+    oldDomUpdates?: boolean | undefined;
+    devToolsEnabled?: boolean | undefined;
+    selectorConfig?: SelectorConfig | undefined;
+    isPostInteraction?: boolean;
+};
+export declare class VCObserver {
+    abortReason: VCAbortReasonType;
+    outOfBoundaryInfo: string;
+    /** config * */
+    static VCParts: string[];
+    viewport: {
+        w: number;
+        h: number;
+    };
+    arraySize: number;
+    heatmap: number[][];
+    ssrInclusiveHeatmap: number[][];
+    componentsLog: ComponentsLogType;
+    vcRatios: VCRatioType;
+    active: boolean;
+    totalTime: number;
+    startTime: number;
+    observers: Observers;
+    private _startMeasureTimestamp;
+    ssr: {
+        reactRendered: number;
+    };
+    devToolsEnabled: boolean;
+    oldDomUpdatesEnabled: boolean;
+    unbind: UnbindFn[];
+    isPostInteraction?: boolean;
+    constructor(options: VCObserverOptions);
+    start({ startTime }: {
+        startTime: number;
+    }): void;
+    stop(): void;
+    getAbortReasonInfo: () => string | null;
+    getVCRawData: () => VCRawDataType | null;
+    getIgnoredElements(componentsLog: ComponentsLogType): {
+        targetName: string;
+        ignoreReason: VCIgnoreReason | undefined;
+    }[];
+    getVCResult: ({ start, stop, tti, prefix, ssr, vc }: GetVCResultType) => VCResult;
+    static calculateVC({ heatmap, ssr, componentsLog, viewport, }: {
+        heatmap: number[][];
+        ssr?: number;
+        componentsLog: ComponentsLogType;
+        viewport: {
+            w: number;
+            h: number;
+        };
+    }): {
+        VC: {
+            [key: string]: number | null;
+        };
+        VCBox: {
+            [key: string]: string[] | null;
+        };
+        VCEntries: {
+            abs: number[][];
+            rel: VCEntryType[];
+        };
+        totalPainted: number;
+    };
+    setSSRElement(element: HTMLElement): void;
+    setReactRootRenderStart(startTime?: number): void;
+    setReactRootRenderStop(stopTime?: number): void;
+    private handleUpdate;
+    private setAbortReason;
+    private resetState;
+    private getCleanHeatmap;
+    private setViewportSize;
+    private mapPixelsToHeatmap;
+    private getElementRatio;
+    private applyChangesToHeatMap;
+    static makeVCReturnObj<T>(): {
+        [key: string]: T | null;
+    };
+    private abortReasonCallback;
+    private attachAbortListeners;
+    private detachAbortListeners;
+    private measureStart;
+    private measureStop;
+}
+export {};

package/dist/types/vc/vc-observer/media-wrapper/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    children: React.ReactNode;
+};
+export declare const MEDIA_WRAPPER_TAG = "data-media-vc-wrapper";
+export default function MediaWrapper({ children }: Props): JSX.Element;
+export {};

package/dist/types/vc/vc-observer/media-wrapper/vc-utils.d.ts

@@ -0,0 +1 @@
+export declare const isContainedWithinMediaWrapper: (node: Node | null) => boolean;

package/dist/types/vc/vc-observer/observers/index.d.ts

@@ -0,0 +1,39 @@
+import type { BrowserObservers, Callback } from './types';
+export type SelectorConfig = {
+    id: boolean;
+    testId: boolean;
+    role: boolean;
+    className: boolean;
+    dataVC?: boolean;
+};
+type ConstructorOptions = {
+    selectorConfig: SelectorConfig;
+};
+export declare class Observers implements BrowserObservers {
+    private intersectionObserver;
+    private mutationObserver;
+    private observedMutations;
+    private elementsInView;
+    private callbacks;
+    private totalTime;
+    private _startMeasureTimestamp;
+    private ssrPlaceholderHandler;
+    private ssr;
+    private selectorConfig;
+    constructor(opts: ConstructorOptions);
+    isBrowserSupported(): boolean;
+    observe(): void;
+    disconnect(): void;
+    subscribeResults: (cb: Callback) => void;
+    getTotalTime(): number;
+    setReactRootElement(element: HTMLElement): void;
+    setReactRootRenderStart(startTime?: number): void;
+    setReactRootRenderStop(stopTime?: number): void;
+    private observeElement;
+    private getMutationObserver;
+    private getElementName;
+    private getIntersectionObserver;
+    private measureStart;
+    private measureStop;
+}
+export {};

package/dist/types/vc/vc-observer/observers/ssr-placeholders/index.d.ts

@@ -0,0 +1,23 @@
+export declare class SSRPlaceholderHandlers {
+    private staticPlaceholders;
+    private callbacks;
+    private getSizeCallbacks;
+    private reactValidateCallbacks;
+    private intersectionObserver;
+    constructor();
+    clear(): void;
+    isPlaceholder(element: HTMLElement): boolean;
+    isPlaceholderReplacement(element: HTMLElement): boolean;
+    isPlaceholderIgnored(element: HTMLElement): boolean;
+    findNearestPlaceholderContainerIfIgnored(element: HTMLElement): HTMLElement;
+    checkIfExistedAndSizeMatching(el: HTMLElement): Promise<unknown>;
+    getSize(el: HTMLElement): Promise<unknown>;
+    validateReactComponentMatchToPlaceholder(el: HTMLElement): Promise<unknown>;
+    hasSameSizePosition(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | undefined, boundingClientRect: DOMRectReadOnly): boolean;
+    intersectionObserverCallback: ({ target, boundingClientRect }: IntersectionObserverEntry) => void;
+}

package/dist/types/vc/vc-observer/observers/ssr-placeholders/ssr-scripts/bindAbortListeners.d.ts

@@ -0,0 +1 @@
+export declare function bindAbortListeners(document: Document, window: Window): void;

package/dist/types/vc/vc-observer/observers/ssr-placeholders/ssr-scripts/collectSSRPlaceholderDimensions.d.ts

@@ -0,0 +1 @@
+export declare function collectSSRPlaceholderDimensions(document: Document, window: Window): void;

package/dist/types/vc/vc-observer/observers/ssr-placeholders/ssr-scripts/index.d.ts

@@ -0,0 +1,2 @@
+export { collectSSRPlaceholderDimensions } from './collectSSRPlaceholderDimensions';
+export { bindAbortListeners } from './bindAbortListeners';

package/dist/types/vc/vc-observer/observers/types.d.ts

@@ -0,0 +1,11 @@
+import { type VCIgnoreReason } from '../../../common/vc/types';
+export type Callback = (time: number, box: DOMRectReadOnly, targetName: string, node: HTMLElement, ignoreReason?: VCIgnoreReason) => void;
+export type MutationRecordWithTimestamp = MutationRecord & {
+    timestamp?: number;
+};
+export interface BrowserObservers {
+    observe: () => void;
+    disconnect: () => void;
+    subscribeResults: (cb: Callback) => void;
+    getTotalTime: () => number;
+}

package/dist/types-ts4.5/additional-payload/index.d.ts

@@ -0,0 +1,2 @@
+export { startLighthouseObserver, getLighthouseMetrics } from './utils/lighthouse-metrics';
+export { getCacheHitRatio } from './utils/cache-hit-ratio';

package/dist/types-ts4.5/additional-payload/utils/cache-hit-ratio/index.d.ts

@@ -0,0 +1,8 @@
+type CacheHitRatio = {
+    cacheHitRatio?: number;
+    preloadCacheHitRatio?: number;
+};
+export declare const getCacheHitRatio: ({ start }: {
+    start: number;
+}) => CacheHitRatio;
+export {};

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/cls/index.d.ts

@@ -0,0 +1,2 @@
+import type { PerformanceEntryBuffer } from '../utils/buffer';
+export declare const getCLS: (start: number, stop: number, buffer: PerformanceEntryBuffer) => number;

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/cls/types.d.ts

@@ -0,0 +1,3 @@
+export interface LayoutShiftPerformanceEntry extends PerformanceEntry {
+    value: number;
+}

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/const.d.ts

@@ -0,0 +1,5 @@
+export declare const PerformanceObserverEntryTypes: {
+    readonly LayoutShift: "layout-shift";
+    readonly LongTask: "longtask";
+};
+export type PerformanceObserverEntryTypes = (typeof PerformanceObserverEntryTypes)[keyof typeof PerformanceObserverEntryTypes];

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/index.d.ts

@@ -0,0 +1,7 @@
+export declare function startLighthouseObserver(): void;
+export declare const getLighthouseMetrics: ({ start, stop, }: {
+    start: number;
+    stop: number;
+}) => {
+    [key: string]: number;
+};

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/tbt/index.d.ts

@@ -0,0 +1,5 @@
+import type { PerformanceEntryBuffer } from '../utils/buffer';
+export declare const getTBT: (start: number, stop: number, buffer: PerformanceEntryBuffer) => {
+    total: number;
+    observed: number;
+};

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/utils/buffer/index.d.ts

@@ -0,0 +1,13 @@
+export declare class BufferWithMaxLength<T> {
+    buffer: Array<T>;
+    maxLength: number;
+    full: boolean;
+    constructor(maxLength?: number);
+    push(item: T): void;
+    getAll(): T[];
+}
+export type EntriesBufferType = {
+    [key: string]: BufferWithMaxLength<PerformanceEntry>;
+};
+export type PerformanceEntryBuffer = BufferWithMaxLength<PerformanceEntry>;
+export declare const EntriesBuffer: EntriesBufferType;

package/dist/types-ts4.5/additional-payload/utils/lighthouse-metrics/utils/observer/index.d.ts

@@ -0,0 +1,2 @@
+export declare const startLSObserver: () => void;
+export declare const startLTObserver: () => void;

package/dist/types-ts4.5/bundle-eval-timing/index.d.ts

@@ -0,0 +1,16 @@
+type MappedPerformanceMark = {
+    type: 'start' | 'end';
+    name: string;
+};
+export type BundleEvalTimingsConfig = {
+    mapPerformanceMark: (mark: string) => MappedPerformanceMark | null;
+};
+type ReportedTimings = {
+    [key: string]: {
+        startTime: number;
+        duration: number;
+    };
+};
+export declare function configure(bundleEvalTimingConfiguration: BundleEvalTimingsConfig): void;
+export declare function getBundleEvalTimings(interactionStartTime: number): ReportedTimings;
+export {};

package/dist/types-ts4.5/coinflip/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A random function that passes one in rate times.
+ * E.g. coinflip(2) is the same as if you flipped a coin.
+ * It will pass 50% of the time
+ * @param rate The change that it will pass (1 in <rate> times)
+ * @returns bool, if it passes or not
+ */
+export default function coinflip(rate: number): boolean;

package/dist/types-ts4.5/common/common/types.d.ts

@@ -0,0 +1,201 @@
+import type { TraceIdContext } from '../../experience-trace-id-context';
+import type { LabelStack, UFOInteractionContextType } from '../../interaction-context';
+import { type VCRawDataType, type VCResult } from '../vc/types';
+export type LifecycleMarkType = 'render' | 'beforePaint' | 'afterPaint' | 'nextTick' | 'mount' | 'commit';
+export type MarkType = ('placeholder' | 'bm3_stop' | 'bundle_preload' | 'custom') | LifecycleMarkType;
+export type SpanType = 'placeholder' | 'relay' | 'hidden_timing' | 'bundle_load' | 'graphql' | 'fetch' | 'reducer' | 'custom';
+export type InteractionType = 'page_load' | 'press' | 'typing' | 'transition' | 'segment';
+export type AbortReasonType = 'new_interaction' | 'unload' | 'transition' | 'timeout' | 'excluded_by_sampling';
+export interface ReactProfilerTiming {
+    type: 'mount' | 'update' | 'nested-update';
+    actualDuration: number;
+    baseDuration: number;
+    startTime: number;
+    commitTime: number;
+    labelStack: LabelStack;
+}
+export interface Span {
+    type: SpanType;
+    name: string;
+    labelStack: LabelStack | null;
+    start: number;
+    end: number;
+    size?: number;
+}
+export interface Mark {
+    type: MarkType;
+    name: string;
+    labelStack: LabelStack | null;
+    time: number;
+}
+export interface InteractionError {
+    name: string;
+    labelStack: LabelStack | null;
+    errorType: string;
+    errorMessage: string;
+    errorStack?: string;
+    forcedError?: boolean;
+}
+interface FlushInfo {
+    label?: string;
+    size: number;
+    time: number;
+}
+export interface RequestInfo {
+    name: string;
+    start: number;
+    flushes: FlushInfo[];
+    networkStart?: number;
+    networkComplete?: number;
+    fetchStart?: number;
+    end?: number;
+    size?: number;
+    error?: Error;
+}
+type FeatureFlagValue = boolean | string | number | Record<any, any> | 'non_boolean';
+export interface ApdexType {
+    key: string;
+    startTime?: number;
+    stopTime: number;
+    labelStack?: LabelStack;
+}
+export interface SegmentInfo {
+    labelStack: LabelStack;
+}
+export interface CustomData {
+    [key: string]: null | undefined | string | number | boolean | undefined | CustomData | Record<string, CustomData>;
+}
+export type CustomTiming = Record<string, {
+    startTime: number;
+    endTime: number;
+}>;
+export interface HoldActive {
+    labelStack: LabelStack;
+    name: string;
+    start: number;
+    ignoreOnSubmit?: boolean;
+}
+export type HoldInfo = HoldActive & {
+    end: number;
+};
+export interface Redirect {
+    fromInteractionName: string;
+    time: number;
+}
+export interface InteractionMetrics {
+    id: string;
+    start: number;
+    end: number;
+    ufoName: string;
+    previousInteractionName?: string;
+    isPreviousInteractionAborted: boolean;
+    type: InteractionType;
+    marks: Mark[];
+    customData: {
+        labelStack: LabelStack;
+        data: CustomData;
+    }[];
+    customTimings: {
+        labelStack: LabelStack;
+        data: CustomTiming;
+    }[];
+    spans: Span[];
+    requestInfo: (RequestInfo & {
+        labelStack: LabelStack;
+    })[];
+    holdInfo: HoldInfo[];
+    holdActive: Map<string, HoldActive>;
+    reactProfilerTimings: ReactProfilerTiming[];
+    measureStart: number;
+    rate: number;
+    cancelCallbacks: (() => void)[];
+    cleanupCallbacks: (() => void)[];
+    metaData: Record<string, unknown>;
+    errors: InteractionError[];
+    abortReason?: AbortReasonType;
+    abortedByInteractionName?: string;
+    /**
+     * Apdex is legacy performance measurement where it is
+     * capturing TTI at arbitrary point in the code (bm3/UFOv1)
+     *
+     * We are intercepting its values now just so we can use it for
+     * topline metric, but should encourage teams adopt TTAI
+     *
+     * This field might be ignored/dropped in the future.
+     */
+    apdex: ApdexType[];
+    /**
+     * LabelStack is a stack of labels that are used to identify the
+     * breadcrumb of segments of the current interaction.
+     * For example, it could look something like:
+     * ```
+     * [
+     *  { name: 'product', segmentId: 'xxx' },
+     *  { name: 'issue-navigator', segmentId: 'xxx' },
+     *  { name: 'ui', segmentId: 'xxx' }
+     * ]
+     * ```
+     */
+    labelStack: LabelStack | null;
+    routeName: string | null;
+    featureFlags?: {
+        prior: Record<string, FeatureFlagValue>;
+        during: Record<string, FeatureFlagValue>;
+    };
+    knownSegments: SegmentInfo[];
+    awaitReactProfilerCount: number;
+    redirects: Redirect[];
+    timerID: ReturnType<typeof setInterval> | undefined;
+    changeTimeout: (newTime: number) => void;
+    trace: TraceIdContext | null;
+    legacyMetrics?: BM3Event[];
+    vc?: VCRawDataType | null;
+}
+export type LoadProfilerEventInfo = {
+    identifier: string;
+};
+export interface RelayMetricsRecorder {
+    retainQuery(info: RequestInfo): void;
+}
+export interface LazyLoadProfilerContext {
+    addPreload(moduleId: string, timestamp: number): void;
+    addLoad(identifier: string, start: number, end: number): void;
+}
+export interface EnhancedUFOInteractionContextType extends UFOInteractionContextType, RelayMetricsRecorder, LazyLoadProfilerContext {
+    _internalHold(labelStack: LabelStack, name: string): void | (() => void);
+    _internalHoldByID(labelStack: LabelStack, id: string, name: string, remove: boolean): void | (() => void);
+    addHoldByID(labelStack: LabelStack, id: string, name?: string): void;
+    removeHoldByID(labelStack: LabelStack, id: string, name?: string): void;
+    onRender: (phase: 'mount' | 'update' | 'nested-update', actualDuration: number, baseDuration: number, startTime: number, commitTime: number) => void;
+    complete(endTime?: number): void;
+}
+export type BM3Event = {
+    key: string;
+    custom: any;
+    config: {
+        timings?: {
+            key: string;
+            startMark?: string;
+            endMark?: string;
+            component?: string;
+        }[];
+        type: string;
+        reactUFOName?: string;
+    };
+    start: number | null;
+    stop: number | null;
+    marks?: {
+        [key: string]: number;
+    };
+    submetrics?: BM3Event[];
+    pageVisibleState?: string;
+    type: string;
+};
+export type LastInteractionFinishInfo = Pick<InteractionMetrics, 'ufoName' | 'start' | 'end' | 'id' | 'abortReason' | 'abortedByInteractionName' | 'routeName' | 'type'>;
+export type PostInteractionLogOutput = {
+    lastInteractionFinish: LastInteractionFinishInfo;
+    reactProfilerTimings?: ReactProfilerTiming[];
+    postInteractionFinishVCResult?: VCResult;
+    lastInteractionFinishVCResult?: VCResult;
+};
+export {};

package/dist/types-ts4.5/common/constants.d.ts

@@ -0,0 +1 @@
+export declare const REACT_UFO_VERSION = "1.0.1";

package/dist/types-ts4.5/common/index.d.ts

@@ -0,0 +1,5 @@
+export type { LifecycleMarkType, MarkType, SpanType, InteractionType, AbortReasonType, CustomTiming, HoldInfo, LoadProfilerEventInfo, ReactProfilerTiming, Span, Mark, InteractionError, RequestInfo, ApdexType, SegmentInfo, CustomData, HoldActive, Redirect, InteractionMetrics, EnhancedUFOInteractionContextType, BM3Event, PostInteractionLogOutput, LastInteractionFinishInfo, } from './common/types';
+/**
+ * @deprecated Prefer import from @atlaskit/react-ufo/interaction-context
+ */
+export type { Label, SegmentLabel, LabelStack } from '../interaction-context';

package/dist/types-ts4.5/common/vc/types.d.ts

@@ -0,0 +1,91 @@
+import type { UnbindFn } from 'bind-event-listener';
+export declare const AbortEvent: {
+    readonly wheel: "wheel";
+    readonly keydown: "keydown";
+    readonly resize: "resize";
+};
+export type VCAbortReason = 'scroll' | 'keypress' | 'resize' | 'error' | 'not-supported';
+export type VCAbortReasonType = {
+    reason: null | VCAbortReason;
+    info: string;
+    timestamp: number;
+    blocking: boolean;
+};
+export type VCRatioType = {
+    [elementName: string]: number;
+};
+export type VCRawDataType = {
+    abortReasonInfo: string | null;
+    abortReason: VCAbortReasonType;
+    heatmap: number[][];
+    oldHeatmap: number[][];
+    outOfBoundaryInfo: string;
+    totalTime: number;
+    componentsLog: ComponentsLogType;
+    viewport: {
+        w: number;
+        h: number;
+    };
+    oldDomUpdatesEnabled: boolean;
+    devToolsEnabled: boolean;
+    ratios: VCRatioType;
+};
+export type VCEntryType = {
+    time: number;
+    vc: number;
+    elements: string[];
+};
+export type VCIgnoreReason = 'image' | 'ssr-hydration' | '';
+export type ComponentsLogEntry = {
+    targetName: string;
+    __debug__element: WeakRef<Element> | null;
+    intersectionRect: DOMRectReadOnly;
+    ignoreReason?: VCIgnoreReason;
+};
+export type VCIgnoredElement = Pick<ComponentsLogEntry, 'targetName' | 'ignoreReason'>;
+export type VCResult = {
+    [key: string]: boolean | number | string | null | VCEntryType[] | VCIgnoredElement[] | {
+        w: number;
+        h: number;
+    } | {
+        [key: string]: boolean | number | string[] | null | VCEntryType[];
+    };
+};
+export type MetricsDevToolsTypes = {
+    '75': number | null;
+    '80': number | null;
+    '85': number | null;
+    '90': number | null;
+    '95': number | null;
+    '98': number | null;
+    '99': number | null;
+    tti: number;
+    ttai: number;
+};
+export type ExperimentalVCDevToolsOptions = {
+    enableLog?: boolean;
+};
+export type ComponentsLogType = {
+    [timestamp: number]: ComponentsLogEntry[];
+};
+declare global {
+    interface Window {
+        __vc?: {
+            entries: VCEntryType[];
+            log: ComponentsLogType;
+            metrics: MetricsDevToolsTypes;
+            heatmap: number[][];
+            ratios: VCRatioType;
+        };
+        __vcNotAvailableReason?: string;
+        __SSR_PLACEHOLDERS_DIMENSIONS__?: {
+            [key: string]: DOMRectReadOnly;
+        };
+        __SSR_ABORT_LISTENERS__?: {
+            unbinds: UnbindFn[];
+            aborts: {
+                [key in keyof typeof AbortEvent]?: number;
+            };
+        };
+    }
+}