@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/cjs/domain/configuration/configuration.d.ts

@@ -1,11 +1,19 @@
-import type { Configuration, InitConfiguration, MatchOption } from '@kubesense/kubesense-browser-core';
+import type { InitConfiguration } from '@kubesense/kubesense-browser-core';
 import { DefaultPrivacyLevel, TraceContextInjection } from '@kubesense/kubesense-browser-core';
+import type { InferredConfig, MatchOption } from '@kubesense/kubesense-js-core/configuration';
 import type { RumEventDomainContext } from '../../domainContext.types';
 import type { RumEvent } from '../../rumEvent.types';
+import type { SdkName } from '../contexts/defaultContext';
 import type { RumPlugin } from '../plugins';
 import type { PropagatorType, TracingOption } from '../tracing/tracer.types';
+import type { RemoteConfigurationMetadata } from './remoteConfigurationCache';
 import type { SessionReplayRoutes } from './sessionReplayRoutes';
 export declare const DEFAULT_PROPAGATOR_TYPES: PropagatorType[];
+/**
+ * Default list of headers collected on resource events when {@link RumInitConfiguration.trackResourceHeaders | trackResourceHeaders}
+ * is set to `true`.
+ */
+export declare const DEFAULT_TRACKED_RESOURCE_HEADERS: readonly ["cache-control", "etag", "age", "expires", "content-type", "content-encoding", "vary", "content-length", "server-timing", "x-cache", "cf-cache-status", "x-vercel-cache"];
 /**
  * Init Configuration for the RUM browser SDK.
  *
@@ -17,6 +25,7 @@ export declare const DEFAULT_PROPAGATOR_TYPES: PropagatorType[];
  * kubesenseSdk.init({
  *   applicationId: '<KUBESENSE_APPLICATION_ID>',
  *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',
+ *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',
  *   // ...
  * })
  * ```
@@ -25,6 +34,7 @@ export declare const DEFAULT_PROPAGATOR_TYPES: PropagatorType[];
  * KUBESENSE_SDK.init({
  *   applicationId: '<KUBESENSE_APPLICATION_ID>',
  *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',
+ *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',
  *   ...
  * })
  * ```
@@ -36,11 +46,20 @@ export interface RumInitConfiguration extends InitConfiguration {
      * @category Authentication
      */
     applicationId: string;
+    /**
+     * The service name for your application. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).
+     *
+     * `allowedTracingUrls` still requires an explicitly configured service.
+     *
+     * @category Data Collection
+     * @defaultValue the `applicationId`
+     */
+    service?: string | undefined | null;
     /**
      * Whether to propagate user and account IDs in the baggage header of trace requests.
      *
      * @category Tracing
-     * @defaultValue false
+     * @defaultValue true
      */
     propagateTraceBaggage?: boolean | undefined;
     /**
@@ -53,36 +72,49 @@ export interface RumInitConfiguration extends InitConfiguration {
      * See [Enrich And Control Browser RUM Data With beforeSend](https://docs.kubesense.ai/real_user_monitoring/guide/enrich-and-control-rum-data) for further information.
      *
      * @category Data Collection
-     * @param event - The RUM event
-     * @param context - The RUM event domain context providing access to native browser data based on the event type (e.g. error, performance entry).
-     * @returns true if the event should be sent to Kubesense, false otherwise
      */
