@kubesense/kubesense-browser-rum-core 1.0.0

package/cjs/domain/hooks.d.ts

@@ -0,0 +1,23 @@
+import type { DISCARDED, Duration, HookNamesAsConst, RecursivePartial, RelativeTime, SKIPPED, TelemetryEvent } from '@kubesense/kubesense-browser-core';
+import type { RumEvent } from '../rumEvent.types';
+export type DefaultRumEventAttributes = RecursivePartial<RumEvent> & {
+    type: RumEvent['type'];
+};
+export type DefaultTelemetryEventAttributes = RecursivePartial<TelemetryEvent>;
+export interface HookCallbackMap {
+    [HookNamesAsConst.ASSEMBLE]: (param: {
+        eventType: RumEvent['type'];
+        startTime: RelativeTime;
+        duration?: Duration | undefined;
+    }) => DefaultRumEventAttributes | SKIPPED | DISCARDED;
+    [HookNamesAsConst.ASSEMBLE_TELEMETRY]: (param: {
+        startTime: RelativeTime;
+    }) => DefaultTelemetryEventAttributes | SKIPPED | DISCARDED;
+}
+export type Hooks = ReturnType<typeof createHooks>;
+export declare const createHooks: () => {
+    register<K extends import("@kubesense/kubesense-browser-core").HookNames>(hookName: K, callback: HookCallbackMap[K]): {
+        unregister: () => void;
+    };
+    triggerHook<K extends import("@kubesense/kubesense-browser-core").HookNames>(hookName: K, param: Parameters<HookCallbackMap[K]>[0]): "DISCARDED" | Exclude<ReturnType<HookCallbackMap[K]>, "SKIPPED"> | undefined;
+};

package/cjs/domain/hooks.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHooks = void 0;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+exports.createHooks = (kubesense_browser_core_1.abstractHooks);
+//# sourceMappingURL=hooks.js.map

package/cjs/domain/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../src/domain/hooks.ts"],"names":[],"mappings":";;;AASA,8EAAiE;AAqBpD,QAAA,WAAW,GAAG,CAAA,sCAA8B,CAAA,CAAA"}

package/cjs/domain/lifeCycle.d.ts

