@sentry/replay 7.67.0-beta.0 → 7.68.0

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

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

@@ -0,0 +1,7 @@
+import { DsnComponents, ReplayEnvelope, ReplayEvent, ReplayRecordingData } from '@sentry/types';
+/**
+ * Create a replay envelope ready to be sent.
+ * This includes both the replay event, as well as the recording data.
+ */
+export declare function createReplayEnvelope(replayEvent: ReplayEvent, recordingData: ReplayRecordingData, dsn: DsnComponents, tunnel?: string): ReplayEnvelope;
+//# sourceMappingURL=createReplayEnvelope.d.ts.map

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

@@ -0,0 +1,30 @@
+type DebouncedCallback = {
+    (): void | unknown;
+    flush: () => void | unknown;
+    cancel: () => void;
+};
+type CallbackFunction = () => unknown;
+type DebounceOptions = {
+    maxWait?: number;
+};
+/**
+ * Heavily simplified debounce function based on lodash.debounce.
+ *
+ * This function takes a callback function (@param fun) and delays its invocation
+ * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,
+ * which ensures that the callback is invoked at least once after the specified max. wait time.
+ *
+ * @param func the function whose invocation is to be debounced
+ * @param wait the minimum time until the function is invoked after it was called once
+ * @param options the options object, which can contain the `maxWait` property
+ *
+ * @returns the debounced version of the function, which needs to be called at least once to start the
+ *          debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc
+ *          was already invoked in the meantime, return @param func's return value.
+ *          The debounced function has two additional properties:
+ *          - `flush`: Invokes the debounced function immediately and returns its return value
+ *          - `cancel`: Cancels the debouncing process and resets the debouncing timer
+ */
+export declare function debounce(func: CallbackFunction, wait: number, options?: DebounceOptions): DebouncedCallback;
+export {};
+//# sourceMappingURL=debounce.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * There are some difficulties diagnosing why there are duplicate navigation
+ * entries. We've witnessed several intermittent results:
+ * - duplicate entries have duration = 0
+ * - duplicate entries are the same object reference
+ * - none of the above
+ *
+ * Compare the values of several keys to determine if the entries are duplicates or not.
+ */
+export declare function dedupePerformanceEntries(currentList: PerformanceEntryList, newList: PerformanceEntryList): PerformanceEntryList;
+//# sourceMappingURL=dedupePerformanceEntries.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ErrorEvent, Event, ReplayEvent, TransactionEvent } from '@sentry/types';
+/** If the event is an error event */
+export declare function isErrorEvent(event: Event): event is ErrorEvent;
+/** If the event is a transaction event */
+export declare function isTransactionEvent(event: Event): event is TransactionEvent;
+/** If the event is an replay event */
+export declare function isReplayEvent(event: Event): event is ReplayEvent;
+//# sourceMappingURL=eventUtils.d.ts.map

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

@@ -0,0 +1,19 @@
+import { DeprecatedPrivacyOptions, ReplayIntegrationPrivacyOptions } from '../types';
+type GetPrivacyOptions = Required<Pick<ReplayIntegrationPrivacyOptions, Exclude<keyof ReplayIntegrationPrivacyOptions, 'maskFn'>>> & Pick<DeprecatedPrivacyOptions, Exclude<keyof DeprecatedPrivacyOptions, 'maskInputOptions'>>;
+interface GetPrivacyReturn {
+    maskTextSelector: string;
+    unmaskTextSelector: string;
+    maskInputSelector: string;
+    unmaskInputSelector: string;
+    blockSelector: string;
+    unblockSelector: string;
+    ignoreSelector: string;
+    blockClass?: RegExp;
+    maskTextClass?: RegExp;
+}
+/**
+ * Returns privacy related configuration for use in rrweb
+ */
+export declare function getPrivacyOptions({ mask, unmask, block, unblock, ignore, blockClass, blockSelector, maskTextClass, maskTextSelector, ignoreClass, }: GetPrivacyOptions): GetPrivacyReturn;
+export {};
+//# sourceMappingURL=getPrivacyOptions.d.ts.map

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

@@ -0,0 +1,14 @@
+import { RecordingEvent, ReplayContainer, ReplayOptionFrameEvent } from '../types';
+type RecordingEmitCallback = (event: RecordingEvent, isCheckout?: boolean) => void;
+/**
+ * Handler for recording events.
+ *
+ * Adds to event buffer, and has varying flushing behaviors if the event was a checkout.
+ */
+export declare function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCallback;
+/**
+ * Exported for tests
+ */
+export declare function createOptionsEvent(replay: ReplayContainer): ReplayOptionFrameEvent;
+export {};
+//# sourceMappingURL=handleRecordingEmit.d.ts.map

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