-    beforeSend?: ((event: RumEvent, context: RumEventDomainContext) => boolean) | undefined;
+    beforeSend?: RumBeforeSend | undefined;
     /**
      * A list of request origins ignored when computing the page activity.
      * See [How page activity is calculated](https://docs.kubesense.ai/real_user_monitoring/browser/monitoring_page_performance/#how-page-activity-is-calculated) for further information.
      */
     excludedActivityUrls?: MatchOption[] | undefined;
     /**
-     * URL pointing to the Kubesense Browser SDK Worker JavaScript file. The URL can be relative or absolute, but is required to have the same origin as the web application.
+     * URL pointing to the KubeSense Browser SDK Worker JavaScript file. The URL can be relative or absolute, but is required to have the same origin as the web application.
      * See [Content Security Policy guidelines](https://docs.kubesense.ai/integrations/content_security_policy_logs/?tab=firefox#use-csp-with-real-user-monitoring-and-session-replay) for further information.
      *
      * @category Transport
      */
     workerUrl?: string;
     /**
-     * Compress requests sent to the Kubesense intake to reduce bandwidth usage when sending large amounts of data. The compression is done in a Worker thread.
+     * Compress requests sent to the KubeSense intake to reduce bandwidth usage when sending large amounts of data. The compression is done in a Worker thread.
      * See [Content Security Policy guidelines](https://docs.kubesense.ai/integrations/content_security_policy_logs/?tab=firefox#use-csp-with-real-user-monitoring-and-session-replay) for further information.
      *
      * @category Transport
      */
     compressIntakeRequests?: boolean | undefined;
     /**
-     * [Internal option] Id of the remote configuration
+     * [Internal option] Id of the remote configuration.
+     * Prefer `remoteConfiguration.id` for the non-blocking cache-and-reload path.
      *
      * @internal
      */
     remoteConfigurationId?: string | undefined;
+    /**
+     * [Internal option] Remote configuration descriptor. By default the SDK reads a cached
+     * configuration synchronously and refreshes it in the background. Set `sync: true` to fall back
+     * to the legacy blocking fetch. Set `required: true` to prevent the SDK from starting on the
+     * current page load when the remote configuration cache is empty or unreadable (the background
+     * fetch still runs to populate the cache for the next load). Ignored when `sync: true` is set
+     * or when the legacy `remoteConfigurationId` field is used.
+     *
+     * @internal
+     */
+    remoteConfiguration?: {
+        id: string;
+        sync?: boolean;
+        required?: boolean;
+    } | undefined;
     /**
      * [Internal option] set a proxy URL for the remote configuration
      *
@@ -90,28 +122,60 @@ export interface RumInitConfiguration extends InitConfiguration {
      */
     remoteConfigurationProxy?: string | undefined;
     /**
-     * Enable dashboard-managed SDK settings served by the Kubesense collector.
+     * Enable dashboard-managed SDK settings served by the KubeSense collector.
      *
      * The configuration document is fetched asynchronously after the SDK starts and cached in
      * local storage, so it never delays initialization. Cached settings are applied on the next
      * page load. Local `init()` values are used until a document has been fetched, and any
      * setting absent from the document keeps its local value.
      *
+     * @category Data Collection
      * @defaultValue false
      */
     enableRemoteSdkConfiguration?: boolean | undefined;
+    /**
+     * Restrict Session Replay recording to specific routes.
+     *
+     * Recording starts and stops as the user navigates: it runs only while the current route
+     * matches `include` (when provided) and does not match `exclude`. Rules are matched against
+     * the path (`pathname` + `search` + `hash`), and string entries match by prefix, so
+     * `/checkout` also covers `/checkout/payment`.
+     *
+     * These rules only narrow recording — a session that was not sampled in by
+     * `sessionReplaySampleRate` is never recorded, whatever the routes say.
+     *
+     * @category Session Replay
+     * @example
+     * ```ts
+     * sessionReplayRoutes: { include: ['/checkout', '/signup'], exclude: ['/checkout/card'] }
+     * ```
+     */
+    sessionReplayRoutes?: SessionReplayRoutes | undefined;
+    /**
+     * A list of domains to treat as first-party in resource provider classification.
+     * Accepts strings (exact hostname match), RegExp, or functions.
+     * The current page hostname is always treated as first-party.
+     *
+     * @category Data Collection
+     * @example ['api.myapp.com', /\.myapp\.com$/, (host) => host.endsWith('.internal')]
+     */
+    firstPartyDomains?: MatchOption[] | undefined;
     /**
      * A list of request URLs used to inject tracing headers.
      * See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
      *
      * @category Tracing
      */