@@ -0,0 +1,73 @@
+import type { Context, Duration, PageMayExitEvent, RawError, RelativeTime } from '@kubesense/kubesense-browser-core';
+import { AbstractLifeCycle } from '@kubesense/kubesense-browser-core';
+import type { RumEventDomainContext } from '../domainContext.types';
+import type { RawRumEvent, AssembledRumEvent } from '../rawRumEvent.types';
+import type { RequestCompleteEvent, RequestStartEvent } from './requestCollection';
+import type { AutoAction } from './action/actionCollection';
+import type { ViewEvent, ViewCreatedEvent, ViewEndedEvent, BeforeViewUpdateEvent } from './view/trackViews';
+export declare const enum LifeCycleEventType {
+    AUTO_ACTION_COMPLETED = 0,
+    BEFORE_VIEW_CREATED = 1,
+    VIEW_CREATED = 2,
+    BEFORE_VIEW_UPDATED = 3,
+    VIEW_UPDATED = 4,
+    VIEW_ENDED = 5,
+    AFTER_VIEW_ENDED = 6,
+    REQUEST_STARTED = 7,
+    REQUEST_COMPLETED = 8,
+    SESSION_EXPIRED = 9,
+    SESSION_RENEWED = 10,
+    PAGE_MAY_EXIT = 11,
+    RAW_RUM_EVENT_COLLECTED = 12,
+    RUM_EVENT_COLLECTED = 13,
+    RAW_ERROR_COLLECTED = 14
+}
+declare const LifeCycleEventTypeAsConst: {
+    AUTO_ACTION_COMPLETED: LifeCycleEventType.AUTO_ACTION_COMPLETED;
+    BEFORE_VIEW_CREATED: LifeCycleEventType.BEFORE_VIEW_CREATED;
+    VIEW_CREATED: LifeCycleEventType.VIEW_CREATED;
+    BEFORE_VIEW_UPDATED: LifeCycleEventType.BEFORE_VIEW_UPDATED;
+    VIEW_UPDATED: LifeCycleEventType.VIEW_UPDATED;
+    VIEW_ENDED: LifeCycleEventType.VIEW_ENDED;
+    AFTER_VIEW_ENDED: LifeCycleEventType.AFTER_VIEW_ENDED;
+    REQUEST_STARTED: LifeCycleEventType.REQUEST_STARTED;
+    REQUEST_COMPLETED: LifeCycleEventType.REQUEST_COMPLETED;
+    SESSION_EXPIRED: LifeCycleEventType.SESSION_EXPIRED;
+    SESSION_RENEWED: LifeCycleEventType.SESSION_RENEWED;
+    PAGE_MAY_EXIT: LifeCycleEventType.PAGE_MAY_EXIT;
+    RAW_RUM_EVENT_COLLECTED: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED;
+    RUM_EVENT_COLLECTED: LifeCycleEventType.RUM_EVENT_COLLECTED;
+    RAW_ERROR_COLLECTED: LifeCycleEventType.RAW_ERROR_COLLECTED;
+};
+export interface LifeCycleEventMap {
+    [LifeCycleEventTypeAsConst.AUTO_ACTION_COMPLETED]: AutoAction;
+    [LifeCycleEventTypeAsConst.BEFORE_VIEW_CREATED]: ViewCreatedEvent;
+    [LifeCycleEventTypeAsConst.VIEW_CREATED]: ViewCreatedEvent;
+    [LifeCycleEventTypeAsConst.BEFORE_VIEW_UPDATED]: BeforeViewUpdateEvent;
+    [LifeCycleEventTypeAsConst.VIEW_UPDATED]: ViewEvent;
+    [LifeCycleEventTypeAsConst.VIEW_ENDED]: ViewEndedEvent;
+    [LifeCycleEventTypeAsConst.AFTER_VIEW_ENDED]: ViewEndedEvent;
+    [LifeCycleEventTypeAsConst.REQUEST_STARTED]: RequestStartEvent;
+    [LifeCycleEventTypeAsConst.REQUEST_COMPLETED]: RequestCompleteEvent;
+    [LifeCycleEventTypeAsConst.SESSION_EXPIRED]: void;
+    [LifeCycleEventTypeAsConst.SESSION_RENEWED]: void;
+    [LifeCycleEventTypeAsConst.PAGE_MAY_EXIT]: PageMayExitEvent;
+    [LifeCycleEventTypeAsConst.RAW_RUM_EVENT_COLLECTED]: RawRumEventCollectedData;
+    [LifeCycleEventTypeAsConst.RUM_EVENT_COLLECTED]: AssembledRumEvent;
+    [LifeCycleEventTypeAsConst.RAW_ERROR_COLLECTED]: {
+        error: RawError;
+        customerContext?: Context;
+    };
+}
+export interface RawRumEventCollectedData<E extends RawRumEvent = RawRumEvent> {
+    startTime: RelativeTime;
+    duration?: Duration;
+    customerContext?: Context;
+    rawRumEvent: E;
+    domainContext: RumEventDomainContext<E['type']>;
+}
+export declare const LifeCycle: {
+    new (): AbstractLifeCycle<LifeCycleEventMap>;
+};
+export type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>;
+export {};

package/cjs/domain/lifeCycle.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifeCycle = void 0;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+exports.LifeCycle = (kubesense_browser_core_1.AbstractLifeCycle);
+//# sourceMappingURL=lifeCycle.js.map

package/cjs/domain/lifeCycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeCycle.js","sourceRoot":"","sources":["../../src/domain/lifeCycle.ts"],"names":[],"mappings":";;;AACA,8EAAqE;AAoGxD,QAAA,SAAS,GAAG,CAAA,0CAAoC,CAAA,CAAA"}

package/cjs/domain/limitModification.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@kubesense/kubesense-browser-core';
+export type ModifiableFieldPaths = Record<string, 'string' | 'object'>;
+/**
+ * Allows declaring and enforcing modifications to specific fields of an object.
+ * Only supports modifying properties of an object (even if nested in an array).
+ * Does not support array manipulation (adding/removing items).
+ */
+export declare function limitModification<T extends Context, Result>(object: T, modifiableFieldPaths: ModifiableFieldPaths, modifier: (object: T) => Result): Result | undefined;

