@sentry/replay 7.67.0 → 7.68.0

package/types-ts3.8/types/replay.d.ts

@@ -0,0 +1,422 @@
+import { Breadcrumb, FetchBreadcrumbHint, HandlerDataFetch, ReplayRecordingData, ReplayRecordingMode, SentryWrappedXMLHttpRequest, Transaction, XhrBreadcrumbHint } from '@sentry/types';
+import { SKIPPED, THROTTLED } from '../util/throttle';
+import { AllPerformanceEntry } from './performance';
+import { ReplayFrameEvent } from './replayFrame';
+import { ReplayNetworkRequestOrResponse } from './request';
+import { ReplayEventWithTime, RrwebRecordOptions } from './rrweb';
+export type RecordingEvent = ReplayFrameEvent | ReplayEventWithTime;
+export type RecordingOptions = RrwebRecordOptions;
+export interface SendReplayData {
+    recordingData: ReplayRecordingData;
+    replayId: string;
+    segmentId: number;
+    eventContext: PopEventContext;
+    timestamp: number;
+    session: Session;
+    options: ReplayPluginOptions;
+}
+export interface Timeouts {
+    sessionIdlePause: number;
+    sessionIdleExpire: number;
+}
+/**
+ * The request payload to worker
+ */
+export interface WorkerRequest {
+    id: number;
+    method: 'clear' | 'addEvent' | 'finish';
+    arg?: string;
+}
+/**
+ * The response from the worker
+ */
+export interface WorkerResponse {
+    id: number;
+    method: string;
+    success: boolean;
+    response: unknown;
+}
+export type AddEventResult = void;
+export interface BeforeAddRecordingEvent {
+    (event: ReplayFrameEvent): ReplayFrameEvent | null | undefined;
+}
+export interface ReplayNetworkOptions {
+    /**
+     * Capture request/response details for XHR/Fetch requests that match the given URLs.
+     * The URLs can be strings or regular expressions.
+     * When provided a string, we will match any URL that contains the given string.
+     * You can use a Regex to handle exact matches or more complex matching.
+     *
+     * Only URLs matching these patterns will have bodies & additional headers captured.
+     */
+    networkDetailAllowUrls: (string | RegExp)[];
+    /**
+     * Deny request/response details for XHR/Fetch requests that match the given URLs.
+     * The URLs can be strings or regular expressions.
+     * When provided a string, we will deny any URL that contains the given string.
+     * You can use a Regex to handle exact matches or more complex matching.
+     * URLs matching these patterns will not have bodies & additional headers captured.
+     */
+    networkDetailDenyUrls: (string | RegExp)[];
+    /**
+     * If request & response bodies should be captured.
+     * Only applies to URLs matched by `networkDetailAllowUrls` and not matched by `networkDetailDenyUrls`.
+     * Defaults to true.
+     */
+    networkCaptureBodies: boolean;
+    /**
+     * Capture the following request headers, in addition to the default ones.
+     * Only applies to URLs matched by `networkDetailAllowUrls` and not matched by `networkDetailDenyUrls`.
+     * Any headers defined here will be captured in addition to the default headers.
+     */
+    networkRequestHeaders: string[];
+    /**
+     * Capture the following response headers, in addition to the default ones.
+     * Only applies to URLs matched by `networkDetailAllowUrls` and not matched by `networkDetailDenyUrls`.
+     * Any headers defined here will be captured in addition to the default headers.
+     */
+    networkResponseHeaders: string[];
+}
+export interface ReplayPluginOptions extends ReplayNetworkOptions {
+    /**
+     * The sample rate for session-long replays. 1.0 will record all sessions and
+     * 0 will record none.
+     */
+    sessionSampleRate: number;
+    /**
+     * The sample rate for sessions that has had an error occur. This is
+     * independent of `sessionSampleRate`.
+     */
+    errorSampleRate: number;
+    /**
+     * If false, will create a new session per pageload. Otherwise, saves session
+     * to Session Storage.
+     */
+    stickySession: boolean;
+    /**
+     * The amount of time to wait before sending a replay
+     */
+    flushMinDelay: number;
+    /**
+     * The max amount of time to wait before sending a replay
+     */
+    flushMaxDelay: number;
+    /**
+     * Attempt to use compression when web workers are available
+     *
+     * (default is true)
+     */
+    useCompression: boolean;
+    /**
+     * Block all media (e.g. images, svg, video) in recordings.
+     */
+    blockAllMedia: boolean;
+    /**
+     * Mask all inputs in recordings
+     */
+    maskAllInputs: boolean;
+    /**
+     * Mask all text in recordings
+     */
+    maskAllText: boolean;
+    /**
+     * A high number of DOM mutations (in a single event loop) can cause
+     * performance regressions in end-users' browsers. This setting will create
+     * a breadcrumb in the recording when the limit has been reached.
+     */
+    mutationBreadcrumbLimit: number;
+    /**
+     * A high number of DOM mutations (in a single event loop) can cause
+     * performance regressions in end-users' browsers. This setting will cause
+     * recording to stop when the limit has been reached.
+     */
+    mutationLimit: number;
+    /**
+     * The max. time in ms to wait for a slow click to finish.
+     * After this amount of time we stop waiting for actions after a click happened.
+     * Set this to 0 to disable slow click capture.
+     *
+     * Default: 7000ms
+     */
+    slowClickTimeout: number;
+    /**
+     * Ignore clicks on elements matching the given selectors for slow click detection.
+     */
+    slowClickIgnoreSelectors: string[];
+    /**
+     * The min. duration (in ms) a replay has to have before it is sent to Sentry.
+     * Whenever attempting to flush a session that is shorter than this, it will not actually send it to Sentry.
+     * Note that this is capped at max. 15s.
+     */
+    minReplayDuration: number;
+    /**
+     * The max. duration (in ms) a replay session may be.
+     * This is capped at max. 60min.
+     */
+    maxReplayDuration: number;
+    /**
+     * Callback before adding a custom recording event
+     *
+     * Events added by the underlying DOM recording library can *not* be modified,
+     * only custom recording events from the Replay integration will trigger the
+     * callback listeners. This can be used to scrub certain fields in an event (e.g. URLs from navigation events).
+     *
+     * Returning a `null` will drop the event completely. Note, dropping a recording
+     * event is not the same as dropping the replay, the replay will still exist and
+     * continue to function.
+     */
+    beforeAddRecordingEvent?: BeforeAddRecordingEvent;
+    /**
+     * _experiments allows users to enable experimental or internal features.
+     * We don't consider such features as part of the public API and hence we don't guarantee semver for them.
+     * Experimental features can be added, changed or removed at any time.
+     *
+     * Default: undefined
+     */
+    _experiments: Partial<{
+        captureExceptions: boolean;
+        traceInternals: boolean;
+    }>;
+}
+/**
+ * Session options that are configurable by the integration configuration
+ */
+export interface SessionOptions extends Pick<ReplayPluginOptions, 'sessionSampleRate' | 'stickySession'> {
+    /**
+     * Should buffer recordings to be saved later either by error sampling, or by
+     * manually calling `flush()`. This is only a factor if not sampled for a
+     * session-based replay.
+     */
+    allowBuffering: boolean;
+}
+export interface ReplayIntegrationPrivacyOptions {
+    /**
+     * Mask text content for elements that match the CSS selectors in the list.
+     */
+    mask?: string[];
+    /**
+     * Unmask text content for elements that match the CSS selectors in the list.
+     */
+    unmask?: string[];
+    /**
+     * Block elements that match the CSS selectors in the list. Blocking replaces
+     * the element with an empty placeholder with the same dimensions.
+     */
+    block?: string[];
+    /**
+     * Unblock elements that match the CSS selectors in the list. This is useful when using `blockAllMedia`.
+     */
+    unblock?: string[];
+    /**
+     * Ignore input events for elements that match the CSS selectors in the list.
+     */
+    ignore?: string[];
+    /**
+     * A callback function to customize how your text is masked.
+     */
+    maskFn?: (s: string) => string;
+}
+type OptionalReplayPluginOptions = Partial<ReplayPluginOptions>;
+export interface DeprecatedPrivacyOptions {
+    /**
+     * @deprecated Use `block` which accepts an array of CSS selectors
+     */
+    blockSelector?: RecordingOptions['blockSelector'];
+    /**
+     * @deprecated Use `block` which accepts an array of CSS selectors
+     */
+    blockClass?: RecordingOptions['blockClass'];
+    /**
+     * @deprecated Use `ignore` which accepts an array of CSS selectors
+     */
+    ignoreClass?: RecordingOptions['ignoreClass'];
+    /**
+     * @deprecated  Use `mask` which accepts an array of CSS selectors
+     */
+    maskInputOptions?: RecordingOptions['maskInputOptions'];
+    /**
+     * @deprecated Use `mask` which accepts an array of CSS selectors
+     */
+    maskTextClass?: RecordingOptions['maskTextClass'];
+    /**
+     * @deprecated Use `mask` which accepts an array of CSS selectors
+     */
+    maskTextSelector?: RecordingOptions['maskTextSelector'];
+}
+export interface ReplayConfiguration extends ReplayIntegrationPrivacyOptions, OptionalReplayPluginOptions, DeprecatedPrivacyOptions, Pick<RecordingOptions, 'maskAllText' | 'maskAllInputs'> {
+}
+interface CommonEventContext {
+    /**
+     * The initial URL of the session
+     */
+    initialUrl: string;
+    /**
+     * The initial starting timestamp in ms of the session.
+     */
+    initialTimestamp: number;
+    /**
+     * Ordered list of URLs that have been visited during a replay segment
+     */
+    urls: string[];
+}
+export interface PopEventContext extends CommonEventContext {
+    /**
+     * List of Sentry error ids that have occurred during a replay segment
+     */
+    errorIds: Array<string>;
+    /**
+     * List of Sentry trace ids that have occurred during a replay segment
+     */
+    traceIds: Array<string>;
+}
+/**
+ * Additional context that will be sent w/ `replay_event`
+ */
+export interface InternalEventContext extends CommonEventContext {
+    /**
+     * Set of Sentry error ids that have occurred during a replay segment
+     */
+    errorIds: Set<string>;
+    /**
+     * Set of Sentry trace ids that have occurred during a replay segment
+     */
+    traceIds: Set<string>;
+}
+export type Sampled = false | 'session' | 'buffer';
+export interface Session {
+    id: string;
+    /**
+     * Start time of current session (in ms)
+     */
+    started: number;
+    /**
+     * Last known activity of the session (in ms)
+     */
+    lastActivity: number;
+    /**
+     * Segment ID for replay events
+     */
+    segmentId: number;
+    /**
+     * The ID of the previous session.
+     * If this is empty, there was no previous session.
+     */
+    previousSessionId?: string;
+    /**
+     * Is the session sampled? `false` if not sampled, otherwise, `session` or `buffer`
+     */
+    sampled: Sampled;
+    /**
+     * If this is false, the session should not be refreshed when it was inactive.
+     * This can be the case if you had a buffered session which is now recording because an error happened.
+     */
+    shouldRefresh: boolean;
+}
+export type EventBufferType = 'sync' | 'worker';
+export interface EventBuffer {
+    /**
+     * If any events have been added to the buffer.
+     */
+    readonly hasEvents: boolean;
+    /**
+     * The buffer type
+     */
+    readonly type: EventBufferType;
+    /**
+     * If the event buffer contains a checkout event.
+     */
+    hasCheckout: boolean;
+    /**
+     * Destroy the event buffer.
+     */
+    destroy(): void;
+    /**
+     * Clear the event buffer.
+     */
+    clear(): void;
+    /**
+     * Add an event to the event buffer.
+     *
+     * Returns a promise that resolves if the event was successfully added, else rejects.
+     */
+    addEvent(event: RecordingEvent): Promise<AddEventResult>;
+    /**
+     * Clears and returns the contents of the buffer.
+     */
+    finish(): Promise<ReplayRecordingData>;
+    /**
+     * Get the earliest timestamp in ms of any event currently in the buffer.
+     */
+    getEarliestTimestamp(): number | null;
+}
+export type AddUpdateCallback = () => boolean | void;
+export interface SendBufferedReplayOptions {
+    continueRecording?: boolean;
+}
+export interface ReplayClickDetector {
+    addListeners(): void;
+    removeListeners(): void;
+    handleClick(breadcrumb: Breadcrumb, node: HTMLElement): void;
+}
+export interface ReplayContainer {
+    eventBuffer: EventBuffer | null;
+    clickDetector: ReplayClickDetector | undefined;
+    performanceEvents: AllPerformanceEntry[];
+    session: Session | undefined;
+    recordingMode: ReplayRecordingMode;
+    timeouts: Timeouts;
+    lastTransaction?: Transaction;
+    throttledAddEvent: (event: RecordingEvent, isCheckout?: boolean) => typeof THROTTLED | typeof SKIPPED | Promise<AddEventResult | null>;
+    isEnabled(): boolean;
+    isPaused(): boolean;
+    getContext(): InternalEventContext;
+    initializeSampling(): void;
+    start(): void;
+    stop(options?: {
+        reason?: string;
+        forceflush?: boolean;
+    }): Promise<void>;
+    pause(): void;
+    resume(): void;
+    startRecording(): void;
+    stopRecording(): boolean;
+    sendBufferedReplayOrFlush(options?: SendBufferedReplayOptions): Promise<void>;
+    conditionalFlush(): Promise<void>;
+    flush(): Promise<void>;
+    flushImmediate(): Promise<void>;
+    cancelFlush(): void;
+    triggerUserActivity(): void;
+    updateUserActivity(): void;
+    addUpdate(cb: AddUpdateCallback): void;
+    getOptions(): ReplayPluginOptions;
+    getSessionId(): string | undefined;
+    checkAndHandleExpiredSession(): boolean | void;
+    setInitialState(): void;
+    getCurrentRoute(): string | undefined;
+}
+type RequestBody = null | Blob | BufferSource | FormData | URLSearchParams | string;
+export type XhrHint = XhrBreadcrumbHint & {
+    xhr: XMLHttpRequest & SentryWrappedXMLHttpRequest;
+    input?: RequestBody;
+};
+export type FetchHint = FetchBreadcrumbHint & {
+    input: HandlerDataFetch['args'];
+    response: Response;
+};
+export type ReplayNetworkRequestData = {
+    startTimestamp: number;
+    endTimestamp: number;
+    url: string;
+    method?: string;
+    statusCode: number;
+    request?: ReplayNetworkRequestOrResponse;
+    response?: ReplayNetworkRequestOrResponse;
+};
+export interface SlowClickConfig {
+    threshold: number;
+    timeout: number;
+    scrollTimeout: number;
+    ignoreSelector: string;
+}
+export {};
+//# sourceMappingURL=replay.d.ts.map