-    allowedTracingUrls?: Array<MatchOption | TracingOption> | undefined;
+    allowedTracingUrls?: Array<MatchOption | {
+        match: MatchOption;
+        propagatorTypes?: PropagatorType[] | null | undefined;
+    }> | undefined;
     /**
      * The percentage of requests to trace: 100 for all, 0 for none.
      * See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
      *
      * @category Tracing
+     * @defaultValue 100
      */
     traceSampleRate?: number | undefined;
     /**
@@ -129,59 +193,87 @@ export interface RumInitConfiguration extends InitConfiguration {
      * See [Replay Privacy Options](https://docs.kubesense.ai/real_user_monitoring/session_replay/browser/privacy_options) for further information.
      *
      * @category Privacy
-     * @defaultValue mask
+     * @defaultValue mask-user-input
      */
     defaultPrivacyLevel?: DefaultPrivacyLevel | undefined;
     /**
-     * If you are accessing Kubesense through a custom subdomain, you can set `subdomain` to include your custom domain in the `getSessionReplayLink()` returned URL .
+     * If you are accessing KubeSense through a custom subdomain, you can set `subdomain` to include your custom domain in the `getSessionReplayLink()` returned URL .
      *
      * See [Connect Session Replay To Your Third-Party Tools](https://docs.kubesense.ai/real_user_monitoring/guide/connect-session-replay-to-your-third-party-tools) for further information.
      *
+     * @category Session Replay
      */
     subdomain?: string;
     /**
-     * The percentage of tracked sessions with [Browser RUM & Session Replay pricing](https://www.kubesense.ai/pricing/?product=real-user-monitoring--session-replay#real-user-monitoring--session-replay) features: 100 for all, 0 for none.
+     * The percentage of tracked sessions with [Browser RUM & Session Replay pricing](https://rum.kubesense.ai/pricing/?product=real-user-monitoring--session-replay#real-user-monitoring--session-replay) features: 100 for all, 0 for none.
      *
      * See [Configure Your Setup For Browser RUM and Browser RUM & Session Replay Sampling](https://docs.kubesense.ai/real_user_monitoring/guide/sampling-browser-plans) for further information.
      *
      * @category Session Replay
+     * @defaultValue 0
      */
     sessionReplaySampleRate?: number | undefined;
     /**
-     * If the session is sampled for Session Replay, only start the recording when `startSessionReplayRecording()` is called, instead of at the beginning of the session. Default: if startSessionReplayRecording is 0, true; otherwise, false.
+     * If the session is sampled for Session Replay, only start the recording when `startSessionReplayRecording()` is called, instead of at the beginning of the session.
      *
      * See [Session Replay Usage](https://docs.kubesense.ai/real_user_monitoring/session_replay/browser/#usage) for further information.
      *
      * @category Session Replay
+     * @defaultValue false
      */
     startSessionReplayRecordingManually?: boolean | undefined;
     /**
-     * Restrict Session Replay recording to specific routes.
+     * Records `<canvas>` content (most chart libraries draw on one) in Session Replay as captured frames.
+     * Canvas recording is disabled when this option is omitted.
      *
-     * Recording starts and stops as the user navigates: it runs only while the current route
-     * matches `include` (when provided) and does not match `exclude`. Rules are matched against
-     * the path (`pathname` + `search` + `hash`), and string entries match by prefix, so
-     * `/checkout` also covers `/checkout/payment`.
+     * A canvas is captured only when its privacy level is `allow` — set with `data-kubesense-privacy="allow"`
+     * or the `kubesense-privacy-allow` class on it or an ancestor — and only when its content changed.
+     * Frames are WebP images (PNG where the browser cannot encode WebP), uploaded next to the replay
+     * segments and deduplicated by content.
      *
-     * These rules only narrow recording — a session that was not sampled in by
-     * `sessionReplaySampleRate` is never recorded, whatever the routes say.
+     * `quality` picks a preset; the other fields override single values of that preset.
      *
      * @category Session Replay
-     * @example
-     * ```ts
-     * sessionReplayRoutes: { include: ['/checkout', '/signup'], exclude: ['/checkout/card'] }
-     * ```
      */