package/cjs/domain/limitModification.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitModification = limitModification;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+/**
+ * Allows declaring and enforcing modifications to specific fields of an object.
+ * Only supports modifying properties of an object (even if nested in an array).
+ * Does not support array manipulation (adding/removing items).
+ */
+function limitModification(object, modifiableFieldPaths, modifier) {
+    const clone = (0, kubesense_browser_core_1.deepClone)(object);
+    const result = modifier(clone);
+    (0, kubesense_browser_core_1.objectEntries)(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => 
+    // Traverse both object and clone simultaneously up to the path and apply the modification from the clone to the original object when the type is valid
+    setValueAtPath(object, clone, fieldPath.split(/\.|(?=\[\])/), fieldType));
+    return result;
+}
+function setValueAtPath(object, clone, pathSegments, fieldType) {
+    const [field, ...restPathSegments] = pathSegments;
+    if (field === '[]') {
+        if (Array.isArray(object) && Array.isArray(clone)) {
+            object.forEach((item, i) => setValueAtPath(item, clone[i], restPathSegments, fieldType));
+        }
+        return;
+    }
+    if (!isValidObject(object) || !isValidObject(clone)) {
+        return;
+    }
+    if (restPathSegments.length > 0) {
+        return setValueAtPath(object[field], clone[field], restPathSegments, fieldType);
+    }
+    setNestedValue(object, field, clone[field], fieldType);
+}
+function setNestedValue(object, field, value, fieldType) {
+    const newType = (0, kubesense_browser_core_1.getType)(value);
+    if (newType === fieldType) {
+        object[field] = (0, kubesense_browser_core_1.sanitize)(value);
+    }
+    else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {
+        object[field] = {};
+    }
+}
+function isValidObject(object) {
+    return (0, kubesense_browser_core_1.getType)(object) === 'object';
+}
+//# sourceMappingURL=limitModification.js.map

package/cjs/domain/limitModification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitModification.js","sourceRoot":"","sources":["../../src/domain/limitModification.ts"],"names":[],"mappings":";;AAUA,8CAcC;AAxBD,8EAA+F;AAK/F;;;;GAIG;AACH,SAAgB,iBAAiB,CAC/B,MAAS,EACT,oBAA0C,EAC1C,QAA+B;IAE/B,MAAM,KAAK,GAAG,IAAA,kCAAS,EAAC,MAAM,CAAC,CAAA;IAC/B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IAE9B,IAAA,sCAAa,EAAC,oBAAoB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,EAAE;IACrE,uJAAuJ;IACvJ,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC,CACzE,CAAA;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAED,SAAS,cAAc,CAAC,MAAe,EAAE,KAAc,EAAE,YAAsB,EAAE,SAA8B;IAC7G,MAAM,CAAC,KAAK,EAAE,GAAG,gBAAgB,CAAC,GAAG,YAAY,CAAA;IAEjD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAClD,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAA;QAC1F,CAAC;QAED,OAAM;IACR,CAAC;IAED,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,OAAM;IACR,CAAC;IAED,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChC,OAAO,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAA;IACjF,CAAC;IAED,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAA;AACxD,CAAC;AAED,SAAS,cAAc,CACrB,MAA+B,EAC/B,KAAa,EACb,KAAc,EACd,SAA8B;IAE9B,MAAM,OAAO,GAAG,IAAA,gCAAO,EAAC,KAAK,CAAC,CAAA;IAE9B,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,CAAC,KAAK,CAAC,GAAG,IAAA,iCAAQ,EAAC,KAAK,CAAC,CAAA;IACjC,CAAC;SAAM,IAAI,SAAS,KAAK,QAAQ,IAAI,CAAC,OAAO,KAAK,WAAW,IAAI,OAAO,KAAK,MAAM,CAAC,EAAE,CAAC;QACrF,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAA;IACpB,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CAAC,MAAe;IACpC,OAAO,IAAA,gCAAO,EAAC,MAAM,CAAC,KAAK,QAAQ,CAAA;AACrC,CAAC"}

package/cjs/domain/longTask/longTaskCollection.d.ts

