@atlaskit/react-ufo 1.1.0 → 2.0.0

package/dist/types-ts4.5/create-post-interaction-log-payload/index.d.ts

@@ -0,0 +1,45 @@
+import { type PostInteractionLogOutput } from '../common';
+export default function createPostInteractionLogPayload({ lastInteractionFinish, reactProfilerTimings, lastInteractionFinishVCResult, postInteractionFinishVCResult, }: PostInteractionLogOutput): {
+    actionSubject: string;
+    action: string;
+    eventType: string;
+    source: string;
+    tags: string[];
+    attributes: {
+        properties: {
+            'event:hostname': string;
+            'event:product': string;
+            'event:schema': string;
+            'event:source': {
+                name: string;
+                version: string;
+                payloadSource: string;
+            };
+            'event:region': string;
+            'experience:key': string;
+            postInteractionLog: {
+                lastInteractionFinish: {
+                    ufoName: string;
+                    start: number;
+                    end: number;
+                    ttai: number;
+                    vc90: number | null;
+                    type: import("../common").InteractionType;
+                    id: string;
+                    abortReason?: import("../common").AbortReasonType | undefined;
+                    abortedByInteractionName?: string | undefined;
+                    routeName: string | null;
+                };
+                revisedEndTime: number;
+                revisedTtai: number;
+                revisedVC90: number | null;
+                lateMutations: {
+                    time: number;
+                    element: string;
+                    viewportHeatmapPercentage: number;
+                }[];
+                reactProfilerTimings: any[];
+            };
+        };
+    };
+} | null;

package/dist/types-ts4.5/custom-data/index.d.ts

@@ -0,0 +1,5 @@
+import { type CustomData } from '../interaction-metrics';
+import type { UFOCustomDataProps } from './types';
+export type { UFOCustomDataProps } from './types';
+export default function UFOCustomData({ data }: UFOCustomDataProps): null;
+export declare function addUFOCustomData(data: CustomData): void;

package/dist/types-ts4.5/custom-data/types.d.ts

@@ -0,0 +1,4 @@
+import type { CustomData } from '../interaction-metrics';
+export type UFOCustomDataProps = {
+    data: CustomData;
+};

package/dist/types-ts4.5/custom-mark/index.d.ts

@@ -0,0 +1,10 @@
+export default function UFOCustomMark({ name, timestamp }: {
+    name: string;
+    timestamp?: number;
+}): null;
+export declare function UFOCustomMarks({ data }: {
+    data: {
+        [key: string]: number;
+    } | undefined;
+}): null;
+export declare function addUFOCustomMark(name: string, timestamp?: number): void;

package/dist/types-ts4.5/custom-spans/index.d.ts

@@ -0,0 +1 @@
+export declare function addCustomSpans(name: string, start: number, end?: number, size?: number): void;

package/dist/types-ts4.5/custom-timings/index.d.ts

@@ -0,0 +1,19 @@
+export type BM3Marks = {
+    [key: string]: number;
+};
+export type BM3TimingsConfig = {
+    key: string;
+    startMark?: string;
+    endMark?: string;
+};
+export declare function getBm3Timings(marks?: BM3Marks, timingConfigs?: BM3TimingsConfig[]): {
+    [key: string]: {
+        startTime: number;
+        endTime: number;
+    };
+};
+export declare function UFOBM3TimingsToUFO({ marks, timings, }: {
+    marks?: BM3Marks;
+    timings?: BM3TimingsConfig[];
+}): null;
+export declare function addBM3TimingsToUFO(marks?: BM3Marks, timingsConfig?: BM3TimingsConfig[]): void;

package/dist/types-ts4.5/experience-trace-id-context/index.d.ts

@@ -0,0 +1,10 @@
+export type { TraceIdContext } from './types';
+export declare const generateSpanId: () => string;
+export declare const setInteractionActiveTrace: (interactionId: string, experienceType: string) => void;
+export declare const setActiveTrace: (traceId: string, spanId: string, type: string) => void;
+export declare const getActiveTrace: () => import("./types").TraceIdContext | undefined;
+export declare const clearActiveTrace: () => void;
+export declare const getActiveTraceHttpRequestHeaders: (_url: string) => {
+    'X-B3-TraceId': string;
+    'X-B3-SpanId': string;
+} | null;