@@ -0,0 +1,3 @@
+/** If sessionStorage is available. */
+export declare function hasSessionStorage(): boolean;
+//# sourceMappingURL=hasSessionStorage.d.ts.map

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

@@ -0,0 +1,5 @@
+/**
+ * Returns true if we are in the browser.
+ */
+export declare function isBrowser(): boolean;
+//# sourceMappingURL=isBrowser.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * Given an initial timestamp and an expiry duration, checks to see if current
+ * time should be considered as expired.
+ */
+export declare function isExpired(initialTime: null | number, expiry: undefined | number, targetTime?: number): boolean;
+//# sourceMappingURL=isExpired.d.ts.map

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

@@ -0,0 +1,6 @@
+import { Event, EventHint } from '@sentry/types';
+/**
+ * Returns true if we think the given event is an error originating inside of rrweb.
+ */
+export declare function isRrwebError(event: Event, hint: EventHint): boolean;
+//# sourceMappingURL=isRrwebError.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Given a sample rate, returns true if replay should be sampled.
+ *
+ * 1.0 = 100% sampling
+ * 0.0 = 0% sampling
+ */
+export declare function isSampled(sampleRate?: number): boolean;
+//# sourceMappingURL=isSampled.d.ts.map

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

@@ -0,0 +1,10 @@
+import { Session } from '../types';
+/**
+ * Checks to see if session is expired
+ */
+export declare function isSessionExpired(session: Session, { maxReplayDuration, sessionIdleExpire, targetTime, }: {
+    maxReplayDuration: number;
+    sessionIdleExpire: number;
+    targetTime?: number;
+}): boolean;
+//# sourceMappingURL=isSessionExpired.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.
+ */
+export declare function logInfo(message: string, shouldAddBreadcrumb?: boolean): void;
+/**
+ * Log a message, and add a breadcrumb in the next tick.
+ * This is necessary when the breadcrumb may be added before the replay is initialized.
+ */
+export declare function logInfoNextTick(message: string, shouldAddBreadcrumb?: boolean): void;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1,9 @@
+import { ReplayRecordingData } from '@sentry/types';
+/**
+ * Prepare the recording data ready to be sent.
+ */
+export declare function prepareRecordingData({ recordingData, headers, }: {
+    recordingData: ReplayRecordingData;
+    headers: Record<string, unknown>;
+}): ReplayRecordingData;
+//# sourceMappingURL=prepareRecordingData.d.ts.map

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

@@ -0,0 +1,15 @@
+import { Scope } from '@sentry/core';
+import { IntegrationIndex } from '@sentry/core/build/types/integration';
+import { Client, ReplayEvent } from '@sentry/types';
+/**
+ * Prepare a replay event & enrich it with the SDK metadata.
+ */
+export declare function prepareReplayEvent({ client, scope, replayId: event_id, event, }: {
+    client: Client & {
+        _integrations?: IntegrationIndex;
+    };
+    scope: Scope;
+    replayId: string;
+    event: ReplayEvent;
+}): Promise<ReplayEvent | null>;
+//# sourceMappingURL=prepareReplayEvent.d.ts.map

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

@@ -0,0 +1,9 @@
+import { SendReplayData } from '../types';
+/**
+ * Finalize and send the current replay event to Sentry
+ */
+export declare function sendReplay(replayData: SendReplayData, retryConfig?: {
+    count: number;
+    interval: number;
+}): Promise<unknown>;
+//# sourceMappingURL=sendReplay.d.ts.map

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

@@ -0,0 +1,13 @@
+import { TransportMakeRequestResponse } from '@sentry/types';
+import { SendReplayData } from '../types';
+/**
+ * Send replay attachment using `fetch()`
+ */
+export declare function sendReplayRequest({ recordingData, replayId, segmentId: segment_id, eventContext, timestamp, session, }: SendReplayData): Promise<void | TransportMakeRequestResponse>;
+/**
+ * This error indicates that the transport returned an invalid status code.
+ */
+export declare class TransportStatusCodeError extends Error {
+    constructor(statusCode: number);
+}
+//# sourceMappingURL=sendReplayRequest.d.ts.map

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

@@ -0,0 +1,7 @@
+import { ReplayContainer } from '../types';
+/**
+ * Check whether a given request URL should be filtered out. This is so we
+ * don't log Sentry ingest requests.
+ */
+export declare function shouldFilterRequest(replay: ReplayContainer, url: string): boolean;
+//# sourceMappingURL=shouldFilterRequest.d.ts.map

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

