@dynatrace/rum-javascript-sdk 1.333.12 → 1.335.1

package/dist/testing/types/dynatrace-testing-fixtures.d.ts

@@ -0,0 +1,24 @@
+import type { DynatraceConfig } from "./dynatrace-config.js";
+import type { DynatraceTesting } from "./dynatrace-testing.js";
+export interface DynatraceTestingFixture {
+    /**
+     * The testing API providing expect methods.
+     */
+    dynatraceTesting: DynatraceTesting;
+    /**
+     * Configuration to enable Dynatrace testing with a given environment.
+     */
+    dynatraceConfig: DynatraceConfig;
+}
+/**
+ * Worker-scoped fixtures for caching RUM JavaScript across tests in the same worker.
+ * This improves performance by avoiding redundant network requests.
+ */
+export interface DynatraceTestingWorkerFixture {
+    /**
+     * Cache for RUM JavaScript snippets, scoped to the worker.
+     *
+     * @internal
+     */
+    rumJavaScriptCache: Map<string, string>;
+}

package/dist/testing/types/dynatrace-testing-fixtures.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYXRyYWNlLXRlc3RpbmctZml4dHVyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvdGVzdGluZy90eXBlcy9keW5hdHJhY2UtdGVzdGluZy1maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEeW5hdHJhY2VDb25maWcgfSBmcm9tIFwiLi9keW5hdHJhY2UtY29uZmlnLmpzXCI7XG5pbXBvcnQgdHlwZSB7IER5bmF0cmFjZVRlc3RpbmcgfSBmcm9tIFwiLi9keW5hdHJhY2UtdGVzdGluZy5qc1wiO1xuXG5leHBvcnQgaW50ZXJmYWNlIER5bmF0cmFjZVRlc3RpbmdGaXh0dXJlIHtcbiAgICAvKipcbiAgICAgKiBUaGUgdGVzdGluZyBBUEkgcHJvdmlkaW5nIGV4cGVjdCBtZXRob2RzLlxuICAgICAqL1xuICAgIGR5bmF0cmFjZVRlc3Rpbmc6IER5bmF0cmFjZVRlc3Rpbmc7XG5cbiAgICAvKipcbiAgICAgKiBDb25maWd1cmF0aW9uIHRvIGVuYWJsZSBEeW5hdHJhY2UgdGVzdGluZyB3aXRoIGEgZ2l2ZW4gZW52aXJvbm1lbnQuXG4gICAgICovXG4gICAgZHluYXRyYWNlQ29uZmlnOiBEeW5hdHJhY2VDb25maWc7XG59XG5cbi8qKlxuICogV29ya2VyLXNjb3BlZCBmaXh0dXJlcyBmb3IgY2FjaGluZyBSVU0gSmF2YVNjcmlwdCBhY3Jvc3MgdGVzdHMgaW4gdGhlIHNhbWUgd29ya2VyLlxuICogVGhpcyBpbXByb3ZlcyBwZXJmb3JtYW5jZSBieSBhdm9pZGluZyByZWR1bmRhbnQgbmV0d29yayByZXF1ZXN0cy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEeW5hdHJhY2VUZXN0aW5nV29ya2VyRml4dHVyZSB7XG4gICAgLyoqXG4gICAgICogQ2FjaGUgZm9yIFJVTSBKYXZhU2NyaXB0IHNuaXBwZXRzLCBzY29wZWQgdG8gdGhlIHdvcmtlci5cbiAgICAgKlxuICAgICAqIEBpbnRlcm5hbFxuICAgICAqL1xuICAgIHJ1bUphdmFTY3JpcHRDYWNoZTogTWFwPHN0cmluZywgc3RyaW5nPjtcbn1cbiJdfQ==

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

@@ -0,0 +1,66 @@
+import type { SnapshotOptions } from "../snapshot.js";
+export interface DynatraceTesting {
+    /**
+     * Waits for a specified number of beacon requests or until a timeout occurs.
+     *
+     * @param options Configuration options for waiting for beacons
+     * @returns       A promise that resolves with an array of beacon requests
+     */
+    waitForBeacons(options?: WaitForBeaconsOptions): Promise<BeaconRequest[]>;
+    /**
+     * Verifies that a specific event has been sent, optionally within a timeout period.
+     *
+     * @param event   The event to check, represented as a key-value pair object. This uses Playwrights expect(event).toMatchObject.
+     * @param options Configuration options for the verification
+     * @returns       A promise that resolves when the event is confirmed to have been sent
+     */
+    expectToHaveSentEvent(event: Record<string, unknown>, options?: ExpectOptions): Promise<void>;
+    /**
+     * Verifies that a specific event has been sent a specified number of times, optionally within a timeout period.
+     *
+     * @param event   The event to check, represented as a key-value pair object. This uses Playwrights expect(event).toMatchObject.
+     * @param times   The exact number of times the event is expected to have been sent
+     * @param options Configuration options for the verification
+     * @returns       A promise that resolves when the event is confirmed to have been sent the specified number of times
+     */
+    expectToHaveSentEventTimes(event: Record<string, unknown>, times: number, options?: ExpectOptions): Promise<void>;
+    /**
+     * Clears all events and beacons, allowing for subsequent expectations to ignore events that have been sent
+     * in the past. Example:
+     * ```
+     * sendFooEvent();
+     * await dynatraceTesting.expectToHaveSentEventTimes({ foo: "bar" }, 1);
+     * dynatraceTesting.clearEvents();
+     * await dynatraceTesting.expectToHaveSentEventTimes({ foo: "bar" }, 1);
+     * ```
+     */
+    clearEvents(): void;
+    /**
+     * Compares captured events against a stored snapshot file.
+     * On first run, creates the snapshot. On subsequent runs, compares and fails if different.
+     * Volatile fields (timestamps, IDs, etc.) are masked by default to prevent flaky tests.
+     *
+     * @param options Configuration for snapshot comparison
+     */
+    toMatchEventSnapshot(options?: SnapshotOptions): Promise<void>;
+}
+export interface WaitForBeaconsOptions {
+    /**
+     * The minimum number of beacon requests to wait for
+     */
+    minCount?: number;
+    /**
+     * The maximum time to wait for beacon requests, in milliseconds - Default: 5_000
+     */
+    timeout?: number;
+}
+export interface ExpectOptions {
+    /**
+     * The maximum time to wait for the event to be sent, in milliseconds - Default: 5_000
+     */
+    timeout?: number;
+}
+export interface BeaconRequest {
+    url: string;
+    body: Record<string, unknown>;
+}

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

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

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,89 @@ 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.
+     * Use {@link UserInteractionSpecialKey} enum values for modifier and special keys (e.g. `ctrl`, `enter`).
+     * Regular (non-special) keys are plain strings (e.g. `"S"`, `"A"`, `"1"`).
+     */
+    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.
+     *
+     * Use {@link UserInteractionSpecialKey} enum values for modifier and special keys
+     * (ctrl, cmd, shift, alt, esc, enter, tab, space). Regular keys are plain strings (e.g. `"S"`, `"A"`).
+     *
+     * @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
  */