package/dist/types-ts4.5/experience-trace-id-context/types.d.ts

@@ -0,0 +1,8 @@
+export type TraceIdContext = {
+    traceId: string;
+    spanId: string;
+    type: string;
+};
+export type TraceIdContextStateType = {
+    context: TraceIdContext | null;
+};

package/dist/types-ts4.5/experience-trace-id-context/utils/make-trace-http-request-headers/index.d.ts

@@ -0,0 +1,4 @@
+export declare const makeTraceHttpRequestHeaders: (traceId: string, spanId: string) => {
+    'X-B3-TraceId': string;
+    'X-B3-SpanId': string;
+};

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

@@ -0,0 +1 @@
+export declare const NON_BOOLEAN_VALUE = "non_boolean";

package/dist/types-ts4.5/feature-flags-accessed/common/types.d.ts

@@ -0,0 +1,2 @@
+import type { NON_BOOLEAN_VALUE } from './constants';
+export type FeatureFlagValue = boolean | string | number | Record<any, any> | typeof NON_BOOLEAN_VALUE;

package/dist/types-ts4.5/feature-flags-accessed/common/utils/index.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureFlagValue } from '../types';
+export declare const shouldRedactValue: (value: any) => boolean;
+export declare const redactValue: (featureFlagValue: FeatureFlagValue) => FeatureFlagValue;

package/dist/types-ts4.5/feature-flags-accessed/index.d.ts

@@ -0,0 +1,14 @@
+import type { FeatureFlagValue } from './common/types';
+export { redactValue } from './common/utils';
+export type { FeatureFlagValue } from './common/types';
+declare global {
+    var __CRITERION__: {
+        addFeatureFlagAccessed?: (flagName: string, flagValue: FeatureFlagValue) => void;
+    };
+}
+export declare const allFeatureFlagsAccessed: Map<string, FeatureFlagValue>;
+export declare const currentFeatureFlagsAccessed: Map<string, FeatureFlagValue>;
+/**
+ * Used for tracking accessed feature flags in "@atlassian/jira-feature-flagging".
+ * */
+export declare const addFeatureFlagAccessed: (featureFlagName: string, featureFlagValue: FeatureFlagValue) => void;

package/dist/types-ts4.5/generate-id/index.d.ts

@@ -0,0 +1,2 @@
+/** Get a new string id each time it's called */
+export default function generateId(): string;

package/dist/types-ts4.5/global-error-handler/index.d.ts

@@ -0,0 +1,3 @@
+export declare const sinkErrorHandler: (sinkFunc: (name: string, labelStack: null, errorType: string, errorMessage: string, errorStack?: string) => void) => void;
+declare const setupUFOGlobalErrorHandler: () => void;
+export default setupUFOGlobalErrorHandler;

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

@@ -0,0 +1,7 @@
+export type HiddenTimingItem = {
+    time: number;
+    hidden: boolean;
+};
+export type PageVisibility = 'hidden' | 'mixed' | 'visible';
+export declare function setupHiddenTimingCapture(): void;
+export declare function getPageVisibilityState(start: number, end: number): PageVisibility;

package/dist/types-ts4.5/initial-page-load-extra-timing/index.d.ts

@@ -0,0 +1,9 @@
+export type ReportedTiming = {
+    startTime: number;
+    duration: number;
+};
+export type ReportedTimings = {
+    [key: string]: ReportedTiming;
+};
+export declare function addTimingFromPerformanceMark(name: string, startMark: string, stopMark: string, cleanStart?: boolean, cleanStop?: boolean): void;
+export declare function getTimings(): ReportedTimings;

package/dist/types-ts4.5/interaction-context/index.d.ts

