@sentry/replay 10.70.0 → 11.0.0-alpha.1

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

@@ -1,52 +0,0 @@
-import { ReplayRecordingData } from '@sentry/core';
-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;
-    /** @inheritdoc */
-    waitForCheckout: 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 occurred.
-     */
-    ensureReady(): Promise<void>;
-    /**
-     * Destroy the event buffer.
-     */
-    destroy(): void;
-    /**
-     * Add an event to the event buffer.
-     *
-     * Returns true if event was successfully 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/build/npm/types-ts3.8/eventBuffer/EventBufferProxy.d.ts

@@ -1,45 +0,0 @@
-import { ReplayRecordingData } from '@sentry/core';
-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
-    @inheritdoc */
-    waitForCheckout: boolean;
-    /*@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/build/npm/types-ts3.8/eventBuffer/WorkerHandler.d.ts

@@ -1,29 +0,0 @@
-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?;
-    private _pending;
-    constructor(worker: Worker);
-    /**
-     * Ensure the worker is ready (or not).
-     * This will either resolve when the worker is ready, or reject if an error occurred.
-     */
-    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>;
-    private _onMessage;
-    /** Get the current ID and increment it for the next call. */
-    private _getAndIncrementId;
-}
-//# sourceMappingURL=WorkerHandler.d.ts.map

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

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

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

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

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

@@ -1,4 +0,0 @@
-export { replayIntegration } from './integration';
-export { ReplayConfiguration, ReplayEventType, ReplayEventWithTime, ReplayBreadcrumbFrame, ReplayBreadcrumbFrameEvent, ReplayOptionFrameEvent, ReplayFrame, ReplayFrameEvent, ReplaySpanFrame, ReplaySpanFrameEvent, CanvasManagerInterface, CanvasManagerOptions, } from './types';
-export { getReplay } from './util/getReplay';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,117 +0,0 @@
-import { Client, Integration, ReplayRecordingMode, StreamedSpanJSON } from '@sentry/core';
-import { ReplayConfiguration, SendBufferedReplayOptions } from './types';
-/**
- * Instruments the global Request constructor to store the original body.
- * This allows us to retrieve the original body value later, since Request
- * converts string bodies to ReadableStreams.
- */
-export declare function _INTERNAL_instrumentRequestInterface(): void;
-/**
- * Sentry integration for [Session Replay](https://sentry.io/for/session-replay/).
- *
- * See the [Replay documentation](https://docs.sentry.io/platforms/javascript/guides/session-replay/) for more information.
- *
- * @example
- *
- * ```
- * Sentry.init({
- *   dsn: '__DSN__',
- *   integrations: [Sentry.replayIntegration()],
- * });
- * ```
- */
-export declare const replayIntegration: (options?: ReplayConfiguration) => Replay;
-/**
- * Replay integration
- */
-export declare class Replay implements Integration {
-    /**
-     * @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, workerUrl, _experiments, maskAllText, maskAllInputs, blockAllMedia, mutationBreadcrumbLimit, mutationLimit, slowClickTimeout, slowClickIgnoreSelectors, networkDetailAllowUrls, networkDetailDenyUrls, networkCaptureBodies, networkRequestHeaders, networkResponseHeaders, mask, maskAttributes, unmask, block, unblock, ignore, maskFn, beforeAddRecordingEvent, beforeErrorSampling, onError, attachRawBodyFromRequest, }?: ReplayConfiguration);
-    /*If replay has already been initialized
-    Update _isInitialized */
-    protected _isInitialized: boolean;
-    /**
-     * Setup and initialize replay container
-     */
-    afterAllSetup(client: Client): void;
-    /**
-     * Start a replay regardless of sampling rate. Calling this will always
-     * create a new session. Will log a message 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
-     *
-     * @param options.flush - Whether to flush the pending replay segment when stopping.
-     * When recording in `session` mode, `stop()` flushes the buffered-but-unsent segment by
-     * default (`flush: true`), matching the previous behavior. Pass `flush: false` to stop
-     * recording without sending that pending segment — useful when a user withdraws consent
-     * and no further data should leave the browser.
-     *
-     * Note: `flush: false` only prevents the *pending* (final) segment from being sent. It does
-     * **not** retract segments that were already sent earlier during `session` recording.
-     */
-    stop(options?: {
-        flush?: boolean;
-    }): Promise<void>;
-    /**
-     * If not in "session" recording mode, flush event buffer which will create a new replay.
-     * If replay is not enabled, a new session replay is started.
-     * 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.
-     *
-     * @param onlyIfSampled - If true, will only return the session ID if the session is sampled.
-     *
-     */
-    getReplayId(onlyIfSampled?: boolean): string | undefined;
-    /**
-     * Get the current recording mode. This can be either `session` or `buffer`.
-     *
-     * `session`: Recording the whole session, sending it continuously
-     * `buffer`: Always keeping the last 60s of recording, requires:
-     *   - having replaysOnErrorSampleRate > 0 to capture replay when an error occurs
-     *   - or calling `flush()` to send the replay
-     */
-    getRecordingMode(): ReplayRecordingMode | undefined;
-    processSpan(span: StreamedSpanJSON): void;
-    /**
-     * Initializes replay.
-     */
-    protected _initialize(client: Client): void;
-    /** Setup the integration. */
-    private _setup;
-    /** Get canvas options from ReplayCanvas integration, if it is also added. */
-    private _maybeLoadFromReplayCanvasIntegration;
-}
-//# sourceMappingURL=integration.d.ts.map

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