@@ -0,0 +1,18 @@
+import type { RelativeTime, ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import type { LifeCycle } from '../lifeCycle';
+import { RumPerformanceEntryType } from '../../browser/performanceObservable';
+import type { RumConfiguration } from '../configuration';
+export declare const LONG_TASK_ID_HISTORY_TIME_OUT_DELAY: number;
+export interface LongTaskContext {
+    id: string;
+    startClocks: ClocksState;
+    duration: Duration;
+    entryType: RumPerformanceEntryType.LONG_ANIMATION_FRAME | RumPerformanceEntryType.LONG_TASK;
+}
+export interface LongTaskContexts {
+    findLongTasks: (startTime: RelativeTime) => LongTaskContext[];
+}
+export declare function startLongTaskCollection(lifeCycle: LifeCycle, configuration: RumConfiguration): {
+    stop: () => void;
+    longTaskContexts: LongTaskContexts;
+};

package/cjs/domain/longTask/longTaskCollection.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LONG_TASK_ID_HISTORY_TIME_OUT_DELAY = void 0;
+exports.startLongTaskCollection = startLongTaskCollection;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const rawRumEvent_types_1 = require("../../rawRumEvent.types");
+const performanceObservable_1 = require("../../browser/performanceObservable");
+exports.LONG_TASK_ID_HISTORY_TIME_OUT_DELAY = kubesense_browser_core_1.SESSION_TIME_OUT_DELAY;
+function startLongTaskCollection(lifeCycle, configuration) {
+    const history = (0, kubesense_browser_core_1.createValueHistory)({
+        expireDelay: exports.LONG_TASK_ID_HISTORY_TIME_OUT_DELAY,
+    });
+    const entryType = (0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.LONG_ANIMATION_FRAME)
+        ? performanceObservable_1.RumPerformanceEntryType.LONG_ANIMATION_FRAME
+        : performanceObservable_1.RumPerformanceEntryType.LONG_TASK;
+    const subscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
+        type: entryType,
+        buffered: true,
+    }).subscribe((entries) => {
+        for (const entry of entries) {
+            if (!configuration.trackLongTasks) {
+                break;
+            }
+            const startClocks = (0, kubesense_browser_core_1.relativeToClocks)(entry.startTime);
+            const taskId = (0, kubesense_browser_core_1.generateUUID)();
+            const rawRumEvent = processEntry(entry, startClocks, taskId);
+            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {
+                rawRumEvent,
+                startTime: startClocks.relative,
+                duration: entry.duration,
+                domainContext: { performanceEntry: entry },
+            });
+            history.add({ id: taskId, startClocks, duration: entry.duration, entryType }, startClocks.relative);
+            history.closeActive((0, kubesense_browser_core_1.addDuration)(startClocks.relative, entry.duration));
+        }
+    });
+    const longTaskContexts = {
+        findLongTasks: (startTime) => history.findAll(startTime),
+    };
+    return {
+        stop: () => {
+            subscription.unsubscribe();
+            history.stop();
+        },
+        longTaskContexts,
+    };
+}
+function processEntry(entry, startClocks, taskId) {
+    const baseEvent = {
+        date: startClocks.timeStamp,
+        type: rawRumEvent_types_1.RumEventType.LONG_TASK,
+        _kubesense: { discarded: false },
+    };
+    if (entry.entryType === performanceObservable_1.RumPerformanceEntryType.LONG_TASK) {
+        return {
+            ...baseEvent,
+            long_task: {
+                id: taskId,
+                entry_type: rawRumEvent_types_1.RumLongTaskEntryType.LONG_TASK,
+                duration: (0, kubesense_browser_core_1.toServerDuration)(entry.duration),
+            },
+        };
+    }
+    return {
+        ...baseEvent,
+        long_task: {
+            id: taskId,
+            entry_type: rawRumEvent_types_1.RumLongTaskEntryType.LONG_ANIMATION_FRAME,
+            duration: (0, kubesense_browser_core_1.toServerDuration)(entry.duration),
+            blocking_duration: (0, kubesense_browser_core_1.toServerDuration)(entry.blockingDuration),
+            first_ui_event_timestamp: (0, kubesense_browser_core_1.toServerDuration)(entry.firstUIEventTimestamp),
+            render_start: (0, kubesense_browser_core_1.toServerDuration)(entry.renderStart),
+            style_and_layout_start: (0, kubesense_browser_core_1.toServerDuration)(entry.styleAndLayoutStart),
+            start_time: (0, kubesense_browser_core_1.toServerDuration)(entry.startTime),
+            scripts: entry.scripts.map((script) => ({
+                duration: (0, kubesense_browser_core_1.toServerDuration)(script.duration),
+                pause_duration: (0, kubesense_browser_core_1.toServerDuration)(script.pauseDuration),
+                forced_style_and_layout_duration: (0, kubesense_browser_core_1.toServerDuration)(script.forcedStyleAndLayoutDuration),
+                start_time: (0, kubesense_browser_core_1.toServerDuration)(script.startTime),
+                execution_start: (0, kubesense_browser_core_1.toServerDuration)(script.executionStart),
+                source_url: script.sourceURL,
+                source_function_name: script.sourceFunctionName,
+                source_char_position: script.sourceCharPosition,
+                invoker: script.invoker,
+                invoker_type: script.invokerType,
+                window_attribution: script.windowAttribution,
+            })),
+        },
+    };
+}
+//# sourceMappingURL=longTaskCollection.js.map

package/cjs/domain/longTask/longTaskCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"longTaskCollection.js","sourceRoot":"","sources":["../../../src/domain/longTask/longTaskCollection.ts"],"names":[],"mappings":"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"}

package/cjs/domain/plugins.d.ts