@@ -0,0 +1,33 @@
+import { type Context } from 'react';
+import { type InteractionContextType } from '@atlaskit/interaction-context';
+export type CustomData = {
+    [key: string]: null | undefined | string | number | boolean | undefined | CustomData;
+};
+export type CustomTiming = {
+    [key: string]: {
+        startTime: number;
+        endTime: number;
+    };
+};
+export type Label = Readonly<{
+    name: string;
+}>;
+export type SegmentLabel = Readonly<{
+    name: string;
+    segmentId: string;
+}>;
+export type LabelStack = ReadonlyArray<Label | SegmentLabel>;
+export interface UFOInteractionContextType extends InteractionContextType {
+    labelStack: LabelStack;
+    addMark(name: string, timestamp?: number): void;
+    addCustomData(customData: CustomData): void;
+    addCustomTimings(customTimings: CustomTiming): void;
+    addApdex(apdexInfo: {
+        key: string;
+        startTime?: number;
+        stopTime: number;
+    }): void;
+}
+declare const _default: Context<UFOInteractionContextType | null>;
+export default _default;
+export declare function useInteractionContext(): UFOInteractionContextType | null;

package/dist/types-ts4.5/interaction-id-context/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export type InteractionIDContextType = {
+    current: string | null;
+};
+export declare const DefaultInteractionID: InteractionIDContextType;
+declare const _default: import("react").Context<InteractionIDContextType>;
+export default _default;
+export declare const getInteractionId: () => InteractionIDContextType;
+export declare const useInteractionId: () => InteractionIDContextType;

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

@@ -0,0 +1,3 @@
+import type { InteractionMetrics } from '../../common';
+declare const interactions: Map<string, InteractionMetrics>;
+export default interactions;

package/dist/types-ts4.5/interaction-metrics/index.d.ts