@@ -1,320 +0,0 @@
-import { ReplayRecordingMode, ReplayStopReason, Span } from '@sentry/core';
-import { ClickDetector } from './coreHandlers/handleClick';
-import { AddEventResult, AddUpdateCallback, AllPerformanceEntry, AllPerformanceEntryData, EventBuffer, InternalEventContext, RecordingEvent, RecordingOptions, ReplayContainer as ReplayContainerInterface, ReplayPerformanceEntry, ReplayPluginOptions, SendBufferedReplayOptions, Session, Timeouts } from './types';
-import { SKIPPED } from './util/throttle';
-import { THROTTLED } from './util/throttle';
-/**
- * The main replay container class, which holds all the state and methods for recording and sending replays.
- */
-export declare class ReplayContainer implements ReplayContainerInterface {
-    eventBuffer: EventBuffer | null;
-    performanceEntries: AllPerformanceEntry[];
-    replayPerformanceEntries: ReplayPerformanceEntry<AllPerformanceEntryData>[];
-    session: Session | undefined;
-    clickDetector: ClickDetector | undefined;
-    /**
-     * Recording can happen in one of two modes:
-     *   - session: Record the whole session, sending it continuously
-     *   - buffer: Always keep the last 60s of recording, requires:
-     *     - having replaysOnErrorSampleRate > 0 to capture replay when an error occurs
-     *     - or calling `flush()` to send the replay
-     */
-    recordingMode: ReplayRecordingMode;
-    /**
-     * The current or last active span.
-     * This is only available when performance is enabled.
-     */
-    lastActiveSpan?: Span;
-    /**
-     * These are here so we can overwrite them in tests etc.
-     * @hidden
-     */
-    readonly timeouts: Timeouts;
-    /** The replay has to be manually started, because no sample rate (neither session or error) was provided. */
-    private _requiresManualStart;
-    private _throttledAddEvent;
-    /**
-     * Options to pass to `rrweb.record()`
-     */
-    private readonly _recordingOptions;
-    private readonly _options;
-    private _performanceCleanupCallback?;
-    private _debouncedFlush;
-    private _flushLock;
-    /**
-     * Timestamp of the last user activity. This lives across sessions.
-     */
-    private _lastActivity;
-    /**
-     * Is the integration currently active?
-     */
-    private _isEnabled;
-    /**
-     * Paused is a state where:
-     * - DOM Recording is not listening at all
-     * - Nothing will be added to event buffer (e.g. core SDK events)
-     */
-    private _isPaused;
-    /**
-     * Have we attached listeners to the core SDK?
-     * Note we have to track this as there is no way to remove instrumentation handlers.
-     */
-    private _hasInitializedCoreListeners;
-    /**
-     * Function to stop recording
-     */
-    private _stopRecording;
-    private _context;
-    /**
-     * Internal use for canvas recording options
-     */
-    private _canvas;
-    /**
-     * Handle when visibility of the page content changes. Opening a new tab will
-     * cause the state to change to hidden because of content of current page will
-     * be hidden. Likewise, moving a different window to cover the contents of the
-     * page will also trigger a change to a hidden state.
-     */
-    private _handleVisibilityChange;
-    /**
-     * Handle when page is blurred
-     */
-    private _handleWindowBlur;
-    /**
-     * Handle when page is focused
-     */
-    private _handleWindowFocus;
-    /** Ensure page remains active when a key is pressed. */
-    private _handleKeyboardEvent;
-    constructor({ options, recordingOptions, }: {
-        options: ReplayPluginOptions;
-        recordingOptions: RecordingOptions;
-    });
-    /** Get the event context. */
-    getContext(): InternalEventContext;
-    /** If recording is currently enabled. */
-    isEnabled(): boolean;
-    /** If recording is currently paused. */
-    isPaused(): boolean;
-    /**
-     * Determine if canvas recording is enabled
-     */
-    isRecordingCanvas(): boolean;
-    /** Get the replay integration options. */
-    getOptions(): ReplayPluginOptions;
-    /** A wrapper to conditionally capture exceptions. */
-    handleException(error: unknown): void;
-    /**
-     * Initializes the plugin based on sampling configuration. Should not be
-     * called outside of constructor.
-     */
-    initializeSampling(previousSessionId?: string): void;
-    /**
-     * Start a replay regardless of sampling rate. Calling this will always
-     * create a new session. Will log a message 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, an error occurs.
-     */
-    startBuffering(): void;
-    /**
-     * Start recording.
-     *
-     * Note that this will cause a new DOM checkout
-     */
-    startRecording(): void;
-    /**
-     * Stops the recording, if it was running.
-     *
-     * Returns true if it was previously stopped, or is now stopped,
-     * otherwise false.
-     */
-    stopRecording(): boolean;
-    /**
-     * Currently, this needs to be manually called (e.g. for tests). Sentry SDK
-     * does not support a teardown
-     */
-    stop({ forceFlush, reason, }?: {
-        forceFlush?: boolean;
-        reason?: ReplayStopReason;
-    }): Promise<void>;
-    /**
-     * Pause some replay functionality. See comments for `_isPaused`.
-     * This differs from stop as this only stops DOM recording, it is
-     * not as thorough of a shutdown as `stop()`.
-     */
-    pause(): void;
-    /**
-     * Resumes recording, see notes for `pause().
-     *
-     * Note that calling `startRecording()` here will cause a
-     * new DOM checkout.`
-     */
-    resume(): 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.
-     */
-    sendBufferedReplayOrFlush({ continueRecording }?: SendBufferedReplayOptions): Promise<void>;
-    /**
-     * We want to batch uploads of replay events. Save events only if
-     * `<flushMinDelay>` milliseconds have elapsed since the last event
-     * *OR* if `<flushMaxDelay>` milliseconds have elapsed.
-     *
-     * Accepts a callback to perform side-effects and returns true to stop batch
-     * processing and hand back control to caller.
-     */
-    addUpdate(cb: AddUpdateCallback): void;
-    /**
-     * Updates the user activity timestamp and resumes recording. This should be
-     * called in an event handler for a user action that we consider as the user
-     * being "active" (e.g. a mouse click).
-     */
-    triggerUserActivity(): void;
-    /**
-     * Updates the user activity timestamp *without* resuming
-     * recording. Some user events (e.g. keydown) can be create
-     * low-value replays that only contain the keypress as a
-     * breadcrumb. Instead this would require other events to
-     * create a new replay after a session has expired.
-     */
-    updateUserActivity(): void;
-    /**
-     * Only flush if `this.recordingMode === 'session'`
-     */
-    conditionalFlush(): Promise<void>;
-    /**
-     * Flush using debounce flush
-     */
-    flush(): Promise<void>;
-    /**
-     * Always flush via `_debouncedFlush` so that we do not have flushes triggered
-     * from calling both `flush` and `_debouncedFlush`. Otherwise, there could be
-     * cases of multiple flushes happening closely together.
-     */
-    flushImmediate(): Promise<void>;
-    /**
-     * Cancels queued up flushes.
-     */
-    cancelFlush(): void;
-    /** Get the current session (=replay) ID
-     *
-     * @param onlyIfSampled - If true, will only return the session ID if the session is sampled.
-     */
-    getSessionId(onlyIfSampled?: boolean): string | undefined;
-    /**
-     * Checks if recording should be stopped due to user inactivity. Otherwise
-     * check if session is expired and create a new session if so. Triggers a new
-     * full snapshot on new session.
-     *
-     * Returns true if session is not expired, false otherwise.
-     * @hidden
-     */
-    checkAndHandleExpiredSession(): boolean | void;
-    /**
-     * Capture some initial state that can change throughout the lifespan of the
-     * replay. This is required because otherwise they would be captured at the
-     * first flush.
-     */
-    setInitialState(): void;
-    /**
-     * Add a breadcrumb event, that may be throttled.
-     * If it was throttled, we add a custom breadcrumb to indicate that.
-     */
-    throttledAddEvent(event: RecordingEvent, isCheckout?: boolean): typeof THROTTLED | typeof SKIPPED | Promise<AddEventResult | null>;
-    /**
-     * This will get the parametrized route name of the current page.
-     * This is only available if performance is enabled, and if an instrumented router is used.
-     */
-    getCurrentRoute(): string | undefined;
-    /**
-     * Initialize and start all listeners to varying events (DOM,
-     * Performance Observer, Recording, Sentry SDK, etc)
-     */
-    private _initializeRecording;
-    /**
-     * Loads (or refreshes) the current session.
-     */
-    private _initializeSessionForSampling;
-    /**
-     * Checks and potentially refreshes the current session.
-     * Returns false if session is not recorded.
-     */
-    private _checkSession;
-    /**
-     * Refresh a session with a new one.
-     * This stops the current session (without forcing a flush, as that would never work since we are expired),
-     * and then does a new sampling based on the refreshed session.
-     */
-    private _refreshSession;
-    /**
-     * Adds listeners to record events for the replay
-     */
-    private _addListeners;
-    /**
-     * Cleans up listeners that were created in `_addListeners`
-     */
-    private _removeListeners;
-    /**
-     * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)
-     */
-    private _doChangeToBackgroundTasks;
-    /**
-     * Tasks to run when we consider a page to be visible (via focus and/or visibility)
-     */
-    private _doChangeToForegroundTasks;
-    /**
-     * Update user activity (across session lifespans)
-     */
-    private _updateUserActivity;
-    /**
-     * Updates the session's last activity timestamp
-     */
-    private _updateSessionActivity;
-    /**
-     * Helper to create (and buffer) a replay breadcrumb from a core SDK breadcrumb
-     */
-    private _createCustomBreadcrumb;
-    /**
-     * Observed performance events are added to `this.performanceEntries`. These
-     * are included in the replay event before it is finished and sent to Sentry.
-     */
-    private _addPerformanceEntries;
-    /**
-     * Clear _context
-     */
-    private _clearContext;
-    /** Update the initial timestamp based on the buffer content. */
-    private _updateInitialTimestampFromEventBuffer;
-    /**
-     * Return and clear _context
-     */
-    private _popEventContext;
-    /**
-     * Flushes replay event buffer to Sentry.
-     *
-     * Performance events are only added right before flushing - this is
-     * due to the buffered performance observer events.
-     *
-     * Should never be called directly, only by `flush`
-     */
-    private _runFlush;
-    /**
-     * Flush recording data to Sentry. Creates a lock so that only a single flush
-     * can be active at a time. Do not call this directly.
-     */
-    private _flush;
-    /** Save the session, if it is sticky */
-    private _maybeSaveSession;
-    /** Handler for rrweb.record.onMutation */
-    private _onMutationHandler;
-}
-//# sourceMappingURL=replay.d.ts.map

