@dynatrace/rum-javascript-sdk 1.333.15 → 1.337.1

package/dist/types/api/dynatrace-api-types.d.ts

@@ -1,4 +1,5 @@
 import type { ApiCreatedEventPropertiesEvent, ApiCreatedSessionPropertiesEvent, JSONEvent, JSONObject } from "../rum-events/json-event.js";
+import type { RumEventKeys, RUMKeyPressActionEvent } from "../rum-events/index.js";
 import type { EventContext } from "../rum-events/event-context/event-context.js";
 import type { UserActionStartOptions } from "../user-actions/user-action-start-options.js";
 import type { UserActionTracker } from "../user-actions/user-action-tracker.js";
@@ -22,6 +23,95 @@ export interface HealthCheckConfig {
     returnDiagnosticData?: boolean;
     runDetailedOverrideCheck?: boolean;
 }
+/**
+ * The fields allowed for {@link Interactions.sendKeyPressEvent}.
+ *
+ * Includes the required `keys` array and optional `ui_element.custom_name`.
+ * Additional user-defined fields are limited to `event_properties.*` entries.
+ * The fields object must be a JSON-serializable plain object.
+ *
+ * @category API
+ */
+export type SendUserInteractionFields = {
+    /**
+     * The key combination for the interaction. Must contain at least one key.
+     * Values can be {@link UserInteractionSpecialKey} members or raw
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key | KeyboardEvent.key}
+     * strings — raw values are normalized internally.
+     * The enum is optional but improves readability when constructing key arrays manually.
+     *
+     * Import `UserInteractionSpecialKey` from `@dynatrace/rum-javascript-sdk/types/rum-events`.
+     */
+    keys: RUMKeyPressActionEvent["keys"];
+    /**
+     * An optional custom name for the UI element, included as `ui_element.custom_name` in the emitted event.
+     * This field is independent of the auto-detected element name (`ui_element.detected_name`).
+     * It is included in the emitted event regardless of whether `elementOrEvent` is provided.
+     */
+    [RumEventKeys.UI_ELEMENT$CUSTOM_NAME]?: string;
+} & ApiCreatedEventPropertiesEvent;
+/**
+ * @experimental
+ * @category API
+ */
+export interface Interactions {
+    /**
+     * Sends a user interaction event for reporting custom keyboard shortcuts or key combinations
+     * that are not automatically detected. Only available if the User Interaction module is enabled.
+     *
+     * Keys can be specified using {@link UserInteractionSpecialKey} members or raw
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key | KeyboardEvent.key}
+     * strings — raw values are normalized internally (e.g. `" "` → `"space"`, `"Control"` → `"ctrl"`).
+     * The enum is optional but improves readability when constructing key arrays manually.
+     *
+     * @example
+     * ```typescript
+     * import { UserInteractionSpecialKey } from "@dynatrace/rum-javascript-sdk/types/rum-events";
+     *
+     * // Basic key combination
+     * dynatrace.interactions?.sendKeyPressEvent({
+     *     keys: [UserInteractionSpecialKey.CTRL, "S"]
+     * });
+     *
+     * // With an Element to capture UI element fields (tag_name, id, detected_name, components, etc.)
+     * const button = document.getElementById("saveBtn");
+     * dynatrace.interactions?.sendKeyPressEvent({
+     *     keys: [UserInteractionSpecialKey.ENTER]
+     * }, button);
+     *
+     * // With a native KeyboardEvent to resolve the target element
+     * document.addEventListener("keydown", (event) => {
+     *     dynatrace.interactions?.sendKeyPressEvent({
+     *         keys: [UserInteractionSpecialKey.CTRL, "S"]
+     *     }, event);
+     * });
+     *
+     * // With a custom_name for the UI element
+     * dynatrace.interactions?.sendKeyPressEvent({
+     *     keys: [UserInteractionSpecialKey.ESC],
+     *     "ui_element.custom_name": "CloseModal"
+     * });
+     *
+     * // With event properties for enrichment
+     * dynatrace.interactions?.sendKeyPressEvent({
+     *     keys: [UserInteractionSpecialKey.CTRL, "S"],
+     *     "event_properties.context": "editor"
+     * });
+     * ```
+     *
+     * @param fields         The interaction fields. Must contain a `keys` array with at least one key.
+     *                       The fields object must be JSON-serializable. Optionally include `ui_element.custom_name`
+     *                       to provide a custom name for the UI element and `event_properties.*` entries.
+     *                       See {@link SendUserInteractionFields} for details.
+     * @param elementOrEvent An optional {@link Element} or {@link KeyboardEvent} used to auto-generate UI element fields
+     *                       such as `tag_name`, `id`, `detected_name`, `components`, `features`, and `properties`.
+     *                       When a {@link KeyboardEvent} is provided, the target element is resolved from the event.
+     *                       If omitted, no UI element fields are included in the emitted event.
+     * @see UserInteractionSpecialKey
+     * @see SendUserInteractionFields
+     */
+    sendKeyPressEvent(this: void, fields: SendUserInteractionFields, elementOrEvent?: Element | Event): void;
+}
 /**
  * @category API
  */