-    sessionReplayRoutes?: SessionReplayRoutes | undefined;
+    sessionReplayCanvasRecording?: {
+        /**
+         * Enables recording canvas elements in Session Replay.
+         */
+        enable: boolean;
+        /**
+         * Trades frame rate and image resolution for bandwidth. See {@link CanvasRecordingQuality}.
+         *
+         * @defaultValue 'medium'
+         */
+        quality?: CanvasRecordingQuality | undefined;
+        /**
+         * Overrides the preset's maximum number of frames captured per second, between 0 and 8. `0`
+         * stops capturing frames.
+         */
+        maxFramesPerSecond?: number | undefined;
+        /**
+         * Overrides the preset's longest side of a captured frame, in pixels, between 1 and 1280. Larger
+         * canvases are downscaled proportionally.
+         */
+        maxImageDimension?: number | undefined;
+        /**
+         * Overrides the preset's size of the thumbnail compared to detect a changed canvas, in pixels,
+         * between 1 and 100.
+         */
+        hashingMaxDimension?: number | undefined;
+    } | undefined;
     /**
      * Enables privacy control for action names.
      *
      * @category Privacy
+     * @defaultValue true
      */
     enablePrivacyForActionName?: boolean | undefined;
     /**
      * Enables automatic collection of users actions.
      *
+     * Add `data-dd-ignore-frustration` without a value, or set it to `all`, to ignore all frustration signals for an element and its descendants. To ignore specific signals, use a space-separated list of `rage-click`, `dead-click`, and `error-click`.
+     *
      * See [Tracking User Actions](https://docs.kubesense.ai/real_user_monitoring/browser/tracking_user_actions) for further information.
      *
      * @category Data Collection
@@ -202,13 +294,6 @@ export interface RumInitConfiguration extends InitConfiguration {
      * @category Data Collection
      */
     trackViewsManually?: boolean | undefined;
-    /**
-     * Enable the creation of dedicated views for pages restored from the Back-Forward cache.
-     *
-     * @category Data Collection
-     * @defaultValue false
-     */
-    trackBfcacheViews?: boolean | undefined;
     /**
      * Enables collection of resource events.
      *
@@ -217,22 +302,45 @@ export interface RumInitConfiguration extends InitConfiguration {
      */
     trackResources?: boolean | undefined;
     /**
-     * Enables collection of long task events.
+     * Enables collection of request and response headers on resource events.
+     *
+     * - `true`: collect {@link DEFAULT_TRACKED_RESOURCE_HEADERS} for all URLs, both directions
+     * - `MatchHeader[]`: each {@link MatchHeader} targets a header name, with optional URL scope
+     * (`url`), value extraction (`extractor`), and `location`. When `name` is omitted, the matcher
+     * applies to {@link DEFAULT_TRACKED_RESOURCE_HEADERS}. By default, both request and response
+     * headers are captured; set `location` to `'request'` or `'response'` to restrict to one.
+     *
+     * Headers whose names match a built-in sensitive-data pattern are always dropped, regardless
+     * of the configured matchers. The pattern blocks headers whose names contain: `token`, `cookie`,
+     * `secret`, `authorization`, `api-key`, `secret-key`, `access-key`, `app-key`, `client-ip`,
+     * `connecting-ip`, `real-ip`, or `forwarded`.
      *
      * @category Data Collection
-     * @defaultValue true
+     * @defaultValue false (disabled)
+     * @example
+     * // Collect default headers plus custom ones for all URLs
+     * trackResourceHeaders: [{}, { name: 'x-request-id' }]
+     * @example
+     * // Collect default headers from responses only
+     * trackResourceHeaders: [{ location: 'response' }]
+     * @example
+     * // URL-scoped rule: capture specific response headers only for calls to /api
+     * trackResourceHeaders: [{ url: /\/api\//, name: 'cache-control', location: 'response' }]
+     * @example
+     * // Extract a partial value from a header
+     * trackResourceHeaders: [{ url: /\/api\//, name: 'server-timing', extractor: /dur=(\d+)/, location: 'response' }]
      */
-    trackLongTasks?: boolean | undefined;
+    trackResourceHeaders?: boolean | MatchHeader[] | undefined;
     /**
-     * Enables early request collection before resource timing entries are available.
+     * Enables collection of long task events.
      *
      * @category Data Collection
-     * @defaultValue false
+     * @defaultValue true
      */