@@ -108,7 +192,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.
@@ -226,6 +310,12 @@ export declare namespace dynatrace {
      *               must be followed by an alphabetic character or number.
      */
     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.
      *

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":"AAyHA;;GAEG;AACH,MAAM,KAAW,SAAS,CA+NzB;AA/ND,WAAiB,SAAS;AA+N1B,CAAC,EA/NgB,SAAS,KAAT,SAAS,QA+NzB","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     * Use {@link UserInteractionSpecialKey} enum values for modifier and special keys (e.g. `ctrl`, `enter`).\n     * Regular (non-special) keys are plain strings (e.g. `\"S\"`, `\"A\"`, `\"1\"`).\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     * Use {@link UserInteractionSpecialKey} enum values for modifier and special keys\n     * (ctrl, cmd, shift, alt, esc, enter, tab, space). Regular keys are plain strings (e.g. `\"S\"`, `\"A\"`).\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 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 {@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     * 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 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({ 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"]}

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

@@ -53,7 +53,7 @@ export type ApiCreatedAllowedGenerationFields = Partial<WritableFields>;
  *
  * @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;
+export type AllowedModificationFields = `event_properties.${string}` | `md.${string | number}` | `session_properties.${string}` | 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/rum-internal-selfmonitoring-event.d.ts

@@ -74,6 +74,10 @@ export declare const enum InternalSelfmonitoringEventCodes {
      * @group General Information
      */
     EVENT_UPDATES_ADDED = 2009,
+    /**
+     * @group General Information
+     */
+    CONFIG_OUTSIDE_OF_BOUNDS = 2010,
     /**
      * @group Web specific errors
      */

package/dist/types/rum-events/rum-internal-selfmonitoring-event.js

@@ -64,6 +64,10 @@ export var InternalSelfmonitoringEventCodes;
      * @group General Information
      */
     InternalSelfmonitoringEventCodes[InternalSelfmonitoringEventCodes["EVENT_UPDATES_ADDED"] = 2009] = "EVENT_UPDATES_ADDED";
+    /**
+     * @group General Information
+     */
+    InternalSelfmonitoringEventCodes[InternalSelfmonitoringEventCodes["CONFIG_OUTSIDE_OF_BOUNDS"] = 2010] = "CONFIG_OUTSIDE_OF_BOUNDS";
     /**
      * @group Web specific errors
      */
@@ -120,4 +124,4 @@ export var InjectionAttributeModifiers;
     InjectionAttributeModifiers["INTEGRITY"] = "integrity";
     InjectionAttributeModifiers["NONE"] = "";
 })(InjectionAttributeModifiers || (InjectionAttributeModifiers = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/rum-events/rum-user-interaction-event.d.ts

@@ -103,6 +103,8 @@ export interface DragElementEventFields {
     [RumEventKeys.DRAG_ELEMENT$ANCESTOR$CSS_CLASS]?: string[];
 }
 /**
+ * Supported user interaction types for RUM event reporting.
+ *
  * @category User Interactions
  */
 export declare const enum UserInteraction {
@@ -118,6 +120,21 @@ export declare const enum UserInteraction {
     DROP = "drop",
     ZOOM = "zoom"
 }
+/**
+ * Special key values that can be used in key press interactions.
+ *
+ * @category User Interactions
+ */
+export declare const enum UserInteractionSpecialKey {
+    CTRL = "ctrl",
+    CMD = "cmd",
+    SHIFT = "shift",
+    ALT = "alt",
+    ESC = "esc",
+    ENTER = "enter",
+    TAB = "tab",
+    SPACE = "space"
+}
 /**
  * Drag action fields.
  *

package/dist/types/rum-events/rum-user-interaction-event.js

@@ -12,6 +12,8 @@ export var ElementTypes;
     ElementTypes["DRAG_ELEMENT"] = "drag_element";
 })(ElementTypes || (ElementTypes = {}));
 /**
+ * Supported user interaction types for RUM event reporting.
+ *
  * @category User Interactions
  */
 export var UserInteraction;
@@ -28,6 +30,22 @@ export var UserInteraction;
     UserInteraction["DROP"] = "drop";
     UserInteraction["ZOOM"] = "zoom";
 })(UserInteraction || (UserInteraction = {}));
+/**
+ * Special key values that can be used in key press interactions.
+ *
+ * @category User Interactions
+ */
+export var UserInteractionSpecialKey;
+(function (UserInteractionSpecialKey) {
+    UserInteractionSpecialKey["CTRL"] = "ctrl";
+    UserInteractionSpecialKey["CMD"] = "cmd";
+    UserInteractionSpecialKey["SHIFT"] = "shift";
+    UserInteractionSpecialKey["ALT"] = "alt";
+    UserInteractionSpecialKey["ESC"] = "esc";
+    UserInteractionSpecialKey["ENTER"] = "enter";
+    UserInteractionSpecialKey["TAB"] = "tab";
+    UserInteractionSpecialKey["SPACE"] = "space";
+})(UserInteractionSpecialKey || (UserInteractionSpecialKey = {}));
 /**
  * @category User Interactions
  */
@@ -42,4 +60,4 @@ export var DragResolveResolution;
      */
     DragResolveResolution["INVALID_DROP"] = "invalid_drop";
 })(DragResolveResolution || (DragResolveResolution = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rum-user-interaction-event.js","sourceRoot":"","sources":["../../../source/types/rum-events/rum-user-interaction-event.ts"],"names":[],"mappings":"AAAA,mHAAmH;AACnH,yFAAyF;AA4GzF;;;GAGG;AACH,MAAM,CAAN,IAAkB,YAKjB;AALD,WAAkB,YAAY;IAC1B,yCAAyB,CAAA;IACzB,+CAA+B,CAAA;IAC/B,6CAA6B,CAAA;IAC7B,6CAA6B,CAAA;AACjC,CAAC,EALiB,YAAY,KAAZ,YAAY,QAK7B;AA4FD;;GAEG;AACH,MAAM,CAAN,IAAkB,eAYjB;AAZD,WAAkB,eAAe;IAC7B,gCAAa,CAAA;IACb,oCAAiB,CAAA;IACjB,kCAAe,CAAA;IACf,kCAAe,CAAA;IACf,0CAAuB,CAAA;IACvB,4CAAyB,CAAA;IACzB,oCAAiB,CAAA;IACjB,gCAAa,CAAA;IACb,oCAAiB,CAAA;IACjB,gCAAa,CAAA;IACb,gCAAa,CAAA;AACjB,CAAC,EAZiB,eAAe,KAAf,eAAe,QAYhC;AAUD;;GAEG;AACH,MAAM,CAAN,IAAkB,qBASjB;AATD,WAAkB,qBAAqB;IACnC;;OAEG;IACH,kDAAyB,CAAA;IACzB;;OAEG;IACH,sDAA6B,CAAA;AACjC,CAAC,EATiB,qBAAqB,KAArB,qBAAqB,QAStC","sourcesContent":["/* eslint-disable typescript-sort-keys/string-enum,@dynatrace/dem-eslint-rules/union-type -- keep things grouped */\n// https://dt-rnd.atlassian.net/wiki/spaces/DEX/pages/382304347/RUM+UserInteraction+Event\n\nimport type {\n    eventContextSymbol,\n    RUMUserInteractionDragEventContext,\n    RUMUserInteractionDropEventContext,\n    RUMUserInteractionSingleEventContext\n} from \"./event-context/event-context.js\";\nimport type { GeneralRumEventFields } from \"./shared-namespaces-and-fields/general-rum-event-fields.js\";\nimport type { RumEventKeys } from \"./rum-event-keys.js\";\nimport type { SCHEMA_VERSION } from \"./schema-versions.js\";\n\n/**\n * User interaction element fields.\n *\n * @category User Interactions\n */\nexport type RUMUserInteractionEventKeys =\n    | RumEventKeys.INTERACTION$NAME\n    | RumEventKeys.DOM_EVENT$IS_TRUSTED\n\n    // Drag Element\n    | RumEventKeys.DRAG_ELEMENT$ID\n    | RumEventKeys.DRAG_ELEMENT$DETECTED_NAME\n    | RumEventKeys.DRAG_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.DRAG_ELEMENT$TAG_NAME\n    | RumEventKeys.DRAG_ELEMENT$XPATH\n    | RumEventKeys.DRAG_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.DRAG_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.DRAG_ELEMENT$FEATURES\n    | RumEventKeys.DRAG_ELEMENT$PROPERTIES\n    | RumEventKeys.DRAG_ELEMENT$COMPONENTS\n    | RumEventKeys.DRAG_ELEMENT$CSS_CLASS\n    | RumEventKeys.DRAG_ELEMENT$SRC$FULL\n    | RumEventKeys.DRAG_ELEMENT$ALT\n    | RumEventKeys.DRAG_ELEMENT$HREF$FULL\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$ID\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$DETECTED_NAME\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$NAME_ORIGIN\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$CUSTOM_NAME\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$TAG_NAME\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$CSS_CLASS\n\n    // Form Element\n    | RumEventKeys.FORM_ELEMENT$ID\n    | RumEventKeys.FORM_ELEMENT$DETECTED_NAME\n    | RumEventKeys.FORM_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.FORM_ELEMENT$XPATH\n    | RumEventKeys.FORM_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.FORM_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.FORM_ELEMENT$FEATURES\n    | RumEventKeys.FORM_ELEMENT$PROPERTIES\n    | RumEventKeys.FORM_ELEMENT$COMPONENTS\n    | RumEventKeys.FORM_ELEMENT$CSS_CLASS\n\n    // Label Element\n    | RumEventKeys.LABEL_ELEMENT$ID\n    | RumEventKeys.LABEL_ELEMENT$DETECTED_NAME\n    | RumEventKeys.LABEL_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.LABEL_ELEMENT$XPATH\n    | RumEventKeys.LABEL_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.LABEL_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.LABEL_ELEMENT$FEATURES\n    | RumEventKeys.LABEL_ELEMENT$PROPERTIES\n    | RumEventKeys.LABEL_ELEMENT$COMPONENTS\n    | RumEventKeys.LABEL_ELEMENT$CSS_CLASS\n\n    // UI Element\n    | RumEventKeys.UI_ELEMENT$ID\n    | RumEventKeys.UI_ELEMENT$DETECTED_NAME\n    | RumEventKeys.UI_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.UI_ELEMENT$TAG_NAME\n    | RumEventKeys.UI_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.UI_ELEMENT$XPATH\n    | RumEventKeys.UI_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.UI_ELEMENT$FEATURES\n    | RumEventKeys.UI_ELEMENT$PROPERTIES\n    | RumEventKeys.UI_ELEMENT$COMPONENTS\n    | RumEventKeys.UI_ELEMENT$CSS_CLASS\n    | RumEventKeys.UI_ELEMENT$SRC$FULL\n    | RumEventKeys.UI_ELEMENT$ALT\n    | RumEventKeys.UI_ELEMENT$HREF$FULL\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$ID\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$DETECTED_NAME\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$NAME_ORIGIN\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$CUSTOM_NAME\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$TAG_NAME\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$CSS_CLASS\n    // Only for change event\n    | RumEventKeys.UI_ELEMENT$VALUE$CONTENT\n    | RumEventKeys.UI_ELEMENT$VALUE$LENGTH\n    | RumEventKeys.UI_ELEMENT$VALUE$SELECTION_COUNT\n    | RumEventKeys.UI_ELEMENT$VALUE$TYPE\n    | RumEventKeys.UI_ELEMENT$VALUE$VALIDITY\n\n    // Scroll event specific\n    | RumEventKeys.SCROLL_TARGET$XPATH\n\n    // Zoom event specific\n    | RumEventKeys.ZOOM$LEVEL\n\n    // Mouse over event specific\n    | RumEventKeys.DURATION;\n\n/**\n * @internal\n * @ignore\n */\nexport const enum ElementTypes {\n    UI_ELEMENT = \"ui_element\",\n    LABEL_ELEMENT = \"label_element\",\n    FORM_ELEMENT = \"form_element\",\n    DRAG_ELEMENT = \"drag_element\"\n}\n\n/**\n * @category User Interactions\n */\nexport interface UIElementEventFields {\n    [RumEventKeys.UI_ELEMENT$ID]?: string;\n    [RumEventKeys.UI_ELEMENT$DETECTED_NAME]: string | null;\n    [RumEventKeys.UI_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.UI_ELEMENT$TAG_NAME]: string;\n    [RumEventKeys.UI_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.UI_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.UI_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.UI_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.UI_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.UI_ELEMENT$CSS_CLASS]?: string[];\n    [RumEventKeys.UI_ELEMENT$SRC$FULL]?: string;\n    [RumEventKeys.UI_ELEMENT$ALT]?: string;\n    [RumEventKeys.UI_ELEMENT$HREF$FULL]?: string;\n    // Ancestor fields\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$ID]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$DETECTED_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$NAME_ORIGIN]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$CUSTOM_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$TAG_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH]?: string[];\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface FormElementEventFields {\n    [RumEventKeys.FORM_ELEMENT$ID]?: string;\n    [RumEventKeys.FORM_ELEMENT$DETECTED_NAME]: string;\n    [RumEventKeys.FORM_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.FORM_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.FORM_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.FORM_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.FORM_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.FORM_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.FORM_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.FORM_ELEMENT$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface LabelElementEventFields {\n    [RumEventKeys.LABEL_ELEMENT$ID]?: string;\n    [RumEventKeys.LABEL_ELEMENT$DETECTED_NAME]: string;\n    [RumEventKeys.LABEL_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.LABEL_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.LABEL_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface DragElementEventFields {\n    [RumEventKeys.DRAG_ELEMENT$ID]?: string;\n    [RumEventKeys.DRAG_ELEMENT$DETECTED_NAME]: string;\n    [RumEventKeys.DRAG_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.DRAG_ELEMENT$TAG_NAME]: string;\n    [RumEventKeys.DRAG_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$CSS_CLASS]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$SRC$FULL]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ALT]?: string;\n    [RumEventKeys.DRAG_ELEMENT$HREF$FULL]?: string;\n    // Ancestor fields\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$ID]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$DETECTED_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$NAME_ORIGIN]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$CUSTOM_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$TAG_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport const enum UserInteraction {\n    BLUR = \"blur\",\n    CHANGE = \"change\",\n    CLICK = \"click\",\n    FOCUS = \"focus\",\n    KEY_PRESS = \"key_press\",\n    MOUSE_OVER = \"mouse_over\",\n    SCROLL = \"scroll\",\n    DRAG = \"drag\",\n    RESIZE = \"resize\",\n    DROP = \"drop\",\n    ZOOM = \"zoom\"\n}\n\n/**\n * Drag action fields.\n *\n * @internal\n */\nexport type DragActionKeys =\n    | RumEventKeys.DRAG_RESOLVE;\n\n/**\n * @category User Interactions\n */\nexport const enum DragResolveResolution {\n    /**\n     * The element was dropped on a valid drop zone.\n     */\n    VALID_DROP = \"valid_drop\",\n    /**\n     * The element was not dropped on a valid drop zone.\n     */\n    INVALID_DROP = \"invalid_drop\"\n}\n\n/**\n * Click action fields.\n *\n * @internal\n */\nexport type ClickActionKeys =\n    | RumEventKeys.MOUSE_BUTTON;\n\n/**\n * Keypress action fields.\n *\n * @internal\n */\nexport type KeyPressActionKeys =\n    | RumEventKeys.KEYS\n    | RumEventKeys.CODE\n    | RumEventKeys.IS_COMPOSING;\n\n/**\n * Position information fields.\n *\n * @internal\n */\nexport type PositionInformationKeys =\n    | RumEventKeys.POSITIONS;\n\n/**\n * @ignore\n * @inline\n */\nexport interface PositionInformation {\n    x: number;\n    y: number;\n    start_time?: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMUserInteractionBase extends GeneralRumEventFields {\n    [RumEventKeys.DT$RUM$SCHEMA_VERSION]: typeof SCHEMA_VERSION;\n    [RumEventKeys.CHARACTERISTICS$HAS_USER_INTERACTION]: true;\n    [RumEventKeys.DOM_EVENT$IS_TRUSTED]: boolean;\n\n    [eventContextSymbol]: RUMUserInteractionSingleEventContext;\n}\n\n/**\n * @category User Interactions\n */\nexport interface PointerPositionInformation {\n    [RumEventKeys.POSITIONS]: PositionInformation[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMClickActionEvent extends RUMUserInteractionBase, PointerPositionInformation, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.CLICK;\n    [RumEventKeys.MOUSE_BUTTON]: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMMouseOverActionEvent extends RUMUserInteractionBase, PointerPositionInformation, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.MOUSE_OVER;\n    [RumEventKeys.DURATION]: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMBlurActionEvent extends RUMUserInteractionBase, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.BLUR;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMFocusActionEvent extends RUMUserInteractionBase, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.FOCUS;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMKeyPressActionEvent extends RUMUserInteractionBase, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.KEY_PRESS;\n\n    [RumEventKeys.KEYS]: [first: string, ...rest: string[]];\n    /**\n     *  @internal\n     *\n     *  Not part of the spec, just for debugging purposes\n     */\n    [RumEventKeys.CODE]: string;\n    /**\n     *  @internal\n     *\n     *  Not part of the spec, just for debugging purposes\n     */\n    [RumEventKeys.IS_COMPOSING]: boolean;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMScrollActionEvent extends RUMUserInteractionBase, UIElementEventFields, PointerPositionInformation {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.SCROLL;\n\n    [RumEventKeys.SCROLL_TARGET$XPATH]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMChangeActionEvent extends\n    RUMUserInteractionBase,\n    UIElementEventFields,\n    Partial<LabelElementEventFields>,\n    Partial<FormElementEventFields> {\n\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.CHANGE;\n\n    [RumEventKeys.UI_ELEMENT$VALUE$CONTENT]?: string;\n    [RumEventKeys.UI_ELEMENT$VALUE$TYPE]: string;\n    [RumEventKeys.UI_ELEMENT$VALUE$LENGTH]?: number;\n    [RumEventKeys.UI_ELEMENT$VALUE$SELECTION_COUNT]?: number;\n    [RumEventKeys.UI_ELEMENT$VALUE$VALIDITY]: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMDragActionEvent extends Omit<RUMUserInteractionBase, typeof eventContextSymbol>, UIElementEventFields, PointerPositionInformation {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.DRAG;\n    [RumEventKeys.DRAG_RESOLVE]: DragResolveResolution;\n\n    [eventContextSymbol]: RUMUserInteractionDragEventContext;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMResizeActionEvent extends RUMUserInteractionBase {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.RESIZE;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMZoomActionEvent extends RUMUserInteractionBase {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.ZOOM;\n\n    [RumEventKeys.ZOOM$LEVEL]: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMDropActionEvent extends Omit<RUMUserInteractionBase, typeof eventContextSymbol>, UIElementEventFields, Partial<DragElementEventFields>, PointerPositionInformation {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.DROP;\n\n    [eventContextSymbol]: RUMUserInteractionDropEventContext;\n}\n\n/**\n * @category User Interactions\n */\nexport type RUMUserInteractionEvent = RUMBlurActionEvent\n    | RUMChangeActionEvent\n    | RUMClickActionEvent\n    | RUMDragActionEvent\n    | RUMDropActionEvent\n    | RUMFocusActionEvent\n    | RUMKeyPressActionEvent\n    | RUMMouseOverActionEvent\n    | RUMResizeActionEvent\n    | RUMScrollActionEvent\n    | RUMZoomActionEvent;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rum-user-interaction-event.js","sourceRoot":"","sources":["../../../source/types/rum-events/rum-user-interaction-event.ts"],"names":[],"mappings":"AAAA,mHAAmH;AACnH,yFAAyF;AA4GzF;;;GAGG;AACH,MAAM,CAAN,IAAkB,YAKjB;AALD,WAAkB,YAAY;IAC1B,yCAAyB,CAAA;IACzB,+CAA+B,CAAA;IAC/B,6CAA6B,CAAA;IAC7B,6CAA6B,CAAA;AACjC,CAAC,EALiB,YAAY,KAAZ,YAAY,QAK7B;AA4FD;;;;GAIG;AACH,MAAM,CAAN,IAAkB,eAYjB;AAZD,WAAkB,eAAe;IAC7B,gCAAa,CAAA;IACb,oCAAiB,CAAA;IACjB,kCAAe,CAAA;IACf,kCAAe,CAAA;IACf,0CAAuB,CAAA;IACvB,4CAAyB,CAAA;IACzB,oCAAiB,CAAA;IACjB,gCAAa,CAAA;IACb,oCAAiB,CAAA;IACjB,gCAAa,CAAA;IACb,gCAAa,CAAA;AACjB,CAAC,EAZiB,eAAe,KAAf,eAAe,QAYhC;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAkB,yBASjB;AATD,WAAkB,yBAAyB;IACvC,0CAAa,CAAA;IACb,wCAAW,CAAA;IACX,4CAAe,CAAA;IACf,wCAAW,CAAA;IACX,wCAAW,CAAA;IACX,4CAAe,CAAA;IACf,wCAAW,CAAA;IACX,4CAAe,CAAA;AACnB,CAAC,EATiB,yBAAyB,KAAzB,yBAAyB,QAS1C;AAUD;;GAEG;AACH,MAAM,CAAN,IAAkB,qBASjB;AATD,WAAkB,qBAAqB;IACnC;;OAEG;IACH,kDAAyB,CAAA;IACzB;;OAEG;IACH,sDAA6B,CAAA;AACjC,CAAC,EATiB,qBAAqB,KAArB,qBAAqB,QAStC","sourcesContent":["/* eslint-disable typescript-sort-keys/string-enum,@dynatrace/dem-eslint-rules/union-type -- keep things grouped */\n// https://dt-rnd.atlassian.net/wiki/spaces/DEX/pages/382304347/RUM+UserInteraction+Event\n\nimport type {\n    eventContextSymbol,\n    RUMUserInteractionDragEventContext,\n    RUMUserInteractionDropEventContext,\n    RUMUserInteractionSingleEventContext\n} from \"./event-context/event-context.js\";\nimport type { GeneralRumEventFields } from \"./shared-namespaces-and-fields/general-rum-event-fields.js\";\nimport type { RumEventKeys } from \"./rum-event-keys.js\";\nimport type { SCHEMA_VERSION } from \"./schema-versions.js\";\n\n/**\n * User interaction element fields.\n *\n * @category User Interactions\n */\nexport type RUMUserInteractionEventKeys =\n    | RumEventKeys.INTERACTION$NAME\n    | RumEventKeys.DOM_EVENT$IS_TRUSTED\n\n    // Drag Element\n    | RumEventKeys.DRAG_ELEMENT$ID\n    | RumEventKeys.DRAG_ELEMENT$DETECTED_NAME\n    | RumEventKeys.DRAG_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.DRAG_ELEMENT$TAG_NAME\n    | RumEventKeys.DRAG_ELEMENT$XPATH\n    | RumEventKeys.DRAG_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.DRAG_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.DRAG_ELEMENT$FEATURES\n    | RumEventKeys.DRAG_ELEMENT$PROPERTIES\n    | RumEventKeys.DRAG_ELEMENT$COMPONENTS\n    | RumEventKeys.DRAG_ELEMENT$CSS_CLASS\n    | RumEventKeys.DRAG_ELEMENT$SRC$FULL\n    | RumEventKeys.DRAG_ELEMENT$ALT\n    | RumEventKeys.DRAG_ELEMENT$HREF$FULL\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$ID\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$DETECTED_NAME\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$NAME_ORIGIN\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$CUSTOM_NAME\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$TAG_NAME\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM\n    | RumEventKeys.DRAG_ELEMENT$ANCESTOR$CSS_CLASS\n\n    // Form Element\n    | RumEventKeys.FORM_ELEMENT$ID\n    | RumEventKeys.FORM_ELEMENT$DETECTED_NAME\n    | RumEventKeys.FORM_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.FORM_ELEMENT$XPATH\n    | RumEventKeys.FORM_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.FORM_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.FORM_ELEMENT$FEATURES\n    | RumEventKeys.FORM_ELEMENT$PROPERTIES\n    | RumEventKeys.FORM_ELEMENT$COMPONENTS\n    | RumEventKeys.FORM_ELEMENT$CSS_CLASS\n\n    // Label Element\n    | RumEventKeys.LABEL_ELEMENT$ID\n    | RumEventKeys.LABEL_ELEMENT$DETECTED_NAME\n    | RumEventKeys.LABEL_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.LABEL_ELEMENT$XPATH\n    | RumEventKeys.LABEL_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.LABEL_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.LABEL_ELEMENT$FEATURES\n    | RumEventKeys.LABEL_ELEMENT$PROPERTIES\n    | RumEventKeys.LABEL_ELEMENT$COMPONENTS\n    | RumEventKeys.LABEL_ELEMENT$CSS_CLASS\n\n    // UI Element\n    | RumEventKeys.UI_ELEMENT$ID\n    | RumEventKeys.UI_ELEMENT$DETECTED_NAME\n    | RumEventKeys.UI_ELEMENT$NAME_ORIGIN\n    | RumEventKeys.UI_ELEMENT$TAG_NAME\n    | RumEventKeys.UI_ELEMENT$CUSTOM_NAME\n    | RumEventKeys.UI_ELEMENT$XPATH\n    | RumEventKeys.UI_ELEMENT$XPATH_SHADOW_DOM\n    | RumEventKeys.UI_ELEMENT$FEATURES\n    | RumEventKeys.UI_ELEMENT$PROPERTIES\n    | RumEventKeys.UI_ELEMENT$COMPONENTS\n    | RumEventKeys.UI_ELEMENT$CSS_CLASS\n    | RumEventKeys.UI_ELEMENT$SRC$FULL\n    | RumEventKeys.UI_ELEMENT$ALT\n    | RumEventKeys.UI_ELEMENT$HREF$FULL\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$ID\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$DETECTED_NAME\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$NAME_ORIGIN\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$CUSTOM_NAME\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$TAG_NAME\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM\n    | RumEventKeys.UI_ELEMENT$ANCESTOR$CSS_CLASS\n    // Only for change event\n    | RumEventKeys.UI_ELEMENT$VALUE$CONTENT\n    | RumEventKeys.UI_ELEMENT$VALUE$LENGTH\n    | RumEventKeys.UI_ELEMENT$VALUE$SELECTION_COUNT\n    | RumEventKeys.UI_ELEMENT$VALUE$TYPE\n    | RumEventKeys.UI_ELEMENT$VALUE$VALIDITY\n\n    // Scroll event specific\n    | RumEventKeys.SCROLL_TARGET$XPATH\n\n    // Zoom event specific\n    | RumEventKeys.ZOOM$LEVEL\n\n    // Mouse over event specific\n    | RumEventKeys.DURATION;\n\n/**\n * @internal\n * @ignore\n */\nexport const enum ElementTypes {\n    UI_ELEMENT = \"ui_element\",\n    LABEL_ELEMENT = \"label_element\",\n    FORM_ELEMENT = \"form_element\",\n    DRAG_ELEMENT = \"drag_element\"\n}\n\n/**\n * @category User Interactions\n */\nexport interface UIElementEventFields {\n    [RumEventKeys.UI_ELEMENT$ID]?: string;\n    [RumEventKeys.UI_ELEMENT$DETECTED_NAME]: string | null;\n    [RumEventKeys.UI_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.UI_ELEMENT$TAG_NAME]: string;\n    [RumEventKeys.UI_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.UI_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.UI_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.UI_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.UI_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.UI_ELEMENT$CSS_CLASS]?: string[];\n    [RumEventKeys.UI_ELEMENT$SRC$FULL]?: string;\n    [RumEventKeys.UI_ELEMENT$ALT]?: string;\n    [RumEventKeys.UI_ELEMENT$HREF$FULL]?: string;\n    // Ancestor fields\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$ID]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$DETECTED_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$NAME_ORIGIN]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$CUSTOM_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$TAG_NAME]?: string;\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH]?: string[];\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.UI_ELEMENT$ANCESTOR$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface FormElementEventFields {\n    [RumEventKeys.FORM_ELEMENT$ID]?: string;\n    [RumEventKeys.FORM_ELEMENT$DETECTED_NAME]: string;\n    [RumEventKeys.FORM_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.FORM_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.FORM_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.FORM_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.FORM_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.FORM_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.FORM_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.FORM_ELEMENT$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface LabelElementEventFields {\n    [RumEventKeys.LABEL_ELEMENT$ID]?: string;\n    [RumEventKeys.LABEL_ELEMENT$DETECTED_NAME]: string;\n    [RumEventKeys.LABEL_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.LABEL_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.LABEL_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.LABEL_ELEMENT$CSS_CLASS]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface DragElementEventFields {\n    [RumEventKeys.DRAG_ELEMENT$ID]?: string;\n    [RumEventKeys.DRAG_ELEMENT$DETECTED_NAME]: string;\n    [RumEventKeys.DRAG_ELEMENT$NAME_ORIGIN]: string;\n    [RumEventKeys.DRAG_ELEMENT$TAG_NAME]: string;\n    [RumEventKeys.DRAG_ELEMENT$CUSTOM_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$XPATH]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$FEATURES]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$PROPERTIES]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$COMPONENTS]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$CSS_CLASS]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$SRC$FULL]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ALT]?: string;\n    [RumEventKeys.DRAG_ELEMENT$HREF$FULL]?: string;\n    // Ancestor fields\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$ID]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$DETECTED_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$NAME_ORIGIN]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$CUSTOM_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$TAG_NAME]?: string;\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$XPATH_SHADOW_DOM]?: string[];\n    [RumEventKeys.DRAG_ELEMENT$ANCESTOR$CSS_CLASS]?: string[];\n}\n\n/**\n * Supported user interaction types for RUM event reporting.\n *\n * @category User Interactions\n */\nexport const enum UserInteraction {\n    BLUR = \"blur\",\n    CHANGE = \"change\",\n    CLICK = \"click\",\n    FOCUS = \"focus\",\n    KEY_PRESS = \"key_press\",\n    MOUSE_OVER = \"mouse_over\",\n    SCROLL = \"scroll\",\n    DRAG = \"drag\",\n    RESIZE = \"resize\",\n    DROP = \"drop\",\n    ZOOM = \"zoom\"\n}\n\n/**\n * Special key values that can be used in key press interactions.\n *\n * @category User Interactions\n */\nexport const enum UserInteractionSpecialKey {\n    CTRL = \"ctrl\",\n    CMD = \"cmd\",\n    SHIFT = \"shift\",\n    ALT = \"alt\",\n    ESC = \"esc\",\n    ENTER = \"enter\",\n    TAB = \"tab\",\n    SPACE = \"space\"\n}\n\n/**\n * Drag action fields.\n *\n * @internal\n */\nexport type DragActionKeys =\n    | RumEventKeys.DRAG_RESOLVE;\n\n/**\n * @category User Interactions\n */\nexport const enum DragResolveResolution {\n    /**\n     * The element was dropped on a valid drop zone.\n     */\n    VALID_DROP = \"valid_drop\",\n    /**\n     * The element was not dropped on a valid drop zone.\n     */\n    INVALID_DROP = \"invalid_drop\"\n}\n\n/**\n * Click action fields.\n *\n * @internal\n */\nexport type ClickActionKeys =\n    | RumEventKeys.MOUSE_BUTTON;\n\n/**\n * Keypress action fields.\n *\n * @internal\n */\nexport type KeyPressActionKeys =\n    | RumEventKeys.KEYS\n    | RumEventKeys.CODE\n    | RumEventKeys.IS_COMPOSING;\n\n/**\n * Position information fields.\n *\n * @internal\n */\nexport type PositionInformationKeys =\n    | RumEventKeys.POSITIONS;\n\n/**\n * @ignore\n * @inline\n */\nexport interface PositionInformation {\n    x: number;\n    y: number;\n    start_time?: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMUserInteractionBase extends GeneralRumEventFields {\n    [RumEventKeys.DT$RUM$SCHEMA_VERSION]: typeof SCHEMA_VERSION;\n    [RumEventKeys.CHARACTERISTICS$HAS_USER_INTERACTION]: true;\n    [RumEventKeys.DOM_EVENT$IS_TRUSTED]: boolean;\n\n    [eventContextSymbol]: RUMUserInteractionSingleEventContext;\n}\n\n/**\n * @category User Interactions\n */\nexport interface PointerPositionInformation {\n    [RumEventKeys.POSITIONS]: PositionInformation[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMClickActionEvent extends RUMUserInteractionBase, PointerPositionInformation, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.CLICK;\n    [RumEventKeys.MOUSE_BUTTON]: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMMouseOverActionEvent extends RUMUserInteractionBase, PointerPositionInformation, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.MOUSE_OVER;\n    [RumEventKeys.DURATION]: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMBlurActionEvent extends RUMUserInteractionBase, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.BLUR;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMFocusActionEvent extends RUMUserInteractionBase, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.FOCUS;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMKeyPressActionEvent extends RUMUserInteractionBase, UIElementEventFields {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.KEY_PRESS;\n\n    [RumEventKeys.KEYS]: [first: string, ...rest: string[]];\n    /**\n     *  @internal\n     *\n     *  Not part of the spec, just for debugging purposes\n     */\n    [RumEventKeys.CODE]: string;\n    /**\n     *  @internal\n     *\n     *  Not part of the spec, just for debugging purposes\n     */\n    [RumEventKeys.IS_COMPOSING]: boolean;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMScrollActionEvent extends RUMUserInteractionBase, UIElementEventFields, PointerPositionInformation {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.SCROLL;\n\n    [RumEventKeys.SCROLL_TARGET$XPATH]?: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMChangeActionEvent extends\n    RUMUserInteractionBase,\n    UIElementEventFields,\n    Partial<LabelElementEventFields>,\n    Partial<FormElementEventFields> {\n\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.CHANGE;\n\n    [RumEventKeys.UI_ELEMENT$VALUE$CONTENT]?: string;\n    [RumEventKeys.UI_ELEMENT$VALUE$TYPE]: string;\n    [RumEventKeys.UI_ELEMENT$VALUE$LENGTH]?: number;\n    [RumEventKeys.UI_ELEMENT$VALUE$SELECTION_COUNT]?: number;\n    [RumEventKeys.UI_ELEMENT$VALUE$VALIDITY]: string[];\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMDragActionEvent extends Omit<RUMUserInteractionBase, typeof eventContextSymbol>, UIElementEventFields, PointerPositionInformation {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.DRAG;\n    [RumEventKeys.DRAG_RESOLVE]: DragResolveResolution;\n\n    [eventContextSymbol]: RUMUserInteractionDragEventContext;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMResizeActionEvent extends RUMUserInteractionBase {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.RESIZE;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMZoomActionEvent extends RUMUserInteractionBase {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.ZOOM;\n\n    [RumEventKeys.ZOOM$LEVEL]: number;\n}\n\n/**\n * @category User Interactions\n */\nexport interface RUMDropActionEvent extends Omit<RUMUserInteractionBase, typeof eventContextSymbol>, UIElementEventFields, Partial<DragElementEventFields>, PointerPositionInformation {\n    [RumEventKeys.INTERACTION$NAME]: UserInteraction.DROP;\n\n    [eventContextSymbol]: RUMUserInteractionDropEventContext;\n}\n\n/**\n * @category User Interactions\n */\nexport type RUMUserInteractionEvent = RUMBlurActionEvent\n    | RUMChangeActionEvent\n    | RUMClickActionEvent\n    | RUMDragActionEvent\n    | RUMDropActionEvent\n    | RUMFocusActionEvent\n    | RUMKeyPressActionEvent\n    | RUMMouseOverActionEvent\n    | RUMResizeActionEvent\n    | RUMScrollActionEvent\n    | RUMZoomActionEvent;\n"]}