package/build/npm/types-ts3.8/session/Session.d.ts

@@ -1,8 +0,0 @@
-import { Sampled, Session } from '../types';
-/**
- * Get a session with defaults & applied sampling.
- */
-export declare function makeSession(session: Partial<Session> & {
-    sampled: Sampled;
-}): Session;
-//# sourceMappingURL=Session.d.ts.map

package/build/npm/types-ts3.8/session/clearSession.d.ts

@@ -1,6 +0,0 @@
-import { ReplayContainer } from '../../src/types';
-/**
- * Removes the session from Session Storage and unsets session in replay instance
- */
-export declare function clearSession(replay: ReplayContainer): void;
-//# sourceMappingURL=clearSession.d.ts.map

package/build/npm/types-ts3.8/session/createSession.d.ts

@@ -1,14 +0,0 @@
-import { Sampled, Session, SessionOptions } from '../types';
-/**
- * Get the sampled status for a session based on sample rates & current sampled status.
- */
-export declare function getSessionSampleType(sessionSampleRate: number, allowBuffering: boolean): Sampled;
-/**
- * Create a new session, which in its current implementation is a Sentry event
- * that all replays will be saved to as attachments. Currently, we only expect
- * one of these Sentry events per "replay session".
- */
-export declare function createSession({ sessionSampleRate, allowBuffering, stickySession }: SessionOptions, { previousSessionId }?: {
-    previousSessionId?: string;
-}): Session;
-//# sourceMappingURL=createSession.d.ts.map