@@ -1,3 +1,67 @@
-import { type LabelStack, type Span } from '../common/types';
+import type { AbortReasonType, ApdexType, BM3Event, CustomData, CustomTiming, InteractionError, InteractionMetrics, InteractionType, LifecycleMarkType, LoadProfilerEventInfo, Mark, MarkType, PostInteractionLogOutput, ReactProfilerTiming, RequestInfo, Span, SpanType } from '../common';
+import { type TraceIdContext } from '../experience-trace-id-context';
+import { type FeatureFlagValue } from '../feature-flags-accessed';
+import type { LabelStack } from '../interaction-context';
+import PostInteractionLog from './post-interaction-log';
+export type { InteractionMetrics, LifecycleMarkType, Span, Mark, MarkType, InteractionType, AbortReasonType, ReactProfilerTiming, RequestInfo, ApdexType, CustomData, CustomTiming, InteractionError, };
+export declare const postInteractionLog: PostInteractionLog;
+export declare function getActiveInteraction(): InteractionMetrics | undefined;
+export declare function remove(interactionId: string): void;
+export declare function updatePageLoadInteractionName(ufoName: string, routeName?: string | null | undefined): void;
+export declare function addMetadata(interactionId: string, data: Record<string, unknown>): void;
+export declare function addCustomData(interactionId: string, labelStack: LabelStack, data: CustomData): void;
+export declare function addCustomTiming(interactionId: string, labelStack: LabelStack, data: CustomTiming): void;
+export declare function addMark(interactionId: string, type: MarkType, name: string, labelStack: LabelStack | null, time?: number): void;
+export declare function addMarkToAll(type: MarkType, name: string, labelStack: LabelStack | null, time?: number): void;
+export declare function addSpan(interactionId: string, type: SpanType, name: string, labelStack: LabelStack | null, start: number, end?: number, size?: number): void;
+export declare function addSpanToAll(type: SpanType, name: string, labelStack: LabelStack | null, start: number, end?: number, size?: number): void;
+export declare function addPreload(moduleId: string, timestamp: number): void;
+export declare function addLoad(identifier: string, start: number, end: number): void;
+export declare function extractModuleName(input: string): string;
+export declare function addHold(interactionId: string, labelStack: LabelStack, name: string): () => void;
+export declare function addHoldByID(interactionId: string, labelStack: LabelStack, name: string, id: string, ignoreOnSubmit?: boolean): () => void;
+export declare function removeHoldByID(interactionId: string, id: string): void;
+export declare function getCurrentInteractionType(interactionId: string): InteractionType | null;
+export declare const ModuleLoadingProfiler: {
+    onPreload(moduleId: string, _priority?: number): void;
+    onLoadStart(info: LoadProfilerEventInfo): void;
+    onLoadComplete(info: LoadProfilerEventInfo): void;
+    placeholderFallBackMounted(id: string, moduleId: string): void;
+    placeholderFallBackUnmounted(id: string): void;
+};
+export declare function addError(interactionId: string, name: string, labelStack: LabelStack | null, errorType: string, errorMessage: string, errorStack?: string, forcedError?: boolean): void;
+export declare function addErrorToAll(name: string, labelStack: LabelStack | null, errorType: string, errorMessage: string, errorStack?: string): void;
+export declare const addProfilerTimings: (interactionId: string, labelStack: LabelStack, type: 'mount' | 'update' | 'nested-update', actualDuration: number, baseDuration: number, startTime: number, commitTime: number) => void;
+export declare const sinkInteractionHandler: (sinkFn: (id: string, data: InteractionMetrics) => void) => void;
+export declare const sinkPostInteractionLogHandler: (sinkFn: (output: PostInteractionLogOutput) => void | Promise<void>) => void;
+export declare function tryComplete(interactionId: string, endTime?: number): void;
+export declare function abort(interactionId: string, abortReason: AbortReasonType): void;
+export declare function abortByNewInteraction(interactionId: string, interactionName: string): void;
+export declare function abortAll(abortReason: AbortReasonType, abortedByInteractionName?: string): void;
+export declare function addOnCancelCallback(id: string, cancelCallback: () => void): void;
+export declare function addNewInteraction(interactionId: string, ufoName: string, type: InteractionType, startTime: number, rate: number, labelStack: LabelStack | null, routeName?: string | null, trace?: TraceIdContext | null): void;
+export declare function addBrowserMetricEvent(event: BM3Event): void;
+export declare function addApdexToAll(apdex: ApdexType): void;
+export declare function addApdex(interactionId: string, apdexInfo: {
+    key: string;
+    stopTime: number;
+    startTime?: number;
+    labelStack?: LabelStack;
+}): void;
+export declare function addRequestInfo(interactionId: string, labelStack: LabelStack, requestInfo: RequestInfo): void;
+export declare function addSegment(labelStack: LabelStack): void;
+export declare function removeSegment(labelStack: LabelStack): void;
+export declare function addRedirect(interactionId: string, fromUfoName: string, nextUfoName: string, nextRouteName: string, time: number): void;
+declare global {
+    interface Window {
+        __REACT_UFO_ENABLE_PERF_TRACING?: boolean;
+        __UFO_COMPACT_PAYLOAD__?: boolean;
+        __CRITERION__?: {
+            addFeatureFlagAccessed?: (flagName: string, flagValue: FeatureFlagValue) => void;
+            addUFOHold?: (id: string, name: string, labelStack: string, startTime: number) => void;
+            removeUFOHold?: (id: string) => void;
+        };
+    }
+}
 export declare const interactionSpans: Span[];
 export declare function addCustomSpans(name: string, start: number, end?: number, size?: number, labelStack?: LabelStack): void;

package/dist/types-ts4.5/interaction-metrics/post-interaction-log.d.ts