@@ -0,0 +1,12 @@
+export declare const THROTTLED = "__THROTTLED";
+export declare const SKIPPED = "__SKIPPED";
+/**
+ * Create a throttled function off a given function.
+ * When calling the throttled function, it will call the original function only
+ * if it hasn't been called more than `maxCount` times in the last `durationSeconds`.
+ *
+ * Returns `THROTTLED` if throttled for the first time, after that `SKIPPED`,
+ * or else the return value of the original function.
+ */
+export declare function throttle<T extends (...rest: any[]) => any>(fn: T, maxCount: number, durationSeconds: number): (...rest: Parameters<T>) => ReturnType<T> | typeof THROTTLED | typeof SKIPPED;
+//# sourceMappingURL=throttle.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Converts a timestamp to ms, if it was in s, or keeps it as ms.
+ */
+export declare function timestampToMs(timestamp: number): number;
+/**
+ * Converts a timestamp to s, if it was in ms, or keeps it as s.
+ */
+export declare function timestampToS(timestamp: number): number;
+//# sourceMappingURL=timestamp.d.ts.map

package/types-ts3.8/util/truncateJson/completeJson.d.ts

@@ -0,0 +1,9 @@
+import { JsonToken } from './constants';
+/**
+ * Complete an incomplete JSON string.
+ * This will ensure that the last element always has a `"~~"` to indicate it was truncated.
+ * For example, `[1,2,` will be completed to `[1,2,"~~"]`
+ * and `{"aa":"b` will be completed to `{"aa":"b~~"}`
+ */
+export declare function completeJson(incompleteJson: string, stack: JsonToken[]): string;
+//# sourceMappingURL=completeJson.d.ts.map

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

@@ -0,0 +1,12 @@
+export declare const OBJ = 10;
+export declare const OBJ_KEY = 11;
+export declare const OBJ_KEY_STR = 12;
+export declare const OBJ_VAL = 13;
+export declare const OBJ_VAL_STR = 14;
+export declare const OBJ_VAL_COMPLETED = 15;
+export declare const ARR = 20;
+export declare const ARR_VAL = 21;
+export declare const ARR_VAL_STR = 22;
+export declare const ARR_VAL_COMPLETED = 23;
+export type JsonToken = typeof OBJ | typeof OBJ_KEY | typeof OBJ_KEY_STR | typeof OBJ_VAL | typeof OBJ_VAL_STR | typeof OBJ_VAL_COMPLETED | typeof ARR | typeof ARR_VAL | typeof ARR_VAL_STR | typeof ARR_VAL_COMPLETED;
+//# sourceMappingURL=constants.d.ts.map

package/types-ts3.8/util/truncateJson/evaluateJson.d.ts

@@ -0,0 +1,6 @@
+import { JsonToken } from './constants';
+/**
+ * Evaluate an (incomplete) JSON string.
+ */
+export declare function evaluateJson(json: string): JsonToken[];
+//# sourceMappingURL=evaluateJson.d.ts.map

package/types-ts3.8/util/truncateJson/fixJson.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Takes an incomplete JSON string, and returns a hopefully valid JSON string.
+ * Note that this _can_ fail, so you should check the return value is valid JSON.
+ */
+export declare function fixJson(incompleteJson: string): string;
+//# sourceMappingURL=fixJson.d.ts.map

package/types/session/shouldRefreshSession.d.ts

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

package/types/session/shouldRefreshSession.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shouldRefreshSession.d.ts","sourceRoot":"","sources":["../../../../src/session/shouldRefreshSession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGlD,iDAAiD;AACjD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAYlF"}

package/types/util/maskAttribute.d.ts

@@ -1,15 +0,0 @@
-import type { getPrivacyOptions } from './getPrivacyOptions';
-interface MaskAttributeParams {
-    maskAttributes: string[];
-    maskAllText: boolean;
-    privacyOptions: ReturnType<typeof getPrivacyOptions>;
-    key: string;
-    value: string;
-    el: HTMLElement;
-}
-/**
- * Masks an attribute if necessary, otherwise return attribute value as-is.
- */
-export declare function maskAttribute({ el, key, maskAttributes, maskAllText, privacyOptions, value, }: MaskAttributeParams): string;
-export {};
-//# sourceMappingURL=maskAttribute.d.ts.map

package/types/util/maskAttribute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maskAttribute.d.ts","sourceRoot":"","sources":["../../../../src/util/maskAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,UAAU,mBAAmB;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IACrD,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,WAAW,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAC5B,EAAE,EACF,GAAG,EACH,cAAc,EACd,WAAW,EACX,cAAc,EACd,KAAK,GACN,EAAE,mBAAmB,GAAG,MAAM,CAqB9B"}