import { UnpluginOptions } from 'unplugin';
import * as vite from 'vite';

declare class TrackedFilesMatcher {
	private trackedFilenames;
	constructor(trackedFiles: string[]);
	private displaySource;
	matchSourcemap(srcmapPath: string, onSourcesNotFound: (reason: string) => void): string[] | undefined;
	matchSources(sources: string[]): string[];
	rawTrackedFilesList(): string[];
	private getFilename;
}
type AuthMethod = "apiKey" | "oauth";
type AppsProtectionLevel = "direct_publish" | "approval_required";
type AppsOptions = {
	enable?: boolean;
	include?: string[];
	dryRun?: boolean;
	identifier?: string;
	name?: string;
	/** Human-readable description of the app. */
	description?: string;
	/** When true, the app appears in the Datadog self-service catalog. */
	selfService?: boolean;
	/** Deployment and identity settings for the app. */
	permissions?: {
		/**
		 * Controls whether publishing the app requires a second approver.
		 * - `direct_publish`: any user with publish rights can deploy immediately.
		 * - `approval_required`: a second user must approve before the app goes live.
		 */
		protectionLevel?: AppsProtectionLevel;
		/**
		 * UUID of the service account the app's backend functions run as.
		 * When omitted the app runs as the uploading user.
		 * Only service accounts are accepted; arbitrary user UUIDs are rejected by the API.
		 */
		runAs?: string;
	};
	authOverrides?: {
		method?: AuthMethod;
	};
};
declare const CONFIG_KEY: "apps";
declare const PLUGIN_NAME: PluginName;
type types = {
	AppsOptions: AppsOptions;
};
declare const getPlugins: GetPlugins;
type MinifiedPathPrefix = `http://${string}` | `https://${string}` | `/${string}`;
type SourcemapsOptions = {
	bailOnError?: boolean;
	dryRun?: boolean;
	maxConcurrency?: number;
	minifiedPathPrefix: MinifiedPathPrefix;
	releaseVersion?: string;
	service: string;
};
type ErrorTrackingOptions = {
	enable?: boolean;
	sourcemaps?: SourcemapsOptions;
};
declare const CONFIG_KEY$1: "errorTracking";
declare const PLUGIN_NAME$1: PluginName;
type types$1 = {
	ErrorTrackingOptions: ErrorTrackingOptions;
};
declare const getPlugins$1: GetPlugins;
declare const VALID_FUNCTION_KINDS: readonly [
	"functionDeclaration",
	"functionExpression",
	"arrowFunction",
	"objectMethod",
	"classMethod",
	"classPrivateMethod"
];
type FunctionKind = (typeof VALID_FUNCTION_KINDS)[number];
type LiveDebuggerOptions = {
	enable?: boolean;
	include?: (string | RegExp)[];
	exclude?: (string | RegExp)[];
	honorSkipComments?: boolean;
	functionTypes?: FunctionKind[];
	namedOnly?: boolean;
};
type LiveDebuggerOptionsWithDefaults = {
	version: string | undefined;
	include: (string | RegExp)[];
	exclude: (string | RegExp)[];
	honorSkipComments: boolean;
	functionTypes: FunctionKind[] | undefined;
	namedOnly: boolean;
};
declare const CONFIG_KEY$2: "liveDebugger";
declare const PLUGIN_NAME$2: PluginName;
type types$2 = {
	LiveDebuggerOptions: LiveDebuggerOptions;
};
declare const getLiveDebuggerPlugin: (pluginOptions: LiveDebuggerOptionsWithDefaults, context: GlobalContext) => PluginOptions;
declare const getPlugins$2: GetPlugins;
type Filter = (metric: Metric) => Metric | null;
type MetricsOptions = {
	enable?: boolean;
	enableDefaultPrefix?: boolean;
	/** @deprecated */
	enableTracing?: boolean;
	filters?: Filter[];
	prefix?: string;
	tags?: string[];
	timestamp?: number;
};
declare const CONFIG_KEY$3: "metrics";
declare const PLUGIN_NAME$3: PluginName;
declare const helpers: {
	filters: ((metric: Metric) => Metric | null)[];
};
type types$3 = {
	Filter: Filter;
	Metric: Metric;
	MetricsOptions: MetricsOptions;
};
declare const getPlugins$3: GetPlugins;
declare const CONFIG_KEY$4: "output";
declare const PLUGIN_NAME$4: PluginName;
declare const FILE_KEYS: readonly [
	"build",
	"bundler",
	"dependencies",
	"errors",
	"logs",
	"metrics",
	"timings",
	"warnings"
];
type FileKey = (typeof FILE_KEYS)[number];
type FileValue = boolean | string;
type OutputOptions = {
	enable?: boolean;
	files?: {
		[K in FileKey]?: FileValue;
	};
	path?: string;
};
declare const helpers$1: {};
type types$4 = {
	OutputOptions: OutputOptions;
};
declare const getFilePath: (outDir: string, pathOption: string, filename: string) => string;
declare const getPlugins$4: GetPlugins;
interface CookieOptions {
	secure?: boolean;
	crossSite?: boolean;
	partitioned?: boolean;
	domain?: string;
}
declare const SessionPersistence: {
	readonly COOKIE: "cookie";
	readonly LOCAL_STORAGE: "local-storage";
};
type SessionPersistence = (typeof SessionPersistence)[keyof typeof SessionPersistence];
type SessionStoreStrategyType = {
	type: typeof SessionPersistence.COOKIE;
	cookieOptions: CookieOptions;
} | {
	type: typeof SessionPersistence.LOCAL_STORAGE;
};
interface Subscription {
	unsubscribe: () => void;
}
type Observer<T> = (data: T) => void;
declare class Observable<T> {
	private onFirstSubscribe?;
	protected observers: Array<Observer<T>>;
	private onLastUnsubscribe?;
	constructor(onFirstSubscribe?: ((observable: Observable<T>) => (() => void) | void) | undefined);
	subscribe(observer: Observer<T>): Subscription;
	notify(data: T): void;
	protected addObserver(observer: Observer<T>): void;
	protected removeObserver(observer: Observer<T>): void;
}
declare class BufferedObservable<T> extends Observable<T> {
	private maxBufferSize;
	private buffer;
	constructor(maxBufferSize: number);
	notify(data: T): void;
	subscribe(observer: Observer<T>): Subscription;
	/**
	 * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not
	 * needed anymore. This can be seen as a performance optimization, and things will work probably
	 * even if this method isn't called, but still useful to clarify our intent and lowering our
	 * memory impact.
	 */
	unbuffer(): void;
}
declare const TrackingConsent: {
	readonly GRANTED: "granted";
	readonly NOT_GRANTED: "not-granted";
};
type TrackingConsent = (typeof TrackingConsent)[keyof typeof TrackingConsent];
interface TrackingConsentState {
	tryToInit: (trackingConsent: TrackingConsent) => void;
	update: (trackingConsent: TrackingConsent) => void;
	isGranted: () => boolean;
	observable: Observable<void>;
}
type MatchOption = string | RegExp | ((value: string) => boolean);
type Site = "datadoghq.com" | "us3.datadoghq.com" | "us5.datadoghq.com" | "datadoghq.eu" | "ddog-gov.com" | "ap1.datadoghq.com" | "ap2.datadoghq.com" | (string & {});
interface Context {
	[x: string]: ContextValue;
}
type ContextValue = string | number | boolean | Context | ContextArray | undefined | null;
interface ContextArray extends Array<ContextValue> {
}
type Duration = number & {
	d: "Duration in ms";
};
type ServerDuration = number & {
	s: "Duration in ns";
};
type TimeStamp = number & {
	t: "Epoch time";
};
type RelativeTime = number & {
	r: "Time relative to navigation start";
} & {
	d: "Duration in ms";
};
interface ClocksState {
	relative: RelativeTime;
	timeStamp: TimeStamp;
}
interface RawErrorCause {
	message: string;
	source: ErrorSource;
	type?: string;
	stack?: string;
}
interface Csp {
	disposition: "enforce" | "report";
}
interface RawError {
	startClocks: ClocksState;
	message: string;
	type?: string;
	stack?: string;
	source: ErrorSource;
	originalError?: unknown;
	handling?: ErrorHandling;
	handlingStack?: string;
	componentStack?: string;
	causes?: RawErrorCause[];
	fingerprint?: string;
	csp?: Csp;
	context?: Context;
}
declare const ErrorSource: {
	readonly AGENT: "agent";
	readonly CONSOLE: "console";
	readonly CUSTOM: "custom";
	readonly LOGGER: "logger";
	readonly NETWORK: "network";
	readonly SOURCE: "source";
	readonly REPORT: "report";
};
declare const enum ErrorHandling {
	HANDLED = "handled",
	UNHANDLED = "unhandled"
}
type ErrorSource = (typeof ErrorSource)[keyof typeof ErrorSource];
interface Payload {
	data: string | FormData | Blob;
	bytesCount: number;
	retry?: RetryInfo;
	encoding?: "deflate";
}
interface RetryInfo {
	count: number;
	lastFailureStatus: number;
}
interface Uint8ArrayBuffer extends Uint8Array {
	readonly buffer: ArrayBuffer;
	subarray(begin?: number, end?: number): Uint8ArrayBuffer;
}
interface Encoder<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
	/**
	 * Whether this encoder might call the provided callbacks asynchronously
	 */
	isAsync: boolean;
	/**
	 * Whether some data has been written since the last finish() or finishSync() call
	 */
	isEmpty: boolean;
	/**
	 * Write a string to be encoded.
	 *
	 * This operation can be synchronous or asynchronous depending on the encoder implementation.
	 *
	 * If specified, the callback will be invoked when the operation finishes, unless the operation is
	 * asynchronous and finish() or finishSync() is called in the meantime.
	 */
	write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void;
	/**
	 * Waits for pending data to be encoded and resets the encoder state.
	 *
	 * This operation can be synchronous or asynchronous depending on the encoder implementation.
	 *
	 * The callback will be invoked when the operation finishes, unless the operation is asynchronous
	 * and another call to finish() or finishSync() occurs in the meantime.
	 */
	finish(callback: (result: EncoderResult<Output>) => void): void;
	/**
	 * Resets the encoder state then returns the encoded data and any potential pending data directly,
	 * discarding all pending write operations and finish() callbacks.
	 */
	finishSync(): EncoderResult<Output> & {
		pendingData: string;
	};
	/**
	 * Returns a rough estimation of the bytes count if the data was encoded.
	 */
	estimateEncodedBytesCount(data: string): number;
}
interface EncoderResult<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
	output: Output;
	outputBytesCount: number;
	/**
	 * An encoding type supported by HTTP Content-Encoding, if applicable.
	 * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives
	 */
	encoding?: "deflate";
	/**
	 * Total bytes count of the input strings encoded to UTF-8.
	 */
	rawBytesCount: number;
}
declare const PageExitReason: {
	readonly HIDDEN: "visibility_hidden";
	readonly UNLOADING: "before_unload";
	readonly PAGEHIDE: "page_hide";
	readonly FROZEN: "page_frozen";
};
type PageExitReason = (typeof PageExitReason)[keyof typeof PageExitReason];
interface PageMayExitEvent {
	reason: PageExitReason;
}
type TrackType = "logs" | "rum" | "replay" | "profile" | "exposures" | "flagevaluation";
type ApiType = "fetch-keepalive" | "fetch" | "beacon" | "manual";
type EndpointBuilder = ReturnType<typeof createEndpointBuilder>;
declare function createEndpointBuilder(initConfiguration: InitConfiguration, trackType: TrackType, extraParameters?: string[]): {
	build(api: ApiType, payload: Payload): string;
	trackType: TrackType;
};
interface TransportConfiguration {
	logsEndpointBuilder: EndpointBuilder;
	rumEndpointBuilder: EndpointBuilder;
	sessionReplayEndpointBuilder: EndpointBuilder;
	profilingEndpointBuilder: EndpointBuilder;
	exposuresEndpointBuilder: EndpointBuilder;
	flagEvaluationEndpointBuilder: EndpointBuilder;
	datacenter?: string | undefined;
	replica?: ReplicaConfiguration;
	site: Site;
	source: "browser" | "flutter" | "unity";
}
interface ReplicaConfiguration {
	logsEndpointBuilder: EndpointBuilder;
	rumEndpointBuilder: EndpointBuilder;
}
declare const DefaultPrivacyLevel: {
	readonly ALLOW: "allow";
	readonly MASK: "mask";
	readonly MASK_USER_INPUT: "mask-user-input";
	readonly MASK_UNLESS_ALLOWLISTED: "mask-unless-allowlisted";
};
type DefaultPrivacyLevel = (typeof DefaultPrivacyLevel)[keyof typeof DefaultPrivacyLevel];
declare const TraceContextInjection: {
	readonly ALL: "all";
	readonly SAMPLED: "sampled";
};
type TraceContextInjection = (typeof TraceContextInjection)[keyof typeof TraceContextInjection];
interface InitConfiguration {
	/**
	 * The client token for Datadog. Required for authenticating your application with Datadog.
	 *
	 * @category Authentication
	 */
	clientToken: string;
	/**
	 * A callback function that can be used to modify events before they are sent to Datadog.
	 *
	 * @category Data Collection
	 */
	beforeSend?: GenericBeforeSendCallback | undefined;
	/**
	 * The percentage of sessions tracked. A value between 0 and 100.
	 *
	 * @category Data Collection
	 * @defaultValue 100
	 */
	sessionSampleRate?: number | undefined;
	/**
	 * The percentage of telemetry events sent. A value between 0 and 100.
	 *
	 * @category Data Collection
	 * @defaultValue 20
	 */
	telemetrySampleRate?: number | undefined;
	/**
	 * Initialization fails silently if the RUM Browser SDK is already initialized on the page.
	 *
	 * @defaultValue false
	 */
	silentMultipleInit?: boolean | undefined;
	/**
	 * Which storage strategy to use for persisting sessions. Can be either 'cookie' or 'local-storage'.
	 *
	 * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
	 *
	 * @category Session Persistence
	 * @defaultValue "cookie"
	 */
	sessionPersistence?: SessionPersistence | undefined;
	/**
	 * Allows the use of localStorage when cookies cannot be set. This enables the RUM Browser SDK to run in environments that do not provide cookie support.
	 *
	 * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
	 * See [Monitor Electron Applications Using the Browser SDK](https://docs.datadoghq.com/real_user_monitoring/guide/monitor-electron-applications-using-browser-sdk) for further information.
	 *
	 * @category Session Persistence
	 * @deprecated use `sessionPersistence: local-storage` where you want to use localStorage instead
	 */
	allowFallbackToLocalStorage?: boolean | undefined;
	/**
	 * Allow listening to DOM events dispatched programmatically ([untrusted events](https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted)). Enabling this option can be useful if you heavily rely on programmatic events, such as in an automated UI test environment.
	 *
	 * @defaultValue false
	 */
	allowUntrustedEvents?: boolean | undefined;
	/**
	 * Store global context and user context in localStorage to preserve them along the user navigation.
	 * See [Contexts life cycle](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/?tab=npm#contexts-life-cycle) for further information.
	 *
	 * @defaultValue false
	 */
	storeContextsAcrossPages?: boolean | undefined;
	/**
	 * Set the initial user tracking consent state.
	 * See [User tracking consent](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/?tab=npm#user-tracking-consent) for further information.
	 *
	 * @category Privacy
	 * @defaultValue granted
	 */
	trackingConsent?: TrackingConsent | undefined;
	/**
	 * List of origins where the SDK is allowed to run when used in a browser extension context.
	 * Matches urls against the extensions origin.
	 * If not provided and the SDK is running in a browser extension, the SDK will not run.
	 */
	allowedTrackingOrigins?: MatchOption[] | undefined;
	/**
	 * Optional proxy URL, for example: https://www.proxy.com/path.
	 * See [Proxy Your Browser RUM Data](https://docs.datadoghq.com/real_user_monitoring/guide/proxy-rum-data) for further information.
	 *
	 * @category Transport
	 */
	proxy?: string | ProxyFn | undefined;
	/**
	 * The Datadog [site](https://docs.datadoghq.com/getting_started/site) parameter of your organization.
	 *
	 * @category Transport
	 * @defaultValue datadoghq.com
	 */
	site?: Site | undefined;
	/**
	 * The service name for your application. Follows the [tag syntax requirements](https://docs.datadoghq.com/getting_started/tagging/#define-tags).
	 *
	 * @category Data Collection
	 */
	service?: string | undefined | null;
	/**
	 * The application’s environment, for example: prod, pre-prod, and staging. Follows the [tag syntax requirements](https://docs.datadoghq.com/getting_started/tagging/#define-tags).
	 *
	 * @category Data Collection
	 */
	env?: string | undefined | null;
	/**
	 * The application’s version, for example: 1.2.3, 6c44da20, and 2020.02.13. Follows the [tag syntax requirements](https://docs.datadoghq.com/getting_started/tagging/#define-tags).
	 *
	 * @category Data Collection
	 */
	version?: string | undefined | null;
	/**
	 * Use a partitioned secure cross-site session cookie. This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`.
	 *
	 * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
	 *
	 * @category Session Persistence
	 * @defaultValue false
	 */
	usePartitionedCrossSiteSessionCookie?: boolean | undefined;
	/**
	 * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.
	 *
	 * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
	 *
	 * @category Session Persistence
	 * @defaultValue false
	 */
	useSecureSessionCookie?: boolean | undefined;
	/**
	 * Preserve the session across subdomains for the same site.
	 *
	 * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
	 *
	 * @category Session Persistence
	 * @defaultValue false
	 */
	trackSessionAcrossSubdomains?: boolean | undefined;
	/**
	 * Track anonymous user for the same site and extend cookie expiration date
	 *
	 * @category Data Collection
	 * @defaultValue true
	 */
	trackAnonymousUser?: boolean | undefined;
	/**
	 * Encode cookie options in the cookie value. This can be used as a mitigation for microssession issues.
	 * ⚠️ This is a beta feature and may be changed or removed in the future.
	 *
	 * @category Beta
	 * @defaultValue false
	 */
	betaEncodeCookieOptions?: boolean | undefined;
	/**
	 * [Internal option] Enable experimental features
	 *
	 * @internal
	 */
	enableExperimentalFeatures?: string[] | undefined;
	/**
	 * [Internal option] Configure the dual shipping to another datacenter
	 *
	 * @internal
	 */
	replica?: ReplicaUserConfiguration | undefined;
	/**
	 * [Internal option] Set the datacenter from where the data is dual shipped
	 *
	 * @internal
	 */
	datacenter?: string;
	/**
	 * [Internal option] Datadog internal analytics subdomain
	 *
	 * @internal
	 */
	internalAnalyticsSubdomain?: string;
	/**
	 * [Internal option] The percentage of telemetry configuration sent. A value between 0 and 100.
	 *
	 * @internal
	 * @defaultValue 5
	 */
	telemetryConfigurationSampleRate?: number;
	/**
	 * [Internal option] The percentage of telemetry usage sent. A value between 0 and 100.
	 *
	 * @internal
	 * @defaultValue 5
	 */
	telemetryUsageSampleRate?: number;
	/**
	 * [Internal option] Additional configuration for the SDK.
	 *
	 * @internal
	 */
	source?: "browser" | "flutter" | "unity" | undefined;
	/**
	 * [Internal option] Additional configuration for the SDK.
	 *
	 * @internal
	 */
	sdkVersion?: string | undefined;
	/**
	 * [Internal option] Additional configuration for the SDK.
	 *
	 * @internal
	 */
	variant?: string | undefined;
}
type GenericBeforeSendCallback = (event: any, context?: any) => unknown;
type ProxyFn = (options: {
	path: string;
	parameters: string;
}) => string;
interface ReplicaUserConfiguration {
	applicationId?: string;
	clientToken: string;
}
interface Configuration extends TransportConfiguration {
	beforeSend: GenericBeforeSendCallback | undefined;
	sessionStoreStrategyType: SessionStoreStrategyType | undefined;
	sessionSampleRate: number;
	telemetrySampleRate: number;
	telemetryConfigurationSampleRate: number;
	telemetryUsageSampleRate: number;
	service?: string | undefined;
	version?: string | undefined;
	env?: string | undefined;
	silentMultipleInit: boolean;
	allowUntrustedEvents: boolean;
	trackingConsent: TrackingConsent;
	storeContextsAcrossPages: boolean;
	trackAnonymousUser?: boolean;
	betaEncodeCookieOptions: boolean;
	sdkVersion: string | undefined;
	source: "browser" | "flutter" | "unity";
	variant: string | undefined;
}
interface PublicApi {
	/**
	 * Version of the Logs browser SDK
	 */
	version: string;
	/**
	 * For CDN async setup: Early RUM API calls must be wrapped in the `window.DD_RUM.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.
	 *
	 * See [CDN async setup](https://docs.datadoghq.com/real_user_monitoring/browser/#cdn-async) for further information.
	 */
	onReady: (callback: () => void) => void;
}
type DeflateWorkerAction = {
	action: "init";
} | {
	action: "write";
	id: number;
	streamId: number;
	data: string;
} | {
	action: "reset";
	streamId: number;
};
interface DeflateWorker extends Worker {
	postMessage(message: DeflateWorkerAction): void;
}
declare const enum DeflateEncoderStreamId {
	REPLAY = 1,
	RUM = 2,
	TELEMETRY = 4,
	PROFILING = 6
}
declare const enum HookNames {
	Assemble = 0,
	AssembleTelemetry = 1
}
declare const HookNamesAsConst: {
	ASSEMBLE: HookNames.Assemble;
	ASSEMBLE_TELEMETRY: HookNames.AssembleTelemetry;
};
type RecursivePartial<T> = {
	[P in keyof T]?: T[P] extends Array<infer U> ? Array<RecursivePartial<U>> : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P];
};
declare const DISCARDED = "DISCARDED";
declare const SKIPPED = "SKIPPED";
type DISCARDED = typeof DISCARDED;
type SKIPPED = typeof SKIPPED;
type TelemetryEvent = TelemetryErrorEvent | TelemetryDebugEvent | TelemetryConfigurationEvent | TelemetryUsageEvent;
type TelemetryErrorEvent = CommonTelemetryProperties & {
	/**
	 * The telemetry log information
	 */
	telemetry: {
		/**
		 * Telemetry type
		 */
		type?: "log";
		/**
		 * Level/severity of the log
		 */
		status: "error";
		/**
		 * Body of the log
		 */
		message: string;
		/**
		 * Error properties
		 */
		error?: {
			/**
			 * The stack trace or the complementary information about the error
			 */
			stack?: string;
			/**
			 * The error type or kind (or code in some cases)
			 */
			kind?: string;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type TelemetryDebugEvent = CommonTelemetryProperties & {
	/**
	 * The telemetry log information
	 */
	telemetry: {
		/**
		 * Telemetry type
		 */
		type?: "log";
		/**
		 * Level/severity of the log
		 */
		status: "debug";
		/**
		 * Body of the log
		 */
		message: string;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type TelemetryConfigurationEvent = CommonTelemetryProperties & {
	/**
	 * The telemetry configuration information
	 */
	telemetry: {
		/**
		 * Telemetry type
		 */
		type: "configuration";
		/**
		 * Configuration properties
		 */
		configuration: {
			/**
			 * The percentage of sessions tracked
			 */
			session_sample_rate?: number;
			/**
			 * The percentage of telemetry events sent
			 */
			telemetry_sample_rate?: number;
			/**
			 * The percentage of telemetry configuration events sent after being sampled by telemetry_sample_rate
			 */
			telemetry_configuration_sample_rate?: number;
			/**
			 * The percentage of telemetry usage events sent after being sampled by telemetry_sample_rate
			 */
			telemetry_usage_sample_rate?: number;
			/**
			 * The percentage of requests traced
			 */
			trace_sample_rate?: number;
			/**
			 * The opt-in configuration to add trace context
			 */
			trace_context_injection?: "all" | "sampled";
			/**
			 * The percentage of sessions with Browser RUM & Session Replay pricing tracked (deprecated in favor of session_replay_sample_rate)
			 */
			premium_sample_rate?: number;
			/**
			 * The percentage of sessions with Browser RUM & Session Replay pricing tracked (deprecated in favor of session_replay_sample_rate)
			 */
			replay_sample_rate?: number;
			/**
			 * The percentage of sessions with RUM & Session Replay pricing tracked
			 */
			session_replay_sample_rate?: number;
			/**
			 * The initial tracking consent value
			 */
			tracking_consent?: "granted" | "not-granted" | "pending";
			/**
			 * Whether the session replay start is handled manually
			 */
			start_session_replay_recording_manually?: boolean;
			/**
			 * Whether Session Replay should automatically start a recording when enabled
			 */
			start_recording_immediately?: boolean;
			/**
			 * Whether a proxy is used
			 */
			use_proxy?: boolean;
			/**
			 * Whether beforeSend callback function is used
			 */
			use_before_send?: boolean;
			/**
			 * Whether initialization fails silently if the SDK is already initialized
			 */
			silent_multiple_init?: boolean;
			/**
			 * Whether sessions across subdomains for the same site are tracked
			 */
			track_session_across_subdomains?: boolean;
			/**
			 * Whether resources are tracked
			 */
			track_resources?: boolean;
			/**
			 * Whether early requests are tracked
			 */
			track_early_requests?: boolean;
			/**
			 * Whether long tasks are tracked
			 */
			track_long_task?: boolean;
			/**
			 * Whether views loaded from the bfcache are tracked
			 */
			track_bfcache_views?: boolean;
			/**
			 * Whether a secure cross-site session cookie is used (deprecated)
			 */
			use_cross_site_session_cookie?: boolean;
			/**
			 * Whether a partitioned secure cross-site session cookie is used
			 */
			use_partitioned_cross_site_session_cookie?: boolean;
			/**
			 * Whether a secure session cookie is used
			 */
			use_secure_session_cookie?: boolean;
			/**
			 * Whether it is allowed to use LocalStorage when cookies are not available (deprecated in favor of session_persistence)
			 */
			allow_fallback_to_local_storage?: boolean;
			/**
			 * Configure the storage strategy for persisting sessions
			 */
			session_persistence?: "local-storage" | "cookie";
			/**
			 * Whether contexts are stored in local storage
			 */
			store_contexts_across_pages?: boolean;
			/**
			 * Whether untrusted events are allowed
			 */
			allow_untrusted_events?: boolean;
			/**
			 * Attribute to be used to name actions
			 */
			action_name_attribute?: string;
			/**
			 * Whether the allowed tracing origins list is used (deprecated in favor of use_allowed_tracing_urls)
			 */
			use_allowed_tracing_origins?: boolean;
			/**
			 * Whether the allowed tracing urls list is used
			 */
			use_allowed_tracing_urls?: boolean;
			/**
			 * Whether the allowed GraphQL urls list is used
			 */
			use_allowed_graph_ql_urls?: boolean;
			/**
			 * Whether GraphQL payload tracking is used for at least one GraphQL endpoint
			 */
			use_track_graph_ql_payload?: boolean;
			/**
			 * Whether GraphQL response errors tracking is used for at least one GraphQL endpoint
			 */
			use_track_graph_ql_response_errors?: boolean;
			/**
			 * A list of selected tracing propagators
			 */
			selected_tracing_propagators?: ("datadog" | "b3" | "b3multi" | "tracecontext")[];
			/**
			 * Session replay default privacy level
			 */
			default_privacy_level?: string;
			/**
			 * Session replay text and input privacy level
			 */
			text_and_input_privacy_level?: string;
			/**
			 * Session replay image privacy level
			 */
			image_privacy_level?: string;
			/**
			 * Session replay touch privacy level
			 */
			touch_privacy_level?: string;
			/**
			 * Privacy control for action name
			 */
			enable_privacy_for_action_name?: boolean;
			/**
			 * Whether the request origins list to ignore when computing the page activity is used
			 */
			use_excluded_activity_urls?: boolean;
			/**
			 * Whether the Worker is loaded from an external URL
			 */
			use_worker_url?: boolean;
			/**
			 * Whether intake requests are compressed
			 */
			compress_intake_requests?: boolean;
			/**
			 * Whether user frustrations are tracked
			 */
			track_frustrations?: boolean;
			/**
			 * Whether the RUM views creation is handled manually
			 */
			track_views_manually?: boolean;
			/**
			 * Whether user actions are tracked (deprecated in favor of track_user_interactions)
			 */
			track_interactions?: boolean;
			/**
			 * Whether user actions are tracked
			 */
			track_user_interactions?: boolean;
			/**
			 * Whether console.error logs, uncaught exceptions and network errors are tracked
			 */
			forward_errors_to_logs?: boolean;
			/**
			 * The number of displays available to the device
			 */
			number_of_displays?: number;
			/**
			 * The console.* tracked
			 */
			forward_console_logs?: string[] | "all";
			/**
			 * The reports from the Reporting API tracked
			 */
			forward_reports?: string[] | "all";
			/**
			 * Whether local encryption is used
			 */
			use_local_encryption?: boolean;
			/**
			 * View tracking strategy
			 */
			view_tracking_strategy?: "ActivityViewTrackingStrategy" | "FragmentViewTrackingStrategy" | "MixedViewTrackingStrategy" | "NavigationViewTrackingStrategy";
			/**
			 * Whether SwiftUI view instrumentation is enabled
			 */
			swiftui_view_tracking_enabled?: boolean;
			/**
			 * Whether SwiftUI action instrumentation is enabled
			 */
			swiftui_action_tracking_enabled?: boolean;
			/**
			 * Whether RUM events are tracked when the application is in Background
			 */
			track_background_events?: boolean;
			/**
			 * The period between each Mobile Vital sample (in milliseconds)
			 */
			mobile_vitals_update_period?: number;
			/**
			 * Whether error monitoring & crash reporting is enabled for the source platform
			 */
			track_errors?: boolean;
			/**
			 * Whether automatic collection of network requests is enabled
			 */
			track_network_requests?: boolean;
			/**
			 * Whether tracing features are enabled
			 */
			use_tracing?: boolean;
			/**
			 * Whether native views are tracked (for cross platform SDKs)
			 */
			track_native_views?: boolean;
			/**
			 * Whether native error monitoring & crash reporting is enabled (for cross platform SDKs)
			 */
			track_native_errors?: boolean;
			/**
			 * Whether long task tracking is performed automatically
			 */
			track_native_long_tasks?: boolean;
			/**
			 * Whether long task tracking is performed automatically for cross platform SDKs
			 */
			track_cross_platform_long_tasks?: boolean;
			/**
			 * Whether the client has provided a list of first party hosts
			 */
			use_first_party_hosts?: boolean;
			/**
			 * The type of initialization the SDK used, in case multiple are supported
			 */
			initialization_type?: string;
			/**
			 * Whether Flutter build and raster time tracking is enabled
			 */
			track_flutter_performance?: boolean;
			/**
			 * The window duration for batches sent by the SDK (in milliseconds)
			 */
			batch_size?: number;
			/**
			 * The upload frequency of batches (in milliseconds)
			 */
			batch_upload_frequency?: number;
			/**
			 * Maximum number of batches processed sequentially without a delay
			 */
			batch_processing_level?: number;
			/**
			 * Whether UIApplication background tasks are enabled
			 */
			background_tasks_enabled?: boolean;
			/**
			 * The version of React used in a ReactNative application
			 */
			react_version?: string;
			/**
			 * The version of ReactNative used in a ReactNative application
			 */
			react_native_version?: string;
			/**
			 * The version of Dart used in a Flutter application
			 */
			dart_version?: string;
			/**
			 * The version of Unity used in a Unity application
			 */
			unity_version?: string;
			/**
			 * The threshold used for iOS App Hangs monitoring (in milliseconds)
			 */
			app_hang_threshold?: number;
			/**
			 * Whether logs are sent to the PCI-compliant intake
			 */
			use_pci_intake?: boolean;
			/**
			 * The tracer API used by the SDK. Possible values: 'Datadog', 'OpenTelemetry', 'OpenTracing'
			 */
			tracer_api?: string;
			/**
			 * The version of the tracer API used by the SDK. Eg. '0.1.0'
			 */
			tracer_api_version?: string;
			/**
			 * Whether logs are sent after the session expiration
			 */
			send_logs_after_session_expiration?: boolean;
			/**
			 * The list of plugins enabled
			 */
			plugins?: {
				/**
				 * The name of the plugin
				 */
				name: string;
				[k: string]: unknown;
			}[];
			/**
			 * Whether the SDK is initialised on the application's main or a secondary process
			 */
			is_main_process?: boolean;
			/**
			 * Interval in milliseconds when the last action is considered as the action that created the next view. Only sent if a time based strategy has been used
			 */
			inv_time_threshold_ms?: number;
			/**
			 * The interval in milliseconds during which all network requests will be considered as initial, i.e. caused by the creation of this view. Only sent if a time based strategy has been used
			 */
			tns_time_threshold_ms?: number;
			/**
			 * The list of events that include feature flags collection. The tracking is always enabled for views and errors.
			 */
			track_feature_flags_for_events?: ("vital" | "resource" | "action" | "long_task")[];
			/**
			 * Whether the anonymous users are tracked
			 */
			track_anonymous_user?: boolean;
			/**
			 * Whether a list of allowed origins is used to control SDK execution in browser extension contexts. When enabled, the SDK will check if the current origin matches the allowed origins list before running.
			 */
			use_allowed_tracking_origins?: boolean;
			/**
			 * The version of the SDK that is running.
			 */
			sdk_version?: string;
			/**
			 * The source of the SDK, e.g., 'browser', 'ios', 'android', 'flutter', 'react-native', 'unity', 'kotlin-multiplatform'.
			 */
			source?: string;
			/**
			 * The variant of the SDK build (e.g., standard, lite, etc.).
			 */
			variant?: string;
			/**
			 * The id of the remote configuration
			 */
			remote_configuration_id?: string;
			/**
			 * Whether a proxy is used for remote configuration
			 */
			use_remote_configuration_proxy?: boolean;
			/**
			 * The percentage of sessions with Profiling enabled
			 */
			profiling_sample_rate?: number;
			/**
			 * Whether trace baggage is propagated to child spans
			 */
			propagate_trace_baggage?: boolean;
			/**
			 * Whether the beta encode cookie options is enabled
			 */
			beta_encode_cookie_options?: boolean;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type TelemetryUsageEvent = CommonTelemetryProperties & {
	/**
	 * The telemetry usage information
	 */
	telemetry: {
		/**
		 * Telemetry type
		 */
		type: "usage";
		usage: TelemetryCommonFeaturesUsage | TelemetryBrowserFeaturesUsage | TelemetryMobileFeaturesUsage;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type TelemetryCommonFeaturesUsage = SetTrackingConsent | StopSession | StartView | SetViewContext | SetViewContextProperty | SetViewName | GetViewContext | AddAction | AddError | GetGlobalContext | SetGlobalContext | SetGlobalContextProperty | RemoveGlobalContextProperty | ClearGlobalContext | GetUser | SetUser | SetUserProperty | RemoveUserProperty | ClearUser | GetAccount | SetAccount | SetAccountProperty | RemoveAccountProperty | ClearAccount | AddFeatureFlagEvaluation | AddOperationStepVital;
type TelemetryBrowserFeaturesUsage = StartSessionReplayRecording | StartDurationVital | StopDurationVital | AddDurationVital;
type TelemetryMobileFeaturesUsage = AddViewLoadingTime | TrackWebView;
interface CommonTelemetryProperties {
	/**
	 * Internal properties
	 */
	_dd: {
		/**
		 * Version of the RUM event format
		 */
		readonly format_version: 2;
		[k: string]: unknown;
	};
	/**
	 * Telemetry event type. Should specify telemetry only.
	 */
	readonly type: "telemetry";
	/**
	 * Start of the event in ms from epoch
	 */
	date: number;
	/**
	 * The SDK generating the telemetry event
	 */
	service: string;
	/**
	 * The source of this event
	 */
	readonly source: "android" | "ios" | "browser" | "flutter" | "react-native" | "unity" | "kotlin-multiplatform";
	/**
	 * The version of the SDK generating the telemetry event
	 */
	version: string;
	/**
	 * Application properties
	 */
	readonly application?: {
		/**
		 * UUID of the application
		 */
		id: string;
		[k: string]: unknown;
	};
	/**
	 * Session properties
	 */
	session?: {
		/**
		 * UUID of the session
		 */
		id: string;
		[k: string]: unknown;
	};
	/**
	 * View properties
	 */
	view?: {
		/**
		 * UUID of the view
		 */
		id: string;
		[k: string]: unknown;
	};
	/**
	 * Action properties
	 */
	action?: {
		/**
		 * UUID of the action
		 */
		id: string;
		[k: string]: unknown;
	};
	/**
	 * The actual percentage of telemetry usage per event
	 */
	effective_sample_rate?: number;
	/**
	 * Enabled experimental features
	 */
	readonly experimental_features?: string[];
	telemetry?: {
		/**
		 * Device properties
		 */
		device?: {
			/**
			 * Architecture of the device
			 */
			architecture?: string;
			/**
			 * Brand of the device
			 */
			brand?: string;
			/**
			 * Model of the device
			 */
			model?: string;
			/**
			 * Number of logical CPU cores available for scheduling on the device at runtime, as reported by the operating system.
			 */
			readonly logical_cpu_count?: number;
			/**
			 * Total RAM in megabytes
			 */
			readonly total_ram?: number;
			/**
			 * Whether the device is considered a low RAM device (Android)
			 */
			readonly is_low_ram?: boolean;
			[k: string]: unknown;
		};
		/**
		 * OS properties
		 */
		os?: {
			/**
			 * Build of the OS
			 */
			build?: string;
			/**
			 * Name of the OS
			 */
			name?: string;
			/**
			 * Version of the OS
			 */
			version?: string;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	[k: string]: unknown;
}
interface SetTrackingConsent {
	/**
	 * setTrackingConsent API
	 */
	feature: "set-tracking-consent";
	/**
	 * The tracking consent value set by the user
	 */
	tracking_consent: "granted" | "not-granted" | "pending";
	[k: string]: unknown;
}
interface StopSession {
	/**
	 * stopSession API
	 */
	feature: "stop-session";
	[k: string]: unknown;
}
interface StartView {
	/**
	 * startView API
	 */
	feature: "start-view";
	[k: string]: unknown;
}
interface SetViewContext {
	/**
	 * setViewContext API
	 */
	feature: "set-view-context";
	[k: string]: unknown;
}
interface SetViewContextProperty {
	/**
	 * setViewContextProperty API
	 */
	feature: "set-view-context-property";
	[k: string]: unknown;
}
interface SetViewName {
	/**
	 * setViewName API
	 */
	feature: "set-view-name";
	[k: string]: unknown;
}
interface GetViewContext {
	/**
	 * getViewContext API
	 */
	feature: "get-view-context";
	[k: string]: unknown;
}
interface AddAction {
	/**
	 * addAction API
	 */
	feature: "add-action";
	[k: string]: unknown;
}
interface AddError {
	/**
	 * addError API
	 */
	feature: "add-error";
	[k: string]: unknown;
}
interface GetGlobalContext {
	/**
	 * getGlobalContext API
	 */
	feature: "get-global-context";
	[k: string]: unknown;
}
interface SetGlobalContext {
	/**
	 * setGlobalContext, addAttribute APIs
	 */
	feature: "set-global-context";
	[k: string]: unknown;
}
interface SetGlobalContextProperty {
	/**
	 * setGlobalContextProperty API
	 */
	feature: "set-global-context-property";
	[k: string]: unknown;
}
interface RemoveGlobalContextProperty {
	/**
	 * removeGlobalContextProperty API
	 */
	feature: "remove-global-context-property";
	[k: string]: unknown;
}
interface ClearGlobalContext {
	/**
	 * clearGlobalContext API
	 */
	feature: "clear-global-context";
	[k: string]: unknown;
}
interface GetUser {
	/**
	 * getUser API
	 */
	feature: "get-user";
	[k: string]: unknown;
}
interface SetUser {
	/**
	 * setUser, setUserInfo APIs
	 */
	feature: "set-user";
	[k: string]: unknown;
}
interface SetUserProperty {
	/**
	 * setUserProperty API
	 */
	feature: "set-user-property";
	[k: string]: unknown;
}
interface RemoveUserProperty {
	/**
	 * removeUserProperty API
	 */
	feature: "remove-user-property";
	[k: string]: unknown;
}
interface ClearUser {
	/**
	 * clearUser API
	 */
	feature: "clear-user";
	[k: string]: unknown;
}
interface GetAccount {
	/**
	 * getAccount API
	 */
	feature: "get-account";
	[k: string]: unknown;
}
interface SetAccount {
	/**
	 * setAccount, setAccountProperty APIs
	 */
	feature: "set-account";
	[k: string]: unknown;
}
interface SetAccountProperty {
	/**
	 * setAccountProperty API
	 */
	feature: "set-account-property";
	[k: string]: unknown;
}
interface RemoveAccountProperty {
	/**
	 * removeAccountProperty API
	 */
	feature: "remove-account-property";
	[k: string]: unknown;
}
interface ClearAccount {
	/**
	 * clearAccount API
	 */
	feature: "clear-account";
	[k: string]: unknown;
}
interface AddFeatureFlagEvaluation {
	/**
	 * addFeatureFlagEvaluation API
	 */
	feature: "add-feature-flag-evaluation";
	[k: string]: unknown;
}
interface AddOperationStepVital {
	/**
	 * addOperationStepVital API
	 */
	feature: "add-operation-step-vital";
	/**
	 * Operations step type
	 */
	action_type: "start" | "succeed" | "fail";
	[k: string]: unknown;
}
interface StartSessionReplayRecording {
	/**
	 * startSessionReplayRecording API
	 */
	feature: "start-session-replay-recording";
	/**
	 * Whether the recording is allowed to start even on sessions sampled out of replay
	 */
	is_forced?: boolean;
	[k: string]: unknown;
}
interface StartDurationVital {
	/**
	 * startDurationVital API
	 */
	feature: "start-duration-vital";
	[k: string]: unknown;
}
interface StopDurationVital {
	/**
	 * stopDurationVital API
	 */
	feature: "stop-duration-vital";
	[k: string]: unknown;
}
interface AddDurationVital {
	/**
	 * addDurationVital API
	 */
	feature: "add-duration-vital";
	[k: string]: unknown;
}
interface AddViewLoadingTime {
	/**
	 * addViewLoadingTime API
	 */
	feature: "addViewLoadingTime";
	/**
	 * Whether the view is not available
	 */
	no_view: boolean;
	/**
	 * Whether the available view is not active
	 */
	no_active_view: boolean;
	/**
	 * Whether the loading time was overwritten
	 */
	overwritten: boolean;
	[k: string]: unknown;
}
interface TrackWebView {
	/**
	 * trackWebView API
	 */
	feature: "trackWebView";
	[k: string]: unknown;
}
interface Telemetry {
	stop: () => void;
	enabled: boolean;
	metricsEnabled: boolean;
}
type EventTypesWithoutData<EventMap> = {
	[K in keyof EventMap]: EventMap[K] extends void ? K : never;
}[keyof EventMap];
declare class AbstractLifeCycle<EventMap> {
	private callbacks;
	notify<EventType extends EventTypesWithoutData<EventMap>>(eventType: EventType): void;
	notify<EventType extends keyof EventMap>(eventType: EventType, data: EventMap[EventType]): void;
	subscribe<EventType extends keyof EventMap>(eventType: EventType, callback: (data: EventMap[EventType]) => void): Subscription;
}
type ContextManager = ReturnType<typeof createContextManager>;
interface PropertiesConfig {
	[key: string]: {
		required?: boolean;
		type?: "string";
	};
}
declare function createContextManager(name?: string, { propertiesConfig, }?: {
	propertiesConfig?: PropertiesConfig;
}): {
	getContext: () => Context;
	setContext: (newContext: unknown) => void;
	setContextProperty: (key: string, property: any) => void;
	removeContextProperty: (key: string) => void;
	clearContext: () => void;
	changeObservable: Observable<void>;
};
interface Account {
	id: string;
	name?: string | undefined;
	[key: string]: unknown;
}
interface User {
	id?: string | undefined;
	email?: string | undefined;
	name?: string | undefined;
	[key: string]: unknown;
}
interface RumInternalContext extends Context {
	application_id: string;
	session_id: string | undefined;
	view?: {
		id: string;
		url: string;
		referrer: string;
		name?: string;
	};
	user_action?: {
		id: string | string[];
	};
}
declare const ResourceType: {
	readonly DOCUMENT: "document";
	readonly XHR: "xhr";
	readonly BEACON: "beacon";
	readonly FETCH: "fetch";
	readonly CSS: "css";
	readonly JS: "js";
	readonly IMAGE: "image";
	readonly FONT: "font";
	readonly MEDIA: "media";
	readonly OTHER: "other";
};
type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
declare const RequestType: {
	readonly FETCH: "fetch";
	readonly XHR: "xhr";
};
type RequestType = (typeof RequestType)[keyof typeof RequestType];
declare const enum BufferedDataType {
	RUNTIME_ERROR = 0
}
interface BufferedData {
	type: BufferedDataType.RUNTIME_ERROR;
	error: RawError;
}
type RumEvent = RumActionEvent | RumTransitionEvent | RumErrorEvent | RumLongTaskEvent | RumResourceEvent | RumViewEvent | RumVitalEvent;
type RumActionEvent = CommonProperties & ViewContainerSchema & {
	/**
	 * RUM event type
	 */
	readonly type: "action";
	/**
	 * Action properties
	 */
	readonly action: {
		/**
		 * Type of the action
		 */
		readonly type: "custom" | "click" | "tap" | "scroll" | "swipe" | "application_start" | "back";
		/**
		 * UUID of the action
		 */
		readonly id?: string;
		/**
		 * Duration in ns to the action is considered loaded
		 */
		readonly loading_time?: number;
		/**
		 * Action target properties
		 */
		readonly target?: {
			/**
			 * Target name
			 */
			name: string;
			[k: string]: unknown;
		};
		/**
		 * Action frustration properties
		 */
		readonly frustration?: {
			/**
			 * Action frustration types
			 */
			readonly type: ("rage_click" | "dead_click" | "error_click" | "rage_tap" | "error_tap")[];
			[k: string]: unknown;
		};
		/**
		 * Properties of the errors of the action
		 */
		readonly error?: {
			/**
			 * Number of errors that occurred on the action
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the crashes of the action
		 */
		readonly crash?: {
			/**
			 * Number of crashes that occurred on the action
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the long tasks of the action
		 */
		readonly long_task?: {
			/**
			 * Number of long tasks that occurred on the action
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the resources of the action
		 */
		readonly resource?: {
			/**
			 * Number of resources that occurred on the action
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	/**
	 * View properties
	 */
	readonly view?: {
		/**
		 * Is the action starting in the foreground (focus in browser)
		 */
		readonly in_foreground?: boolean;
		[k: string]: unknown;
	};
	/**
	 * Internal properties
	 */
	_dd?: {
		/**
		 * Action properties
		 */
		readonly action?: {
			/**
			 * Action position properties
			 */
			readonly position?: {
				/**
				 * X coordinate relative to the target element of the action (in pixels)
				 */
				readonly x: number;
				/**
				 * Y coordinate relative to the target element of the action (in pixels)
				 */
				readonly y: number;
				[k: string]: unknown;
			};
			/**
			 * Target properties
			 */
			target?: {
				/**
				 * CSS selector path of the target element
				 */
				readonly selector?: string;
				/**
				 * Width of the target element (in pixels)
				 */
				readonly width?: number;
				/**
				 * Height of the target element (in pixels)
				 */
				readonly height?: number;
				[k: string]: unknown;
			};
			/**
			 * The strategy of how the auto click action name is computed
			 */
			name_source?: "custom_attribute" | "mask_placeholder" | "standard_attribute" | "text_content" | "mask_disallowed" | "blank";
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumTransitionEvent = CommonProperties & {
	/**
	 * RUM event type
	 */
	readonly type: "transition";
	/**
	 * Stream properties
	 */
	readonly stream: {
		/**
		 * UUID of the stream
		 */
		readonly id: string;
		[k: string]: unknown;
	};
	/**
	 * Transition properties
	 */
	readonly transition: {
		/**
		 * Type of the transition
		 */
		readonly type: string;
		/**
		 * UUID of the transition
		 */
		readonly id?: string;
		/**
		 * The player's current timestamp in milliseconds
		 */
		readonly timestamp?: number;
		/**
		 * Buffer starvation duration, the amount of time spent rebuffering in milliseconds
		 */
		readonly buffer_starvation_duration?: number;
		/**
		 * Media start delay, the amount of time spent loading before playing in milliseconds
		 */
		readonly media_start_delay?: number;
		/**
		 * Error code, as reported by the player
		 */
		readonly error_code?: number;
		/**
		 * Duration of the event in milliseconds
		 */
		readonly duration?: number;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumErrorEvent = CommonProperties & ActionChildProperties & ViewContainerSchema & {
	/**
	 * RUM event type
	 */
	readonly type: "error";
	/**
	 * Error properties
	 */
	readonly error: {
		/**
		 * UUID of the error
		 */
		readonly id?: string;
		/**
		 * Error message
		 */
		message: string;
		/**
		 * Source of the error
		 */
		readonly source: "network" | "source" | "console" | "logger" | "agent" | "webview" | "custom" | "report";
		/**
		 * Stacktrace of the error
		 */
		stack?: string;
		/**
		 * Causes of the error
		 */
		causes?: {
			/**
			 * Error message
			 */
			message: string;
			/**
			 * The type of the error
			 */
			readonly type?: string;
			/**
			 * Stacktrace of the error
			 */
			stack?: string;
			/**
			 * Source of the error
			 */
			readonly source: "network" | "source" | "console" | "logger" | "agent" | "webview" | "custom" | "report";
			[k: string]: unknown;
		}[];
		/**
		 * Whether this error crashed the host application
		 */
		readonly is_crash?: boolean;
		/**
		 * Fingerprint used for Error Tracking custom grouping
		 */
		fingerprint?: string;
		/**
		 * The type of the error
		 */
		readonly type?: string;
		/**
		 * The specific category of the error. It provides a high-level grouping for different types of errors.
		 */
		readonly category?: "ANR" | "App Hang" | "Exception" | "Watchdog Termination" | "Memory Warning" | "Network";
		/**
		 * Whether the error has been handled manually in the source code or not
		 */
		readonly handling?: "handled" | "unhandled";
		/**
		 * Handling call stack
		 */
		readonly handling_stack?: string;
		/**
		 * Source type of the error (the language or platform impacting the error stacktrace format)
		 */
		readonly source_type?: "android" | "browser" | "ios" | "react-native" | "flutter" | "roku" | "ndk" | "ios+il2cpp" | "ndk+il2cpp";
		/**
		 * Resource properties of the error
		 */
		readonly resource?: {
			/**
			 * HTTP method of the resource
			 */
			readonly method: "POST" | "GET" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "TRACE" | "OPTIONS" | "CONNECT";
			/**
			 * HTTP Status code of the resource
			 */
			readonly status_code: number;
			/**
			 * URL of the resource
			 */
			url: string;
			/**
			 * The provider for this resource
			 */
			readonly provider?: {
				/**
				 * The domain name of the provider
				 */
				readonly domain?: string;
				/**
				 * The user friendly name of the provider
				 */
				readonly name?: string;
				/**
				 * The type of provider
				 */
				readonly type?: "ad" | "advertising" | "analytics" | "cdn" | "content" | "customer-success" | "first party" | "hosting" | "marketing" | "other" | "social" | "tag-manager" | "utility" | "video";
				[k: string]: unknown;
			};
			[k: string]: unknown;
		};
		/**
		 * Description of each thread in the process when error happened.
		 */
		threads?: {
			/**
			 * Name of the thread (e.g. 'Thread 0').
			 */
			readonly name: string;
			/**
			 * Tells if the thread crashed.
			 */
			readonly crashed: boolean;
			/**
			 * Unsymbolicated stack trace of the given thread.
			 */
			readonly stack: string;
			/**
			 * Platform-specific state of the thread when its state was captured (CPU registers dump for iOS, thread state enum for Android, etc.).
			 */
			readonly state?: string;
			[k: string]: unknown;
		}[];
		/**
		 * Description of each binary image (native libraries; for Android: .so files) loaded or referenced by the process/application.
		 */
		readonly binary_images?: {
			/**
			 * Build UUID that uniquely identifies the binary image.
			 */
			readonly uuid: string;
			/**
			 * Name of the library.
			 */
			readonly name: string;
			/**
			 * Determines if it's a system or user library.
			 */
			readonly is_system: boolean;
			/**
			 * Library's load address (hexadecimal).
			 */
			readonly load_address?: string;
			/**
			 * Max value from the library address range (hexadecimal).
			 */
			readonly max_address?: string;
			/**
			 * CPU architecture from the library.
			 */
			readonly arch?: string;
			[k: string]: unknown;
		}[];
		/**
		 * A boolean value saying if any of the stack traces was truncated due to minification.
		 */
		readonly was_truncated?: boolean;
		/**
		 * Platform-specific metadata of the error event.
		 */
		readonly meta?: {
			/**
			 * The CPU architecture of the process that crashed.
			 */
			readonly code_type?: string;
			/**
			 * Parent process information.
			 */
			readonly parent_process?: string;
			/**
			 * A client-generated 16-byte UUID of the incident.
			 */
			readonly incident_identifier?: string;
			/**
			 * The name of the crashed process.
			 */
			readonly process?: string;
			/**
			 * The name of the corresponding BSD termination signal. (in case of iOS crash)
			 */
			readonly exception_type?: string;
			/**
			 * CPU specific information about the exception encoded into 64-bit hexadecimal number preceded by the signal code.
			 */
			readonly exception_codes?: string;
			/**
			 * The location of the executable.
			 */
			readonly path?: string;
			[k: string]: unknown;
		};
		/**
		 * Content Security Violation properties
		 */
		readonly csp?: {
			/**
			 * In the context of CSP errors, indicates how the violated policy is configured to be treated by the user agent.
			 */
			readonly disposition?: "enforce" | "report";
			[k: string]: unknown;
		};
		/**
		 * Time since application start when error happened (in milliseconds)
		 */
		readonly time_since_app_start?: number;
		[k: string]: unknown;
	};
	/**
	 * Properties of App Hang and ANR errors
	 */
	readonly freeze?: {
		/**
		 * Duration of the main thread freeze (in ns)
		 */
		readonly duration: number;
		[k: string]: unknown;
	};
	/**
	 * View properties
	 */
	readonly view?: {
		/**
		 * Is the error starting in the foreground (focus in browser)
		 */
		readonly in_foreground?: boolean;
		[k: string]: unknown;
	};
	/**
	 * Feature flags properties
	 */
	readonly feature_flags?: {
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumLongTaskEvent = CommonProperties & ActionChildProperties & ViewContainerSchema & {
	/**
	 * RUM event type
	 */
	readonly type: "long_task";
	/**
	 * Long Task properties
	 */
	readonly long_task: {
		/**
		 * UUID of the long task or long animation frame
		 */
		readonly id?: string;
		/**
		 * Start time of the long animation frame
		 */
		readonly start_time?: number;
		/**
		 * Type of the event: long task or long animation frame
		 */
		readonly entry_type?: "long-task" | "long-animation-frame";
		/**
		 * Duration in ns of the long task or long animation frame
		 */
		readonly duration: number;
		/**
		 * Duration in ns for which the animation frame was being blocked
		 */
		readonly blocking_duration?: number;
		/**
		 * Time difference (in ns) between the timeOrigin and the start time of the rendering cycle, which includes requestAnimationFrame callbacks, style and layout calculation, resize observer and intersection observer callbacks
		 */
		readonly render_start?: number;
		/**
		 * Time difference (in ns) between the timeOrigin and the start time of the time period spent in style and layout calculations
		 */
		readonly style_and_layout_start?: number;
		/**
		 * Time difference (in ns) between the timeOrigin and the start time of of the first UI event (mouse/keyboard and so on) to be handled during the course of this frame
		 */
		readonly first_ui_event_timestamp?: number;
		/**
		 * Whether this long task is considered a frozen frame
		 */
		readonly is_frozen_frame?: boolean;
		/**
		 * A list of long scripts that were executed over the course of the long frame
		 */
		readonly scripts?: {
			/**
			 * Duration in ns between startTime and when the subsequent microtask queue has finished processing
			 */
			readonly duration?: number;
			/**
			 * Duration in ns of the total time spent in 'pausing' synchronous operations (alert, synchronous XHR)
			 */
			readonly pause_duration?: number;
			/**
			 * Duration in ns of the the total time spent processing forced layout and style inside this function
			 */
			readonly forced_style_and_layout_duration?: number;
			/**
			 * Time the entry function was invoked
			 */
			readonly start_time?: number;
			/**
			 * Time after compilation
			 */
			readonly execution_start?: number;
			/**
			 * The script resource name where available (or empty if not found)
			 */
			source_url?: string;
			/**
			 * The script function name where available (or empty if not found)
			 */
			readonly source_function_name?: string;
			/**
			 * The script character position where available (or -1 if not found)
			 */
			readonly source_char_position?: number;
			/**
			 * Information about the invoker of the script
			 */
			invoker?: string;
			/**
			 * Type of the invoker of the script
			 */
			readonly invoker_type?: "user-callback" | "event-listener" | "resolve-promise" | "reject-promise" | "classic-script" | "module-script";
			/**
			 * The container (the top-level document, or an <iframe>) the long animation frame occurred in
			 */
			readonly window_attribution?: string;
			[k: string]: unknown;
		}[];
		[k: string]: unknown;
	};
	/**
	 * Internal properties
	 */
	readonly _dd?: {
		/**
		 * Whether the long task should be discarded or indexed
		 */
		readonly discarded?: boolean;
		/**
		 * Profiling context
		 */
		profiling?: ProfilingInternalContextSchema;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumResourceEvent = CommonProperties & ActionChildProperties & ViewContainerSchema & {
	/**
	 * RUM event type
	 */
	readonly type: "resource";
	/**
	 * Resource properties
	 */
	readonly resource: {
		/**
		 * UUID of the resource
		 */
		readonly id?: string;
		/**
		 * Resource type
		 */
		readonly type: "document" | "xhr" | "beacon" | "fetch" | "css" | "js" | "image" | "font" | "media" | "other" | "native";
		/**
		 * HTTP method of the resource
		 */
		readonly method?: "POST" | "GET" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "TRACE" | "OPTIONS" | "CONNECT";
		/**
		 * URL of the resource
		 */
		url: string;
		/**
		 * HTTP status code of the resource
		 */
		readonly status_code?: number;
		/**
		 * Duration of the resource
		 */
		readonly duration?: number;
		/**
		 * Size in octet of the resource response body
		 */
		readonly size?: number;
		/**
		 * Size in octet of the resource before removing any applied content encodings
		 */
		readonly encoded_body_size?: number;
		/**
		 * Size in octet of the resource after removing any applied encoding
		 */
		readonly decoded_body_size?: number;
		/**
		 * Size in octet of the fetched resource
		 */
		readonly transfer_size?: number;
		/**
		 * Render blocking status of the resource
		 */
		readonly render_blocking_status?: "blocking" | "non-blocking";
		/**
		 * Worker phase properties
		 */
		readonly worker?: {
			/**
			 * Duration in nanoseconds of the resource worker phase
			 */
			readonly duration: number;
			/**
			 * Duration in nanoseconds between start of the request and start of the worker phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * Redirect phase properties
		 */
		readonly redirect?: {
			/**
			 * Duration in ns of the resource redirect phase
			 */
			readonly duration: number;
			/**
			 * Duration in ns between start of the request and start of the redirect phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * DNS phase properties
		 */
		readonly dns?: {
			/**
			 * Duration in ns of the resource dns phase
			 */
			readonly duration: number;
			/**
			 * Duration in ns between start of the request and start of the dns phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * Connect phase properties
		 */
		readonly connect?: {
			/**
			 * Duration in ns of the resource connect phase
			 */
			readonly duration: number;
			/**
			 * Duration in ns between start of the request and start of the connect phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * SSL phase properties
		 */
		readonly ssl?: {
			/**
			 * Duration in ns of the resource ssl phase
			 */
			readonly duration: number;
			/**
			 * Duration in ns between start of the request and start of the ssl phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * First Byte phase properties
		 */
		readonly first_byte?: {
			/**
			 * Duration in ns of the resource first byte phase
			 */
			readonly duration: number;
			/**
			 * Duration in ns between start of the request and start of the first byte phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * Download phase properties
		 */
		readonly download?: {
			/**
			 * Duration in ns of the resource download phase
			 */
			readonly duration: number;
			/**
			 * Duration in ns between start of the request and start of the download phase
			 */
			readonly start: number;
			[k: string]: unknown;
		};
		/**
		 * Network protocol used to fetch the resource (e.g., 'http/1.1', 'h2')
		 */
		readonly protocol?: string;
		/**
		 * Delivery type of the resource
		 */
		readonly delivery_type?: "cache" | "navigational-prefetch" | "other";
		/**
		 * The provider for this resource
		 */
		readonly provider?: {
			/**
			 * The domain name of the provider
			 */
			readonly domain?: string;
			/**
			 * The user friendly name of the provider
			 */
			readonly name?: string;
			/**
			 * The type of provider
			 */
			readonly type?: "ad" | "advertising" | "analytics" | "cdn" | "content" | "customer-success" | "first party" | "hosting" | "marketing" | "other" | "social" | "tag-manager" | "utility" | "video";
			[k: string]: unknown;
		};
		/**
		 * GraphQL requests parameters
		 */
		readonly graphql?: {
			/**
			 * Type of the GraphQL operation
			 */
			readonly operationType?: "query" | "mutation" | "subscription";
			/**
			 * Name of the GraphQL operation
			 */
			readonly operationName?: string;
			/**
			 * Content of the GraphQL operation
			 */
			payload?: string;
			/**
			 * String representation of the operation variables
			 */
			variables?: string;
			/**
			 * Number of GraphQL errors in the response
			 */
			readonly error_count?: number;
			/**
			 * Array of GraphQL errors from the response
			 */
			readonly errors?: {
				/**
				 * Error message
				 */
				readonly message: string;
				/**
				 * Error code (used by some providers)
				 */
				readonly code?: string;
				/**
				 * Array of error locations in the GraphQL query
				 */
				readonly locations?: {
					/**
					 * Line number where the error occurred
					 */
					readonly line: number;
					/**
					 * Column number where the error occurred
					 */
					readonly column: number;
					[k: string]: unknown;
				}[];
				/**
				 * Path to the field that caused the error
				 */
				readonly path?: (string | number)[];
				[k: string]: unknown;
			}[];
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	/**
	 * Internal properties
	 */
	readonly _dd?: {
		/**
		 * span identifier in decimal format
		 */
		readonly span_id?: string;
		/**
		 * parent span identifier in decimal format
		 */
		readonly parent_span_id?: string;
		/**
		 * trace identifier, either a 64 bit decimal number or a 128 bit hexadecimal number padded with 0s
		 */
		readonly trace_id?: string;
		/**
		 * trace sample rate in decimal format
		 */
		readonly rule_psr?: number;
		/**
		 * Whether the resource should be discarded or indexed
		 */
		readonly discarded?: boolean;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumViewEvent = CommonProperties & ViewContainerSchema & StreamSchema & {
	/**
	 * RUM event type
	 */
	readonly type: "view";
	/**
	 * View properties
	 */
	readonly view: {
		/**
		 * Duration in ns to the view is considered loaded
		 */
		readonly loading_time?: number;
		/**
		 * Duration in ns from the moment the view was started until all the initial network requests settled
		 */
		readonly network_settled_time?: number;
		/**
		 * Duration in ns to from the last interaction on previous view to the moment the current view was displayed
		 */
		readonly interaction_to_next_view_time?: number;
		/**
		 * Type of the loading of the view
		 */
		readonly loading_type?: "initial_load" | "route_change" | "activity_display" | "activity_redisplay" | "fragment_display" | "fragment_redisplay" | "view_controller_display" | "view_controller_redisplay";
		/**
		 * Time spent on the view in ns
		 */
		readonly time_spent: number;
		/**
		 * @deprecated
		 * Duration in ns to the first rendering (deprecated in favor of `view.performance.fcp.timestamp`)
		 */
		readonly first_contentful_paint?: number;
		/**
		 * @deprecated
		 * Duration in ns to the largest contentful paint (deprecated in favor of `view.performance.lcp.timestamp`)
		 */
		readonly largest_contentful_paint?: number;
		/**
		 * @deprecated
		 * CSS selector path of the largest contentful paint element (deprecated in favor of `view.performance.lcp.target_selector`)
		 */
		readonly largest_contentful_paint_target_selector?: string;
		/**
		 * @deprecated
		 * Duration in ns of the first input event delay (deprecated in favor of `view.performance.fid.duration`)
		 */
		readonly first_input_delay?: number;
		/**
		 * @deprecated
		 * Duration in ns to the first input (deprecated in favor of `view.performance.fid.timestamp`)
		 */
		readonly first_input_time?: number;
		/**
		 * @deprecated
		 * CSS selector path of the first input target element (deprecated in favor of `view.performance.fid.target_selector`)
		 */
		readonly first_input_target_selector?: string;
		/**
		 * @deprecated
		 * Longest duration in ns between an interaction and the next paint (deprecated in favor of `view.performance.inp.duration`)
		 */
		readonly interaction_to_next_paint?: number;
		/**
		 * @deprecated
		 * Duration in ns between start of the view and start of the INP (deprecated in favor of `view.performance.inp.timestamp`)
		 */
		readonly interaction_to_next_paint_time?: number;
		/**
		 * @deprecated
		 * CSS selector path of the interacted element corresponding to INP (deprecated in favor of `view.performance.inp.target_selector`)
		 */
		readonly interaction_to_next_paint_target_selector?: string;
		/**
		 * @deprecated
		 * Total layout shift score that occurred on the view (deprecated in favor of `view.performance.cls.score`)
		 */
		readonly cumulative_layout_shift?: number;
		/**
		 * @deprecated
		 * Duration in ns between start of the view and start of the largest layout shift contributing to CLS (deprecated in favor of `view.performance.cls.timestamp`)
		 */
		readonly cumulative_layout_shift_time?: number;
		/**
		 * @deprecated
		 * CSS selector path of the first element (in document order) of the largest layout shift contributing to CLS (deprecated in favor of `view.performance.cls.target_selector`)
		 */
		readonly cumulative_layout_shift_target_selector?: string;
		/**
		 * Duration in ns to the complete parsing and loading of the document and its sub resources
		 */
		readonly dom_complete?: number;
		/**
		 * Duration in ns to the complete parsing and loading of the document without its sub resources
		 */
		readonly dom_content_loaded?: number;
		/**
		 * Duration in ns to the end of the parsing of the document
		 */
		readonly dom_interactive?: number;
		/**
		 * Duration in ns to the end of the load event handler execution
		 */
		readonly load_event?: number;
		/**
		 * Duration in ns to the response start of the document request
		 */
		readonly first_byte?: number;
		/**
		 * User custom timings of the view. As timing name is used as facet path, it must contain only letters, digits, or the characters - _ . @ $
		 */
		readonly custom_timings?: {
			[k: string]: number;
		};
		/**
		 * Whether the View corresponding to this event is considered active
		 */
		readonly is_active?: boolean;
		/**
		 * Whether the View had a low average refresh rate
		 */
		readonly is_slow_rendered?: boolean;
		/**
		 * Properties of the actions of the view
		 */
		readonly action: {
			/**
			 * Number of actions that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the errors of the view
		 */
		readonly error: {
			/**
			 * Number of errors that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the crashes of the view
		 */
		readonly crash?: {
			/**
			 * Number of crashes that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the long tasks of the view
		 */
		readonly long_task?: {
			/**
			 * Number of long tasks that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the frozen frames of the view
		 */
		readonly frozen_frame?: {
			/**
			 * Number of frozen frames that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * List of slow frames during the view’s lifetime
		 */
		readonly slow_frames?: {
			/**
			 * Duration in ns between start of the view and the start of the slow frame
			 */
			readonly start: number;
			/**
			 * Duration in ns of the slow frame
			 */
			readonly duration: number;
			[k: string]: unknown;
		}[];
		/**
		 * Properties of the resources of the view
		 */
		readonly resource: {
			/**
			 * Number of resources that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * Properties of the frustrations of the view
		 */
		readonly frustration?: {
			/**
			 * Number of frustrations that occurred on the view
			 */
			readonly count: number;
			[k: string]: unknown;
		};
		/**
		 * List of the periods of time the user had the view in foreground (focused in the browser)
		 */
		readonly in_foreground_periods?: {
			/**
			 * Duration in ns between start of the view and start of foreground period
			 */
			readonly start: number;
			/**
			 * Duration in ns of the view foreground period
			 */
			readonly duration: number;
			[k: string]: unknown;
		}[];
		/**
		 * Average memory used during the view lifetime (in bytes)
		 */
		readonly memory_average?: number;
		/**
		 * Peak memory used during the view lifetime (in bytes)
		 */
		readonly memory_max?: number;
		/**
		 * Total number of cpu ticks during the view’s lifetime
		 */
		readonly cpu_ticks_count?: number;
		/**
		 * Average number of cpu ticks per second during the view’s lifetime
		 */
		readonly cpu_ticks_per_second?: number;
		/**
		 * Average refresh rate during the view’s lifetime (in frames per second)
		 */
		readonly refresh_rate_average?: number;
		/**
		 * Minimum refresh rate during the view’s lifetime (in frames per second)
		 */
		readonly refresh_rate_min?: number;
		/**
		 * Rate of slow frames during the view’s lifetime (in milliseconds per second)
		 */
		readonly slow_frames_rate?: number;
		/**
		 * Rate of freezes during the view’s lifetime (in seconds per hour)
		 */
		readonly freeze_rate?: number;
		/**
		 * Time taken for Flutter 'build' methods.
		 */
		flutter_build_time?: RumPerfMetric;
		/**
		 * Time taken for Flutter to rasterize the view.
		 */
		flutter_raster_time?: RumPerfMetric;
		/**
		 * The JavaScript refresh rate for React Native
		 */
		js_refresh_rate?: RumPerfMetric;
		/**
		 * Performance data. (Web Vitals, etc.)
		 */
		performance?: ViewPerformanceData;
		/**
		 * Accessibility properties of the view
		 */
		accessibility?: ViewAccessibilityProperties;
		[k: string]: unknown;
	};
	/**
	 * Session properties
	 */
	readonly session?: {
		/**
		 * Whether this session is currently active. Set to false to manually stop a session
		 */
		readonly is_active?: boolean;
		/**
		 * Whether this session has been sampled for replay
		 */
		readonly sampled_for_replay?: boolean;
		[k: string]: unknown;
	};
	/**
	 * Feature flags properties
	 */
	readonly feature_flags?: {
		[k: string]: unknown;
	};
	/**
	 * Privacy properties
	 */
	readonly privacy?: {
		/**
		 * The replay privacy level
		 */
		readonly replay_level: "allow" | "mask" | "mask-user-input";
		[k: string]: unknown;
	};
	/**
	 * Internal properties
	 */
	readonly _dd: {
		/**
		 * Version of the update of the view event
		 */
		readonly document_version: number;
		/**
		 * List of the page states during the view
		 */
		readonly page_states?: {
			/**
			 * Page state name
			 */
			readonly state: "active" | "passive" | "hidden" | "frozen" | "terminated";
			/**
			 * Duration in ns between start of the view and start of the page state
			 */
			readonly start: number;
			[k: string]: unknown;
		}[];
		/**
		 * Debug metadata for Replay Sessions
		 */
		replay_stats?: {
			/**
			 * The number of records produced during this view lifetime
			 */
			records_count?: number;
			/**
			 * The number of segments sent during this view lifetime
			 */
			segments_count?: number;
			/**
			 * The total size in bytes of the segments sent during this view lifetime
			 */
			segments_total_raw_size?: number;
			[k: string]: unknown;
		};
		/**
		 * Additional information of the reported Cumulative Layout Shift
		 */
		readonly cls?: {
			/**
			 * Pixel ratio of the device where the layout shift was reported
			 */
			readonly device_pixel_ratio?: number;
			[k: string]: unknown;
		};
		/**
		 * Subset of the SDK configuration options in use during its execution
		 */
		readonly configuration?: {
			/**
			 * Whether session replay recording configured to start manually
			 */
			readonly start_session_replay_recording_manually?: boolean;
			[k: string]: unknown;
		};
		/**
		 * Profiling context
		 */
		profiling?: ProfilingInternalContextSchema;
		[k: string]: unknown;
	};
	/**
	 * Display properties
	 */
	readonly display?: {
		/**
		 * Scroll properties
		 */
		readonly scroll?: {
			/**
			 * Distance between the top and the lowest point reached on this view (in pixels)
			 */
			readonly max_depth: number;
			/**
			 * Page scroll top (scrolled distance) when the maximum scroll depth was reached for this view (in pixels)
			 */
			readonly max_depth_scroll_top: number;
			/**
			 * Maximum page scroll height (total height) for this view (in pixels)
			 */
			readonly max_scroll_height: number;
			/**
			 * Duration between the view start and the time the max scroll height was reached for this view (in nanoseconds)
			 */
			readonly max_scroll_height_time: number;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumVitalEvent = RumVitalDurationEvent | RumVitalOperationStepEvent;
type RumVitalDurationEvent = RumVitalEventCommonProperties & {
	/**
	 * Vital properties
	 */
	readonly vital?: {
		/**
		 * Type of the vital.
		 */
		readonly type: "duration";
		/**
		 * Duration of the vital in nanoseconds.
		 */
		readonly duration: number;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumVitalEventCommonProperties = CommonProperties & ViewContainerSchema & {
	/**
	 * RUM event type
	 */
	readonly type: "vital";
	/**
	 * Vital properties
	 */
	readonly vital: {
		/**
		 * UUID of the vital
		 */
		readonly id: string;
		/**
		 * Name of the vital, as it is also used as facet path for its value, it must contain only letters, digits, or the characters - _ . @ $
		 */
		readonly name?: string;
		/**
		 * Description of the vital. It can be used as a secondary identifier (URL, React component name...)
		 */
		readonly description?: string;
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
type RumVitalOperationStepEvent = RumVitalEventCommonProperties & {
	/**
	 * Vital properties
	 */
	readonly vital?: {
		/**
		 * Type of the vital.
		 */
		readonly type: "operation_step";
		/**
		 * Optional key to distinguish between multiple operations of the same name running in parallel (e.g., 'photo_upload' with keys 'profile_pic' vs 'cover')
		 */
		readonly operation_key?: string;
		/**
		 * Type of the step that triggered the vital, if applicable
		 */
		readonly step_type: "start" | "update" | "retry" | "end";
		/**
		 * Reason for the failure of the step, if applicable
		 */
		readonly failure_reason?: "error" | "abandoned" | "other";
		[k: string]: unknown;
	};
	[k: string]: unknown;
};
interface CommonProperties {
	/**
	 * Start of the event in ms from epoch
	 */
	readonly date: number;
	/**
	 * Application properties
	 */
	readonly application: {
		/**
		 * UUID of the application
		 */
		readonly id: string;
		/**
		 * The user's current locale as a language tag (language + region), computed from their preferences and the app's supported languages, e.g. 'es-FR'.
		 */
		readonly current_locale?: string;
		[k: string]: unknown;
	};
	/**
	 * The service name for this application
	 */
	service?: string;
	/**
	 * The version for this application
	 */
	version?: string;
	/**
	 * The build version for this application
	 */
	readonly build_version?: string;
	/**
	 * Generated unique ID of the application build. Unlike version or build_version this field is not meant to be coming from the user, but rather generated by the tooling for each build.
	 */
	readonly build_id?: string;
	/**
	 * Tags of the event in key:value format, separated by commas (e.g. 'env:prod,version:1.2.3')
	 */
	readonly ddtags?: string;
	/**
	 * Session properties
	 */
	readonly session: {
		/**
		 * UUID of the session
		 */
		readonly id: string;
		/**
		 * Type of the session
		 */
		readonly type: "user" | "synthetics" | "ci_test";
		/**
		 * Whether this session has a replay
		 */
		readonly has_replay?: boolean;
		[k: string]: unknown;
	};
	/**
	 * The source of this event
	 */
	readonly source?: "android" | "ios" | "browser" | "flutter" | "react-native" | "roku" | "unity" | "kotlin-multiplatform";
	/**
	 * View properties
	 */
	readonly view: {
		/**
		 * UUID of the view
		 */
		readonly id: string;
		/**
		 * URL that linked to the initial view of the page
		 */
		referrer?: string;
		/**
		 * URL of the view
		 */
		url: string;
		/**
		 * User defined name of the view
		 */
		name?: string;
		[k: string]: unknown;
	};
	/**
	 * User properties
	 */
	readonly usr?: {
		/**
		 * Identifier of the user
		 */
		readonly id?: string;
		/**
		 * Name of the user
		 */
		readonly name?: string;
		/**
		 * Email of the user
		 */
		readonly email?: string;
		/**
		 * Identifier of the user across sessions
		 */
		readonly anonymous_id?: string;
		[k: string]: unknown;
	};
	/**
	 * Account properties
	 */
	readonly account?: {
		/**
		 * Identifier of the account
		 */
		readonly id: string;
		/**
		 * Name of the account
		 */
		readonly name?: string;
		[k: string]: unknown;
	};
	/**
	 * Device connectivity properties
	 */
	connectivity?: {
		/**
		 * Status of the device connectivity
		 */
		readonly status: "connected" | "not_connected" | "maybe";
		/**
		 * The list of available network interfaces
		 */
		readonly interfaces?: ("bluetooth" | "cellular" | "ethernet" | "wifi" | "wimax" | "mixed" | "other" | "unknown" | "none")[];
		/**
		 * Cellular connection type reflecting the measured network performance
		 */
		readonly effective_type?: "slow-2g" | "2g" | "3g" | "4g";
		/**
		 * Cellular connectivity properties
		 */
		readonly cellular?: {
			/**
			 * The type of a radio technology used for cellular connection
			 */
			readonly technology?: string;
			/**
			 * The name of the SIM carrier
			 */
			readonly carrier_name?: string;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	/**
	 * Display properties
	 */
	display?: {
		/**
		 * The viewport represents the rectangular area that is currently being viewed. Content outside the viewport is not visible onscreen until scrolled into view.
		 */
		readonly viewport?: {
			/**
			 * Width of the viewport (in pixels)
			 */
			readonly width: number;
			/**
			 * Height of the viewport (in pixels)
			 */
			readonly height: number;
			[k: string]: unknown;
		};
		[k: string]: unknown;
	};
	/**
	 * Synthetics properties
	 */
	readonly synthetics?: {
		/**
		 * The identifier of the current Synthetics test
		 */
		readonly test_id: string;
		/**
		 * The identifier of the current Synthetics test results
		 */
		readonly result_id: string;
		/**
		 * Whether the event comes from a SDK instance injected by Synthetics
		 */
		readonly injected?: boolean;
		[k: string]: unknown;
	};
	/**
	 * CI Visibility properties
	 */
	readonly ci_test?: {
		/**
		 * The identifier of the current CI Visibility test execution
		 */
		readonly test_execution_id: string;
		[k: string]: unknown;
	};
	/**
	 * Operating system properties
	 */
	os?: {
		/**
		 * Operating system name, e.g. Android, iOS
		 */
		readonly name: string;
		/**
		 * Full operating system version, e.g. 8.1.1
		 */
		readonly version: string;
		/**
		 * Operating system build number, e.g. 15D21
		 */
		readonly build?: string;
		/**
		 * Major operating system version, e.g. 8
		 */
		readonly version_major: string;
		[k: string]: unknown;
	};
	/**
	 * Device properties
	 */
	device?: {
		/**
		 * Device type info
		 */
		readonly type?: "mobile" | "desktop" | "tablet" | "tv" | "gaming_console" | "bot" | "other";
		/**
		 * Device marketing name, e.g. Xiaomi Redmi Note 8 Pro, Pixel 5, etc.
		 */
		readonly name?: string;
		/**
		 * Device SKU model, e.g. Samsung SM-988GN, etc. Quite often name and model can be the same.
		 */
		readonly model?: string;
		/**
		 * Device marketing brand, e.g. Apple, OPPO, Xiaomi, etc.
		 */
		readonly brand?: string;
		/**
		 * The CPU architecture of the device that is reporting the error
		 */
		readonly architecture?: string;
		/**
		 * The user’s locale as a language tag combining language and region, e.g. 'en-US'.
		 */
		readonly locale?: string;
		/**
		 * Ordered list of the user’s preferred system languages as IETF language tags.
		 */
		readonly locales?: string[];
		/**
		 * The device’s current time zone identifier, e.g. 'Europe/Berlin'.
		 */
		readonly time_zone?: string;
		/**
		 * Current battery level of the device (0.0 to 1.0).
		 */
		readonly battery_level?: number;
		/**
		 * Whether the device is in power saving mode.
		 */
		readonly power_saving_mode?: boolean;
		/**
		 * Current screen brightness level (0.0 to 1.0).
		 */
		readonly brightness_level?: number;
		/**
		 * Number of logical CPU cores available for scheduling on the device at runtime, as reported by the operating system.
		 */
		readonly logical_cpu_count?: number;
		/**
		 * Total RAM in megabytes
		 */
		readonly total_ram?: number;
		/**
		 * Whether the device is considered a low RAM device (Android)
		 */
		readonly is_low_ram?: boolean;
		[k: string]: unknown;
	};
	/**
	 * Internal properties
	 */
	readonly _dd: {
		/**
		 * Version of the RUM event format
		 */
		readonly format_version: 2;
		/**
		 * Session-related internal properties
		 */
		session?: {
			/**
			 * Session plan: 1 is the plan without replay, 2 is the plan with replay (deprecated)
			 */
			plan?: 1 | 2;
			/**
			 * The precondition that led to the creation of the session
			 */
			readonly session_precondition?: "user_app_launch" | "inactivity_timeout" | "max_duration" | "background_launch" | "prewarm" | "from_non_interactive_session" | "explicit_stop";
			[k: string]: unknown;
		};
		/**
		 * Subset of the SDK configuration options in use during its execution
		 */
		readonly configuration?: {
			/**
			 * The percentage of sessions tracked
			 */
			readonly session_sample_rate: number;
			/**
			 * The percentage of sessions with RUM & Session Replay pricing tracked
			 */
			readonly session_replay_sample_rate?: number;
			/**
			 * The percentage of sessions profiled
			 */
			readonly profiling_sample_rate?: number;
			/**
			 * The percentage of sessions with traced resources
			 */
			readonly trace_sample_rate?: number;
			[k: string]: unknown;
		};
		/**
		 * Browser SDK version
		 */
		readonly browser_sdk_version?: string;
		/**
		 * SDK name (e.g. 'logs', 'rum', 'rum-slim', etc.)
		 */
		readonly sdk_name?: string;
		[k: string]: unknown;
	};
	/**
	 * User provided context
	 */
	context?: {
		[k: string]: unknown;
	};
	/**
	 * Stream properties
	 */
	stream?: {
		/**
		 * UUID of the stream
		 */
		readonly id: string;
		[k: string]: unknown;
	};
	[k: string]: unknown;
}
interface ViewContainerSchema {
	/**
	 * View Container properties (view wrapping the current view)
	 */
	readonly container?: {
		/**
		 * Attributes of the view's container
		 */
		readonly view: {
			/**
			 * ID of the parent view
			 */
			readonly id: string;
			[k: string]: unknown;
		};
		/**
		 * Source of the parent view
		 */
		readonly source: "android" | "ios" | "browser" | "flutter" | "react-native" | "roku" | "unity" | "kotlin-multiplatform";
		[k: string]: unknown;
	};
	[k: string]: unknown;
}
interface ActionChildProperties {
	/**
	 * Action properties
	 */
	readonly action?: {
		/**
		 * UUID of the action
		 */
		readonly id: string | string[];
		[k: string]: unknown;
	};
	[k: string]: unknown;
}
interface ProfilingInternalContextSchema {
	/**
	 * Used to track the status of the RUM Profiler.
	 *
	 * They are defined in order of when they can happen, from the moment the SDK is initialized to the moment the Profiler is actually running.
	 *
	 * - `starting`: The Profiler is starting (i.e., when the SDK just started). This is the initial status.
	 * - `running`: The Profiler is running.
	 * - `stopped`: The Profiler is stopped.
	 * - `error`: The Profiler encountered an error. See `error_reason` for more details.
	 */
	readonly status?: "starting" | "running" | "stopped" | "error";
	/**
	 * The reason the Profiler encountered an error. This attribute is only present if the status is `error`.
	 *
	 * Possible values:
	 * - `not-supported-by-browser`: The browser does not support the Profiler (i.e., `window.Profiler` is not available).
	 * - `failed-to-lazy-load`: The Profiler script failed to be loaded by the browser (may be a connection issue or the chunk was not found).
	 * - `missing-document-policy-header`: The Profiler failed to start because its missing `Document-Policy: js-profiling` HTTP response header.
	 * - `unexpected-exception`: An exception occurred when starting the Profiler.
	 */
	readonly error_reason?: "not-supported-by-browser" | "failed-to-lazy-load" | "missing-document-policy-header" | "unexpected-exception";
	[k: string]: unknown;
}
interface StreamSchema {
	/**
	 * Stream properties
	 */
	readonly stream?: {
		/**
		 * current bitrate at the time of collection
		 */
		bitrate?: number;
		/**
		 * How long is the content (VOD only) (in ms)
		 */
		readonly duration?: number;
		/**
		 * Stream format
		 */
		readonly format?: string;
		/**
		 * current frames per second at the time of collection
		 */
		fps?: number;
		/**
		 * Stream resolution
		 */
		readonly resolution?: string;
		/**
		 * current timestamp at the time of collection
		 */
		timestamp?: number;
		/**
		 * how much did the media progress since the last context update (in ms)
		 */
		watch_time?: number;
		/**
		 * Percentage of amount of time watched relative to its total duration
		 */
		completion_percent?: number;
		[k: string]: unknown;
	};
	[k: string]: unknown;
}
interface RumPerfMetric {
	/**
	 * The minimum value seen for this metric during the view's lifetime.
	 */
	readonly min: number;
	/**
	 * The maximum value seen for this metric during the view's lifetime.
	 */
	readonly max: number;
	/**
	 * The average value for this metric during the view's lifetime.
	 */
	readonly average: number;
	/**
	 * The maximum possible value we could see for this metric, if such a max is relevant and can vary from session to session.
	 */
	readonly metric_max?: number;
	[k: string]: unknown;
}
interface ViewPerformanceData {
	/**
	 * Cumulative Layout Shift
	 */
	readonly cls?: {
		/**
		 * Total layout shift score that occurred on the view
		 */
		readonly score: number;
		/**
		 * The time of the largest layout shift contributing to CLS, in ns since view start.
		 */
		readonly timestamp?: number;
		/**
		 * CSS selector path of the first element (in document order) of the largest layout shift contributing to CLS
		 */
		readonly target_selector?: string;
		/**
		 * Bounding client rect of the element before the layout shift
		 */
		previous_rect?: RumRect;
		/**
		 * Bounding client rect of the element after the layout shift
		 */
		current_rect?: RumRect;
		[k: string]: unknown;
	};
	/**
	 * First Contentful Paint
	 */
	readonly fcp?: {
		/**
		 * The time of the first rendering, in ns since view start.
		 */
		readonly timestamp: number;
		[k: string]: unknown;
	};
	/**
	 * First Input Delay
	 */
	readonly fid?: {
		/**
		 * Duration in ns of the first input event delay
		 */
		readonly duration: number;
		/**
		 * Time of the first input event, in ns since view start.
		 */
		readonly timestamp: number;
		/**
		 * CSS selector path of the first input target element
		 */
		readonly target_selector?: string;
		[k: string]: unknown;
	};
	/**
	 * Interaction to Next Paint
	 */
	readonly inp?: {
		/**
		 * Longest duration in ns between an interaction and the next paint
		 */
		readonly duration: number;
		/**
		 * Time of the start of the INP interaction, in ns since view start.
		 */
		readonly timestamp?: number;
		/**
		 * CSS selector path of the interacted element for the INP interaction
		 */
		readonly target_selector?: string;
		[k: string]: unknown;
	};
	/**
	 * Largest Contentful Paint
	 */
	readonly lcp?: {
		/**
		 * Time of the largest contentful paint, in ns since view start.
		 */
		readonly timestamp: number;
		/**
		 * CSS selector path of the largest contentful paint element
		 */
		readonly target_selector?: string;
		/**
		 * URL of the largest contentful paint element
		 */
		resource_url?: string;
		[k: string]: unknown;
	};
	/**
	 * First Build Complete (Flutter)
	 */
	readonly fbc?: {
		/**
		 * Time of all completed `build` methods after a route change, in ns since view start.
		 */
		readonly timestamp: number;
		[k: string]: unknown;
	};
	[k: string]: unknown;
}
interface RumRect {
	/**
	 * The x coordinate of the element's origin
	 */
	readonly x: number;
	/**
	 * The y coordinate of the element's origin
	 */
	readonly y: number;
	/**
	 * The element's width
	 */
	readonly width: number;
	/**
	 * The element's height
	 */
	readonly height: number;
	[k: string]: unknown;
}
interface ViewAccessibilityProperties {
	/**
	 * User’s preferred text scale relative to the default system size.
	 */
	readonly text_size?: string;
	/**
	 * Indicates whether a screen reader is currently active.
	 */
	readonly screen_reader_enabled?: boolean;
	/**
	 * Indicates whether the system-wide bold text accessibility setting is enabled.
	 */
	readonly bold_text_enabled?: boolean;
	/**
	 * Indicates whether the system-wide reduce transparency setting is enabled.
	 */
	readonly reduce_transparency_enabled?: boolean;
	/**
	 * Indicates whether the system-wide reduce motion setting is enabled.
	 */
	readonly reduce_motion_enabled?: boolean;
	/**
	 * Indicates whether the system-wide button shapes setting is enabled.
	 */
	readonly button_shapes_enabled?: boolean;
	/**
	 * Indicates whether the system-wide color inversion setting is enabled.
	 */
	readonly invert_colors_enabled?: boolean;
	/**
	 * Indicates whether the system-wide increase contrast setting is enabled.
	 */
	readonly increase_contrast_enabled?: boolean;
	/**
	 * Indicates whether an alternative input method like Switch Control or Switch Access is currently enabled.
	 */
	readonly assistive_switch_enabled?: boolean;
	/**
	 * Indicates whether the system-wide AssistiveTouch feature is currently enabled.
	 */
	readonly assistive_touch_enabled?: boolean;
	/**
	 * Indicates whether the video autoplay setting is enabled in the system or application.
	 */
	readonly video_autoplay_enabled?: boolean;
	/**
	 * Indicates whether closed captioning is enabled for media playback.
	 */
	readonly closed_captioning_enabled?: boolean;
	/**
	 * Indicates whether the system-wide mono audio setting is enabled.
	 */
	readonly mono_audio_enabled?: boolean;
	/**
	 * Indicates whether the Shake to Undo feature is enabled.
	 */
	readonly shake_to_undo_enabled?: boolean;
	/**
	 * Indicates whether the user prefers reduced animations or cross-fade transitions.
	 */
	readonly reduced_animations_enabled?: boolean;
	/**
	 * Indicates whether the system should differentiate interface elements without relying solely on color.
	 */
	readonly should_differentiate_without_color?: boolean;
	/**
	 * Indicates whether the device display is currently using grayscale mode.
	 */
	readonly grayscale_enabled?: boolean;
	/**
	 * Indicates whether the device is currently locked to a single app through Guided Access or Screen Pinning.
	 */
	readonly single_app_mode_enabled?: boolean;
	/**
	 * Indicates whether on/off switch labels are enabled in the system settings.
	 */
	readonly on_off_switch_labels_enabled?: boolean;
	/**
	 * Indicates whether the Speak Screen feature is enabled.
	 */
	readonly speak_screen_enabled?: boolean;
	/**
	 * Indicates whether the text-to-speech selection feature is enabled.
	 */
	readonly speak_selection_enabled?: boolean;
	/**
	 * Indicates whether the right-to-left support is enabled.
	 */
	readonly rtl_enabled?: boolean;
	[k: string]: unknown;
}
interface RumSessionManager {
	findTrackedSession: (startTime?: RelativeTime) => RumSession | undefined;
	expire: () => void;
	expireObservable: Observable<void>;
	setForcedReplay: () => void;
}
interface RumSession {
	id: string;
	sessionReplay: SessionReplayState;
	anonymousId?: string;
}
declare const enum SessionReplayState {
	OFF = 0,
	SAMPLED = 1,
	FORCED = 2
}
interface EventCounts$1 {
	errorCount: number;
	actionCount: number;
	longTaskCount: number;
	resourceCount: number;
	frustrationCount: number;
}
interface FirstInput {
	delay: Duration;
	time: RelativeTime;
	targetSelector?: string;
}
declare enum RumPerformanceEntryType {
	EVENT = "event",
	FIRST_INPUT = "first-input",
	LARGEST_CONTENTFUL_PAINT = "largest-contentful-paint",
	LAYOUT_SHIFT = "layout-shift",
	LONG_TASK = "longtask",
	LONG_ANIMATION_FRAME = "long-animation-frame",
	NAVIGATION = "navigation",
	PAINT = "paint",
	RESOURCE = "resource",
	VISIBILITY_STATE = "visibility-state"
}
interface NavigationTimings {
	domComplete: Duration;
	domContentLoaded: Duration;
	domInteractive: Duration;
	loadEvent: Duration;
	firstByte: Duration | undefined;
}
interface LargestContentfulPaint {
	value: RelativeTime;
	targetSelector?: string;
	resourceUrl?: string;
}
interface InitialViewMetrics {
	firstContentfulPaint?: Duration;
	navigationTimings?: NavigationTimings;
	largestContentfulPaint?: LargestContentfulPaint;
	firstInput?: FirstInput;
}
interface CumulativeLayoutShift {
	value: number;
	targetSelector?: string;
	time?: Duration;
	previousRect?: RumRect;
	currentRect?: RumRect;
	devicePixelRatio?: number;
}
interface InteractionToNextPaint {
	value: Duration;
	targetSelector?: string;
	time?: Duration;
}
interface ScrollMetrics {
	maxDepth: number;
	maxScrollHeight: number;
	maxDepthScrollTop: number;
	maxScrollHeightTime: Duration;
}
interface CommonViewMetrics {
	loadingTime?: Duration;
	cumulativeLayoutShift?: CumulativeLayoutShift;
	interactionToNextPaint?: InteractionToNextPaint;
	scroll?: ScrollMetrics;
}
interface ViewEvent {
	id: string;
	name?: string;
	service?: string;
	version?: string;
	context?: Context;
	location: Readonly<Location>;
	commonViewMetrics: CommonViewMetrics;
	initialViewMetrics: InitialViewMetrics;
	customTimings: ViewCustomTimings;
	eventCounts: EventCounts$1;
	documentVersion: number;
	startClocks: ClocksState;
	duration: Duration;
	isActive: boolean;
	sessionIsActive: boolean;
	loadingType: ViewLoadingType;
}
interface ViewCreatedEvent {
	id: string;
	name?: string;
	service?: string;
	version?: string;
	context?: Context;
	startClocks: ClocksState;
}
interface BeforeViewUpdateEvent {
	id: string;
	name?: string;
	context?: Context;
	startClocks: ClocksState;
	sessionIsActive: boolean;
}
interface ViewEndedEvent {
	endClocks: ClocksState;
}
interface ViewOptions {
	name?: string;
	service?: RumInitConfiguration["service"];
	version?: RumInitConfiguration["version"];
	context?: Context;
}
type DefaultRumEventAttributes = RecursivePartial<RumEvent> & {
	type: RumEvent["type"];
};
type DefaultTelemetryEventAttributes = RecursivePartial<TelemetryEvent>;
type DeepReadonly<T> = {
	readonly [K in keyof T]: DeepReadonly<T[K]>;
};
interface AssembleHookParams {
	readonly eventType: RumEvent["type"];
	rawRumEvent: DeepReadonly<RawRumEvent>;
	domainContext: DeepReadonly<RumEventDomainContext<RawRumEvent["type"]>>;
	readonly startTime: RelativeTime;
	readonly duration?: Duration | undefined;
}
interface HookCallbackMap {
	[HookNamesAsConst.ASSEMBLE]: (param: AssembleHookParams) => DefaultRumEventAttributes | SKIPPED | DISCARDED;
	[HookNamesAsConst.ASSEMBLE_TELEMETRY]: (param: {
		startTime: RelativeTime;
	}) => DefaultTelemetryEventAttributes | SKIPPED | DISCARDED;
}
type Hooks = ReturnType<typeof createHooks>;
declare const createHooks: () => {
	register<K extends HookNames>(hookName: K, callback: HookCallbackMap[K]): {
		unregister: () => void;
	};
	triggerHook<K extends HookNames>(hookName: K, param: Parameters<HookCallbackMap[K]>[0]): "DISCARDED" | Exclude<ReturnType<HookCallbackMap[K]>, "SKIPPED"> | undefined;
};
declare const enum PageState {
	ACTIVE = "active",
	PASSIVE = "passive",
	HIDDEN = "hidden",
	FROZEN = "frozen",
	TERMINATED = "terminated"
}
interface VitalOptions {
	/**
	 * Vital context
	 */
	context?: any;
	/**
	 * Vital description
	 */
	description?: string;
}
interface DurationVitalOptions extends VitalOptions {
}
interface FeatureOperationOptions extends VitalOptions {
	operationKey?: string;
}
type FailureReason = "error" | "abandoned" | "other";
interface AddDurationVitalOptions extends DurationVitalOptions {
	/**
	 * Vital start time, expects a UNIX timestamp in milliseconds (the number of milliseconds since January 1, 1970)
	 */
	startTime: number;
	/**
	 * Vital duration, expects a duration in milliseconds
	 */
	duration: number;
}
interface DurationVitalReference {
	__dd_vital_reference: true;
}
interface DurationVitalStart extends DurationVitalOptions {
	name: string;
	startClocks: ClocksState;
}
interface BaseVital extends VitalOptions {
	name: string;
	startClocks: ClocksState;
}
interface DurationVital extends BaseVital {
	type: typeof VitalType.DURATION;
	duration: Duration;
}
interface CustomVitalsState {
	vitalsByName: Map<string, DurationVitalStart>;
	vitalsByReference: WeakMap<DurationVitalReference, DurationVitalStart>;
}
type SdkName = "rum" | "rum-slim" | "rum-synthetics";
type ActionCounts = EventCounts$1;
interface ActionOptions {
	/**
	 * Action Type
	 *
	 * @default 'custom'
	 */
	type?: ActionType;
	/**
	 * Action context
	 */
	context?: any;
	/**
	 * Action key
	 */
	actionKey?: string;
}
interface ManualAction {
	id: string;
	type: ActionType;
	name: string;
	startClocks: ClocksState;
	duration?: Duration;
	context?: Context;
	handlingStack?: string;
	counts?: ActionCounts;
	frustrationTypes: FrustrationType[];
}
type AllowedRawRumEvent = (RawRumErrorEvent | RawRumResourceEvent | RawRumLongTaskEvent | RawRumLongAnimationFrameEvent | RawRumActionEvent | RawRumVitalEvent) & {
	context?: Context;
};
interface ProvidedError {
	startClocks: ClocksState;
	error: unknown;
	context?: Context;
	handlingStack: string;
	componentStack?: string;
}
interface ViewHistoryEntry {
	service?: string;
	version?: string;
	context?: Context | undefined;
	id: string;
	name?: string;
	startClocks: ClocksState;
	sessionIsActive?: boolean;
}
interface ViewHistory {
	findView: (startTime?: RelativeTime) => ViewHistoryEntry | undefined;
	stop: () => void;
}
interface LongTaskContext {
	id: string;
	startClocks: ClocksState;
	duration: Duration;
	entryType: RumPerformanceEntryType.LONG_ANIMATION_FRAME | RumPerformanceEntryType.LONG_TASK;
}
interface LongTaskContexts {
	findLongTasks: (startTime: RelativeTime, duration: Duration) => LongTaskContext[];
}
type StartRum = typeof startRum;
type StartRumResult = ReturnType<StartRum>;
declare function startRum(configuration: RumConfiguration, recorderApi: RecorderApi, profilerApi: ProfilerApi, initialViewOptions: ViewOptions | undefined, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder, trackingConsentState: TrackingConsentState, customVitalsState: CustomVitalsState, bufferedDataObservable: BufferedObservable<BufferedData>, sdkName?: SdkName): {
	lifeCycle: AbstractLifeCycle<LifeCycleEventMap>;
	session: RumSessionManager;
	stopSession: () => void;
	telemetry: Telemetry;
	stop: () => void;
	hooks: {
		register<K extends HookNames>(hookName: K, callback: HookCallbackMap[K]): {
			unregister: () => void;
		};
		triggerHook<K extends HookNames>(hookName: K, param: Parameters<HookCallbackMap[K]>[0]): "DISCARDED" | Exclude<ReturnType<HookCallbackMap[K]>, "SKIPPED"> | undefined;
	};
	addAction: (action: Omit<ManualAction, "id" | "duration" | "counts" | "frustrationTypes">) => void;
	startAction: (name: string, options?: ActionOptions, startClocks?: {
		relative: RelativeTime;
		timeStamp: TimeStamp;
	}) => void;
	stopAction: (name: string, options?: ActionOptions, stopClocks?: {
		relative: RelativeTime;
		timeStamp: TimeStamp;
	}) => void;
	addEvent: (startTime: RelativeTime, event: AllowedRawRumEvent, domainContext: RumEventDomainContext, duration?: Duration) => void;
	addError: ({ error, handlingStack, componentStack, startClocks, context }: ProvidedError) => void;
	addTiming: (name: string, time?: RelativeTime | TimeStamp) => void;
	addFeatureFlagEvaluation: (key: string, value: ContextValue) => void;
	startView: (options?: ViewOptions, startClocks?: ClocksState) => void;
	setViewContext: (context: Context) => void;
	setViewContextProperty: (key: string, value: ContextValue) => void;
	getViewContext: () => Context;
	setViewName: (name: string) => void;
	viewHistory: ViewHistory;
	getInternalContext: (startTime?: number) => RumInternalContext | undefined;
	startDurationVital: (name: string, options?: DurationVitalOptions) => DurationVitalReference;
	stopDurationVital: (nameOrRef: string | DurationVitalReference, options?: DurationVitalOptions) => void;
	addDurationVital: (vital: DurationVital) => void;
	addOperationStepVital: (name: string, stepType: "start" | "end", options?: FeatureOperationOptions, failureReason?: FailureReason) => void;
	globalContext: {
		getContext: () => Context;
		setContext: (newContext: unknown) => void;
		setContextProperty: (key: string, property: any) => void;
		removeContextProperty: (key: string) => void;
		clearContext: () => void;
		changeObservable: Observable<void>;
	};
	userContext: {
		getContext: () => Context;
		setContext: (newContext: unknown) => void;
		setContextProperty: (key: string, property: any) => void;
		removeContextProperty: (key: string) => void;
		clearContext: () => void;
		changeObservable: Observable<void>;
	};
	accountContext: {
		getContext: () => Context;
		setContext: (newContext: unknown) => void;
		setContextProperty: (key: string, property: any) => void;
		removeContextProperty: (key: string) => void;
		clearContext: () => void;
		changeObservable: Observable<void>;
	};
	longTaskContexts: LongTaskContexts;
};
interface OnRumStartOptions {
	/**
	 * @deprecated Use `addEvent` instead.
	 */
	strategy?: Strategy;
	/**
	 * Add an event to the RUM browser SDK.
	 */
	addEvent?: StartRumResult["addEvent"];
}
interface RumPlugin {
	name: string;
	getConfigurationTelemetry?(): Record<string, unknown>;
	onInit?(options: {
		initConfiguration: RumInitConfiguration;
		publicApi: RumPublicApi;
	}): void;
	onRumStart?(options: OnRumStartOptions): void;
}
type PropagatorType = "datadog" | "b3" | "b3multi" | "tracecontext";
interface TracingOption {
	match: MatchOption;
	propagatorTypes: PropagatorType[];
}
interface RumInitConfiguration extends InitConfiguration {
	/**
	 * The RUM application ID.
	 *
	 * @category Authentication
	 */
	applicationId: string;
	/**
	 * Whether to propagate user and account IDs in the baggage header of trace requests.
	 *
	 * @category Tracing
	 * @defaultValue false
	 */
	propagateTraceBaggage?: boolean | undefined;
	/**
	 * Access to every event collected by the RUM SDK before they are sent to Datadog.
	 * It allows:
	 * - Enrich your RUM events with additional context attributes
	 * - Modify your RUM events to modify their content, or redact sensitive sequences (see the list of editable properties)
	 * - Discard selected RUM events
	 *
	 * See [Enrich And Control Browser RUM Data With beforeSend](https://docs.datadoghq.com/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 Datadog, false otherwise
	 */
	beforeSend?: ((event: RumEvent, context: RumEventDomainContext) => boolean) | undefined;
	/**
	 * A list of request origins ignored when computing the page activity.
	 * See [How page activity is calculated](https://docs.datadoghq.com/real_user_monitoring/browser/monitoring_page_performance/#how-page-activity-is-calculated) for further information.
	 */
	excludedActivityUrls?: MatchOption[] | undefined;
	/**
	 * URL pointing to the Datadog 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.datadoghq.com/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 Datadog 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.datadoghq.com/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
	 */
	remoteConfigurationId?: string | undefined;
	/**
	 * [Internal option] set a proxy URL for the remote configuration
	 *
	 * @internal
	 */
	remoteConfigurationProxy?: string | undefined;
	/**
	 * A list of request URLs used to inject tracing headers.
	 * See [Connect RUM and Traces](https://docs.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
	 *
	 * @category Tracing
	 */
	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.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
	 *
	 * @category Tracing
	 */
	traceSampleRate?: number | undefined;
	/**
	 * If you set a `traceSampleRate`, to ensure backend services' sampling decisions are still applied, configure the `traceContextInjection` initialization parameter to sampled.
	 *
	 * See [Connect RUM and Traces](https://docs.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
	 *
	 * @category Tracing
	 * @defaultValue sampled
	 */
	traceContextInjection?: TraceContextInjection | undefined;
	/**
	 * Allow to protect end user privacy and prevent sensitive organizational information from being collected.
	 *
	 * See [Replay Privacy Options](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser/privacy_options) for further information.
	 *
	 * @category Privacy
	 * @defaultValue mask
	 */
	defaultPrivacyLevel?: DefaultPrivacyLevel | undefined;
	/**
	 * If you are accessing Datadog 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.datadoghq.com/real_user_monitoring/guide/connect-session-replay-to-your-third-party-tools) for further information.
	 *
	 */
	subdomain?: string;
	/**
	 * The percentage of tracked sessions with [Browser RUM & Session Replay pricing](https://www.datadoghq.com/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.datadoghq.com/real_user_monitoring/guide/sampling-browser-plans) for further information.
	 *
	 * @category Session Replay
	 */
	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.
	 *
	 * See [Session Replay Usage](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser/#usage) for further information.
	 *
	 * @category Session Replay
	 */
	startSessionReplayRecordingManually?: boolean | undefined;
	/**
	 * Enables privacy control for action names.
	 *
	 * @category Privacy
	 */
	enablePrivacyForActionName?: boolean | undefined;
	/**
	 * Enables automatic collection of users actions.
	 *
	 * See [Tracking User Actions](https://docs.datadoghq.com/real_user_monitoring/browser/tracking_user_actions) for further information.
	 *
	 * @category Data Collection
	 * @defaultValue true
	 */
	trackUserInteractions?: boolean | undefined;
	/**
	 * Specify your own attribute to use to name actions.
	 *
	 * See [Declare a name for click actions](https://docs.datadoghq.com/real_user_monitoring/browser/tracking_user_actions/#declare-a-name-for-click-actions) for further information.
	 *
	 * @category Data Collection
	 */
	actionNameAttribute?: string | undefined;
	/**
	 * Enables accurate action names for clicks inside Shadow DOM elements.
	 * ⚠️ This is a beta feature and will be updated in the future with selector tracking.
	 *
	 * @category Beta
	 * @defaultValue false
	 */
	betaTrackActionsInShadowDom?: boolean | undefined;
	/**
	 * Allows you to control RUM views creation. See [Override default RUM view names](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/?tab=npm#override-default-rum-view-names) for further information.
	 *
	 * @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.
	 *
	 * @category Data Collection
	 * @defaultValue true
	 */
	trackResources?: boolean | undefined;
	/**
	 * Enables collection of long task events.
	 *
	 * @category Data Collection
	 * @defaultValue true
	 */
	trackLongTasks?: boolean | undefined;
	/**
	 * Enables early request collection before resource timing entries are available.
	 *
	 * @category Data Collection
	 * @defaultValue false
	 */
	trackEarlyRequests?: 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 Datadog matching the version of the SDK you are
	 * using.
	 */
	plugins?: RumPlugin[] | undefined;
	/**
	 * Enables collection of features flags in additional events (e.g. long task, resource, action, vital).
	 *
	 * @category Data Collection
	 */
	trackFeatureFlagsForEvents?: FeatureFlagsForEvents[];
	/**
	 * The percentage of users profiled. A value between 0 and 100.
	 *
	 * @category Profiling
	 * @defaultValue 0
	 */
	profilingSampleRate?: number | undefined;
	/**
	 * A list of GraphQL endpoint URLs to track and enrich with GraphQL-specific metadata.
	 *
	 * @category Data Collection
	 */
	allowedGraphQlUrls?: Array<MatchOption | GraphQlUrlOption> | undefined;
}
type FeatureFlagsForEvents = "vital" | "action" | "long_task" | "resource";
interface GraphQlUrlOption {
	match: MatchOption;
	trackPayload?: boolean;
	trackResponseErrors?: boolean;
}
interface RumConfiguration extends Configuration {
	actionNameAttribute: string | undefined;
	betaTrackActionsInShadowDom: boolean;
	traceSampleRate: number;
	rulePsr: number | undefined;
	allowedTracingUrls: TracingOption[];
	excludedActivityUrls: MatchOption[];
	workerUrl: string | undefined;
	compressIntakeRequests: boolean;
	applicationId: string;
	defaultPrivacyLevel: DefaultPrivacyLevel;
	enablePrivacyForActionName: boolean;
	sessionReplaySampleRate: number;
	startSessionReplayRecordingManually: boolean;
	trackUserInteractions: boolean;
	trackViewsManually: boolean;
	trackResources: boolean;
	trackLongTasks: boolean;
	trackBfcacheViews: boolean;
	trackEarlyRequests: boolean;
	subdomain?: string;
	traceContextInjection: TraceContextInjection;
	plugins: RumPlugin[];
	trackFeatureFlagsForEvents: FeatureFlagsForEvents[];
	profilingSampleRate: number;
	propagateTraceBaggage: boolean;
	allowedGraphQlUrls: GraphQlUrlOption[];
}
interface BaseIdentifier {
	toString(radix?: number): string;
}
interface TraceIdentifier extends BaseIdentifier {
	__brand: "traceIdentifier";
}
interface SpanIdentifier extends BaseIdentifier {
	__brand: "spanIdentifier";
}
interface RequestStartEvent {
	requestIndex: number;
	url: string;
}
interface RequestCompleteEvent {
	requestIndex: number;
	type: RequestType;
	method: string;
	url: string;
	status: number;
	responseType?: string;
	startClocks: ClocksState;
	duration: Duration;
	spanId?: SpanIdentifier;
	traceId?: TraceIdentifier;
	traceSampled?: boolean;
	xhr?: XMLHttpRequest;
	response?: Response;
	input?: unknown;
	init?: RequestInit;
	error?: Error;
	isAborted: boolean;
	handlingStack?: string;
	requestBody?: unknown;
	responseBody?: string;
}
interface GraphQlError {
	message: string;
	code?: string;
	locations?: Array<{
		line: number;
		column: number;
	}>;
	path?: Array<string | number>;
}
interface GraphQlMetadata {
	operationType?: "query" | "mutation" | "subscription";
	operationName?: string;
	variables?: string;
	payload?: string;
	error_count?: number;
	errors?: GraphQlError[];
}
declare const RumEventType: {
	readonly ACTION: "action";
	readonly ERROR: "error";
	readonly LONG_TASK: "long_task";
	readonly VIEW: "view";
	readonly RESOURCE: "resource";
	readonly VITAL: "vital";
};
type RumEventType = (typeof RumEventType)[keyof typeof RumEventType];
type AssembledRumEvent = (RumViewEvent | RumActionEvent | RumResourceEvent | RumErrorEvent | RumVitalEvent | RumLongTaskEvent) & Context;
declare const RumLongTaskEntryType: {
	readonly LONG_TASK: "long-task";
	readonly LONG_ANIMATION_FRAME: "long-animation-frame";
};
type RumLongTaskEntryType = (typeof RumLongTaskEntryType)[keyof typeof RumLongTaskEntryType];
interface RawRumResourceEvent {
	date: TimeStamp;
	type: typeof RumEventType.RESOURCE;
	resource: {
		type: ResourceType;
		id: string;
		duration?: ServerDuration;
		url: string;
		method?: string;
		status_code?: number;
		size?: number;
		encoded_body_size?: number;
		decoded_body_size?: number;
		transfer_size?: number;
		render_blocking_status?: string;
		redirect?: ResourceEntryDetailsElement;
		dns?: ResourceEntryDetailsElement;
		connect?: ResourceEntryDetailsElement;
		ssl?: ResourceEntryDetailsElement;
		worker?: ResourceEntryDetailsElement;
		first_byte?: ResourceEntryDetailsElement;
		download?: ResourceEntryDetailsElement;
		protocol?: string;
		delivery_type?: DeliveryType;
		graphql?: GraphQlMetadata;
	};
	_dd: {
		trace_id?: string;
		span_id?: string;
		rule_psr?: number;
		discarded: boolean;
		page_states?: PageStateServerEntry[];
	};
}
interface ResourceEntryDetailsElement {
	duration: ServerDuration;
	start: ServerDuration;
}
interface RawRumErrorEvent {
	date: TimeStamp;
	type: typeof RumEventType.ERROR;
	error: {
		id: string;
		type?: string;
		stack?: string;
		handling_stack?: string;
		component_stack?: string;
		fingerprint?: string;
		source: ErrorSource;
		message: string;
		handling?: ErrorHandling;
		causes?: RawErrorCause[];
		source_type: "browser";
		csp?: Csp;
	};
	view?: {
		in_foreground: boolean;
	};
	context?: Context;
}
interface RawRumViewEvent {
	date: TimeStamp;
	type: typeof RumEventType.VIEW;
	view: {
		loading_type: ViewLoadingType;
		first_byte?: ServerDuration;
		first_contentful_paint?: ServerDuration;
		first_input_delay?: ServerDuration;
		first_input_time?: ServerDuration;
		first_input_target_selector?: string;
		interaction_to_next_paint?: ServerDuration;
		interaction_to_next_paint_time?: ServerDuration;
		interaction_to_next_paint_target_selector?: string;
		cumulative_layout_shift?: number;
		cumulative_layout_shift_time?: ServerDuration;
		cumulative_layout_shift_target_selector?: string;
		custom_timings?: {
			[key: string]: ServerDuration;
		};
		largest_contentful_paint?: ServerDuration;
		largest_contentful_paint_target_selector?: string;
		dom_interactive?: ServerDuration;
		dom_content_loaded?: ServerDuration;
		dom_complete?: ServerDuration;
		load_event?: ServerDuration;
		loading_time?: ServerDuration;
		time_spent: ServerDuration;
		is_active: boolean;
		name?: string;
		error: Count;
		action: Count;
		long_task: Count;
		resource: Count;
		frustration: Count;
		performance?: ViewPerformanceData$1;
	};
	display?: ViewDisplay;
	privacy?: {
		replay_level: DefaultPrivacyLevel;
	};
	_dd: {
		document_version: number;
		replay_stats?: ReplayStats;
		page_states?: PageStateServerEntry[];
		cls?: {
			device_pixel_ratio: number;
		};
		configuration: {
			start_session_replay_recording_manually: boolean;
		};
	};
	device?: {
		locale?: string;
		locales?: readonly string[];
		time_zone?: string;
	};
}
interface ViewDisplay {
	scroll: {
		max_depth?: number;
		max_depth_scroll_top?: number;
		max_scroll_height?: number;
		max_scroll_height_time?: ServerDuration;
	};
}
interface ViewPerformanceData$1 {
	cls?: {
		score: number;
		timestamp?: ServerDuration;
		target_selector?: string;
		previous_rect?: RumRect$1;
		current_rect?: RumRect$1;
	};
	fcp?: {
		timestamp: number;
	};
	fid?: {
		duration: ServerDuration;
		timestamp: ServerDuration;
		target_selector?: string;
	};
	inp?: {
		duration: ServerDuration;
		timestamp?: ServerDuration;
		target_selector?: string;
	};
	lcp?: {
		timestamp: ServerDuration;
		target_selector?: string;
		resource_url?: string;
	};
}
interface RumRect$1 {
	x: number;
	y: number;
	width: number;
	height: number;
}
interface PageStateServerEntry {
	state: PageState;
	start: ServerDuration;
	[k: string]: unknown;
}
declare const ViewLoadingType: {
	readonly INITIAL_LOAD: "initial_load";
	readonly ROUTE_CHANGE: "route_change";
	readonly BF_CACHE: "bf_cache";
};
type ViewLoadingType = (typeof ViewLoadingType)[keyof typeof ViewLoadingType];
interface ViewCustomTimings {
	[key: string]: Duration;
}
interface ReplayStats {
	records_count: number;
	segments_count: number;
	segments_total_raw_size: number;
}
interface Count {
	count: number;
}
interface RawRumLongTaskEvent {
	date: TimeStamp;
	type: typeof RumEventType.LONG_TASK;
	long_task: {
		id: string;
		entry_type: typeof RumLongTaskEntryType.LONG_TASK;
		duration: ServerDuration;
	};
	_dd: {
		discarded: boolean;
	};
}
type DeliveryType = "cache" | "navigational-prefetch" | "other";
type InvokerType = "user-callback" | "event-listener" | "resolve-promise" | "reject-promise" | "classic-script" | "module-script";
interface RawRumLongAnimationFrameEvent {
	date: TimeStamp;
	type: typeof RumEventType.LONG_TASK;
	long_task: {
		id: string;
		entry_type: typeof RumLongTaskEntryType.LONG_ANIMATION_FRAME;
		duration: ServerDuration;
		blocking_duration: ServerDuration;
		first_ui_event_timestamp: ServerDuration;
		render_start: ServerDuration;
		style_and_layout_start: ServerDuration;
		start_time: ServerDuration;
		scripts: Array<{
			duration: ServerDuration;
			pause_duration: ServerDuration;
			forced_style_and_layout_duration: ServerDuration;
			start_time: ServerDuration;
			execution_start: ServerDuration;
			source_url: string;
			source_function_name: string;
			source_char_position: number;
			invoker: string;
			invoker_type: InvokerType;
			window_attribution: string;
		}>;
	};
	_dd: {
		discarded: boolean;
	};
}
interface RawRumActionEvent {
	date: TimeStamp;
	type: typeof RumEventType.ACTION;
	action: {
		id: string;
		type: ActionType;
		loading_time?: ServerDuration;
		frustration?: {
			type: FrustrationType[];
		};
		error?: Count;
		long_task?: Count;
		resource?: Count;
		target: {
			name: string;
		};
	};
	view?: {
		in_foreground: boolean;
	};
	_dd?: {
		action?: {
			target?: {
				selector?: string;
				width?: number;
				height?: number;
			};
			name_source?: string;
			position?: {
				x: number;
				y: number;
			};
			pointer_up_delay?: Duration;
		};
	};
	context?: Context;
}
declare const ActionType: {
	readonly CLICK: "click";
	readonly CUSTOM: "custom";
	readonly TAP: "tap";
	readonly SCROLL: "scroll";
	readonly SWIPE: "swipe";
	readonly APPLICATION_START: "application_start";
	readonly BACK: "back";
};
type ActionType = (typeof ActionType)[keyof typeof ActionType];
declare const FrustrationType: {
	readonly RAGE_CLICK: "rage_click";
	readonly ERROR_CLICK: "error_click";
	readonly DEAD_CLICK: "dead_click";
};
type FrustrationType = (typeof FrustrationType)[keyof typeof FrustrationType];
interface RawRumVitalEvent {
	date: TimeStamp;
	type: typeof RumEventType.VITAL;
	vital: {
		id: string;
		name: string;
		type: VitalType;
		step_type?: string;
		operation_key?: string;
		failure_reason?: string;
		description?: string;
		duration?: number;
	};
	_dd?: {
		vital: {
			computed_value: true;
		};
	};
	context?: Context;
}
declare const VitalType: {
	readonly DURATION: "duration";
	readonly OPERATION_STEP: "operation_step";
};
type VitalType = (typeof VitalType)[keyof typeof VitalType];
type RawRumEvent = RawRumErrorEvent | RawRumResourceEvent | RawRumViewEvent | RawRumLongTaskEvent | RawRumLongAnimationFrameEvent | RawRumActionEvent | RawRumVitalEvent;
type RumEventDomainContext<T extends RumEventType = any> = T extends typeof RumEventType.VIEW ? RumViewEventDomainContext : T extends typeof RumEventType.ACTION ? RumActionEventDomainContext : T extends typeof RumEventType.RESOURCE ? RumFetchResourceEventDomainContext | RumXhrResourceEventDomainContext | RumOtherResourceEventDomainContext : T extends typeof RumEventType.ERROR ? RumErrorEventDomainContext : T extends typeof RumEventType.LONG_TASK ? RumLongTaskEventDomainContext : T extends typeof RumEventType.VITAL ? RumVitalEventDomainContext : never;
interface RumViewEventDomainContext {
	location: Readonly<Location>;
}
interface RumActionEventDomainContext {
	events?: Event[];
	handlingStack?: string;
}
interface RumFetchResourceEventDomainContext {
	requestInit: RequestInit | undefined;
	requestInput: RequestInfo;
	response: Response | undefined;
	error: Error | undefined;
	performanceEntry: PerformanceEntry | undefined;
	isAborted: boolean;
	handlingStack: string | undefined;
}
interface RumXhrResourceEventDomainContext {
	xhr: XMLHttpRequest;
	performanceEntry: PerformanceEntry | undefined;
	isAborted: boolean;
	handlingStack: string | undefined;
}
interface RumOtherResourceEventDomainContext {
	performanceEntry: PerformanceEntry;
}
interface RumErrorEventDomainContext {
	error: unknown;
	handlingStack?: string;
}
interface RumLongTaskEventDomainContext {
	performanceEntry: PerformanceEntry;
}
interface RumVitalEventDomainContext {
}
declare const enum ActionNameSource {
	CUSTOM_ATTRIBUTE = "custom_attribute",
	MASK_PLACEHOLDER = "mask_placeholder",
	TEXT_CONTENT = "text_content",
	STANDARD_ATTRIBUTE = "standard_attribute",
	BLANK = "blank"
}
interface ExtraPointerEventFields {
	target: Element;
	timeStamp: RelativeTime;
}
type MouseEventOnElement = PointerEvent & ExtraPointerEventFields;
interface ActionCounts$1 {
	errorCount: number;
	longTaskCount: number;
	resourceCount: number;
}
interface ClickAction {
	type: typeof ActionType.CLICK;
	id: string;
	name: string;
	nameSource: ActionNameSource;
	target?: {
		selector: string | undefined;
		width: number;
		height: number;
	};
	position?: {
		x: number;
		y: number;
	};
	startClocks: ClocksState;
	duration?: Duration;
	counts: ActionCounts$1;
	event: MouseEventOnElement;
	frustrationTypes: FrustrationType[];
	events: Event[];
}
type AutoAction = ClickAction;
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;
};
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;
	};
}
interface RawRumEventCollectedData<E extends RawRumEvent = RawRumEvent> {
	startTime: RelativeTime;
	duration?: Duration;
	rawRumEvent: E;
	domainContext: RumEventDomainContext<E["type"]>;
}
declare const LifeCycle: {
	new (): AbstractLifeCycle<LifeCycleEventMap>;
};
type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>;
interface StartRecordingOptions {
	force: boolean;
}
interface RumPublicApi extends PublicApi {
	/**
	 * Init the RUM browser SDK.
	 *
	 * See [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser) for further information.
	 *
	 * @category Init
	 * @param initConfiguration - Configuration options of the SDK
	 * @example
	 * ```ts
	 * datadogRum.init({
	 *   applicationId: '<DATADOG_APPLICATION_ID>',
	 *   clientToken: '<DATADOG_CLIENT_TOKEN>',
	 *   site: '<DATADOG_SITE>',
	 *   // ...
	 * })
	 * ```
	 */
	init: (initConfiguration: RumInitConfiguration) => void;
	/**
	 * Set the tracking consent of the current user.
	 *
	 * Data will be sent only if it is set to "granted". This value won't be stored by the library
	 * across page loads: you will need to call this method or set the appropriate `trackingConsent`
	 * field in the init() method at each page load.
	 *
	 * If this method is called before the init() method, the provided value will take precedence
	 * over the one provided as initialization parameter.
	 *
	 * See [User tracking consent](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-tracking-consent) for further information.
	 *
	 * @category Privacy
	 * @param trackingConsent - The user tracking consent
	 */
	setTrackingConsent: (trackingConsent: TrackingConsent) => void;
	/**
	 * Set View Name.
	 *
	 * Enable to manually change the name of the current view.
	 * See [Override default RUM view names](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#override-default-rum-view-names) for further information.
	 *
	 * @category Context - View
	 * @param name - Name of the view
	 */
	setViewName: (name: string) => void;
	/**
	 * Set View Context.
	 *
	 * Enable to manually set the context of the current view.
	 *
	 * @category Context - View
	 * @param context - Context of the view
	 */
	setViewContext: (context: Context) => void;
	/**
	 * Set View Context Property.
	 *
	 * Enable to manually set a property of the context of the current view.
	 *
	 * @category Context - View
	 * @param key - key of the property
	 * @param value - value of the property
	 */
	setViewContextProperty: (key: string, value: any) => void;
	/**
	 * Get View Context.
	 *
	 * @category Context - View
	 */
	getViewContext(): Context;
	/**
	 * [Internal API] Get the internal SDK context
	 *
	 * @internal
	 */
	getInternalContext: (startTime?: number) => RumInternalContext | undefined;
	/**
	 * Get the init configuration
	 *
	 * @category Init
	 * @returns RumInitConfiguration | undefined
	 */
	getInitConfiguration: () => RumInitConfiguration | undefined;
	/**
	 * Add a custom action, stored in `@action`
	 *
	 * See [Send RUM Custom Actions](https://docs.datadoghq.com/real_user_monitoring/guide/send-rum-custom-actions) for further information.
	 *
	 * @category Data Collection
	 * @param name - Name of the action
	 * @param context - Context of the action
	 */
	addAction: (name: string, context?: object) => void;
	/**
	 * [Experimental] Start an action, stored in `@action`
	 *
	 * @category Data Collection
	 * @param name - Name of the action
	 * @param options - Options of the action (@default type: 'custom')
	 */
	startAction: (name: string, options?: ActionOptions) => void;
	/**
	 * [Experimental] Stop an action, stored in `@action`
	 *
	 * @category Data Collection
	 * @param name - Name of the action
	 * @param options - Options of the action
	 */
	stopAction: (name: string, options?: ActionOptions) => void;
	/**
	 * Add a custom error, stored in `@error`.
	 *
	 * See [Send RUM Custom Actions](https://docs.datadoghq.com/real_user_monitoring/guide/send-rum-custom-actions) for further information.
	 *
	 * @category Data Collection
	 * @param error - Error. Favor sending a [Javascript Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) to have a stack trace attached to the error event.
	 * @param context - Context of the error
	 */
	addError: (error: unknown, context?: object) => void;
	/**
	 * Add a custom timing relative to the start of the current view,
	 * stored in `@view.custom_timings.<timing_name>`
	 *
	 * Note: passing a relative time is discouraged since it is actually used as-is but displayed relative to the view start.
	 * We currently don't provide a way to retrieve the view start time, so it can be challenging to provide a timing relative to the view start.
	 * see https://github.com/DataDog/browser-sdk/issues/2552
	 *
	 * @category Data Collection
	 * @param name - Name of the custom timing
	 * @param [time] - Epoch timestamp of the custom timing (if not set, will use current time)
	 */
	addTiming: (name: string, time?: number) => void;
	/**
	 * Set the global context information to all events, stored in `@context`
	 * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.
	 *
	 * @category Context - Global Context
	 * @param context - Global context
	 */
	setGlobalContext: (context: Context) => void;
	/**
	 * Get the global Context
	 *
	 * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.
	 *
	 * @category Context - Global Context
	 */
	getGlobalContext: () => Context;
	/**
	 * Set or update a global context property, stored in `@context.<key>`
	 *
	 * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.
	 *
	 * @category Context - Global Context
	 * @param key - Key of the property
	 * @param value - Value of the property
	 */
	setGlobalContextProperty: (key: any, value: any) => void;
	/**
	 * Remove a global context property
	 *
	 * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.
	 *
	 * @category Context - Global Context
	 */
	removeGlobalContextProperty: (key: any) => void;
	/**
	 * Clear the global context
	 *
	 * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.
	 *
	 * @category Context - Global Context
	 */
	clearGlobalContext(): void;
	/**
	 * Set user information to all events, stored in `@usr`
	 *
	 * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.
	 *
	 * @category Context - User
	 * @param newUser - User information
	 */
	setUser(newUser: User & {
		id: string;
	}): void;
	/**
	 * Set user information to all events, stored in `@usr`
	 *
	 * @category Context - User
	 * @deprecated You must specify a user id, favor using {@link setUser} instead
	 * @param newUser - User information with optional id
	 */
	setUser(newUser: User): void;
	/**
	 * Get user information
	 *
	 * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.
	 *
	 * @category Context - User
	 * @returns User information
	 */
	getUser: () => Context;
	/**
	 * Set or update the user property, stored in `@usr.<key>`
	 *
	 * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.
	 *
	 * @category Context - User
	 * @param key - Key of the property
	 * @param property - Value of the property
	 */
	setUserProperty: (key: any, property: any) => void;
	/**
	 * Remove a user property
	 *
	 * @category Context - User
	 * @param key - Key of the property to remove
	 * @see [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.
	 */
	removeUserProperty: (key: any) => void;
	/**
	 * Clear all user information
	 *
	 * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.
	 *
	 * @category Context - User
	 */
	clearUser: () => void;
	/**
	 * Set account information to all events, stored in `@account`
	 *
	 * @category Context - Account
	 * @param newAccount - Account information
	 */
	setAccount: (newAccount: Account) => void;
	/**
	 * Get account information
	 *
	 * @category Context - Account
	 * @returns Account information
	 */
	getAccount: () => Context;
	/**
	 * Set or update the account property, stored in `@account.<key>`
	 *
	 * @category Context - Account
	 * @param key - Key of the property
	 * @param property - Value of the property
	 */
	setAccountProperty: (key: string, property: any) => void;
	/**
	 * Remove an account property
	 *
	 * @category Context - Account
	 * @param key - Key of the property to remove
	 */
	removeAccountProperty: (key: string) => void;
	/**
	 * Clear all account information
	 *
	 * @category Context - Account
	 * @returns Clear all account information
	 */
	clearAccount: () => void;
	/**
	 * Start a view manually.
	 * Enable to manual start a view, use `trackViewsManually: true` init parameter and call `startView()` to create RUM views and be aligned with how you’ve defined them in your SPA application routing.
	 *
	 * See [Override default RUM view names](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#override-default-rum-view-names) for further information.
	 *
	 * Context - @category Data Collection
	 *
	 * @param nameOrOptions - Name or options (name, service, version) for the view
	 */
	startView(nameOrOptions?: string | ViewOptions): void;
	/**
	 * Stop the session. A new session will start at the next user interaction with the page.
	 *
	 * @category Session
	 */
	stopSession(): void;
	/**
	 * Add a feature flag evaluation,
	 * stored in `@feature_flags.<feature_flag_key>`
	 *
	 * We recommend enabling the intake request compression when using feature flags `compressIntakeRequests: true`.
	 *
	 * See [Feature Flag Tracking](https://docs.datadoghq.com/real_user_monitoring/feature_flag_tracking/) for further information.
	 *
	 * @category Data Collection
	 * @param key - The key of the feature flag.
	 * @param value - The value of the feature flag.
	 */
	addFeatureFlagEvaluation: (key: string, value: any) => void;
	/**
	 * Get the Session Replay Link.
	 *
	 * See [Connect Session Replay To Your Third-Party Tools](https://docs.datadoghq.com/real_user_monitoring/guide/connect-session-replay-to-your-third-party-tools) for further information.
	 *
	 * @category Session Replay
	 */
	getSessionReplayLink: () => string | undefined;
	/**
	 * Start Session Replay recording.
	 * Enable to conditionally start the recording, use the `startSessionReplayRecordingManually:true` init parameter and call `startSessionReplayRecording()`
	 *
	 * See [Browser Session Replay](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser) for further information.
	 *
	 * @category Session Replay
	 */
	startSessionReplayRecording: (options?: StartRecordingOptions) => void;
	/**
	 * Stop Session Replay recording.
	 *
	 * See [Browser Session Replay](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser) for further information.
	 *
	 * @category Session Replay
	 */
	stopSessionReplayRecording: () => void;
	/**
	 * Add a custom duration vital
	 *
	 * @category Vital - Duration
	 * @param name - Name of the custom vital
	 * @param options - Options for the custom vital (startTime, duration, context, description)
	 */
	addDurationVital: (name: string, options: AddDurationVitalOptions) => void;
	/**
	 * Start a custom duration vital.
	 *
	 * If you plan to have multiple durations for the same vital, you should use the reference returned by this method.
	 *
	 * @category Vital - Duration
	 * @param name - Name of the custom vital
	 * @param options - Options for the custom vital (context, description)
	 * @returns reference to the custom vital
	 */
	startDurationVital: (name: string, options?: DurationVitalOptions) => DurationVitalReference;
	/**
	 * Stop a custom duration vital
	 *
	 * @category Vital - Duration
	 * @param nameOrRef - Name or reference of the custom vital
	 * @param options - Options for the custom vital (operationKey, context, description)
	 */
	stopDurationVital: (nameOrRef: string | DurationVitalReference, options?: DurationVitalOptions) => void;
	/**
	 * start a feature operation
	 *
	 * @category Vital - Feature Operation
	 * @param name - Name of the operation step
	 * @param options - Options for the operation step (operationKey, context, description)
	 * @hidden // TODO: replace by @since when GA
	 */
	startFeatureOperation: (name: string, options?: FeatureOperationOptions) => void;
	/**
	 * succeed a feature operation
	 *
	 * @category Vital - Feature Operation
	 * @param name - Name of the operation step
	 * @param options - Options for the operation step (operationKey, context, description)
	 * @hidden // TODO: replace by @since when GA
	 */
	succeedFeatureOperation: (name: string, options?: FeatureOperationOptions) => void;
	/**
	 * fail a feature operation
	 *
	 * @category Vital - Feature Operation
	 * @param name - Name of the operation step
	 * @param failureReason
	 * @param options - Options for the operation step (operationKey, context, description)
	 * @hidden // TODO: replace by @since when GA
	 */
	failFeatureOperation: (name: string, failureReaon: FailureReason, options?: FeatureOperationOptions) => void;
}
interface RecorderApi {
	start: (options?: StartRecordingOptions) => void;
	stop: () => void;
	onRumStart: (lifeCycle: LifeCycle, configuration: RumConfiguration, sessionManager: RumSessionManager, viewHistory: ViewHistory, deflateWorker: DeflateWorker | undefined, telemetry: Telemetry) => void;
	isRecording: () => boolean;
	getReplayStats: (viewId: string) => ReplayStats | undefined;
	getSessionReplayLink: () => string | undefined;
}
interface ProfilerApi {
	stop: () => void;
	onRumStart: (lifeCycle: LifeCycle, hooks: Hooks, configuration: RumConfiguration, sessionManager: RumSessionManager, viewHistory: ViewHistory, longTaskContexts: LongTaskContexts, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder) => void;
}
interface Strategy {
	init: (initConfiguration: RumInitConfiguration, publicApi: RumPublicApi, errorStack?: string) => void;
	initConfiguration: RumInitConfiguration | undefined;
	getInternalContext: StartRumResult["getInternalContext"];
	stopSession: StartRumResult["stopSession"];
	addTiming: StartRumResult["addTiming"];
	startView: StartRumResult["startView"];
	setViewName: StartRumResult["setViewName"];
	setViewContext: StartRumResult["setViewContext"];
	setViewContextProperty: StartRumResult["setViewContextProperty"];
	getViewContext: StartRumResult["getViewContext"];
	globalContext: ContextManager;
	userContext: ContextManager;
	accountContext: ContextManager;
	addAction: StartRumResult["addAction"];
	startAction: StartRumResult["startAction"];
	stopAction: StartRumResult["stopAction"];
	addError: StartRumResult["addError"];
	addFeatureFlagEvaluation: StartRumResult["addFeatureFlagEvaluation"];
	startDurationVital: StartRumResult["startDurationVital"];
	stopDurationVital: StartRumResult["stopDurationVital"];
	addDurationVital: StartRumResult["addDurationVital"];
	addOperationStepVital: StartRumResult["addOperationStepVital"];
}
interface PrivacyOptions {
	exclude?: RegExp[] | string[];
	include?: RegExp[] | string[];
	addToDictionaryFunctionName?: string;
	helperCodeExpression?: string;
}
type SourceCodeContextOptions = {
	service?: string;
	version?: string;
	debugId?: boolean;
};
type RumOptions = {
	enable?: boolean;
	sdk?: SDKOptions;
	privacy?: PrivacyOptions;
	sourceCodeContext?: SourceCodeContextOptions;
};
type SDKOptions = Assign<RumInitConfiguration, {
	clientToken?: string;
}>;
declare const CONFIG_KEY$5: "rum";
declare const PLUGIN_NAME$5: PluginName;
declare const helpers$2: {};
type types$5 = {
	RumOptions: RumOptions;
	RumPublicApi: RumPublicApi;
	RumInitConfiguration: RumInitConfiguration;
};
declare const getPlugins$5: GetPlugins;
declare const ALL_ENVS: readonly [
	"development",
	"production",
	"test"
];
declare const SUPPORTED_BUNDLERS: readonly [
	"webpack",
	"vite",
	"esbuild",
	"rollup",
	"rspack"
];
declare const SITES: readonly [
	"datadoghq.com",
	"us3.datadoghq.com",
	"us5.datadoghq.com",
	"datadoghq.eu",
	"ddog-gov.com",
	"us2.ddog-gov.com",
	"ap1.datadoghq.com",
	"ap2.datadoghq.com",
	"datad0g.com"
];
type Assign<A, B> = Omit<A, keyof B> & B;
interface RepositoryData {
	commit: {
		hash: string;
		message: string;
		author: {
			name: string;
			email: string;
			date: string;
		};
		committer: {
			name: string;
			email: string;
			date: string;
		};
	};
	hash: string;
	branch: string;
	remote: string;
	trackedFilesMatcher: TrackedFilesMatcher;
}
type FileReport = {
	filepath: string;
	name: string;
	size: number;
	type: string;
};
type Input = FileReport & {
	dependencies: Set<Input>;
	dependents: Set<Input>;
};
type Output = FileReport & {
	inputs: (Input | Output)[];
};
type Entry = Output & {
	outputs: Output[];
};
interface Metric {
	metric: string;
	type: "count" | "size" | "duration";
	points: [
		number,
		number
	][];
	tags: string[];
}
type Log = {
	bundler?: BundlerName;
	pluginName: string;
	type: LogLevel;
	message: string;
	time: number;
};
type LogTags = string[];
type Timer = {
	label: string;
	pluginName: string;
	spans: {
		start: number;
		end?: number;
		tags: LogTags;
	}[];
	tags: LogTags;
	total: number;
	logLevel: LogLevel;
};
type BuildMetadata = {
	name?: string;
	version?: string;
};
type BuildReport = {
	bundler: GlobalData["bundler"];
	errors: GlobalStores["errors"];
	warnings: GlobalStores["warnings"];
	logs: GlobalStores["logs"];
	timings: GlobalStores["timings"];
	metadata: GlobalData["metadata"];
	entries?: Entry[];
	inputs?: Input[];
	outputs?: Output[];
	start?: number;
	end?: number;
	duration?: number;
	writeDuration?: number;
};
type BundlerName = (typeof SUPPORTED_BUNDLERS)[number];
type BundlerReport = GlobalData["bundler"] & {
	outDir: string;
	rawConfig?: any;
};
type ChunkInfo = {
	sourceOrHash: string;
	fileName: string;
	isEntry: boolean;
};
type InjectedValue = string | (() => Promise<string>) | ((chunk?: ChunkInfo) => string);
declare enum InjectPosition {
	BEFORE = 0,
	MIDDLE = 1,
	AFTER = 2
}
type ToInjectItem = {
	type: "file" | "code";
	value: InjectedValue;
	fallback?: ToInjectItem;
} & ({
	position?: InjectPosition.BEFORE | InjectPosition.AFTER;
	injectIntoAllChunks?: boolean;
} | {
	position: InjectPosition.MIDDLE;
});
type TimeLogger = {
	timer: Timer;
	resume: (startTime?: number) => void;
	end: (endTime?: number) => void;
	pause: (pauseTime?: number, warn?: boolean) => void;
	tag: (tags: LogTags, opts?: {
		span?: boolean;
	}) => void;
};
type TimeLog = (label: string, opts?: {
	level?: LogLevel;
	start?: boolean | number;
	log?: boolean;
	tags?: LogTags;
}) => TimeLogger;
type GetLogger = (name: string) => Logger;
type LogOptions = {
	forward?: boolean;
	context?: LogData;
};
type LoggerFn = (text: any, opts?: LogOptions) => void;
type Logger = {
	getLogger: GetLogger;
	time: TimeLog;
	error: LoggerFn;
	warn: LoggerFn;
	info: LoggerFn;
	debug: LoggerFn;
};
type RestContext = string | string[] | number | boolean;
type LogData = Record<string, RestContext | Record<string, RestContext>>;
type DdLogOptions = {
	message: string;
	context?: LogData;
};
type Env = (typeof ALL_ENVS)[number];
type TriggerHook<R> = <K extends keyof CustomHooks>(name: K, ...args: Parameters<NonNullable<CustomHooks[K]>>) => R;
type GlobalContext = {
	addMetric: (metric: Metric) => void;
	asyncHook: TriggerHook<Promise<void[]>>;
	auth: AuthOptionsWithDefaults;
	build: BuildReport;
	bundler: BundlerReport;
	buildRoot: string;
	env: GlobalData["env"];
	getLogger: GetLogger;
	git?: RepositoryData;
	hook: TriggerHook<void>;
	inject: (item: ToInjectItem) => void;
	pluginNames: string[];
	plugins: (PluginOptions | CustomPluginOptions)[];
	queue: (promise: Promise<any>) => void;
	sendLog: (args: DdLogOptions) => Promise<void>;
	start: number;
	version: GlobalData["version"];
};
type HookFn<T extends Array<any>> = (...args: T) => void;
type AsyncHookFn<T extends Array<any>> = (...args: T) => Promise<void> | void;
type CustomHooks = {
	asyncTrueEnd?: () => Promise<void> | void;
	buildRoot?: HookFn<[
		string
	]>;
	flush?: () => Promise<void> | void;
	init?: HookFn<[
		GlobalContext
	]>;
	buildReport?: AsyncHookFn<[
		BuildReport
	]>;
	bundlerReport?: HookFn<[
		BundlerReport
	]>;
	git?: AsyncHookFn<[
		RepositoryData
	]>;
	metrics?: AsyncHookFn<[
		Set<Metric>
	]>;
	syncTrueEnd?: () => void;
	timings?: AsyncHookFn<[
		TimingsReport
	]>;
};
type PluginOptions = Assign<UnpluginOptions & CustomHooks, {
	name: PluginName;
}>;
type CustomPluginOptions = Assign<PluginOptions, {
	name: string;
}>;
type GetPluginsArg = {
	bundler: any;
	context: GlobalContext;
	options: OptionsWithDefaults;
	data: GlobalData;
	stores: GlobalStores;
};
type GetPlugins = (arg: GetPluginsArg) => PluginOptions[];
type GetCustomPlugins = (arg: GetPluginsArg) => CustomPluginOptions[];
type LogLevel = "debug" | "info" | "warn" | "error" | "none";
type Site$1 = (typeof SITES)[number];
type AuthOptions = {
	apiKey?: string;
	appKey?: string;
	site?: string;
};
type AuthOptionsWithDefaults = Omit<AuthOptions, "site"> & {
	site: Site$1;
	siteSubdomain?: string;
};
interface BaseOptions {
	auth?: AuthOptions;
	metadata?: BuildMetadata;
	enableGit?: boolean;
	logLevel?: LogLevel;
}
interface Options extends BaseOptions {
	[CONFIG_KEY]?: AppsOptions;
	[CONFIG_KEY$1]?: ErrorTrackingOptions;
	[CONFIG_KEY$2]?: LiveDebuggerOptions;
	[CONFIG_KEY$3]?: MetricsOptions;
	[CONFIG_KEY$4]?: OutputOptions;
	[rum.CONFIG_KEY]?: RumOptions;
	customPlugins?: GetCustomPlugins;
}
type OptionsWithDefaults = Assign<Assign<Options, Required<BaseOptions>>, {
	auth: AuthOptionsWithDefaults;
}>;
type PluginName = `datadog-${Lowercase<string>}-plugin`;
type GlobalData = {
	bundler: {
		name: BundlerName;
		version: string;
	};
	env: Env;
	metadata: BuildMetadata;
	packageName: string;
	version: string;
};
type GlobalStores = {
	errors: string[];
	logs: Log[];
	metrics: Set<Metric>;
	queue: Promise<any>[];
	timings: Timer[];
	warnings: string[];
};
type TAP_TYPES = "default" | "async" | "promise";
interface ValueContext {
	type: string;
	name: string;
	value?: string;
}
interface Value {
	start: number;
	end: number;
	duration: number;
	context?: ValueContext[];
	type?: TAP_TYPES;
}
interface Timing {
	name: string;
	duration: number;
	increment: number;
	events: {
		[key: string]: {
			name: string;
			values: Value[];
		};
	};
}
type TimingsMap = Map<string, Timing>;
interface TimingsReport {
	tapables?: TimingsMap;
	loaders?: TimingsMap;
	modules?: TimingsMap;
}
export type VitePluginOptions = Options;
export declare const datadogVitePlugin: (options: Options) => vite.Plugin<any>[];
export declare const version: string;
declare const helpers$3: {
	metrics: {
		filters: ((metric: Metric) => Metric | null)[];
	};
};

declare namespace rum {
	export { CONFIG_KEY$5 as CONFIG_KEY, PLUGIN_NAME$5 as PLUGIN_NAME, getPlugins$5 as getPlugins, helpers$2 as helpers, types$5 as types };
}

export {
	helpers$3 as helpers,
	types as AppsTypes,
	types$1 as ErrorTrackingTypes,
	types$2 as LiveDebuggerTypes,
	types$3 as MetricsTypes,
	types$4 as OutputTypes,
	types$5 as RumTypes,
};

export {};