@@ -0,0 +1,40 @@
+import type { RumPublicApi, Strategy } from '../boot/rumPublicApi';
+import type { StartRumResult } from '../boot/startRum';
+import type { RumInitConfiguration } from './configuration';
+/**
+ * onRumStart plugin API options.
+ *
+ * @experimental
+ */
+export interface OnRumStartOptions {
+    /**
+     * @deprecated Use `addEvent` instead.
+     */
+    strategy?: Strategy;
+    /**
+     * Add an event to the RUM browser SDK.
+     */
+    addEvent?: StartRumResult['addEvent'];
+}
+/**
+ * Plugin interface of the RUM browser SDK.
+ *
+ * The plugins API is unstable and experimental, and may change without
+ * notice. Please use only plugins provided by Kubesense matching the version of the SDK you are
+ * using.
+ *
+ * @experimental
+ */
+export interface RumPlugin {
+    name: string;
+    getConfigurationTelemetry?(): Record<string, unknown>;
+    onInit?(options: {
+        initConfiguration: RumInitConfiguration;
+        publicApi: RumPublicApi;
+    }): void;
+    onRumStart?(options: OnRumStartOptions): void;
+}
+type MethodNames = 'onInit' | 'onRumStart';
+type MethodParameter<MethodName extends MethodNames> = Parameters<NonNullable<RumPlugin[MethodName]>>[0];
+export declare function callPluginsMethod<MethodName extends MethodNames>(plugins: RumPlugin[] | undefined, methodName: MethodName, parameter: MethodParameter<MethodName>): void;
+export {};

package/cjs/domain/plugins.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callPluginsMethod = callPluginsMethod;
+function callPluginsMethod(plugins, methodName, parameter) {
+    if (!plugins) {
+        return;
+    }
+    for (const plugin of plugins) {
+        const method = plugin[methodName];
+        if (method) {
+            method(parameter);
+        }
+    }
+}
+//# sourceMappingURL=plugins.js.map

package/cjs/domain/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","sourceRoot":"","sources":["../../src/domain/plugins.ts"],"names":[],"mappings":";;AA4CA,8CAcC;AAdD,SAAgB,iBAAiB,CAC/B,OAAgC,EAChC,UAAsB,EACtB,SAAc;IAEd,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAM;IACR,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;QACjC,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,SAAS,CAAC,CAAA;QACnB,CAAC;IACH,CAAC;AACH,CAAC"}

package/cjs/domain/privacy.d.ts

@@ -0,0 +1,44 @@
+import { NodePrivacyLevel } from './privacyConstants';
+import type { RumConfiguration } from './configuration';
+export type NodePrivacyLevelCache = Map<Node, NodePrivacyLevel>;
+/**
+ * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is
+ * know, it is best to use something like:
+ *
+ * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)
+ */
+export declare function getNodePrivacyLevel(node: Node, defaultPrivacyLevel: NodePrivacyLevel, cache?: NodePrivacyLevelCache): NodePrivacyLevel;
+/**
+ * Reduces the next privacy level based on self + parent privacy levels
+ */
+export declare function reducePrivacyLevel(childPrivacyLevel: NodePrivacyLevel | undefined, parentNodePrivacyLevel: NodePrivacyLevel): NodePrivacyLevel;
+/**
+ * Determines the node's own privacy level without checking for ancestors.
+ */
+export declare function getNodeSelfPrivacyLevel(node: Node): NodePrivacyLevel | undefined;
+/**
+ * Helper aiming to unify `mask` and `mask-user-input` privacy levels:
+ *
+ * In the `mask` case, it is trivial: we should mask the element.
+ *
+ * In the `mask-user-input` case, we should mask the element only if it is a "form" element or the
+ * direct parent is a form element for text nodes).
+ *
+ * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a
+ * node if it is ignored or hidden? it doesn't matter since it won't be serialized).
+ */
+export declare function shouldMaskNode(node: Node, privacyLevel: NodePrivacyLevel): boolean;
+export declare function shouldMaskAttribute(tagName: string, attributeName: string, attributeValue: string | null, nodePrivacyLevel: NodePrivacyLevel, configuration: RumConfiguration): boolean;
+export declare function getTextContent(textNode: Node, parentNodePrivacyLevel: NodePrivacyLevel): string | undefined;
+/**
+ * TODO: Preserve CSS element order, and record the presence of the tag, just don't render
+ * We don't need this logic on the recorder side.
+ * For security related meta's, customer can mask themmanually given they
+ * are easy to identify in the HEAD tag.
+ */
+export declare function shouldIgnoreElement(element: Element): boolean;
+export interface BrowserWindow extends Window {
+    $KUBESENSE_ALLOW?: Set<string>;
+}
+export declare function isAllowlisted(text: string): boolean;
+export declare function maskDisallowedTextContent(text: string, fixedMask?: string): string;