@@ -0,0 +1,69 @@
+import { type LastInteractionFinishInfo, type PostInteractionLogOutput, type ReactProfilerTiming } from '../common/common/types';
+import type { VCResult } from '../common/vc/types';
+import type { LabelStack } from '../interaction-context';
+import { VCObserver, type VCObserverOptions } from '../vc/vc-observer';
+export default class PostInteractionLog {
+    /**
+     * Basic info about interaction that has just finished
+     */
+    lastInteractionFinish: LastInteractionFinishInfo | null;
+    /**
+     * Array of observed react render timings
+     */
+    reactProfilerTimings: ReactProfilerTiming[];
+    /**
+     * Store the scheduled sink timeout Id so that it can be cancelled when needed
+     */
+    sinkTimeoutId: number | null;
+    /**
+     * independent VC observer, that observes until `custom.post-interaction-logs` event is sent
+     */
+    vcObserver: VCObserver | null;
+    vcObserverSSRConfig: {
+        ssr: number | undefined;
+    } | null;
+    lastInteractionFinishVCResult?: VCResult;
+    initializeVCObserver(options: VCObserverOptions): void;
+    startVCObserver({ startTime }: {
+        startTime: number;
+    }): void;
+    setVCObserverSSRConfig(vcObserverSSRConfig: {
+        ssr: number | undefined;
+    } | null): void;
+    /**
+     * Set the VC result as per the last interaction
+     * Used to compare diffs of VC updates vs post interaction VC observer
+     * @param result - VC result as calculated by UFO create payload
+     */
+    setLastInteractionFinishVCResult(result: VCResult): void;
+    /**
+     * Handler function to process / send the observation data
+     */
+    sinkHandlerFn: (output: PostInteractionLogOutput) => void | Promise<void>;
+    /**
+     * Set the fn that would be invoked to process / send the observation data
+     */
+    sinkHandler(sinkHandlerFn: (output: PostInteractionLogOutput) => void | Promise<void>): void;
+    /**
+     * Reset state of the log
+     */
+    reset(): void;
+    /**
+     * Check if there is data in the log
+     */
+    hasData(): boolean;
+    /**
+     * Send the log if there is data
+     */
+    sendPostInteractionLog(): void;
+    /**
+     * This fn should be invoked when an interaction has finished
+     * Basic details about the finished interaction will be recorded
+     * A timeout will be setup to send the post interaction observation after some time.
+     */
+    onInteractionComplete({ ufoName, start, end, id, abortReason, abortedByInteractionName, routeName, type, }: LastInteractionFinishInfo): void;
+    /**
+     * This fn should be invoked when a React render happens after interaction has finished
+     */
+    addProfilerTimings(labelStack: LabelStack, type: 'mount' | 'update' | 'nested-update', actualDuration: number, baseDuration: number, startTime: number, commitTime: number): void;
+}

package/dist/types-ts4.5/interaction-metrics-init/index.d.ts

@@ -0,0 +1,11 @@
+import { type Config } from '../config';
+export interface GenericAnalyticWebClientInstance {
+    sendOperationalEvent: (payload: any) => void;
+}
+export interface GenericAnalyticWebClient {
+    getInstance: () => GenericAnalyticWebClientInstance;
+}
+export interface GenericAnalyticWebClientPromise {
+    getAnalyticsWebClientPromise: () => Promise<GenericAnalyticWebClient>;
+}
+export declare const init: (analyticsWebClientAsync: Promise<GenericAnalyticWebClientPromise> | Promise<GenericAnalyticWebClientInstance>, config: Config) => void;

package/dist/types-ts4.5/label/UFOLabel.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+/**
+ * Annotate part of the react tree with a product name
+ * ```
+ * <UFOLabel name="card">
+ *   <Card card={data} />
+ * </UFOLabel>
+ * ```
+ */
+export default function UFOLabel({ name, children }: {
+    name: string;
+    children: ReactNode;
+}): JSX.Element;

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

@@ -0,0 +1,2 @@
+import UFOLabel from './UFOLabel';
+export default UFOLabel;

package/dist/types-ts4.5/load-hold/UFOLoadHold.d.ts