@@ -54,9 +144,7 @@ export declare namespace dynatrace {
      *                     modified with additional properties, thus also empty objects are valid. Only properties
      *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are
      *                     allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
-     *                     All event property keys must contain only alphabetic characters, numbers,
-     *                     underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
-     *                     must be followed by an alphabetic character or number.
+     *                     All event property key names must match the naming rules defined by {@link VALID_KEY_REGEX}.
      * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the
      *                     result event within the modification callback.
      */
@@ -108,7 +196,7 @@ export declare namespace dynatrace {
      * and prevents future mutator functions to be executed.
      *
      * Certain reserved fields and namespaces can’t be modified in any way (added, removed or overridden), while others are open for modification.
-     * See the public documentation for a detailed list of reserved/open fields (link will be added in the future).
+     * See {@link AllowedModificationFields} for details.
      *
      * The context differs based on the processed event and availability of data.
      * For events sent with {@link dynatrace.sendEvent}, the optionally provided context will be provided as custom context.
@@ -188,6 +276,18 @@ export declare namespace dynatrace {
      * ```
      */
     function identifyUser(value: string): void;
+    /**
+     * Grants consent for data collection.
+     *
+     * @internal
+     */
+    function userOptIn(): void;
+    /**
+     * Revokes consent for data collection.
+     *
+     * @internal
+     */
+    function userOptOut(): void;
     /**
      * Sends a sessionPropertyEvent.
      *
@@ -205,10 +305,8 @@ export declare namespace dynatrace {
      *               using JSON.stringify. The resulting event will be populated with `fields` parameter, and
      *               is modified with additional properties, thus also empty objects are valid. Only properties
      *               prefixed with `session_properties.`, the `duration` property and the `start_time` property are
-     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off. All
-     *               session property keys must contain only alphabetic characters, numbers, underscores or
-     *               dots. Each dot must be followed by an alphabetic character. Each underscore must be followed by an
-     *               alphabetic character or number.
+     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
+     *               All session property key names must match the naming rules defined by {@link VALID_KEY_REGEX}.
      */
     function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void;
     /**
@@ -221,11 +319,15 @@ export declare namespace dynatrace {
      *               modified with additional properties, thus also empty objects are valid. Only properties
      *               prefixed with `event_properties.`, the `duration` property and the `start_time` property are
      *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
-     *               All event property keys must contain only alphabetic characters, numbers,
-     *               underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
-     *               must be followed by an alphabetic character or number.
+     *               All event property key names must match the naming rules defined by {@link VALID_KEY_REGEX}.
      */
     let sendExceptionEvent: ((error: Error, fields?: ApiCreatedEventPropertiesEvent) => void) | undefined;
+    /**
+     * This property is `undefined` if the User Interaction module is disabled.
+     *
+     * @experimental
+     */
+    let interactions: Interactions | undefined;
     /**
      * This property is `undefined` if the User Actions module is disabled.
      *
@@ -243,20 +345,20 @@ export interface UserActions {
      *
      * @example
      * ```typescript
-     * const userAction = dynatrace.userActions.create({ autoClose: false });
+     * const userAction = dynatrace.userActions.create({ completeAutomatically: false });
      * const unsubscribe = userAction.subscribe(currentUserAction => {
      *     console.log(`User action would have been completed due to ${currentUserAction.completeReason}`, event);
      * });
      * // execute user actions
-     * userAction.finish();
+     * userAction.complete();
      * unsubscribe();
      * ```
      *
      * @experimental
-     * @param options           An optional options object to configure the user action.
-     * @param options.autoClose If true, automatically stops the user action using RUM JavaScript user action rules.
-     *                          If false, the user action remains active until the next call to `create(...)` or to `userAction.finish()`.
-     * @returns                 An `UserActionTracker` object that can be started and finished, or `undefined` if the user action module is not enabled.
+     * @param options                       An optional options object to configure the user action.
+     * @param options.completeAutomatically If true, automatically completes the user action using RUM JavaScript user action rules.
+     *                                      If false, the user action remains active until the next call to `create(...)` or to `userAction.complete()`.
+     * @returns                             An `UserActionTracker` object that can be started and completed, or `undefined` if the user action module is not enabled.
      */
     create(this: void, options?: UserActionStartOptions): UserActionTracker;
     /**
@@ -266,9 +368,9 @@ export interface UserActions {
      * ```typescript
      * const unsubscribe = dynatrace.userActions?.subscribe(userAction => {
      *     // Disable automatic userAction completion
-     *     userAction.autoClose = false;
-     *     // Execute some requests or mutations, then finish the user action
-     *     userAction.finish();
+     *     userAction.completeAutomatically = false;
+     *     // Execute some requests or mutations, then complete the user action
+     *     userAction.complete();
      * });
      * // Some time later if you don't want to listen to userActions anymore
      * unsubscribe();
@@ -287,10 +389,10 @@ export interface UserActions {
      * dynatrace.userActions?.setAutomaticDetection(false);
      *
      * async function handleClick(router) {
-     *     const userAction = dynatrace.userActions?.create({ autoClose: false });
+     *     const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
      *     // this would normally create an user action that would finish this manual user action
      *     await router.redirect("home");
-     *     userAction.finish();
+     *     userAction.complete();
      * }
      * ```
      *
@@ -307,10 +409,10 @@ export interface UserActions {
      * async function postMessageChannel(message, channel) {
      *   const currentUserAction = dynatrace.userActions?.current;
      *   if (currentUserAction) {
-     *      currentUserAction.autoClose = false;
+     *      currentUserAction.completeAutomatically = false;
      *   }
      *   const response = await channel.send(message);
-     *   currentUserAction?.finish();
+     *   currentUserAction?.complete();
      *   return response;
      * }
      * ```

package/dist/types/api/dynatrace-api-types.js

@@ -4,4 +4,4 @@
 export var dynatrace;
 (function (dynatrace) {
 })(dynatrace || (dynatrace = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynatrace-api-types.js","sourceRoot":"","sources":["../../../source/types/api/dynatrace-api-types.ts"],"names":[],"mappings":"AAgCA;;GAEG;AACH,MAAM,KAAW,SAAS,CAwNzB;AAxND,WAAiB,SAAS;AAwN1B,CAAC,EAxNgB,SAAS,KAAT,SAAS,QAwNzB","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    JSONEvent,\n    JSONObject\n} from \"../rum-events/json-event.js\";\nimport type { EventContext } from \"../rum-events/event-context/event-context.js\";\nimport type { UserActionStartOptions } from \"../user-actions/user-action-start-options.js\";\nimport type { UserActionTracker } from \"../user-actions/user-action-tracker.js\";\n\n/**\n * A method which deactivates behavior when invoked.\n * See the returning method's API for more details.\n *\n * @inline\n * @ignore\n */\nexport type Unsubscriber = () => void;\n\n/**\n * The configuration object provided to the runHealthCheck API.\n *\n * @see runHealthCheck\n * @inline\n * @ignore\n */\nexport interface HealthCheckConfig {\n    logVerbose?: boolean;\n    returnDiagnosticData?: boolean;\n    runDetailedOverrideCheck?: boolean;\n}\n\n/**\n * @category API\n */\nexport namespace dynatrace {\n    /**\n     * Sends an event with the provided fields.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.sendEvent({\n     *     \"event_properties.prop\": \"value\",\n     *     \"duration\": 123,\n     *     \"event_properties.url\": \"www.dynatrace.com\",\n     *     \"event_properties.id\": \"123456789\",\n     * });\n     *\n     * // Using context:\n     * document.addEventListener(\"load\", (event) => {\n     *     dynatrace.sendEvent({\n     *          \"event_properties.prop\": \"value\",\n     *          \"duration\": 123,\n     *          \"event_properties.url\": \"www.dynatrace.com\",\n     *          \"event_properties.id\": \"123456789\",\n     *     }, event); // add the event context here\n     * });\n     *```\n     * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *                     values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *                     using JSON.stringify. The resulting event will contain the provided `fields`, and is\n     *                     modified with additional properties, thus also empty objects are valid. Only properties\n     *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n     *                     allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n     *                     All event property keys must contain only alphabetic characters, numbers,\n     *                     underscores or dots. Each dot must be followed by an alphabetic character. Each underscore\n     *                     must be followed by an alphabetic character or number.\n     * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the\n     *                     result event within the modification callback.\n     */\n    export declare function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown): void;\n\n    /**\n     * Send a Business Event.\n     *\n     * With sendBizEvent, you can report a business event. These standalone events are being sent detached from user\n     * actions or sessions.\n     *\n     * Note: Business events are currently only supported on Dynatrace SaaS deployments.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.sendBizEvent(\"type\", {\n     *     prop: \"value\",\n     *     name: \"biz event name\",\n     *     timestamp: 123,\n     *     url: \"www.dynatrace.com\",\n     *     page_id: \"123456789\",\n     *     \"window.orientation\": \"diagonal\"\n     * });\n     *\n     * // Using context:\n     * document.addEventListener(\"load\", (event) => {\n     *     dynatrace.sendBizEvent(\"type\", {\n     *         prop: \"value\",\n     *         name: \"biz event name\",\n     *         timestamp: 123,\n     *         url: \"www.dynatrace.com\",\n     *         page_id: \"123456789\",\n     *         \"window.orientation\": \"diagonal\"\n     *     }, event); // add the event context here\n     * });\n     *```\n     *\n     * @internal\n     * @param type         Mandatory event type\n     * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *                     values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and\n     *                     modified with additional properties, thus also empty objects are valid.\n     * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the\n     *                     result event within the modification callback. Will be provided as CustomEventContext TODO\n     */\n    export declare function sendBizEvent(type: string, fields: JSONObject, eventContext?: unknown): void;\n\n    /**\n     * Modifies future events with the provided modifier function. Returning a non-object or `null` discards this event\n     * and prevents future mutator functions to be executed.\n     *\n     * Certain reserved fields and namespaces can’t be modified in any way (added, removed or overridden), while others are open for modification.\n     * See the public documentation for a detailed list of reserved/open fields (link will be added in the future).\n     *\n     * The context differs based on the processed event and availability of data.\n     * For events sent with {@link dynatrace.sendEvent}, the optionally provided context will be provided as custom context.\n     * The context object contains a \"type\" and optionally a \"sub_type\" parameter, which can be used to distinguish them.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.addEventModifier(function (event) {\n     *     if (event[\"event.type\"] !== \"click\") {\n     *         return event;\n     *     }\n     *     return {\n     *         ...event,\n     *         \"event_properties.prop\": \"value\",\n     *         \"url.full\": \"www.dynatrace.com\",\n     *         \"view.detected_name\": \"123456789\",\n     *     }\n     * });\n     *\n     * // Using context:\n     * dynatrace.addEventModifier(function (event, context) {\n     *     if (event[\"event.type\"] !== \"click\") {\n     *         return event;\n     *     }\n     *     if (context?.additionalData) {\n     *         return {\n     *           ...event,\n     *           \"event_properties.extra_data\": `received extra data: ${context.additionalData}`\n     *         };\n     *     }\n     *     return event;\n     * });\n     *\n     * // Discarding an event:\n     * dynatrace.addEventModifier(function (event) {\n     *   if (event[\"event.type\"] === \"click\") {\n     *     return null;\n     *   }\n     *   return event;\n     * });\n     * ```\n     *\n     * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context\n     *                      depending on the type of event, if available. The returned event must be a new object, otherwise\n     *                      modification will be ignored. Modification is only allowed for fields declared in\n     *                      {@link AllowedModificationFields}.\n     * @returns             The unsubscriber function to turn off event modification.\n     */\n    export declare function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null): Unsubscriber;\n\n    /**\n     * If not already enabled, dynamically loads the Health Check module which will read accumulated health check data\n     * and present it in the browser developer tools console.\n     *\n     * @param config                          The optional configuration object for the health check.\n     * @param config.logVerbose               If true, verbose information is included in the health check.\n     * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.\n     * @param config.runDetailedOverrideCheck if true, additional information will be logged to the console for overridden native APIs.\n     * @returns                               A promise that settles as soon as the health check has been performed.\n     */\n    export declare function runHealthCheck(config?: HealthCheckConfig): Promise<unknown[] | undefined>;\n\n    /**\n     * Enables debug logging.\n     *\n     * @internal not public yet\n     * @param    loggingInformation An object that specifies what should be logged\n     * @returns                     A promise that settles as soon as debug logging has been enabled\n     */\n    // eslint-disable-next-line @dynatrace/dem-eslint-rules/correct-null-void-undefined -- necessary, because we override the function after loading the healthcheck module\n    export declare function enableDebugLogging(loggingInformation: Record<string, boolean>): Promise<void> | void;\n\n    /**\n     * Use to identify individual users across different browsers, devices, and user sessions.\n     *\n     * @param value The name of the user. For example, use a name, userid, or your user's email address.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.identifyUser(\"john.doe@example.com\");\n     * ```\n     */\n    export declare function identifyUser(value: string): void;\n\n    /**\n     * Sends a sessionPropertyEvent.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.sendSessionPropertyEvent({\n     *     \"session_properties.some_custom\": true,\n     *     \"session_properties.my_id\": \"m123456\",\n     *     \"session_properties.my_other_id_2\": \"x123\",\n     *     \"session_properties.my_fully_other.id3\": \"id007\",\n     * });\n     *```\n     * @param fields Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *               values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *               using JSON.stringify. The resulting event will be populated with `fields` parameter, and\n     *               is modified with additional properties, thus also empty objects are valid. Only properties\n     *               prefixed with `session_properties.`, the `duration` property and the `start_time` property are\n     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off. All\n     *               session property keys must contain only alphabetic characters, numbers, underscores or\n     *               dots. Each dot must be followed by an alphabetic character. Each underscore must be followed by an\n     *               alphabetic character or number.\n     */\n    export declare function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void;\n\n    /**\n     * This function is only available if the Error module is enabled\n     *\n     * @param error  Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.\n     * @param fields Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *               values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *               using JSON.stringify. The resulting event will contain the provided `fields`, and is\n     *               modified with additional properties, thus also empty objects are valid. Only properties\n     *               prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n     *               All event property keys must contain only alphabetic characters, numbers,\n     *               underscores or dots. Each dot must be followed by an alphabetic character. Each underscore\n     *               must be followed by an alphabetic character or number.\n     */\n    export declare let sendExceptionEvent: ((error: Error, fields?: ApiCreatedEventPropertiesEvent) => void) | undefined;\n\n    /**\n     * This property is `undefined` if the User Actions module is disabled.\n     *\n     * @experimental\n     */\n    export declare let userActions: UserActions | undefined;\n}\n\n/**\n * @experimental\n * @category User Actions\n */\nexport interface UserActions {\n    /**\n     * Creates a new controllable user action.\n     *\n     * @example\n     * ```typescript\n     * const userAction = dynatrace.userActions.create({ autoClose: false });\n     * const unsubscribe = userAction.subscribe(currentUserAction => {\n     *     console.log(`User action would have been completed due to ${currentUserAction.completeReason}`, event);\n     * });\n     * // execute user actions\n     * userAction.finish();\n     * unsubscribe();\n     * ```\n     *\n     * @experimental\n     * @param options           An optional options object to configure the user action.\n     * @param options.autoClose If true, automatically stops the user action using RUM JavaScript user action rules.\n     *                          If false, the user action remains active until the next call to `create(...)` or to `userAction.finish()`.\n     * @returns                 An `UserActionTracker` object that can be started and finished, or `undefined` if the user action module is not enabled.\n     */\n    create(this: void, options?: UserActionStartOptions): UserActionTracker;\n\n    /**\n     * Subscribes to user actions.\n     *\n     * @example\n     * ```typescript\n     * const unsubscribe = dynatrace.userActions?.subscribe(userAction => {\n     *     // Disable automatic userAction completion\n     *     userAction.autoClose = false;\n     *     // Execute some requests or mutations, then finish the user action\n     *     userAction.finish();\n     * });\n     * // Some time later if you don't want to listen to userActions anymore\n     * unsubscribe();\n     * ```\n     *\n     * @experimental\n     * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.\n     * @returns          An unsubscriber function to remove the subscription.\n     */\n    subscribe(this: void, subscriber: (userAction: UserActionTracker) => void): Unsubscriber;\n\n    /**\n     * Disables automatic user action detection. Useful in case it interferes with manual user action handling.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.userActions?.setAutomaticDetection(false);\n     *\n     * async function handleClick(router) {\n     *     const userAction = dynatrace.userActions?.create({ autoClose: false });\n     *     // this would normally create an user action that would finish this manual user action\n     *     await router.redirect(\"home\");\n     *     userAction.finish();\n     * }\n     * ```\n     *\n     * @experimental\n     * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.\n     */\n    setAutomaticDetection(this: void, automaticDetection: boolean): void;\n\n    /**\n     * The current user action, or `undefined` if no user action is in progress.\n     *\n     * @experimental\n     * @example\n     * ```typescript\n     * async function postMessageChannel(message, channel) {\n     *   const currentUserAction = dynatrace.userActions?.current;\n     *   if (currentUserAction) {\n     *      currentUserAction.autoClose = false;\n     *   }\n     *   const response = await channel.send(message);\n     *   currentUserAction?.finish();\n     *   return response;\n     * }\n     * ```\n     */\n    current: UserActionTracker | undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynatrace-api-types.js","sourceRoot":"","sources":["../../../source/types/api/dynatrace-api-types.ts"],"names":[],"mappings":"AA+HA;;GAEG;AACH,MAAM,KAAW,SAAS,CAuOzB;AAvOD,WAAiB,SAAS;AAuO1B,CAAC,EAvOgB,SAAS,KAAT,SAAS,QAuOzB","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    JSONEvent,\n    JSONObject\n} from \"../rum-events/json-event.js\";\nimport type {\n    RumEventKeys,\n    RUMKeyPressActionEvent\n} from \"../rum-events/index.js\";\nimport type { EventContext } from \"../rum-events/event-context/event-context.js\";\nimport type { UserActionStartOptions } from \"../user-actions/user-action-start-options.js\";\nimport type { UserActionTracker } from \"../user-actions/user-action-tracker.js\";\n\n/**\n * A method which deactivates behavior when invoked.\n * See the returning method's API for more details.\n *\n * @inline\n * @ignore\n */\nexport type Unsubscriber = () => void;\n\n/**\n * The configuration object provided to the runHealthCheck API.\n *\n * @see runHealthCheck\n * @inline\n * @ignore\n */\nexport interface HealthCheckConfig {\n    logVerbose?: boolean;\n    returnDiagnosticData?: boolean;\n    runDetailedOverrideCheck?: boolean;\n}\n\n/**\n * The fields allowed for {@link Interactions.sendKeyPressEvent}.\n *\n * Includes the required `keys` array and optional `ui_element.custom_name`.\n * Additional user-defined fields are limited to `event_properties.*` entries.\n * The fields object must be a JSON-serializable plain object.\n *\n * @category API\n */\nexport type SendUserInteractionFields = {\n    /**\n     * The key combination for the interaction. Must contain at least one key.\n     * Values can be {@link UserInteractionSpecialKey} members or raw\n     * {@link https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key | KeyboardEvent.key}\n     * strings — raw values are normalized internally.\n     * The enum is optional but improves readability when constructing key arrays manually.\n     *\n     * Import `UserInteractionSpecialKey` from `@dynatrace/rum-javascript-sdk/types/rum-events`.\n     */\n    keys: RUMKeyPressActionEvent[\"keys\"];\n    /**\n     * An optional custom name for the UI element, included as `ui_element.custom_name` in the emitted event.\n     * This field is independent of the auto-detected element name (`ui_element.detected_name`).\n     * It is included in the emitted event regardless of whether `elementOrEvent` is provided.\n     */\n    [RumEventKeys.UI_ELEMENT$CUSTOM_NAME]?: string;\n} & ApiCreatedEventPropertiesEvent;\n\n/**\n * @experimental\n * @category API\n */\nexport interface Interactions {\n    /**\n     * Sends a user interaction event for reporting custom keyboard shortcuts or key combinations\n     * that are not automatically detected. Only available if the User Interaction module is enabled.\n     *\n     * Keys can be specified using {@link UserInteractionSpecialKey} members or raw\n     * {@link https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key | KeyboardEvent.key}\n     * strings — raw values are normalized internally (e.g. `\" \"` → `\"space\"`, `\"Control\"` → `\"ctrl\"`).\n     * The enum is optional but improves readability when constructing key arrays manually.\n     *\n     * @example\n     * ```typescript\n     * import { UserInteractionSpecialKey } from \"@dynatrace/rum-javascript-sdk/types/rum-events\";\n     *\n     * // Basic key combination\n     * dynatrace.interactions?.sendKeyPressEvent({\n     *     keys: [UserInteractionSpecialKey.CTRL, \"S\"]\n     * });\n     *\n     * // With an Element to capture UI element fields (tag_name, id, detected_name, components, etc.)\n     * const button = document.getElementById(\"saveBtn\");\n     * dynatrace.interactions?.sendKeyPressEvent({\n     *     keys: [UserInteractionSpecialKey.ENTER]\n     * }, button);\n     *\n     * // With a native KeyboardEvent to resolve the target element\n     * document.addEventListener(\"keydown\", (event) => {\n     *     dynatrace.interactions?.sendKeyPressEvent({\n     *         keys: [UserInteractionSpecialKey.CTRL, \"S\"]\n     *     }, event);\n     * });\n     *\n     * // With a custom_name for the UI element\n     * dynatrace.interactions?.sendKeyPressEvent({\n     *     keys: [UserInteractionSpecialKey.ESC],\n     *     \"ui_element.custom_name\": \"CloseModal\"\n     * });\n     *\n     * // With event properties for enrichment\n     * dynatrace.interactions?.sendKeyPressEvent({\n     *     keys: [UserInteractionSpecialKey.CTRL, \"S\"],\n     *     \"event_properties.context\": \"editor\"\n     * });\n     * ```\n     *\n     * @param fields         The interaction fields. Must contain a `keys` array with at least one key.\n     *                       The fields object must be JSON-serializable. Optionally include `ui_element.custom_name`\n     *                       to provide a custom name for the UI element and `event_properties.*` entries.\n     *                       See {@link SendUserInteractionFields} for details.\n     * @param elementOrEvent An optional {@link Element} or {@link KeyboardEvent} used to auto-generate UI element fields\n     *                       such as `tag_name`, `id`, `detected_name`, `components`, `features`, and `properties`.\n     *                       When a {@link KeyboardEvent} is provided, the target element is resolved from the event.\n     *                       If omitted, no UI element fields are included in the emitted event.\n     * @see UserInteractionSpecialKey\n     * @see SendUserInteractionFields\n     */\n    sendKeyPressEvent(this: void, fields: SendUserInteractionFields, elementOrEvent?: Element | Event): void;\n}\n\n/**\n * @category API\n */\nexport namespace dynatrace {\n    /**\n     * Sends an event with the provided fields.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.sendEvent({\n     *     \"event_properties.prop\": \"value\",\n     *     \"duration\": 123,\n     *     \"event_properties.url\": \"www.dynatrace.com\",\n     *     \"event_properties.id\": \"123456789\",\n     * });\n     *\n     * // Using context:\n     * document.addEventListener(\"load\", (event) => {\n     *     dynatrace.sendEvent({\n     *          \"event_properties.prop\": \"value\",\n     *          \"duration\": 123,\n     *          \"event_properties.url\": \"www.dynatrace.com\",\n     *          \"event_properties.id\": \"123456789\",\n     *     }, event); // add the event context here\n     * });\n     *```\n     * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *                     values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *                     using JSON.stringify. The resulting event will contain the provided `fields`, and is\n     *                     modified with additional properties, thus also empty objects are valid. Only properties\n     *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n     *                     allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n     *                     All event property key names must match the naming rules defined by {@link VALID_KEY_REGEX}.\n     * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the\n     *                     result event within the modification callback.\n     */\n    export declare function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown): void;\n\n    /**\n     * Send a Business Event.\n     *\n     * With sendBizEvent, you can report a business event. These standalone events are being sent detached from user\n     * actions or sessions.\n     *\n     * Note: Business events are currently only supported on Dynatrace SaaS deployments.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.sendBizEvent(\"type\", {\n     *     prop: \"value\",\n     *     name: \"biz event name\",\n     *     timestamp: 123,\n     *     url: \"www.dynatrace.com\",\n     *     page_id: \"123456789\",\n     *     \"window.orientation\": \"diagonal\"\n     * });\n     *\n     * // Using context:\n     * document.addEventListener(\"load\", (event) => {\n     *     dynatrace.sendBizEvent(\"type\", {\n     *         prop: \"value\",\n     *         name: \"biz event name\",\n     *         timestamp: 123,\n     *         url: \"www.dynatrace.com\",\n     *         page_id: \"123456789\",\n     *         \"window.orientation\": \"diagonal\"\n     *     }, event); // add the event context here\n     * });\n     *```\n     *\n     * @internal\n     * @param type         Mandatory event type\n     * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *                     values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and\n     *                     modified with additional properties, thus also empty objects are valid.\n     * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the\n     *                     result event within the modification callback. Will be provided as CustomEventContext TODO\n     */\n    export declare function sendBizEvent(type: string, fields: JSONObject, eventContext?: unknown): void;\n\n    /**\n     * Modifies future events with the provided modifier function. Returning a non-object or `null` discards this event\n     * and prevents future mutator functions to be executed.\n     *\n     * Certain reserved fields and namespaces can’t be modified in any way (added, removed or overridden), while others are open for modification.\n     * See {@link AllowedModificationFields} for details.\n     *\n     * The context differs based on the processed event and availability of data.\n     * For events sent with {@link dynatrace.sendEvent}, the optionally provided context will be provided as custom context.\n     * The context object contains a \"type\" and optionally a \"sub_type\" parameter, which can be used to distinguish them.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.addEventModifier(function (event) {\n     *     if (event[\"event.type\"] !== \"click\") {\n     *         return event;\n     *     }\n     *     return {\n     *         ...event,\n     *         \"event_properties.prop\": \"value\",\n     *         \"url.full\": \"www.dynatrace.com\",\n     *         \"view.detected_name\": \"123456789\",\n     *     }\n     * });\n     *\n     * // Using context:\n     * dynatrace.addEventModifier(function (event, context) {\n     *     if (event[\"event.type\"] !== \"click\") {\n     *         return event;\n     *     }\n     *     if (context?.additionalData) {\n     *         return {\n     *           ...event,\n     *           \"event_properties.extra_data\": `received extra data: ${context.additionalData}`\n     *         };\n     *     }\n     *     return event;\n     * });\n     *\n     * // Discarding an event:\n     * dynatrace.addEventModifier(function (event) {\n     *   if (event[\"event.type\"] === \"click\") {\n     *     return null;\n     *   }\n     *   return event;\n     * });\n     * ```\n     *\n     * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context\n     *                      depending on the type of event, if available. The returned event must be a new object, otherwise\n     *                      modification will be ignored. Modification is only allowed for fields declared in\n     *                      {@link AllowedModificationFields}.\n     * @returns             The unsubscriber function to turn off event modification.\n     */\n    export declare function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null): Unsubscriber;\n\n    /**\n     * If not already enabled, dynamically loads the Health Check module which will read accumulated health check data\n     * and present it in the browser developer tools console.\n     *\n     * @param config                          The optional configuration object for the health check.\n     * @param config.logVerbose               If true, verbose information is included in the health check.\n     * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.\n     * @param config.runDetailedOverrideCheck if true, additional information will be logged to the console for overridden native APIs.\n     * @returns                               A promise that settles as soon as the health check has been performed.\n     */\n    export declare function runHealthCheck(config?: HealthCheckConfig): Promise<unknown[] | undefined>;\n\n    /**\n     * Enables debug logging.\n     *\n     * @internal not public yet\n     * @param    loggingInformation An object that specifies what should be logged\n     * @returns                     A promise that settles as soon as debug logging has been enabled\n     */\n    // eslint-disable-next-line @dynatrace/dem-eslint-rules/correct-null-void-undefined -- necessary, because we override the function after loading the healthcheck module\n    export declare function enableDebugLogging(loggingInformation: Record<string, boolean>): Promise<void> | void;\n\n    /**\n     * Use to identify individual users across different browsers, devices, and user sessions.\n     *\n     * @param value The name of the user. For example, use a name, userid, or your user's email address.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.identifyUser(\"john.doe@example.com\");\n     * ```\n     */\n    export declare function identifyUser(value: string): void;\n\n    /**\n     * Grants consent for data collection.\n     *\n     * @internal\n     */\n    export declare function userOptIn(): void;\n\n    /**\n     * Revokes consent for data collection.\n     *\n     * @internal\n     */\n    export declare function userOptOut(): void;\n\n    /**\n     * Sends a sessionPropertyEvent.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.sendSessionPropertyEvent({\n     *     \"session_properties.some_custom\": true,\n     *     \"session_properties.my_id\": \"m123456\",\n     *     \"session_properties.my_other_id_2\": \"x123\",\n     *     \"session_properties.my_fully_other.id3\": \"id007\",\n     * });\n     *```\n     * @param fields Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *               values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *               using JSON.stringify. The resulting event will be populated with `fields` parameter, and\n     *               is modified with additional properties, thus also empty objects are valid. Only properties\n     *               prefixed with `session_properties.`, the `duration` property and the `start_time` property are\n     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n     *               All session property key names must match the naming rules defined by {@link VALID_KEY_REGEX}.\n     */\n    export declare function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void;\n\n    /**\n     * This function is only available if the Error module is enabled\n     *\n     * @param error  Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.\n     * @param fields Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n     *               values, otherwise they will be replaced with null. The `fields` need to be serializable\n     *               using JSON.stringify. The resulting event will contain the provided `fields`, and is\n     *               modified with additional properties, thus also empty objects are valid. Only properties\n     *               prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n     *               All event property key names must match the naming rules defined by {@link VALID_KEY_REGEX}.\n     */\n    export declare let sendExceptionEvent: ((error: Error, fields?: ApiCreatedEventPropertiesEvent) => void) | undefined;\n\n    /**\n     * This property is `undefined` if the User Interaction module is disabled.\n     *\n     * @experimental\n     */\n    export declare let interactions: Interactions | undefined;\n\n    /**\n     * This property is `undefined` if the User Actions module is disabled.\n     *\n     * @experimental\n     */\n    export declare let userActions: UserActions | undefined;\n}\n\n/**\n * @experimental\n * @category User Actions\n */\nexport interface UserActions {\n    /**\n     * Creates a new controllable user action.\n     *\n     * @example\n     * ```typescript\n     * const userAction = dynatrace.userActions.create({ completeAutomatically: false });\n     * const unsubscribe = userAction.subscribe(currentUserAction => {\n     *     console.log(`User action would have been completed due to ${currentUserAction.completeReason}`, event);\n     * });\n     * // execute user actions\n     * userAction.complete();\n     * unsubscribe();\n     * ```\n     *\n     * @experimental\n     * @param options                       An optional options object to configure the user action.\n     * @param options.completeAutomatically If true, automatically completes the user action using RUM JavaScript user action rules.\n     *                                      If false, the user action remains active until the next call to `create(...)` or to `userAction.complete()`.\n     * @returns                             An `UserActionTracker` object that can be started and completed, or `undefined` if the user action module is not enabled.\n     */\n    create(this: void, options?: UserActionStartOptions): UserActionTracker;\n\n    /**\n     * Subscribes to user actions.\n     *\n     * @example\n     * ```typescript\n     * const unsubscribe = dynatrace.userActions?.subscribe(userAction => {\n     *     // Disable automatic userAction completion\n     *     userAction.completeAutomatically = false;\n     *     // Execute some requests or mutations, then complete the user action\n     *     userAction.complete();\n     * });\n     * // Some time later if you don't want to listen to userActions anymore\n     * unsubscribe();\n     * ```\n     *\n     * @experimental\n     * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.\n     * @returns          An unsubscriber function to remove the subscription.\n     */\n    subscribe(this: void, subscriber: (userAction: UserActionTracker) => void): Unsubscriber;\n\n    /**\n     * Disables automatic user action detection. Useful in case it interferes with manual user action handling.\n     *\n     * @example\n     * ```typescript\n     * dynatrace.userActions?.setAutomaticDetection(false);\n     *\n     * async function handleClick(router) {\n     *     const userAction = dynatrace.userActions?.create({ completeAutomatically: false });\n     *     // this would normally create an user action that would finish this manual user action\n     *     await router.redirect(\"home\");\n     *     userAction.complete();\n     * }\n     * ```\n     *\n     * @experimental\n     * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.\n     */\n    setAutomaticDetection(this: void, automaticDetection: boolean): void;\n\n    /**\n     * The current user action, or `undefined` if no user action is in progress.\n     *\n     * @experimental\n     * @example\n     * ```typescript\n     * async function postMessageChannel(message, channel) {\n     *   const currentUserAction = dynatrace.userActions?.current;\n     *   if (currentUserAction) {\n     *      currentUserAction.completeAutomatically = false;\n     *   }\n     *   const response = await channel.send(message);\n     *   currentUserAction?.complete();\n     *   return response;\n     * }\n     * ```\n     */\n    current: UserActionTracker | undefined;\n}\n"]}

package/dist/types/index-typedoc.d.ts

@@ -9,6 +9,7 @@ export * from "./rum-events/event-context/event-context.js";
 export * from "./rum-events/rum-event.js";
 export * from "./rum-events/event-updates.js";
 export * from "./rum-events/json-event.js";
+export * from "./rum-events/open-fields.js";
 export * from "./rum-events/rum-biz-event.js";
 export * from "./rum-events/rum-event-keys.js";
 export * from "./rum-events/schema-versions.js";

package/dist/types/index-typedoc.js

@@ -9,6 +9,7 @@ export * from "./rum-events/event-context/event-context.js";
 export * from "./rum-events/rum-event.js";
 export * from "./rum-events/event-updates.js";
 export * from "./rum-events/json-event.js";
+export * from "./rum-events/open-fields.js";
 export * from "./rum-events/rum-biz-event.js";
 export * from "./rum-events/rum-event-keys.js";
 export * from "./rum-events/schema-versions.js";
@@ -33,4 +34,4 @@ export * from "./rum-events/shared-namespaces-and-fields/page-source-fields.js";
 export * from "./rum-events/shared-namespaces-and-fields/view-source-fields.js";
 export * from "./rum-events/shared-namespaces-and-fields/general-rum-error-fields.js";
 export * from "./rum-events/shared-namespaces-and-fields/general-rum-event-fields.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/rum-events/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./open-fields.js";
 export * from "./rum-event-keys.js";
 export * from "./json-event.js";
 export * from "./rum-user-action-event.js";

package/dist/types/rum-events/index.js

@@ -1,3 +1,4 @@
+export * from "./open-fields.js";
 export * from "./rum-event-keys.js";
 export * from "./json-event.js";
 export * from "./rum-user-action-event.js";
@@ -18,4 +19,4 @@ export * from "./schema-versions.js";
 export * from "./event-updates.js";
 export * from "./event-context/index.js";
 export * from "./shared-namespaces-and-fields/index.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/rum-events/json-event.d.ts

@@ -48,12 +48,6 @@ type WritableFields = Pick<GeneralRumEventFields, RumEventKeys.DURATION | RumEve
  * @ignore
  */
 export type ApiCreatedAllowedGenerationFields = Partial<WritableFields>;
-/**
- * Event fields that area allowed to be modified using {@link dynatrace.addEventModifier}.
- *
- * @category API
- */
-export type AllowedModificationFields = `event_properties.${string | number}` | `md.${string | number}` | `session_properties.${string | number}` | RumEventKeys.CSP$STACK_TRACE | RumEventKeys.EXCEPTION$STACK_TRACE | RumEventKeys.PAGE$DETECTED_NAME | RumEventKeys.PAGE$URL$FULL | RumEventKeys.VIEW$DETECTED_NAME | RumEventKeys.VIEW$URL$FULL | RumEventKeys.URL$FULL | RumEventKeys.DRAG_ELEMENT$DETECTED_NAME | RumEventKeys.FORM_ELEMENT$DETECTED_NAME | RumEventKeys.LABEL_ELEMENT$DETECTED_NAME | RumEventKeys.UI_ELEMENT$DETECTED_NAME | RumEventKeys.VIEW$SOURCE$DETECTED_NAME;
 /**
  * @inline
  * @ignore

package/dist/types/rum-events/json-event.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/rum-events/open-fields.d.ts

@@ -0,0 +1,74 @@
+import { RumEventKeys } from "./rum-event-keys.js";
+/**
+ * Validates custom field key names.
+ *
+ * Pattern: `/^[\dA-Za-z]+(?:\.[A-Za-z][\dA-Za-z]*|_[\dA-Za-z]+)*$/`
+ *
+ * Rules: alphanumeric characters (a-z, A-Z, 0-9), underscores (_) and dots (.).
+ * Each dot must be followed by an alphabetic character.
+ * Each underscore must be followed by an alphanumeric character.
+ *
+ * @example valid:   `"my_key"`, `"event.type"`, `"my.custom2_key"`
+ * @example invalid: `"my-key"`, `"my..key"`, `"_key"`, `".key"`
+ *
+ * @category API
+ */
+export declare const VALID_KEY_REGEX: RegExp;
+/**
+ * Consolidated enum containing all RUM event field namespace keys.
+ *
+ * @inline
+ * @category API
+ */
+export declare const enum RumEventPropertyNamespaces {
+    EVENT_PROPERTIES = "event_properties",
+    SESSION_PROPERTIES = "session_properties"
+}
+/**
+ * Explicit event field keys that can be added via generation API {@link dynatrace.sendEvent} or {@link dynatrace.sendSessionPropertyEvent}
+ *
+ * @see {@link AllowedAddedFields}
+ * @inline
+ * @category API
+ */
+export declare const ADDABLE_FIELD_KEYS: readonly [RumEventKeys.DURATION];
+/**
+ * Explicit event field keys that can be overridden via {@link dynatrace.addEventModifier}.
+ *
+ * @see {@link AllowedModificationFields}
+ * @inline
+ * @category API
+ */
+export declare const OVERRIDABLE_FIELD_KEYS: readonly [RumEventKeys.URL$FULL, RumEventKeys.VIEW$URL$FULL, RumEventKeys.VIEW$DETECTED_NAME, RumEventKeys.VIEW$SOURCE$DETECTED_NAME, RumEventKeys.PAGE$URL$FULL, RumEventKeys.PAGE$DETECTED_NAME, RumEventKeys.CSP$STACK_TRACE, RumEventKeys.EXCEPTION$STACK_TRACE, RumEventKeys.UI_ELEMENT$DETECTED_NAME, RumEventKeys.FORM_ELEMENT$DETECTED_NAME, RumEventKeys.LABEL_ELEMENT$DETECTED_NAME, RumEventKeys.DRAG_ELEMENT$DETECTED_NAME];
+/**
+ * Explicit event namespace keys that have fields that can be added via {@link dynatrace.sendEvent} or {@link dynatrace.sendSessionPropertyEvent} with caveats:
+ * - {@link RumEventPropertyNamespaces.EVENT_PROPERTIES} can always be added unless created with {@link dynatrace.sendSessionPropertyEvent}
+ * - {@link RumEventPropertyNamespaces.SESSION_PROPERTIES} can only be added when created with {@link dynatrace.sendSessionPropertyEvent}
+ *
+ * @see {@link AllowedAddedFields}
+ * @inline
+ * @category API
+ */
+export declare const ADDABLE_NAMESPACE_KEYS: readonly [RumEventPropertyNamespaces.SESSION_PROPERTIES, RumEventPropertyNamespaces.EVENT_PROPERTIES];
+/**
+ * Explicit event namespace keys that have fields that can be overridden via {@link dynatrace.addEventModifier} with caveats:
+ * - {@link RumEventPropertyNamespaces.EVENT_PROPERTIES} can always be modified unless created with {@link dynatrace.sendSessionPropertyEvent}
+ * - {@link RumEventPropertyNamespaces.SESSION_PROPERTIES} can only be modified when created with {@link dynatrace.sendSessionPropertyEvent}
+ *
+ * @see {@link AllowedModificationFields}
+ * @inline
+ * @category API
+ */
+export declare const OVERRIDABLE_NAMESPACE_KEYS: readonly [RumEventPropertyNamespaces.SESSION_PROPERTIES, RumEventPropertyNamespaces.EVENT_PROPERTIES];
+/**
+ * Event fields that are allowed to be added using {@link dynatrace.sendEvent} or {@link dynatrace.sendSessionPropertyEvent}.
+ *
+ * @category API
+ */
+export type AllowedAddedFields = typeof ADDABLE_FIELD_KEYS[number] | typeof ADDABLE_NAMESPACE_KEYS[number];
+/**
+ * Event fields that are allowed to be modified using {@link dynatrace.addEventModifier}.
+ *
+ * @category API
+ */
+export type AllowedModificationFields = typeof OVERRIDABLE_FIELD_KEYS[number] | typeof OVERRIDABLE_NAMESPACE_KEYS[number];