@sentry/replay 7.67.0 → 7.68.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sentry/replay",
-  "version": "7.67.0",
+  "version": "7.68.0",
   "description": "User replays for Sentry",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "types": "types/index.d.ts",
   "typesVersions": {
     "<4.9": {
-      "build/npm/types/index.d.ts": [
+      "types/index.d.ts": [
         "types-ts3.8/index.d.ts"
       ]
     }
@@ -25,16 +25,16 @@
   "homepage": "https://docs.sentry.io/platforms/javascript/session-replay/",
   "devDependencies": {
     "@babel/core": "^7.17.5",
-    "@sentry-internal/replay-worker": "7.67.0",
+    "@sentry-internal/replay-worker": "7.68.0",
     "@sentry-internal/rrweb": "1.108.0",
     "@sentry-internal/rrweb-snapshot": "1.108.0",
     "jsdom-worker": "^0.2.1",
     "tslib": "^2.4.1 || ^1.9.3"
   },
   "dependencies": {
-    "@sentry/core": "7.67.0",
-    "@sentry/types": "7.67.0",
-    "@sentry/utils": "7.67.0"
+    "@sentry/core": "7.68.0",
+    "@sentry/types": "7.68.0",
+    "@sentry/utils": "7.68.0"
   },
   "engines": {
     "node": ">=12"

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

@@ -0,0 +1,25 @@
+export declare const WINDOW: import("@sentry/utils").InternalGlobal & Window;
+export declare const REPLAY_SESSION_KEY = "sentryReplaySession";
+export declare const REPLAY_EVENT_NAME = "replay_event";
+export declare const RECORDING_EVENT_NAME = "replay_recording";
+export declare const UNABLE_TO_SEND_REPLAY = "Unable to send Replay";
+export declare const SESSION_IDLE_PAUSE_DURATION = 300000;
+export declare const SESSION_IDLE_EXPIRE_DURATION = 900000;
+/** Default flush delays */
+export declare const DEFAULT_FLUSH_MIN_DELAY = 5000;
+export declare const DEFAULT_FLUSH_MAX_DELAY = 5500;
+export declare const BUFFER_CHECKOUT_TIME = 60000;
+export declare const RETRY_BASE_INTERVAL = 5000;
+export declare const RETRY_MAX_COUNT = 3;
+export declare const NETWORK_BODY_MAX_SIZE = 150000;
+export declare const CONSOLE_ARG_MAX_SIZE = 5000;
+export declare const SLOW_CLICK_THRESHOLD = 3000;
+export declare const SLOW_CLICK_SCROLL_TIMEOUT = 300;
+/** When encountering a total segment size exceeding this size, stop the replay (as we cannot properly ingest it). */
+export declare const REPLAY_MAX_EVENT_BUFFER_SIZE = 20000000;
+/** Replays must be min. 5s long before we send them. */
+export declare const MIN_REPLAY_DURATION = 4999;
+export declare const MIN_REPLAY_DURATION_LIMIT = 15000;
+/** The max. length of a replay. */
+export declare const MAX_REPLAY_DURATION = 3600000;
+//# sourceMappingURL=constants.d.ts.map

package/types-ts3.8/coreHandlers/handleAfterSendEvent.d.ts

@@ -0,0 +1,9 @@
+import { Event, TransportMakeRequestResponse } from '@sentry/types';
+import { ReplayContainer } from '../types';
+type AfterSendEventCallback = (event: Event, sendResponse: TransportMakeRequestResponse | void) => void;
+/**
+ * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.
+ */
+export declare function handleAfterSendEvent(replay: ReplayContainer): AfterSendEventCallback;
+export {};
+//# sourceMappingURL=handleAfterSendEvent.d.ts.map

package/types-ts3.8/coreHandlers/handleClick.d.ts

@@ -0,0 +1,39 @@
+import { Breadcrumb } from '@sentry/types';
+import { ReplayClickDetector, ReplayContainer, SlowClickConfig } from '../types';
+import { addBreadcrumbEvent } from './util/addBreadcrumbEvent';
+/** Handle a click. */
+export declare function handleClick(clickDetector: ReplayClickDetector, clickBreadcrumb: Breadcrumb, node: HTMLElement): void;
+/** A click detector class that can be used to detect slow or rage clicks on elements. */
+export declare class ClickDetector implements ReplayClickDetector {
+    protected _lastMutation: number;
+    protected _lastScroll: number;
+    private _clicks;
+    private _teardown;
+    private _threshold;
+    private _scollTimeout;
+    private _timeout;
+    private _ignoreSelector;
+    private _replay;
+    private _checkClickTimeout?;
+    private _addBreadcrumbEvent;
+    constructor(replay: ReplayContainer, slowClickConfig: SlowClickConfig, _addBreadcrumbEvent?: typeof addBreadcrumbEvent);
+    /** Register click detection handlers on mutation or scroll. */
+    addListeners(): void;
+    /** Clean up listeners. */
+    removeListeners(): void;
+    /** Handle a click */
+    handleClick(breadcrumb: Breadcrumb, node: HTMLElement): void;
+    /** Count multiple clicks on elements. */
+    private _handleMultiClick;
+    /** Get all pending clicks for a given node. */
+    private _getClicks;
+    /** Check the clicks that happened. */
+    private _checkClicks;
+    /** Generate matching breadcrumb(s) for the click. */
+    private _generateBreadcrumbs;
+    /** Schedule to check current clicks. */
+    private _scheduleCheckClicks;
+}
+/** exported for tests only */
+export declare function ignoreElement(node: HTMLElement, ignoreSelector: string): boolean;
+//# sourceMappingURL=handleClick.d.ts.map

package/types-ts3.8/coreHandlers/handleDom.d.ts

@@ -0,0 +1,13 @@
+import { INode } from '@sentry-internal/rrweb-snapshot';
+import { Breadcrumb } from '@sentry/types';
+import { ReplayContainer } from '../types';
+import { DomHandlerData } from './util/domUtils';
+export declare const handleDomListener: (replay: ReplayContainer) => (handlerData: DomHandlerData) => void;
+/** Get the base DOM breadcrumb. */
+export declare function getBaseDomBreadcrumb(target: Node | INode | null, message: string): Breadcrumb;
+/**
+ * An event handler to react to DOM events.
+ * Exported for tests.
+ */
+export declare function handleDom(handlerData: DomHandlerData): Breadcrumb | null;
+//# sourceMappingURL=handleDom.d.ts.map

package/types-ts3.8/coreHandlers/handleFetch.d.ts

@@ -0,0 +1,9 @@
+import { HandlerDataFetch } from '@sentry/types';
+import { NetworkRequestData, ReplayContainer, ReplayPerformanceEntry } from '../types';
+/** only exported for tests */
+export declare function handleFetch(handlerData: HandlerDataFetch): null | ReplayPerformanceEntry<NetworkRequestData>;
+/**
+ * Returns a listener to be added to `addInstrumentationHandler('fetch', listener)`.
+ */
+export declare function handleFetchSpanListener(replay: ReplayContainer): (handlerData: HandlerDataFetch) => void;
+//# sourceMappingURL=handleFetch.d.ts.map

package/types-ts3.8/coreHandlers/handleGlobalEvent.d.ts

@@ -0,0 +1,7 @@
+import { Event, EventHint } from '@sentry/types';
+import { ReplayContainer } from '../types';
+/**
+ * Returns a listener to be added to `addGlobalEventProcessor(listener)`.
+ */
+export declare function handleGlobalEventListener(replay: ReplayContainer, includeAfterSendEventHandling?: boolean): (event: Event, hint: EventHint) => Event | null;
+//# sourceMappingURL=handleGlobalEvent.d.ts.map

package/types-ts3.8/coreHandlers/handleHistory.d.ts

@@ -0,0 +1,11 @@
+import { ReplayContainer } from '../types';
+interface HistoryHandlerData {
+    from: string;
+    to: string;
+}
+/**
+ * Returns a listener to be added to `addInstrumentationHandler('history', listener)`.
+ */
+export declare function handleHistorySpanListener(replay: ReplayContainer): (handlerData: HistoryHandlerData) => void;
+export {};
+//# sourceMappingURL=handleHistory.d.ts.map

package/types-ts3.8/coreHandlers/handleKeyboardEvent.d.ts

@@ -0,0 +1,7 @@
+import { Breadcrumb } from '@sentry/types';
+import { ReplayContainer } from '../types';
+/** Handle keyboard events & create breadcrumbs. */
+export declare function handleKeyboardEvent(replay: ReplayContainer, event: KeyboardEvent): void;
+/** exported only for tests */
+export declare function getKeyboardBreadcrumb(event: KeyboardEvent): Breadcrumb | null;
+//# sourceMappingURL=handleKeyboardEvent.d.ts.map

package/types-ts3.8/coreHandlers/handleNetworkBreadcrumbs.d.ts

@@ -0,0 +1,17 @@
+import { Breadcrumb, BreadcrumbHint, TextEncoderInternal } from '@sentry/types';
+import { ReplayContainer, ReplayNetworkOptions } from '../types';
+interface ExtendedNetworkBreadcrumbsOptions extends ReplayNetworkOptions {
+    replay: ReplayContainer;
+    textEncoder: TextEncoderInternal;
+}
+/**
+ * This method does two things:
+ * - It enriches the regular XHR/fetch breadcrumbs with request/response size data
+ * - It captures the XHR/fetch breadcrumbs to the replay
+ *   (enriching it with further data that is _not_ added to the regular breadcrumbs)
+ */
+export declare function handleNetworkBreadcrumbs(replay: ReplayContainer): void;
+/** just exported for tests */
+export declare function beforeAddNetworkBreadcrumb(options: ExtendedNetworkBreadcrumbsOptions, breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void;
+export {};
+//# sourceMappingURL=handleNetworkBreadcrumbs.d.ts.map

package/types-ts3.8/coreHandlers/handleScope.d.ts

@@ -0,0 +1,13 @@
+import { Breadcrumb, Scope } from '@sentry/types';
+import { ReplayContainer } from '../types';
+import { ReplayFrame } from '../types/replayFrame';
+type BreadcrumbWithCategory = Required<Pick<Breadcrumb, 'category'>>;
+export declare const handleScopeListener: (replay: ReplayContainer) => (scope: Scope) => void;
+/**
+ * An event handler to handle scope changes.
+ */
+export declare function handleScope(scope: Scope): Breadcrumb | null;
+/** exported for tests only */
+export declare function normalizeConsoleBreadcrumb(breadcrumb: Pick<Breadcrumb, Exclude<keyof Breadcrumb, 'category'>> & BreadcrumbWithCategory): ReplayFrame;
+export {};
+//# sourceMappingURL=handleScope.d.ts.map

package/types-ts3.8/coreHandlers/handleXhr.d.ts

@@ -0,0 +1,9 @@
+import { HandlerDataXhr } from '@sentry/types';
+import { NetworkRequestData, ReplayContainer, ReplayPerformanceEntry } from '../types';
+/** only exported for tests */
+export declare function handleXhr(handlerData: HandlerDataXhr): ReplayPerformanceEntry<NetworkRequestData> | null;
+/**
+ * Returns a listener to be added to `addInstrumentationHandler('xhr', listener)`.
+ */
+export declare function handleXhrSpanListener(replay: ReplayContainer): (handlerData: HandlerDataXhr) => void;
+//# sourceMappingURL=handleXhr.d.ts.map

package/types-ts3.8/coreHandlers/performanceObserver.d.ts

@@ -0,0 +1,6 @@
+import { ReplayContainer } from '../types';
+/**
+ * Sets up a PerformanceObserver to listen to all performance entry types.
+ */
+export declare function setupPerformanceObserver(replay: ReplayContainer): PerformanceObserver;
+//# sourceMappingURL=performanceObserver.d.ts.map

package/types-ts3.8/coreHandlers/util/addBreadcrumbEvent.d.ts

@@ -0,0 +1,7 @@
+import { Breadcrumb } from '@sentry/types';
+import { ReplayContainer } from '../../types';
+/**
+ * Add a breadcrumb event to replay.
+ */
+export declare function addBreadcrumbEvent(replay: ReplayContainer, breadcrumb: Breadcrumb): void;
+//# sourceMappingURL=addBreadcrumbEvent.d.ts.map

package/types-ts3.8/coreHandlers/util/addNetworkBreadcrumb.d.ts

@@ -0,0 +1,4 @@
+import { NetworkRequestData, ReplayContainer, ReplayPerformanceEntry } from '../../types';
+/** Add a performance entry breadcrumb */
+export declare function addNetworkBreadcrumb(replay: ReplayContainer, result: ReplayPerformanceEntry<NetworkRequestData> | null): void;
+//# sourceMappingURL=addNetworkBreadcrumb.d.ts.map

package/types-ts3.8/coreHandlers/util/domUtils.d.ts

@@ -0,0 +1,19 @@
+import { INode } from '@sentry-internal/rrweb-snapshot';
+export interface DomHandlerData {
+    name: string;
+    event: Node | {
+        target: EventTarget;
+    };
+}
+/**
+ * For clicks, we check if the target is inside of a button or link
+ * If so, we use this as the target instead
+ * This is useful because if you click on the image in <button><img></button>,
+ * The target will be the image, not the button, which we don't want here
+ */
+export declare function getClickTargetNode(event: DomHandlerData['event'] | MouseEvent): Node | INode | null;
+/** Get the event target node. */
+export declare function getTargetNode(event: Node | {
+    target: EventTarget | null;
+}): Node | INode | null;
+//# sourceMappingURL=domUtils.d.ts.map

package/types-ts3.8/coreHandlers/util/fetchUtils.d.ts

@@ -0,0 +1,23 @@
+import { Breadcrumb, FetchBreadcrumbData, TextEncoderInternal } from '@sentry/types';
+import { FetchHint, ReplayContainer, ReplayNetworkOptions } from '../../types';
+/**
+ * Capture a fetch breadcrumb to a replay.
+ * This adds additional data (where approriate).
+ */
+export declare function captureFetchBreadcrumbToReplay(breadcrumb: Breadcrumb & {
+    data: FetchBreadcrumbData;
+}, hint: FetchHint, options: ReplayNetworkOptions & {
+    textEncoder: TextEncoderInternal;
+    replay: ReplayContainer;
+}): Promise<void>;
+/**
+ * Enrich a breadcrumb with additional data.
+ * This has to be sync & mutate the given breadcrumb,
+ * as the breadcrumb is afterwards consumed by other handlers.
+ */
+export declare function enrichFetchBreadcrumb(breadcrumb: Breadcrumb & {
+    data: FetchBreadcrumbData;
+}, hint: FetchHint, options: {
+    textEncoder: TextEncoderInternal;
+}): void;
+//# sourceMappingURL=fetchUtils.d.ts.map

package/types-ts3.8/coreHandlers/util/getAttributesToRecord.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Inclusion list of attributes that we want to record from the DOM element
+ */
+export declare function getAttributesToRecord(attributes: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=getAttributesToRecord.d.ts.map

package/types-ts3.8/coreHandlers/util/networkUtils.d.ts

@@ -0,0 +1,23 @@
+import { TextEncoderInternal } from '@sentry/types';
+import { NetworkBody, NetworkRequestData, ReplayNetworkRequestData, ReplayNetworkRequestOrResponse, ReplayPerformanceEntry } from '../../types';
+/** Get the size of a body. */
+export declare function getBodySize(body: RequestInit['body'], textEncoder: TextEncoder | TextEncoderInternal): number | undefined;
+/** Convert a Content-Length header to number/undefined.  */
+export declare function parseContentLengthHeader(header: string | null | undefined): number | undefined;
+/** Get the string representation of a body. */
+export declare function getBodyString(body: unknown): string | undefined;
+/** Convert ReplayNetworkRequestData to a PerformanceEntry. */
+export declare function makeNetworkReplayBreadcrumb(type: string, data: ReplayNetworkRequestData | null): ReplayPerformanceEntry<NetworkRequestData> | null;
+/** Get either a JSON network body, or a text representation. */
+export declare function getNetworkBody(bodyText: string | undefined): NetworkBody | undefined;
+/** Build the request or response part of a replay network breadcrumb that was skipped. */
+export declare function buildSkippedNetworkRequestOrResponse(bodySize: number | undefined): ReplayNetworkRequestOrResponse;
+/** Build the request or response part of a replay network breadcrumb. */
+export declare function buildNetworkRequestOrResponse(headers: Record<string, string>, bodySize: number | undefined, body: string | undefined): ReplayNetworkRequestOrResponse | undefined;
+/** Filter a set of headers */
+export declare function getAllowedHeaders(headers: Record<string, string>, allowedHeaders: string[]): Record<string, string>;
+/** Match an URL against a list of strings/Regex. */
+export declare function urlMatches(url: string, urls: (string | RegExp)[]): boolean;
+/** exported for tests */
+export declare function getFullUrl(url: string, baseURI?: string): string;
+//# sourceMappingURL=networkUtils.d.ts.map

package/types-ts3.8/coreHandlers/util/onWindowOpen.d.ts

@@ -0,0 +1,8 @@
+type WindowOpenHandler = () => void;
+/**
+ * Register a handler to be called when `window.open()` is called.
+ * Returns a cleanup function.
+ */
+export declare function onWindowOpen(cb: WindowOpenHandler): () => void;
+export {};
+//# sourceMappingURL=onWindowOpen.d.ts.map

package/types-ts3.8/coreHandlers/util/shouldSampleForBufferEvent.d.ts

@@ -0,0 +1,9 @@
+import { Event } from '@sentry/types';
+import { ReplayContainer } from '../../types';
+/**
+ * Determine if event should be sampled (only applies in buffer mode).
+ * When an event is captured by `hanldleGlobalEvent`, when in buffer mode
+ * we determine if we want to sample the error or not.
+ */
+export declare function shouldSampleForBufferEvent(replay: ReplayContainer, event: Event): boolean;
+//# sourceMappingURL=shouldSampleForBufferEvent.d.ts.map

package/types-ts3.8/coreHandlers/util/xhrUtils.d.ts

@@ -0,0 +1,22 @@
+import { Breadcrumb, TextEncoderInternal, XhrBreadcrumbData } from '@sentry/types';
+import { ReplayContainer, ReplayNetworkOptions, XhrHint } from '../../types';
+/**
+ * Capture an XHR breadcrumb to a replay.
+ * This adds additional data (where approriate).
+ */
+export declare function captureXhrBreadcrumbToReplay(breadcrumb: Breadcrumb & {
+    data: XhrBreadcrumbData;
+}, hint: XhrHint, options: ReplayNetworkOptions & {
+    replay: ReplayContainer;
+}): Promise<void>;
+/**
+ * Enrich a breadcrumb with additional data.
+ * This has to be sync & mutate the given breadcrumb,
+ * as the breadcrumb is afterwards consumed by other handlers.
+ */
+export declare function enrichXhrBreadcrumb(breadcrumb: Breadcrumb & {
+    data: XhrBreadcrumbData;
+}, hint: XhrHint, options: {
+    textEncoder: TextEncoderInternal;
+}): void;
+//# sourceMappingURL=xhrUtils.d.ts.map

package/types-ts3.8/eventBuffer/EventBufferArray.d.ts

@@ -0,0 +1,28 @@
+import { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';
+/**
+ * A basic event buffer that does not do any compression.
+ * Used as fallback if the compression worker cannot be loaded or is disabled.
+ */
+export declare class EventBufferArray implements EventBuffer {
+    /** All the events that are buffered to be sent. */
+    events: RecordingEvent[];
+    /** @inheritdoc */
+    hasCheckout: boolean;
+    private _totalSize;
+    constructor();
+    /*@inheritdoc */
+    readonly hasEvents: boolean;
+    /*@inheritdoc */
+    readonly type: EventBufferType;
+    /** @inheritdoc */
+    destroy(): void;
+    /** @inheritdoc */
+    addEvent(event: RecordingEvent): Promise<AddEventResult>;
+    /** @inheritdoc */
+    finish(): Promise<string>;
+    /** @inheritdoc */
+    clear(): void;
+    /** @inheritdoc */
+    getEarliestTimestamp(): number | null;
+}
+//# sourceMappingURL=EventBufferArray.d.ts.map

package/types-ts3.8/eventBuffer/EventBufferCompressionWorker.d.ts

@@ -0,0 +1,50 @@
+import { ReplayRecordingData } from '@sentry/types';
+import { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';
+/**
+ * Event buffer that uses a web worker to compress events.
+ * Exported only for testing.
+ */
+export declare class EventBufferCompressionWorker implements EventBuffer {
+    /** @inheritdoc */
+    hasCheckout: boolean;
+    private _worker;
+    private _earliestTimestamp;
+    private _totalSize;
+    constructor(worker: Worker);
+    /*@inheritdoc */
+    readonly hasEvents: boolean;
+    /*@inheritdoc */
+    readonly type: EventBufferType;
+    /**
+     * Ensure the worker is ready (or not).
+     * This will either resolve when the worker is ready, or reject if an error occured.
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * Destroy the event buffer.
+     */
+    destroy(): void;
+    /**
+     * Add an event to the event buffer.
+     *
+     * Returns true if event was successfuly received and processed by worker.
+     */
+    addEvent(event: RecordingEvent): Promise<AddEventResult>;
+    /**
+     * Finish the event buffer and return the compressed data.
+     */
+    finish(): Promise<ReplayRecordingData>;
+    /** @inheritdoc */
+    clear(): void;
+    /** @inheritdoc */
+    getEarliestTimestamp(): number | null;
+    /**
+     * Send the event to the worker.
+     */
+    private _sendEventToWorker;
+    /**
+     * Finish the request and return the compressed data from the worker.
+     */
+    private _finishRequest;
+}
+//# sourceMappingURL=EventBufferCompressionWorker.d.ts.map

package/types-ts3.8/eventBuffer/EventBufferProxy.d.ts

@@ -0,0 +1,42 @@
+import { ReplayRecordingData } from '@sentry/types';
+import { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';
+/**
+ * This proxy will try to use the compression worker, and fall back to use the simple buffer if an error occurs there.
+ * This can happen e.g. if the worker cannot be loaded.
+ * Exported only for testing.
+ */
+export declare class EventBufferProxy implements EventBuffer {
+    private _fallback;
+    private _compression;
+    private _used;
+    private _ensureWorkerIsLoadedPromise;
+    constructor(worker: Worker);
+    /*@inheritdoc */
+    readonly type: EventBufferType;
+    /*@inheritDoc */
+    readonly hasEvents: boolean;
+    /*@inheritdoc
+    @inheritdoc */
+    hasCheckout: boolean;
+    /** @inheritDoc */
+    destroy(): void;
+    /** @inheritdoc */
+    clear(): void;
+    /** @inheritdoc */
+    getEarliestTimestamp(): number | null;
+    /**
+     * Add an event to the event buffer.
+     *
+     * Returns true if event was successfully added.
+     */
+    addEvent(event: RecordingEvent): Promise<AddEventResult>;
+    /** @inheritDoc */
+    finish(): Promise<ReplayRecordingData>;
+    /** Ensure the worker has loaded. */
+    ensureWorkerIsLoaded(): Promise<void>;
+    /** Actually check if the worker has been loaded. */
+    private _ensureWorkerIsLoaded;
+    /** Switch the used buffer to the compression worker. */
+    private _switchToCompressionWorker;
+}
+//# sourceMappingURL=EventBufferProxy.d.ts.map

package/types-ts3.8/eventBuffer/WorkerHandler.d.ts

@@ -0,0 +1,27 @@
+import { WorkerRequest } from '../types';
+/**
+ * Event buffer that uses a web worker to compress events.
+ * Exported only for testing.
+ */
+export declare class WorkerHandler {
+    private _worker;
+    private _id;
+    private _ensureReadyPromise?;
+    constructor(worker: Worker);
+    /**
+     * Ensure the worker is ready (or not).
+     * This will either resolve when the worker is ready, or reject if an error occured.
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * Destroy the worker.
+     */
+    destroy(): void;
+    /**
+     * Post message to worker and wait for response before resolving promise.
+     */
+    postMessage<T>(method: WorkerRequest['method'], arg?: WorkerRequest['arg']): Promise<T>;
+    /** Get the current ID and increment it for the next call. */
+    private _getAndIncrementId;
+}
+//# sourceMappingURL=WorkerHandler.d.ts.map

package/types-ts3.8/eventBuffer/error.d.ts

@@ -0,0 +1,5 @@
+/** This error indicates that the event buffer size exceeded the limit.. */
+export declare class EventBufferSizeExceededError extends Error {
+    constructor();
+}
+//# sourceMappingURL=error.d.ts.map

package/types-ts3.8/eventBuffer/index.d.ts

@@ -0,0 +1,10 @@
+import { EventBuffer } from '../types';
+interface CreateEventBufferParams {
+    useCompression: boolean;
+}
+/**
+ * Create an event buffer for replays.
+ */
+export declare function createEventBuffer({ useCompression }: CreateEventBufferParams): EventBuffer;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+export { Replay } from './integration';
+export { ReplayEventType, ReplayEventWithTime, ReplayBreadcrumbFrame, ReplayBreadcrumbFrameEvent, ReplayOptionFrameEvent, ReplayFrame, ReplayFrameEvent, ReplaySpanFrame, ReplaySpanFrameEvent, } from './types';
+export * from './types/deprecated';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,73 @@
+import { Integration } from '@sentry/types';
+import { ReplayConfiguration, SendBufferedReplayOptions } from './types';
+/**
+ * The main replay integration class, to be passed to `init({  integrations: [] })`.
+ */
+export declare class Replay implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * Options to pass to `rrweb.record()`
+     */
+    private readonly _recordingOptions;
+    /**
+     * Initial options passed to the replay integration, merged with default values.
+     * Note: `sessionSampleRate` and `errorSampleRate` are not required here, as they
+     * can only be finally set when setupOnce() is called.
+     *
+     * @private
+     */
+    private readonly _initialOptions;
+    private _replay?;
+    constructor({ flushMinDelay, flushMaxDelay, minReplayDuration, maxReplayDuration, stickySession, useCompression, _experiments, sessionSampleRate, errorSampleRate, maskAllText, maskAllInputs, blockAllMedia, mutationBreadcrumbLimit, mutationLimit, slowClickTimeout, slowClickIgnoreSelectors, networkDetailAllowUrls, networkDetailDenyUrls, networkCaptureBodies, networkRequestHeaders, networkResponseHeaders, mask, unmask, block, unblock, ignore, maskFn, beforeAddRecordingEvent, blockClass, blockSelector, maskInputOptions, maskTextClass, maskTextSelector, ignoreClass, }?: ReplayConfiguration);
+    /*If replay has already been initialized
+    Update _isInitialized */
+    protected _isInitialized: boolean;
+    /**
+     * Setup and initialize replay container
+     */
+    setupOnce(): void;
+    /**
+     * Start a replay regardless of sampling rate. Calling this will always
+     * create a new session. Will throw an error if replay is already in progress.
+     *
+     * Creates or loads a session, attaches listeners to varying events (DOM,
+     * PerformanceObserver, Recording, Sentry SDK, etc)
+     */
+    start(): void;
+    /**
+     * Start replay buffering. Buffers until `flush()` is called or, if
+     * `replaysOnErrorSampleRate` > 0, until an error occurs.
+     */
+    startBuffering(): void;
+    /**
+     * Currently, this needs to be manually called (e.g. for tests). Sentry SDK
+     * does not support a teardown
+     */
+    stop(): Promise<void>;
+    /**
+     * If not in "session" recording mode, flush event buffer which will create a new replay.
+     * Unless `continueRecording` is false, the replay will continue to record and
+     * behave as a "session"-based replay.
+     *
+     * Otherwise, queue up a flush.
+     */
+    flush(options?: SendBufferedReplayOptions): Promise<void>;
+    /**
+     * Get the current session ID.
+     */
+    getReplayId(): string | undefined;
+    /**
+     * Initializes replay.
+     */
+    protected _initialize(): void;
+    /** Setup the integration. */
+    private _setup;
+}
+//# sourceMappingURL=integration.d.ts.map