@@ -0,0 +1,53 @@
+import { type ReactNode } from 'react';
+/**
+ * Render this whenever you're loading.
+ *
+ * Wrap loading elements
+ * ```js
+ * if (isLoading){
+ *   return (
+ *     <UFOLoadHold name="card">
+ *       <Skeleton />
+ *     </UFOLoadHold>
+ *   )
+ * }
+ * ```
+ *
+ * Or render it as a sibling
+ * ```
+ * if (isLoading){
+ *   return (
+ *     <>
+ *       <Skeleton />
+ *       <UFOLoadHold name="card">
+ *     </UFOLoadHold>
+ *   )
+ * }
+ * ```
+ *
+ * Or wrap your content conditionally
+ * ```
+ * return (
+ *   <UFOLoadHold name="card" hold={isLoading}>
+ *     <Card />
+ *   </UFOLoadHold>
+ * )
+ * ```
+ *
+ * Or render as a sibling conditionally
+ * ```
+ * return (
+ *   <>
+ *     <Card />
+ *     <UFOLoadHold name="card" hold={isLoading} />
+ *   </>
+ * )
+ * ```
+ */
+type Props = {
+    name: string;
+    hold?: boolean;
+    children?: ReactNode;
+};
+export default function UFOLoadHold({ children, name, hold }: Props): JSX.Element | null;
+export {};

package/dist/types-ts4.5/load-hold/index.d.ts

@@ -0,0 +1,2 @@
+import UFOLoadHold from './UFOLoadHold';
+export default UFOLoadHold;

package/dist/types-ts4.5/placeholder/Placeholder.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { type LazySuspenseProps } from './loosely-lazy';
+/**
+ * Provides a placeholder for lazily loaded content, improving perceived performance.
+ *
+ * Named placeholders are especially useful for analyzing page load breakdowns
+ * in performance monitoring tools like Performance Portal.
+ */
+export default function Placeholder({ name, children, fallback, }: {
+    name: string;
+    children?: LazySuspenseProps['children'];
+    fallback?: LazySuspenseProps['fallback'];
+}): JSX.Element;

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

@@ -0,0 +1,2 @@
+import Placeholder from './Placeholder';
+export default Placeholder;

package/dist/types-ts4.5/placeholder/loosely-lazy/index.d.ts

@@ -0,0 +1,3 @@
+export { WaitContext } from './wait-context';
+export { LazySuspense } from './lazy-suspense';
+export type { LazySuspenseProps } from './types';

package/dist/types-ts4.5/placeholder/loosely-lazy/lazy-suspense.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { LazySuspenseProps } from './types';
+export declare const LazySuspense: {
+    ({ fallback, children, name }: LazySuspenseProps): JSX.Element;
+    displayName: string;
+};

package/dist/types-ts4.5/placeholder/loosely-lazy/types.d.ts

@@ -0,0 +1,20 @@
+import type { SuspenseProps } from 'react';
+export type Fallback = SuspenseProps['fallback'];
+export type LazySuspenseContextType = {
+    fallback: Fallback;
+    setFallback(fallback: Fallback): void;
+    name?: string;
+};
+export type LazySuspenseProps = {
+    children?: SuspenseProps['children'];
+    fallback: Fallback;
+    name?: string;
+};
+export type DynamicFallbackProps = {
+    children(fallback: Fallback): any;
+    outsideSuspense: boolean;
+};
+export type SubscriptionContextValue = {
+    subscribe: (callback: () => void) => () => void;
+    currentValue: () => number;
+};

package/dist/types-ts4.5/placeholder/loosely-lazy/wait-context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { type SubscriptionContextValue } from './types';
+export declare const WaitContext: import("react").Context<SubscriptionContextValue>;

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