-    trackEarlyRequests?: boolean | undefined;
+    trackLongTasks?: boolean | undefined;
     /**
      * List of plugins to enable. 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
+     * notice. Please use only plugins provided by KubeSense matching the version of the SDK you are
      * using.
      */
     plugins?: RumPlugin[] | undefined;
@@ -256,53 +364,433 @@ export interface RumInitConfiguration extends InitConfiguration {
      */
     allowedGraphQlUrls?: Array<MatchOption | GraphQlUrlOption> | undefined;
     /**
-     * A list of domains to treat as first-party in resource provider classification.
-     * Accepts strings (exact hostname match), RegExp, or functions.
-     * The current page hostname is always treated as first-party.
+     * Enable partial view updates, which reduces bandwidth by sending only changed
+     * fields instead of full view events on intermediate updates.
      *
-     * @category Data Collection
-     * @example ['api.myapp.com', /\.myapp\.com$/, (host) => host.endsWith('.internal')]
+     * Enabled by default when the SDK is loaded from the CDN and no `proxy` is configured.
+     * Disabled by default otherwise, because a proxy may not forward the `view_update` event type.
+     *
+     * @category Beta
      */
-    firstPartyDomains?: MatchOption[] | undefined;
+    betaEnableViewUpdates?: boolean | undefined;
+    /**
+     * Enables collection of WebSocket resource events.
+     *
+     * Warning: enabling this option introduces WebSocket resource events to the `beforeSend` hook.
+     * Their domain context is WebSocket-specific and does not contain the XHR, Fetch, or performance
+     * entry fields available on regular resource events. Narrow the context using the existing
+     * `isManual` and `isWebSocket` discriminants before accessing those fields.
+     *
+     * @category Beta
+     */
+    betaTrackWebSockets?: boolean | undefined;
+}
+/**
+ * Recording quality presets for canvas capture. See {@link RumInitConfiguration.sessionReplayCanvasRecording}.
+ *
+ * | Preset   | Frames per second | Longest side | WebP quality |
+ * | -------- | ----------------- | ------------ | ------------ |
+ * | `low`    | 1                 | 600 px       | 0.3          |
+ * | `medium` | 4                 | 1000 px      | 0.5          |
+ * | `high`   | 8                 | 1280 px      | 0.75         |
+ *
+ * @example
+ * ```ts
+ * kubesenseSdk.init({
+ *   // ...
+ *   sessionReplayCanvasRecording: {
+ *     enable: true,
+ *     quality: CanvasRecordingQuality.MEDIUM,
+ *   },
+ * })
+ * ```
+ */
+export declare const CanvasRecordingQuality: {
+    readonly LOW: "low";
+    readonly MEDIUM: "medium";
+    readonly HIGH: "high";
+};
+export type CanvasRecordingQuality = (typeof CanvasRecordingQuality)[keyof typeof CanvasRecordingQuality];
+/**
+ * The resolved canvas recording tuning behind each {@link CanvasRecordingQuality} preset.
+ */
+export interface CanvasRecordingConfiguration {
+    enable: true;
+    maxFramesPerSecond: number;
+    hashingMaxDimension: number;
+    maxImageDimension: number;
+    encodeQuality: number;
 }
-export type HybridInitConfiguration = Omit<RumInitConfiguration, 'applicationId' | 'clientToken'>;
 export type FeatureFlagsForEvents = 'vital' | 'action' | 'long_task' | 'resource';
+/**
+ * Function called before a RUM event is sent to KubeSense. See {@link RumInitConfiguration.beforeSend}
+ *
+ * @param event - The RUM event
+ * @param context - The RUM event domain context providing access to native browser data based on the event type (e.g. error, performance entry).
+ * @returns true if the event should be sent to KubeSense, false otherwise
+ */
+export type RumBeforeSend = (event: RumEvent, context: RumEventDomainContext) => boolean;
 export interface GraphQlUrlOption {
     match: MatchOption;
     trackPayload?: boolean;
     trackResponseErrors?: boolean;
 }