package/types-ts3.8/types/replayFrame.d.ts

@@ -0,0 +1,173 @@
+import { Breadcrumb } from '@sentry/types';
+import { HistoryData, LargestContentfulPaintData, MemoryData, NavigationData, NetworkRequestData, PaintData, ResourceData } from './performance';
+import { ReplayEventTypeCustom } from './rrweb';
+type AnyRecord = Record<string, any>;
+interface ReplayBaseBreadcrumbFrame {
+    timestamp: number;
+    /**
+     * For compatibility reasons
+     */
+    type: string;
+    category: string;
+    data?: AnyRecord;
+    message?: string;
+}
+interface ReplayBaseDomFrameData {
+    nodeId?: number;
+    node?: {
+        id: number;
+        tagName: string;
+        textContent: string;
+        attributes: AnyRecord;
+    };
+}
+interface ReplayConsoleFrameData {
+    logger: string;
+    arguments?: unknown[];
+}
+interface ReplayConsoleFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'console';
+    level: Breadcrumb['level'];
+    message: string;
+    data: ReplayConsoleFrameData;
+}
+type ReplayClickFrameData = ReplayBaseDomFrameData;
+interface ReplayClickFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.click';
+    message: string;
+    data: ReplayClickFrameData;
+}
+interface ReplayInputFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.input';
+    message: string;
+}
+interface ReplayMutationFrameData {
+    count: number;
+    limit: boolean;
+}
+interface ReplayMutationFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'replay.mutations';
+    data: ReplayMutationFrameData;
+}
+interface ReplayKeyboardEventFrameData extends ReplayBaseDomFrameData {
+    metaKey: boolean;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    key: string;
+}
+interface ReplayKeyboardEventFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.keyDown';
+    data: ReplayKeyboardEventFrameData;
+}
+interface ReplayBlurFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.blur';
+}
+interface ReplayFocusFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.focus';
+}
+interface ReplaySlowClickFrameData extends ReplayClickFrameData {
+    url: string;
+    route?: string;
+    timeAfterClickMs: number;
+    endReason: string;
+    clickCount?: number;
+}
+export interface ReplaySlowClickFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.slowClickDetected';
+    data: ReplaySlowClickFrameData;
+}
+interface ReplayMultiClickFrameData extends ReplayClickFrameData {
+    url: string;
+    route?: string;
+    clickCount: number;
+    metric: true;
+}
+export interface ReplayMultiClickFrame extends ReplayBaseBreadcrumbFrame {
+    category: 'ui.multiClick';
+    data: ReplayMultiClickFrameData;
+}
+interface ReplayOptionFrame {
+    blockAllMedia: boolean;
+    errorSampleRate: number;
+    maskAllInputs: boolean;
+    maskAllText: boolean;
+    networkCaptureBodies: boolean;
+    networkDetailHasUrls: boolean;
+    networkRequestHasHeaders: boolean;
+    networkResponseHasHeaders: boolean;
+    sessionSampleRate: number;
+    useCompression: boolean;
+    useCompressionOption: boolean;
+}
+export type ReplayBreadcrumbFrame = ReplayConsoleFrame | ReplayClickFrame | ReplayInputFrame | ReplayKeyboardEventFrame | ReplayBlurFrame | ReplayFocusFrame | ReplaySlowClickFrame | ReplayMultiClickFrame | ReplayMutationFrame | ReplayBaseBreadcrumbFrame;
+interface ReplayBaseSpanFrame {
+    op: string;
+    description: string;
+    startTimestamp: number;
+    endTimestamp: number;
+    data?: undefined | AnyRecord;
+}
+interface ReplayHistoryFrame extends ReplayBaseSpanFrame {
+    data: HistoryData;
+    op: 'navigation.push';
+}
+interface ReplayLargestContentfulPaintFrame extends ReplayBaseSpanFrame {
+    data: LargestContentfulPaintData;
+    op: 'largest-contentful-paint';
+}
+interface ReplayMemoryFrame extends ReplayBaseSpanFrame {
+    data: MemoryData;
+    op: 'memory';
+}
+interface ReplayNavigationFrame extends ReplayBaseSpanFrame {
+    data: NavigationData;
+    op: 'navigation.navigate' | 'navigation.reload' | 'navigation.back_forward';
+}
+interface ReplayPaintFrame extends ReplayBaseSpanFrame {
+    data: PaintData;
+    op: 'paint';
+}
+interface ReplayRequestFrame extends ReplayBaseSpanFrame {
+    data: NetworkRequestData;
+    op: 'resource.fetch' | 'resource.xhr';
+}
+interface ReplayResourceFrame extends ReplayBaseSpanFrame {
+    data: ResourceData;
+    op: 'resource.css' | 'resource.ReplayiFrame' | 'resource.img' | 'resource.link' | 'resource.other' | 'resource.script';
+}
+export type ReplaySpanFrame = ReplayBaseSpanFrame | ReplayHistoryFrame | ReplayRequestFrame | ReplayLargestContentfulPaintFrame | ReplayMemoryFrame | ReplayNavigationFrame | ReplayPaintFrame | ReplayResourceFrame;
+export type ReplayFrame = ReplayBreadcrumbFrame | ReplaySpanFrame;
+interface RecordingCustomEvent {
+    type: typeof ReplayEventTypeCustom;
+    timestamp: number;
+    data: {
+        tag: string;
+        payload: unknown;
+    };
+}
+export interface ReplayBreadcrumbFrameEvent extends RecordingCustomEvent {
+    data: {
+        tag: 'breadcrumb';
+        payload: ReplayBreadcrumbFrame;
+        /**
+         * This will indicate to backend to additionally log as a metric
+         */
+        metric?: boolean;
+    };
+}
+export interface ReplaySpanFrameEvent extends RecordingCustomEvent {
+    data: {
+        tag: 'performanceSpan';
+        payload: ReplaySpanFrame;
+    };
+}
+export interface ReplayOptionFrameEvent extends RecordingCustomEvent {
+    data: {
+        tag: 'options';
+        payload: ReplayOptionFrame;
+    };
+}
+export type ReplayFrameEvent = ReplayBreadcrumbFrameEvent | ReplaySpanFrameEvent | ReplayOptionFrameEvent;
+export {};
+//# sourceMappingURL=replayFrame.d.ts.map