@@ -0,0 +1,41 @@
+export type ResourceEntry = {
+    name: string;
+    initiatorType: string;
+    transferSize: number | void;
+    startTime: number;
+    duration: number;
+    responseStart: number;
+    requestStart: number;
+    fetchStart: number;
+    workerStart: number;
+    serverTime?: number;
+    networkTime?: number;
+    encodedSize?: number | null;
+    decodedSize?: number | null;
+};
+export type ResourceTimingsConfig = {
+    sanitiseEndpoints: (url: string) => string | null;
+    mapResources: (url: string) => string | null;
+    xhrFilter?: (url: string) => boolean;
+    hasTimingHeaders?: (url: string) => boolean;
+};
+interface BasicResourceTiming {
+    startTime: number;
+    duration: number;
+    type: string;
+    workerStart: number;
+    fetchStart: number;
+}
+interface CacheableResourceTiming extends BasicResourceTiming {
+    transferType: string;
+    ttfb?: number;
+}
+interface NonCacheableResourceTiming extends BasicResourceTiming {
+    size: number;
+    ttfb: number;
+}
+export type ResourceTiming = BasicResourceTiming | NonCacheableResourceTiming | CacheableResourceTiming;
+export type ResourceTimings = {
+    [key: string]: ResourceTiming;
+};
+export {};

package/dist/types-ts4.5/resource-timing/common/utils/config.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceTimingsConfig } from '../types';
+export declare function configure(resourceTimingConfig: ResourceTimingsConfig): void;
+export declare const getConfig: () => ResourceTimingsConfig;

package/dist/types-ts4.5/resource-timing/common/utils/resource-timing-buffer.d.ts

@@ -0,0 +1,11 @@
+import type { ResourceEntry } from '../types';
+export declare const resourceTimingBuffer: {
+    timings: ResourceEntry[];
+    maxSize: number;
+    observer: PerformanceObserver | null;
+    transformResource: (entry: PerformanceResourceTiming) => ResourceEntry;
+    start: () => void;
+    stop: () => void;
+    addTimings: (list: PerformanceObserverEntryList) => void;
+};
+export declare const filterResourceTimings: (startTime: number, endTime: number) => ResourceEntry[] | null;

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

@@ -0,0 +1,4 @@
+export type { ResourceTimings } from './common/types';
+export { configure } from './common/utils/config';
+export { getResourceTimings } from './main';
+export { startResourceTimingBuffer } from './utils';

package/dist/types-ts4.5/resource-timing/main.d.ts

@@ -0,0 +1,2 @@
+import type { ResourceTimings } from './common/types';
+export declare const getResourceTimings: (interactionStart: number, interactionEnd: number) => ResourceTimings;

package/dist/types-ts4.5/resource-timing/utils.d.ts

@@ -0,0 +1 @@
+export declare function startResourceTimingBuffer(): void;

package/dist/types-ts4.5/round-number/index.d.ts

@@ -0,0 +1 @@
+export declare const roundEpsilon: (num: number, places?: number) => number;

package/dist/types-ts4.5/route-name/index.d.ts

@@ -0,0 +1,4 @@
+export default function getUFORouteName(route: {
+    ufoName?: string;
+    name: string;
+}): string;

package/dist/types-ts4.5/route-name-context/index.d.ts

@@ -0,0 +1,5 @@
+type RouteNameContextType = {
+    current: string | null;
+};
+declare const UFORouteName: RouteNameContextType;
+export default UFORouteName;

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

@@ -0,0 +1,2 @@
+import UFOSegment from './segment';
+export default UFOSegment;

package/dist/types-ts4.5/segment/segment-highlight.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+type Props = {
+    segmentName: string;
+};
+export declare function SegmentHighlight({ segmentName }: Props): JSX.Element | null;
+export {};

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

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+type Props = {
+    name: string;
+    children: ReactNode;
+};
+/** A portion of the page we apply measurement to */
+export default function UFOSegment({ name: segmentName, children }: Props): JSX.Element;
+export {};

package/dist/types-ts4.5/set-interaction-error/index.d.ts

@@ -0,0 +1,4 @@
+import { type InteractionError } from '../interaction-metrics';
+type InteractionErrorManual = Pick<InteractionError, 'errorMessage' | 'name'>;
+export declare function setInteractionError(interactionName: string, error: InteractionErrorManual): void;
+export {};

package/dist/types-ts4.5/short-id/index.d.ts

@@ -0,0 +1 @@
+export default function generateId(length?: number): string;