-export interface RumConfiguration extends Configuration {
-    actionNameAttribute: string | undefined;
-    traceSampleRate: number;
-    rulePsr: number | undefined;
+export interface MatchHeader {
+    url?: MatchOption;
+    name?: MatchOption;
+    extractor?: RegExp;
+    location?: 'request' | 'response' | 'any';
+}
+export declare const RUM_SCHEMA: {
+    readonly applicationId: {
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly actionNameAttribute: {
+        readonly type: "string";
+    };
+    readonly workerUrl: {
+        readonly type: "string";
+    };
+    readonly subdomain: {
+        readonly type: "string";
+    };
+    readonly sessionReplaySampleRate: {
+        readonly type: "percentage";
+        readonly default: 0;
+    };
+    readonly traceSampleRate: {
+        readonly type: "percentage";
+        readonly default: 100;
+    };
+    readonly profilingSampleRate: {
+        readonly type: "percentage";
+        readonly default: 0;
+    };
+    readonly compressIntakeRequests: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly trackUserInteractions: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly strict: false;
+    };
+    readonly trackResources: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly strict: false;
+    };
+    readonly trackLongTasks: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly strict: false;
+    };
+    readonly trackViewsManually: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly betaEnableViewUpdates: {
+        readonly type: "boolean";
+    };
+    readonly betaTrackWebSockets: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly enablePrivacyForActionName: {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly propagateTraceBaggage: {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly startSessionReplayRecordingManually: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly enableRemoteSdkConfiguration: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly firstPartyDomains: {
+        readonly type: "match-option";
+        readonly multiple: true;
+        readonly default: MatchOption[];
+    };
+    readonly sessionReplayRoutes: {
+        readonly type: "schema";
+        readonly strict: false;
+        readonly schema: {
+            readonly include: {
+                readonly type: "match-option";
+                readonly multiple: true;
+                readonly strict: false;
+            };
+            readonly exclude: {
+                readonly type: "match-option";
+                readonly multiple: true;
+                readonly strict: false;
+            };
+        };
+    };
+    readonly sessionReplayCanvasRecording: {
+        readonly type: "schema";
+        readonly schema: {
+            readonly enable: {
+                readonly type: "boolean";
+                readonly required: true;
+            };
+            readonly quality: {
+                readonly type: "enum";
+                readonly values: {
+                    readonly LOW: "low";
+                    readonly MEDIUM: "medium";
+                    readonly HIGH: "high";
+                };
+                readonly default: "medium";
+            };
+            readonly maxFramesPerSecond: {
+                readonly type: "number";
+                readonly min: 0;
+                readonly max: 8;
+            };
+            readonly maxImageDimension: {
+                readonly type: "number";
+                readonly min: 1;
+                readonly max: 1280;
+            };
+            readonly hashingMaxDimension: {
+                readonly type: "number";
+                readonly min: 1;
+                readonly max: 100;
+            };
+        };
+    };
+    readonly defaultPrivacyLevel: {
+        readonly type: "enum";
+        readonly values: {
+            readonly ALLOW: "allow";
+            readonly MASK: "mask";
+            readonly MASK_USER_INPUT: "mask-user-input";
+            readonly MASK_UNLESS_ALLOWLISTED: "mask-unless-allowlisted";
+        };
+        readonly default: "mask-user-input";
+        readonly strict: false;
+    };
+    readonly traceContextInjection: {
+        readonly type: "enum";
+        readonly values: {
+            readonly ALL: "all";
+            readonly SAMPLED: "sampled";
+        };
+        readonly default: "sampled";
+        readonly strict: false;
+    };
+    readonly excludedActivityUrls: {
+        readonly type: "match-option";
+        readonly multiple: true;
+        readonly default: MatchOption[];
+    };
+    readonly allowedTracingUrls: {
+        readonly type: "union";
+        readonly multiple: true;
+        readonly strict: false;
+        readonly default: Array<MatchOption | {
+            match: MatchOption;
+            propagatorTypes: PropagatorType[];
+        }>;
+        readonly variants: readonly [{
+            readonly type: "match-option";
+        }, {
+            readonly type: "schema";
+            readonly schema: {
+                readonly match: {
+                    readonly type: "match-option";
+                    readonly required: true;
+                };
+                readonly propagatorTypes: {
+                    readonly type: "enum";
+                    readonly values: readonly ["kubesense", "b3", "b3multi", "tracecontext"];
+                    readonly multiple: true;
+                    readonly strict: false;
+                    readonly default: PropagatorType[];
+                };
+            };
+        }];
+    };
+    readonly plugins: {
+        readonly type: "schema";
+        readonly multiple: true;
+        readonly strict: false;
+        readonly default: RumPlugin[];
+        readonly schema: {
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly getConfigurationTelemetry: {
+                readonly type: "function";
+                readonly strict: false;
+                readonly signature: RumPlugin["getConfigurationTelemetry"];
+            };
+            readonly onInit: {
+                readonly type: "function";
+                readonly strict: false;
+                readonly signature: RumPlugin["onInit"];
+            };
+            readonly onRumStart: {
+                readonly type: "function";
+                readonly strict: false;
+                readonly signature: RumPlugin["onRumStart"];
+            };
+        };
+    };
+    readonly trackFeatureFlagsForEvents: {
+        readonly type: "enum";
+        readonly values: readonly ["vital", "action", "long_task", "resource"];
+        readonly multiple: true;
+        readonly strict: false;
+        readonly default: FeatureFlagsForEvents[];
+    };
+    readonly clientToken: {
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly service: {
+        readonly type: "string";
+    };
+    readonly env: {
+        readonly type: "string";
+    };
+    readonly version: {
+        readonly type: "string";
+    };
+    readonly kubesenseRumEndpoint: {
+        readonly type: "site";
+        readonly default: string;
+    };
+    readonly proxy: {
+        readonly type: "union";
+        readonly variants: readonly [{
+            readonly type: "string";
+        }, {
+            readonly type: "function";
+            readonly signature: import("@kubesense/kubesense-js-core/transport").ProxyFn | undefined;
+        }];
+    };
+    readonly sessionSampleRate: {
+        readonly type: "percentage";
+        readonly default: 100;
+    };
+    readonly telemetrySampleRate: {
+        readonly type: "percentage";
+        readonly default: 20;
+    };
+    readonly telemetryConfigurationSampleRate: {
+        readonly type: "percentage";
+        readonly default: 5;
+    };
+    readonly telemetryUsageSampleRate: {
+        readonly type: "percentage";
+        readonly default: 5;
+    };
+    readonly silentMultipleInit: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly storeContextsAcrossPages: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly trackAnonymousUser: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly strict: false;
+    };
+    readonly useSecureSessionCookie: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly usePartitionedCrossSiteSessionCookie: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly trackSessionAcrossSubdomains: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly allowedTrackingOrigins: {
+        readonly type: "match-option";
+        readonly multiple: true;
+        readonly strict: false;
+    };
+    readonly trackingConsent: {
+        readonly type: "enum";
+        readonly values: {
+            readonly GRANTED: "granted";
+            readonly NOT_GRANTED: "not-granted";
+        };
+        readonly default: "granted";
+    };
+    readonly beforeSend: {
+        readonly type: "function";
+        readonly signature: ((event: any, context?: any) => unknown) | undefined;
+    };
+    readonly source: {
+        readonly type: "enum";
+        readonly values: readonly ["browser", "flutter", "unity"];
+        readonly default: "browser";
+        readonly strict: false;
+    };
+    readonly sessionPersistence: {
+        readonly type: "enum";
+        readonly values: readonly ["cookie", "local-storage", "memory"];
+        readonly multiple: true;
+        readonly strict: false;
+    };
+    readonly replica: {
+        readonly type: "schema";
+        readonly schema: {
+            readonly clientToken: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly applicationId: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly datacenter: {
+        readonly type: "string";
+    };
+    readonly sdkVersion: {
+        readonly type: "string";
+    };
+    readonly variant: {
+        readonly type: "string";
+    };
+};
+export type RumConfiguration = Omit<InferredConfig<typeof RUM_SCHEMA>, 'allowedTracingUrls' | 'sessionReplayCanvasRecording'> & {
     allowedTracingUrls: TracingOption[];
-    excludedActivityUrls: MatchOption[];
-    workerUrl: string | undefined;
-    compressIntakeRequests: boolean;
-    applicationId: string;
-    defaultPrivacyLevel: DefaultPrivacyLevel;
-    enablePrivacyForActionName: boolean;
-    sessionReplaySampleRate: number;
-    startSessionReplayRecordingManually: boolean;
-    sessionReplayRoutes: SessionReplayRoutes | undefined;
-    trackUserInteractions: boolean;
-    trackViewsManually: boolean;
-    trackResources: boolean;
-    trackLongTasks: boolean;
-    trackBfcacheViews: boolean;
-    trackEarlyRequests: boolean;
-    subdomain?: string;
-    traceContextInjection: TraceContextInjection;
-    plugins: RumPlugin[];
-    trackFeatureFlagsForEvents: FeatureFlagsForEvents[];
-    profilingSampleRate: number;
-    propagateTraceBaggage: boolean;
+    betaEnableViewUpdates: boolean;
+    rulePsr: number | undefined;
+    trackResourceHeaders: MatchHeader[];
     allowedGraphQlUrls: GraphQlUrlOption[];
-    firstPartyDomains: MatchOption[];
-}
-export declare function validateAndBuildRumConfiguration(initConfiguration: RumInitConfiguration, errorStack?: string): RumConfiguration | undefined;
-export declare function serializeRumConfiguration(configuration: RumInitConfiguration): {
+    remoteConfigurationId: string | undefined;
+    sessionReplayCanvasRecording: CanvasRecordingConfiguration | undefined;
+};
+export declare function validateAndBuildRumConfiguration(initConfiguration: RumInitConfiguration, sdkName?: SdkName): RumConfiguration | undefined;
+export declare function serializeRumConfiguration(configuration: RumInitConfiguration, sdkName?: SdkName, remoteConfigurationMetadata?: RemoteConfigurationMetadata): {
     session_sample_rate: number | undefined;
     telemetry_sample_rate: number | undefined;
     telemetry_configuration_sample_rate: number | undefined;
@@ -315,12 +803,10 @@ export declare function serializeRumConfiguration(configuration: RumInitConfigur
     track_session_across_subdomains: boolean | undefined;
     track_anonymous_user: boolean | undefined;
     session_persistence: import("@kubesense/kubesense-browser-core").SessionPersistence | undefined;
-    allow_fallback_to_local_storage: boolean;
     store_contexts_across_pages: boolean;
     allow_untrusted_events: boolean;
     tracking_consent: import("@kubesense/kubesense-browser-core").TrackingConsent | undefined;
     use_allowed_tracking_origins: boolean;
-    beta_encode_cookie_options: boolean | undefined;
     source: "browser" | "flutter" | "unity" | undefined;
     sdk_version: string | undefined;
     variant: string | undefined;
@@ -344,15 +830,23 @@ export declare function serializeRumConfiguration(configuration: RumInitConfigur
     track_user_interactions: boolean | undefined;
     track_resources: boolean | undefined;
     track_long_task: boolean | undefined;
-    track_bfcache_views: boolean | undefined;
-    track_early_requests: boolean | undefined;
     plugins: {
         name: string;
     }[] | undefined;
     track_feature_flags_for_events: FeatureFlagsForEvents[] | undefined;
     remote_configuration_id: string | undefined;
+    remote_configuration: {
+        last_modified: number | undefined;
+        last_synced: import("@kubesense/kubesense-js-core/time").TimeStamp;
+        first_applied: import("@kubesense/kubesense-js-core/time").TimeStamp | undefined;
+        sync_id: string;
+    } | undefined;
     profiling_sample_rate: number | undefined;
     use_remote_configuration_proxy: boolean;
     enable_remote_sdk_configuration: boolean;
     use_session_replay_routes: boolean;
+    use_first_party_domains: boolean;
+    track_resource_headers: "custom" | "default_headers" | undefined;
+    beta_enable_view_updates: boolean;
+    beta_track_web_sockets: boolean | undefined;
 };