package/build/npm/types-ts3.8/session/fetchSession.d.ts

@@ -1,6 +0,0 @@
-import { Session } from '../types';
-/**
- * Fetches a session from storage
- */
-export declare function fetchSession(): Session | null;
-//# sourceMappingURL=fetchSession.d.ts.map

package/build/npm/types-ts3.8/session/loadOrCreateSession.d.ts

@@ -1,11 +0,0 @@
-import { Session, SessionOptions } from '../types';
-/**
- * Get or create a session, when initializing the replay.
- * Returns a session that may be unsampled.
- */
-export declare function loadOrCreateSession({ sessionIdleExpire, maxReplayDuration, previousSessionId, }: {
-    sessionIdleExpire: number;
-    maxReplayDuration: number;
-    previousSessionId?: string;
-}, sessionOptions: SessionOptions): Session;
-//# sourceMappingURL=loadOrCreateSession.d.ts.map

package/build/npm/types-ts3.8/session/saveSession.d.ts

@@ -1,6 +0,0 @@
-import { Session } from '../types';
-/**
- * Save a session to session storage.
- */
-export declare function saveSession(session: Session): void;
-//# sourceMappingURL=saveSession.d.ts.map

package/build/npm/types-ts3.8/session/shouldRefreshSession.d.ts

@@ -1,7 +0,0 @@
-import { Session } from '../types';
-/** If the session should be refreshed or not. */
-export declare function shouldRefreshSession(session: Session, { sessionIdleExpire, maxReplayDuration }: {
-    sessionIdleExpire: number;
-    maxReplayDuration: number;
-}): boolean;
-//# sourceMappingURL=shouldRefreshSession.d.ts.map

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

@@ -1,6 +0,0 @@
-export * from './performance';
-export * from './replay';
-export * from './replayFrame';
-export * from './request';
-export * from './rrweb';
-//# sourceMappingURL=index.d.ts.map