package/types-ts3.8/types/request.d.ts

@@ -0,0 +1,15 @@
+type JsonObject = Record<string, unknown>;
+type JsonArray = unknown[];
+export type NetworkBody = JsonObject | JsonArray | string;
+export type NetworkMetaWarning = 'JSON_TRUNCATED' | 'TEXT_TRUNCATED' | 'INVALID_JSON' | 'URL_SKIPPED';
+interface NetworkMeta {
+    warnings?: NetworkMetaWarning[];
+}
+export interface ReplayNetworkRequestOrResponse {
+    size?: number;
+    body?: NetworkBody;
+    headers: Record<string, string>;
+    _meta?: NetworkMeta;
+}
+export {};
+//# sourceMappingURL=request.d.ts.map

package/types-ts3.8/types/rrweb.d.ts

@@ -0,0 +1,37 @@
+type ClassOption = string | RegExp;
+/** Duplicate this from @sentry-internal/rrweb so we can export this as well. */
+export declare const ReplayEventTypeDomContentLoaded = 0;
+export declare const ReplayEventTypeLoad = 1;
+export declare const ReplayEventTypeFullSnapshot = 2;
+export declare const ReplayEventTypeIncrementalSnapshot = 3;
+export declare const ReplayEventTypeMeta = 4;
+export declare const ReplayEventTypeCustom = 5;
+export declare const ReplayEventTypePlugin = 6;
+export type ReplayEventType = typeof ReplayEventTypeDomContentLoaded | typeof ReplayEventTypeLoad | typeof ReplayEventTypeFullSnapshot | typeof ReplayEventTypeIncrementalSnapshot | typeof ReplayEventTypeMeta | typeof ReplayEventTypeCustom | typeof ReplayEventTypePlugin;
+/**
+ * This is a partial copy of rrweb's eventWithTime type which only contains the properties
+ * we specifcally need in the SDK.
+ */
+export type ReplayEventWithTime = {
+    type: ReplayEventType;
+    data: unknown;
+    timestamp: number;
+    delay?: number;
+};
+/**
+ * This is a partial copy of rrweb's recording options which only contains the properties
+ * we specifically us in the SDK. Users can specify additional properties, hence we add the
+ * Record<string, unknown> union type.
+ */
+export type RrwebRecordOptions = {
+    maskAllText?: boolean;
+    maskAllInputs?: boolean;
+    blockClass?: ClassOption;
+    ignoreClass?: string;
+    maskTextClass?: ClassOption;
+    maskTextSelector?: string;
+    blockSelector?: string;
+    maskInputOptions?: Record<string, boolean>;
+} & Record<string, unknown>;
+export {};
+//# sourceMappingURL=rrweb.d.ts.map

package/types-ts3.8/util/addEvent.d.ts

@@ -0,0 +1,7 @@
+import { AddEventResult, RecordingEvent, ReplayContainer } from '../types';
+/**
+ * Add an event to the event buffer.
+ * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.
+ */
+export declare function addEvent(replay: ReplayContainer, event: RecordingEvent, isCheckout?: boolean): Promise<AddEventResult | null>;
+//# sourceMappingURL=addEvent.d.ts.map

package/types-ts3.8/util/addGlobalListeners.d.ts

@@ -0,0 +1,6 @@
+import { ReplayContainer } from '../types';
+/**
+ * Add global listeners that cannot be removed.
+ */
+export declare function addGlobalListeners(replay: ReplayContainer): void;
+//# sourceMappingURL=addGlobalListeners.d.ts.map

package/types-ts3.8/util/addMemoryEntry.d.ts

@@ -0,0 +1,7 @@
+import { AddEventResult, ReplayContainer } from '../types';
+/**
+ * Create a "span" for the total amount of memory being used by JS objects
+ * (including v8 internal objects).
+ */
+export declare function addMemoryEntry(replay: ReplayContainer): Promise<Array<AddEventResult | null>>;
+//# sourceMappingURL=addMemoryEntry.d.ts.map

package/types-ts3.8/util/createBreadcrumb.d.ts

@@ -0,0 +1,6 @@
+import { ReplayBreadcrumbFrame } from '../types/replayFrame';
+/**
+ * Create a breadcrumb for a replay.
+ */
+export declare function createBreadcrumb(breadcrumb: Pick<ReplayBreadcrumbFrame, Exclude<keyof ReplayBreadcrumbFrame, 'timestamp' | 'type'>> & Partial<Pick<ReplayBreadcrumbFrame, 'timestamp'>>): ReplayBreadcrumbFrame;
+//# sourceMappingURL=createBreadcrumb.d.ts.map

package/types-ts3.8/util/createPerformanceEntries.d.ts

@@ -0,0 +1,6 @@
+import { AllPerformanceEntry, AllPerformanceEntryData, ReplayPerformanceEntry } from '../types';
+/**
+ * Create replay performance entries from the browser performance entries.
+ */
+export declare function createPerformanceEntries(entries: AllPerformanceEntry[]): ReplayPerformanceEntry<AllPerformanceEntryData>[];
+//# sourceMappingURL=createPerformanceEntries.d.ts.map

package/types-ts3.8/util/createPerformanceSpans.d.ts

@@ -0,0 +1,6 @@
+import { AddEventResult, AllEntryData, ReplayContainer, ReplayPerformanceEntry } from '../types';
+/**
+ * Create a "span" for each performance entry.
+ */
+export declare function createPerformanceSpans(replay: ReplayContainer, entries: ReplayPerformanceEntry<AllEntryData>[]): Promise<AddEventResult | null>[];
+//# sourceMappingURL=createPerformanceSpans.d.ts.map