@dynatrace/rum-javascript-sdk 1.333.15 → 1.337.1

package/dist/api/index.d.ts

@@ -38,6 +38,22 @@ export declare function runHealthCheck(config?: HealthCheckConfig): Promise<unkn
  * @param value The name of the user. For example, use a name, userid, or your user's email address.
  */
 export declare function identifyUser(value: string): void;
+/**
+ * Safe wrapper for {@link dynatrace.userOptIn} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * Grants consent for data collection.
+ *
+ * @internal
+ */
+export declare function userOptIn(): void;
+/**
+ * Safe wrapper for {@link dynatrace.userOptOut} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * Revokes consent for data collection.
+ *
+ * @internal
+ */
+export declare function userOptOut(): void;
 /**
  * Safe wrapper for {@link dynatrace.sendSessionPropertyEvent} which reverts to a noop if RUM JavaScript is not available.
  *

package/dist/api/index.js

@@ -56,6 +56,30 @@ export function identifyUser(value) {
         dt.identifyUser(value);
     });
 }
+/**
+ * Safe wrapper for {@link dynatrace.userOptIn} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * Grants consent for data collection.
+ *
+ * @internal
+ */
+export function userOptIn() {
+    guardDynatrace((dt) => {
+        dt.userOptIn();
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.userOptOut} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * Revokes consent for data collection.
+ *
+ * @internal
+ */
+export function userOptOut() {
+    guardDynatrace((dt) => {
+        dt.userOptOut();
+    });
+}
 /**
  * Safe wrapper for {@link dynatrace.sendSessionPropertyEvent} which reverts to a noop if RUM JavaScript is not available.
  *
@@ -107,4 +131,4 @@ function guardDynatrace(fn) {
     }
     return fn(globalDt);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/api/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAC,MAAsC,EAAE,YAAsB;IACpF,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,aAAgG;IAC7H,OAAO,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QACzB,OAAO,EAAE,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,MAA0B;IACrD,OAAO,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QACzB,OAAO,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAwC;IAC7E,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAY,EAAE,MAAuC;IACpF,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,CAAC;YACzB,GAAG,CAAC,sFAAsF,CAAC,CAAC;YAC5F,OAAO;QACX,CAAC;QACD,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAkE,EAAK;IAC1F,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;IACxC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,GAAG,CAAC,4BAA4B,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;AACxB,CAAC","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    EventContext,\n    HealthCheckConfig,\n    JSONEvent,\n    Unsubscriber\n} from \"../types/index.js\";\nimport { getGlobal } from \"./global-adapter.js\";\nimport { isValidAgent } from \"./type-guards/is-valid-agent.js\";\nimport { log } from \"./logging.js\";\n\nexport { DynatraceError } from \"./dynatrace-error.js\";\n\n/**\n * Safe wrapper for {@link dynatrace.sendEvent} which reverts to a noop if RUM JavaScript is not available.\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 *                     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.\n * @param eventContext An optional context that can be used to manipulate the\n *                     result event within the modification callback.\n */\nexport function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown): void {\n    guardDynatrace((dt) => {\n        dt.sendEvent(fields, eventContext);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.addEventModifier} which reverts to a noop if RUM JavaScript is not available.\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.\n * @returns             The unsubscriber function to turn off event modification, or undefined if RUM JavaScript is not available.\n */\nexport function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null): Unsubscriber | undefined {\n    return guardDynatrace((dt) => {\n        return dt.addEventModifier(eventModifier);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.runHealthCheck} which reverts to a noop if RUM JavaScript is not available.\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, or undefined if RUM JavaScript is not available.\n */\nexport function runHealthCheck(config?: HealthCheckConfig): Promise<unknown[] | undefined> | undefined {\n    return guardDynatrace((dt) => {\n        return dt.runHealthCheck(config);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.identifyUser} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param value The name of the user. For example, use a name, userid, or your user's email address.\n */\nexport function identifyUser(value: string): void {\n    guardDynatrace((dt) => {\n        dt.identifyUser(value);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.sendSessionPropertyEvent} which reverts to a noop if RUM JavaScript is not available.\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. All keys must be prefixed with \"session_properties.*\" and must contain only\n *               lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case\n *               character. Each underscore must be followed by a lower-case character or number.\n */\nexport function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void {\n    guardDynatrace((dt) => {\n        dt.sendSessionPropertyEvent(fields);\n    });\n}\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 */\nexport function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent): void {\n    guardDynatrace((dt) => {\n        if (!dt.sendExceptionEvent) {\n            log(\"dynatrace.sendExceptionEvent is not available, the Error module might not be enabled\");\n            return;\n        }\n        dt.sendExceptionEvent(error, fields);\n    });\n}\n\n/**\n * Safe wrapper for various RUM JavaScript API functions which reverts to a noop if RUM JavaScript is not available.\n *\n * @param fn The function to be executed if RUM JavaScript is available.\n * @returns  The result of the provided function call if RUM JavaScript is available, otherwise undefined.\n */\nfunction guardDynatrace<T extends (dt: NonNullable<typeof globalThis.dynatrace>) => any>(fn: T): ReturnType<T> | undefined {\n    const globalDt = getGlobal(\"dynatrace\");\n    if (!isValidAgent(globalDt)) {\n        log(\"dynatrace is not available\");\n        return void 0;\n    }\n    return fn(globalDt);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/api/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAC,MAAsC,EAAE,YAAsB;IACpF,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,aAAgG;IAC7H,OAAO,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QACzB,OAAO,EAAE,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,MAA0B;IACrD,OAAO,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QACzB,OAAO,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS;IACrB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU;IACtB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAwC;IAC7E,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAY,EAAE,MAAuC;IACpF,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,CAAC;YACzB,GAAG,CAAC,sFAAsF,CAAC,CAAC;YAC5F,OAAO;QACX,CAAC;QACD,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAkE,EAAK;IAC1F,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;IACxC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,GAAG,CAAC,4BAA4B,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;AACxB,CAAC","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    EventContext,\n    HealthCheckConfig,\n    JSONEvent,\n    Unsubscriber\n} from \"../types/index.js\";\nimport { getGlobal } from \"./global-adapter.js\";\nimport { isValidAgent } from \"./type-guards/is-valid-agent.js\";\nimport { log } from \"./logging.js\";\n\nexport { DynatraceError } from \"./dynatrace-error.js\";\n\n/**\n * Safe wrapper for {@link dynatrace.sendEvent} which reverts to a noop if RUM JavaScript is not available.\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 *                     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.\n * @param eventContext An optional context that can be used to manipulate the\n *                     result event within the modification callback.\n */\nexport function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown): void {\n    guardDynatrace((dt) => {\n        dt.sendEvent(fields, eventContext);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.addEventModifier} which reverts to a noop if RUM JavaScript is not available.\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.\n * @returns             The unsubscriber function to turn off event modification, or undefined if RUM JavaScript is not available.\n */\nexport function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null): Unsubscriber | undefined {\n    return guardDynatrace((dt) => {\n        return dt.addEventModifier(eventModifier);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.runHealthCheck} which reverts to a noop if RUM JavaScript is not available.\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, or undefined if RUM JavaScript is not available.\n */\nexport function runHealthCheck(config?: HealthCheckConfig): Promise<unknown[] | undefined> | undefined {\n    return guardDynatrace((dt) => {\n        return dt.runHealthCheck(config);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.identifyUser} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param value The name of the user. For example, use a name, userid, or your user's email address.\n */\nexport function identifyUser(value: string): void {\n    guardDynatrace((dt) => {\n        dt.identifyUser(value);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.userOptIn} which reverts to a noop if RUM JavaScript is not available.\n *\n * Grants consent for data collection.\n *\n * @internal\n */\nexport function userOptIn(): void {\n    guardDynatrace((dt) => {\n        dt.userOptIn();\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.userOptOut} which reverts to a noop if RUM JavaScript is not available.\n *\n * Revokes consent for data collection.\n *\n * @internal\n */\nexport function userOptOut(): void {\n    guardDynatrace((dt) => {\n        dt.userOptOut();\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.sendSessionPropertyEvent} which reverts to a noop if RUM JavaScript is not available.\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. All keys must be prefixed with \"session_properties.*\" and must contain only\n *               lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case\n *               character. Each underscore must be followed by a lower-case character or number.\n */\nexport function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void {\n    guardDynatrace((dt) => {\n        dt.sendSessionPropertyEvent(fields);\n    });\n}\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 */\nexport function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent): void {\n    guardDynatrace((dt) => {\n        if (!dt.sendExceptionEvent) {\n            log(\"dynatrace.sendExceptionEvent is not available, the Error module might not be enabled\");\n            return;\n        }\n        dt.sendExceptionEvent(error, fields);\n    });\n}\n\n/**\n * Safe wrapper for various RUM JavaScript API functions which reverts to a noop if RUM JavaScript is not available.\n *\n * @param fn The function to be executed if RUM JavaScript is available.\n * @returns  The result of the provided function call if RUM JavaScript is available, otherwise undefined.\n */\nfunction guardDynatrace<T extends (dt: NonNullable<typeof globalThis.dynatrace>) => any>(fn: T): ReturnType<T> | undefined {\n    const globalDt = getGlobal(\"dynatrace\");\n    if (!isValidAgent(globalDt)) {\n        log(\"dynatrace is not available\");\n        return void 0;\n    }\n    return fn(globalDt);\n}\n"]}

package/dist/api/interactions.d.ts

@@ -0,0 +1,25 @@
+import type { SendUserInteractionFields } from "../types/index.js";
+/**
+ * Safe wrapper for {@link dynatrace.interactions.sendKeyPressEvent} which reverts to a noop if RUM JavaScript or the
+ * interactions module is not available.
+ *
+ * @param fields         The interaction fields. Must contain a `keys` array with 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 if applicable.
+ *                       The fields object must be JSON-serializable. Optional `ui_element.custom_name` and
+ *                       `event_properties.*` entries are allowed. See {@link SendUserInteractionFields} for details.
+ * @param elementOrEvent An optional {@link Element} or {@link KeyboardEvent} used to auto-generate UI element fields.
+ *                       When a {@link KeyboardEvent} is provided, the target element is resolved from the event.
+ *
+ * @example
+ * ```typescript
+ * import * as interactions from "@dynatrace/rum-javascript-sdk/api/interactions";
+ * import { UserInteractionSpecialKey } from "@dynatrace/rum-javascript-sdk/types/rum-events";
+ *
+ * interactions.sendKeyPressEvent({
+ *     keys: [UserInteractionSpecialKey.CTRL, "S"]
+ * });
+ * ```
+ */
+export declare function sendKeyPressEvent(fields: SendUserInteractionFields, elementOrEvent?: Element | Event): void;

package/dist/api/interactions.js

@@ -0,0 +1,51 @@
+import { getGlobal } from "./global-adapter.js";
+import { isValidAgent } from "./type-guards/is-valid-agent.js";
+import { log } from "./logging.js";
+/**
+ * Safe wrapper for {@link dynatrace.interactions.sendKeyPressEvent} which reverts to a noop if RUM JavaScript or the
+ * interactions module is not available.
+ *
+ * @param fields         The interaction fields. Must contain a `keys` array with 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 if applicable.
+ *                       The fields object must be JSON-serializable. Optional `ui_element.custom_name` and
+ *                       `event_properties.*` entries are allowed. See {@link SendUserInteractionFields} for details.
+ * @param elementOrEvent An optional {@link Element} or {@link KeyboardEvent} used to auto-generate UI element fields.
+ *                       When a {@link KeyboardEvent} is provided, the target element is resolved from the event.
+ *
+ * @example
+ * ```typescript
+ * import * as interactions from "@dynatrace/rum-javascript-sdk/api/interactions";
+ * import { UserInteractionSpecialKey } from "@dynatrace/rum-javascript-sdk/types/rum-events";
+ *
+ * interactions.sendKeyPressEvent({
+ *     keys: [UserInteractionSpecialKey.CTRL, "S"]
+ * });
+ * ```
+ */
+export function sendKeyPressEvent(fields, elementOrEvent) {
+    guardInteractions((interactions) => {
+        interactions.sendKeyPressEvent(fields, elementOrEvent);
+    });
+}
+/**
+ * Safe wrapper for various interactions API functions which reverts to a noop if RUM JavaScript or the
+ * interactions module is not available.
+ *
+ * @param fn The function to be executed if the interactions module is available.
+ * @returns  The result of the provided function call if the interactions module is available, otherwise undefined.
+ */
+function guardInteractions(fn) {
+    const globalDt = getGlobal("dynatrace");
+    if (!isValidAgent(globalDt)) {
+        log("dynatrace is not available");
+        return void 0;
+    }
+    if (!globalDt.interactions) {
+        log("dynatrace.interactions module is not available");
+        return void 0;
+    }
+    return fn(globalDt.interactions);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/promises/index.d.ts

@@ -1,6 +1,7 @@
 import type { ApiCreatedEventPropertiesEvent, ApiCreatedSessionPropertiesEvent, EventContext, JSONEvent } from "../../types/index.js";
 import type { HealthCheckConfig, Unsubscriber } from "../../types/api/dynatrace-api-types.js";
 export { DynatraceError } from "../dynatrace-error.js";
+export declare const DEFAULT_AGENT_TIMEOUT = 10000;
 /**
  * Async wrapper for {@link dynatrace.sendEvent}.
  *
@@ -51,6 +52,28 @@ export declare function runHealthCheck(config?: HealthCheckConfig, timeout?: num
  *                overridden with an incompatible object
  */
 export declare function identifyUser(value: string, timeout?: number): Promise<void>;
+/**
+ * Async wrapper for {@link dynatrace.userOptIn}.
+ *
+ * Grants consent for data collection.
+ *
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ * @internal
+ */
+export declare function userOptIn(timeout?: number): Promise<void>;
+/**
+ * Async wrapper for {@link dynatrace.userOptOut}.
+ *
+ * Revokes consent for data collection.
+ *
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ * @internal
+ */
+export declare function userOptOut(timeout?: number): Promise<void>;
 /**
  * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.
  *

package/dist/api/promises/index.js

@@ -1,6 +1,7 @@
 import { waitForAgent } from "./wait-for-agent.js";
 import { waitForSendExceptionEvent } from "./wait-for-send-exception-event.js";
 export { DynatraceError } from "../dynatrace-error.js";
+export const DEFAULT_AGENT_TIMEOUT = 10_000;
 /**
  * Async wrapper for {@link dynatrace.sendEvent}.
  *
@@ -16,7 +17,7 @@ export { DynatraceError } from "../dynatrace-error.js";
  * @throws             A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
  *                     overridden with an incompatible object
  */
-export async function sendEvent(fields, eventContext, timeout = 10_000) {
+export async function sendEvent(fields, eventContext, timeout = DEFAULT_AGENT_TIMEOUT) {
     const dynatrace = await waitForAgent(timeout);
     dynatrace.sendEvent(fields, eventContext);
 }
@@ -31,7 +32,7 @@ export async function sendEvent(fields, eventContext, timeout = 10_000) {
  * @throws              A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the
  *                      namespace is overridden with an incompatible object
  */
-export async function addEventModifier(eventModifier, timeout = 10_000) {
+export async function addEventModifier(eventModifier, timeout = DEFAULT_AGENT_TIMEOUT) {
     const dynatrace = await waitForAgent(timeout);
     return dynatrace.addEventModifier(eventModifier);
 }
@@ -47,7 +48,7 @@ export async function addEventModifier(eventModifier, timeout = 10_000) {
  * @throws                                A {@link DynatraceError} if the RUM JavaScript is not available within the
  *                                        timeout, or the namespace is overridden with an incompatible object
  */
-export async function runHealthCheck(config, timeout = 10_000) {
+export async function runHealthCheck(config, timeout = DEFAULT_AGENT_TIMEOUT) {
     const dynatrace = await waitForAgent(timeout);
     return dynatrace.runHealthCheck(config);
 }
@@ -59,10 +60,38 @@ export async function runHealthCheck(config, timeout = 10_000) {
  * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
  *                overridden with an incompatible object
  */
-export async function identifyUser(value, timeout = 10_000) {
+export async function identifyUser(value, timeout = DEFAULT_AGENT_TIMEOUT) {
     const dynatrace = await waitForAgent(timeout);
     dynatrace.identifyUser(value);
 }
+/**
+ * Async wrapper for {@link dynatrace.userOptIn}.
+ *
+ * Grants consent for data collection.
+ *
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ * @internal
+ */
+export async function userOptIn(timeout = DEFAULT_AGENT_TIMEOUT) {
+    const dynatrace = await waitForAgent(timeout);
+    dynatrace.userOptIn();
+}
+/**
+ * Async wrapper for {@link dynatrace.userOptOut}.
+ *
+ * Revokes consent for data collection.
+ *
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ * @internal
+ */
+export async function userOptOut(timeout = DEFAULT_AGENT_TIMEOUT) {
+    const dynatrace = await waitForAgent(timeout);
+    dynatrace.userOptOut();
+}
 /**
  * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.
  *
@@ -75,7 +104,7 @@ export async function identifyUser(value, timeout = 10_000) {
  * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
  *                overridden with an incompatible object
  */
-export async function sendSessionPropertyEvent(fields, timeout = 10_000) {
+export async function sendSessionPropertyEvent(fields, timeout = DEFAULT_AGENT_TIMEOUT) {
     const dynatrace = await waitForAgent(timeout);
     dynatrace.sendSessionPropertyEvent(fields);
 }
@@ -97,8 +126,8 @@ export async function sendSessionPropertyEvent(fields, timeout = 10_000) {
  * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
  *                overridden with an incompatible object
  */
-export async function sendExceptionEvent(error, fields, timeout = 10_000) {
+export async function sendExceptionEvent(error, fields, timeout = DEFAULT_AGENT_TIMEOUT) {
     const sendExceptionEventGuarded = await waitForSendExceptionEvent(timeout);
     sendExceptionEventGuarded(error, fields);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/api/promises/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAAsC,EAAE,YAAsB,EAAE,UAAkB,MAAM;IACpH,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,aAAgG,EAAE,UAAkB,MAAM;IAC7J,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,SAAS,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAA0B,EAAE,UAAkB,MAAM;IACrF,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,KAAa,EAAE,UAAkB,MAAM;IACtE,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,MAAwC,EAAE,UAAkB,MAAM;IAC7G,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,KAAY,EAAE,MAAuC,EAAE,UAAkB,MAAM;IACpH,MAAM,yBAAyB,GAAG,MAAM,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAC3E,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    EventContext,\n    JSONEvent\n} from \"../../types/index.js\";\nimport type {\n    HealthCheckConfig,\n    Unsubscriber\n} from \"../../types/api/dynatrace-api-types.js\";\nimport { waitForAgent } from \"./wait-for-agent.js\";\nimport { waitForSendExceptionEvent } from \"./wait-for-send-exception-event.js\";\n\nexport { DynatraceError } from \"../dynatrace-error.js\";\n\n/**\n * Async wrapper for {@link dynatrace.sendEvent}.\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 *                     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.\n * @param eventContext An optional context that can be used to manipulate the\n *                     result event within the modification callback.\n * @param timeout      Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws             A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                     overridden with an incompatible object\n */\nexport async function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown, timeout: number = 10_000): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.sendEvent(fields, eventContext);\n}\n\n/**\n * Async wrapper for {@link dynatrace.addEventModifier}.\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.\n * @param timeout       Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @returns             A promise that resolves to the unsubscriber function to turn off event modification.\n * @throws              A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the\n *                      namespace is overridden with an incompatible object\n */\nexport async function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null, timeout: number = 10_000): Promise<Unsubscriber> {\n    const dynatrace = await waitForAgent(timeout);\n    return dynatrace.addEventModifier(eventModifier);\n}\n\n/**\n * Async wrapper for {@link dynatrace.runHealthCheck}.\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 * @param timeout                         Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @returns                               A promise that settles as soon as the health check has been performed.\n * @throws                                A {@link DynatraceError} if the RUM JavaScript is not available within the\n *                                        timeout, or the namespace is overridden with an incompatible object\n */\nexport async function runHealthCheck(config?: HealthCheckConfig, timeout: number = 10_000): Promise<unknown[] | undefined> {\n    const dynatrace = await waitForAgent(timeout);\n    return dynatrace.runHealthCheck(config);\n}\n\n/**\n * Async wrapper for {@link dynatrace.identifyUser}.\n *\n * @param value   The name of the user. For example, use a name, userid, or your user's email address.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function identifyUser(value: string, timeout: number = 10_000): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.identifyUser(value);\n}\n\n/**\n * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.\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. All keys must be prefixed with \"session_properties.*\" and must contain only\n *                lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case\n *                character. Each underscore must be followed by a lower-case character or number.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent, timeout: number = 10_000): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.sendSessionPropertyEvent(fields);\n}\n\n/**\n * Async wrapper for {@link dynatrace.sendExceptionEvent}.\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 * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent, timeout: number = 10_000): Promise<void> {\n    const sendExceptionEventGuarded = await waitForSendExceptionEvent(timeout);\n    sendExceptionEventGuarded(error, fields);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/api/promises/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAAsC,EAAE,YAAsB,EAAE,UAAkB,qBAAqB;IACnI,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAClC,aAAgG,EAChG,UAAkB,qBAAqB;IAEvC,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,SAAS,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAA0B,EAAE,UAAkB,qBAAqB;IACpG,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,KAAa,EAAE,UAAkB,qBAAqB;IACrF,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,UAAkB,qBAAqB;IACnE,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,SAAS,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,UAAkB,qBAAqB;IACpE,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,UAAU,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,MAAwC,EAAE,UAAkB,qBAAqB;IAC5H,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,KAAY,EAAE,MAAuC,EAAE,UAAkB,qBAAqB;IACnI,MAAM,yBAAyB,GAAG,MAAM,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAC3E,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    EventContext,\n    JSONEvent\n} from \"../../types/index.js\";\nimport type {\n    HealthCheckConfig,\n    Unsubscriber\n} from \"../../types/api/dynatrace-api-types.js\";\nimport { waitForAgent } from \"./wait-for-agent.js\";\nimport { waitForSendExceptionEvent } from \"./wait-for-send-exception-event.js\";\n\nexport { DynatraceError } from \"../dynatrace-error.js\";\nexport const DEFAULT_AGENT_TIMEOUT = 10_000;\n\n/**\n * Async wrapper for {@link dynatrace.sendEvent}.\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 *                     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.\n * @param eventContext An optional context that can be used to manipulate the\n *                     result event within the modification callback.\n * @param timeout      Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws             A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                     overridden with an incompatible object\n */\nexport async function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown, timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.sendEvent(fields, eventContext);\n}\n\n/**\n * Async wrapper for {@link dynatrace.addEventModifier}.\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.\n * @param timeout       Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @returns             A promise that resolves to the unsubscriber function to turn off event modification.\n * @throws              A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the\n *                      namespace is overridden with an incompatible object\n */\nexport async function addEventModifier(\n    eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null,\n    timeout: number = DEFAULT_AGENT_TIMEOUT\n): Promise<Unsubscriber> {\n    const dynatrace = await waitForAgent(timeout);\n    return dynatrace.addEventModifier(eventModifier);\n}\n\n/**\n * Async wrapper for {@link dynatrace.runHealthCheck}.\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 * @param timeout                         Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @returns                               A promise that settles as soon as the health check has been performed.\n * @throws                                A {@link DynatraceError} if the RUM JavaScript is not available within the\n *                                        timeout, or the namespace is overridden with an incompatible object\n */\nexport async function runHealthCheck(config?: HealthCheckConfig, timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<unknown[] | undefined> {\n    const dynatrace = await waitForAgent(timeout);\n    return dynatrace.runHealthCheck(config);\n}\n\n/**\n * Async wrapper for {@link dynatrace.identifyUser}.\n *\n * @param value   The name of the user. For example, use a name, userid, or your user's email address.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function identifyUser(value: string, timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.identifyUser(value);\n}\n\n/**\n * Async wrapper for {@link dynatrace.userOptIn}.\n *\n * Grants consent for data collection.\n *\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n * @internal\n */\nexport async function userOptIn(timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.userOptIn();\n}\n\n/**\n * Async wrapper for {@link dynatrace.userOptOut}.\n *\n * Revokes consent for data collection.\n *\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n * @internal\n */\nexport async function userOptOut(timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.userOptOut();\n}\n\n/**\n * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.\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. All keys must be prefixed with \"session_properties.*\" and must contain only\n *                lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case\n *                character. Each underscore must be followed by a lower-case character or number.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent, timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.sendSessionPropertyEvent(fields);\n}\n\n/**\n * Async wrapper for {@link dynatrace.sendExceptionEvent}.\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 * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent, timeout: number = DEFAULT_AGENT_TIMEOUT): Promise<void> {\n    const sendExceptionEventGuarded = await waitForSendExceptionEvent(timeout);\n    sendExceptionEventGuarded(error, fields);\n}\n"]}

package/dist/api/promises/interactions.d.ts

@@ -0,0 +1,18 @@
+import type { SendUserInteractionFields } from "../../types/index.js";
+/**
+ * Async wrapper for {@link dynatrace.interactions.sendKeyPressEvent}.
+ * This function is only available if the User Interaction module is enabled.
+ *
+ * @param fields         The interaction fields. Must contain a `keys` array with 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 if applicable.
+ *                       The fields object must be JSON-serializable. Optional `ui_element.custom_name` and
+ *                       `event_properties.*` entries are allowed. See {@link SendUserInteractionFields} for details.
+ * @param elementOrEvent An optional {@link Element} or {@link KeyboardEvent} used to auto-generate UI element fields.
+ *                       When a {@link KeyboardEvent} is provided, the target element is resolved from the event.
+ * @param timeout        Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws                A {@link DynatraceError} if the RUM JavaScript or User Interaction module is not available
+ *                        within the timeout, or the namespace is overridden with an incompatible object
+ */
+export declare function sendKeyPressEvent(fields: SendUserInteractionFields, elementOrEvent?: Element | Event, timeout?: number): Promise<void>;

package/dist/api/promises/interactions.js

@@ -0,0 +1,22 @@
+import { waitForInteractions } from "./wait-for-interactions.js";
+/**
+ * Async wrapper for {@link dynatrace.interactions.sendKeyPressEvent}.
+ * This function is only available if the User Interaction module is enabled.
+ *
+ * @param fields         The interaction fields. Must contain a `keys` array with 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 if applicable.
+ *                       The fields object must be JSON-serializable. Optional `ui_element.custom_name` and
+ *                       `event_properties.*` entries are allowed. See {@link SendUserInteractionFields} for details.
+ * @param elementOrEvent An optional {@link Element} or {@link KeyboardEvent} used to auto-generate UI element fields.
+ *                       When a {@link KeyboardEvent} is provided, the target element is resolved from the event.
+ * @param timeout        Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws                A {@link DynatraceError} if the RUM JavaScript or User Interaction module is not available
+ *                        within the timeout, or the namespace is overridden with an incompatible object
+ */
+export async function sendKeyPressEvent(fields, elementOrEvent, timeout = 10_000) {
+    const interactions = await waitForInteractions(timeout);
+    interactions.sendKeyPressEvent(fields, elementOrEvent);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/promises/wait-for-interactions.d.ts

@@ -0,0 +1,9 @@
+import type { Interactions } from "../../types/index.js";
+/**
+ * Waits for the RUM JavaScript and interactions module to become available.
+ *
+ * @param timeout Timeout in milliseconds to wait for the interactions module to be available (default: 10000)
+ * @returns       A promise that resolves to the interactions module
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or interactions module is not available within the timeout
+ */
+export declare function waitForInteractions(timeout?: number): Promise<Interactions>;

package/dist/api/promises/wait-for-interactions.js

@@ -0,0 +1,18 @@
+import { DynatraceError } from "../dynatrace-error.js";
+import { waitForAgent } from "./wait-for-agent.js";
+/**
+ * Waits for the RUM JavaScript and interactions module to become available.
+ *
+ * @param timeout Timeout in milliseconds to wait for the interactions module to be available (default: 10000)
+ * @returns       A promise that resolves to the interactions module
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or interactions module is not available within the timeout
+ */
+export async function waitForInteractions(timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    if (dynatrace.interactions) {
+        return dynatrace.interactions;
+    }
+    // If not immediately available, it means the module is disabled
+    throw new DynatraceError("The `dynatrace.interactions` module is not available. Ensure the User Interaction module is enabled in your RUM configuration.");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/user-actions.d.ts

@@ -3,14 +3,14 @@ import type { UserActionStartOptions, UserActionTracker } from "../types/index.j
  * Safe wrapper for {@link dynatrace.userActions.create} which reverts to a noop if RUM JavaScript or the user actions module is not available.
  *
  * @param options An optional options object to configure the user action.
- * @returns       A `UserActionTracker` object that can be started and finished, or `undefined` if the user actions module is not enabled.
+ * @returns       A `UserActionTracker` object that can be started and completed, or `undefined` if the user actions module is not enabled.
  *
  * @example
  * ```typescript
  * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
- * const userAction = userActions.create({ autoClose: false });
+ * const userAction = userActions.create({ completeAutomatically: false });
  * // perform work
- * userAction?.finish();
+ * userAction?.complete();
  * ```
  */
 export declare function create(options?: UserActionStartOptions): UserActionTracker | undefined;
@@ -25,7 +25,7 @@ export declare function create(options?: UserActionStartOptions): UserActionTrac
  * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
  * const unsubscribe = userActions.subscribe((userAction) => {
  *     console.log('New user action created');
- *     userAction.autoClose = false;
+ *     userAction.completeAutomatically = false;
  * });
  * // later
  * unsubscribe?.();
@@ -55,7 +55,7 @@ export declare function setAutomaticDetection(automaticDetection: boolean): void
  * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
  * const currentAction = userActions.getCurrent();
  * if (currentAction) {
- *     currentAction.autoClose = false;
+ *     currentAction.completeAutomatically = false;
  * }
  * ```
  */

package/dist/api/user-actions.js

@@ -5,14 +5,14 @@ import { log } from "./logging.js";
  * Safe wrapper for {@link dynatrace.userActions.create} which reverts to a noop if RUM JavaScript or the user actions module is not available.
  *
  * @param options An optional options object to configure the user action.
- * @returns       A `UserActionTracker` object that can be started and finished, or `undefined` if the user actions module is not enabled.
+ * @returns       A `UserActionTracker` object that can be started and completed, or `undefined` if the user actions module is not enabled.
  *
  * @example
  * ```typescript
  * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
- * const userAction = userActions.create({ autoClose: false });
+ * const userAction = userActions.create({ completeAutomatically: false });
  * // perform work
- * userAction?.finish();
+ * userAction?.complete();
  * ```
  */
 export function create(options) {
@@ -31,7 +31,7 @@ export function create(options) {
  * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
  * const unsubscribe = userActions.subscribe((userAction) => {
  *     console.log('New user action created');
- *     userAction.autoClose = false;
+ *     userAction.completeAutomatically = false;
  * });
  * // later
  * unsubscribe?.();
@@ -69,7 +69,7 @@ export function setAutomaticDetection(automaticDetection) {
  * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
  * const currentAction = userActions.getCurrent();
  * if (currentAction) {
- *     currentAction.autoClose = false;
+ *     currentAction.completeAutomatically = false;
  * }
  * ```
  */
@@ -96,4 +96,4 @@ function guardUserActions(fn) {
     }
     return fn(globalDt.userActions);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1hY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL2FwaS91c2VyLWFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMvRCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRW5DOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLFVBQVUsTUFBTSxDQUFDLE9BQWdDO0lBQ25ELE9BQU8sZ0JBQWdCLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRTtRQUNwQyxPQUFPLFdBQVcsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDdkMsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxNQUFNLFVBQVUsU0FBUyxDQUFDLFVBQW1EO0lBQ3pFLE9BQU8sZ0JBQWdCLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRTtRQUNwQyxPQUFPLFdBQVcsQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDN0MsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQ7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsa0JBQTJCO0lBQzdELGdCQUFnQixDQUFDLENBQUMsV0FBVyxFQUFFLEVBQUU7UUFDN0IsV0FBVyxDQUFDLHFCQUFxQixDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDMUQsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQ7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILE1BQU0sVUFBVSxVQUFVO0lBQ3RCLE9BQU8sZ0JBQWdCLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRTtRQUNwQyxPQUFPLFdBQVcsQ0FBQyxPQUFPLENBQUM7SUFDL0IsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxTQUFTLGdCQUFnQixDQUE4QyxFQUFLO0lBQ3hFLE1BQU0sUUFBUSxHQUFHLFNBQVMsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUN4QyxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7UUFDMUIsR0FBRyxDQUFDLDRCQUE0QixDQUFDLENBQUM7UUFDbEMsT0FBTyxLQUFLLENBQUMsQ0FBQztJQUNsQixDQUFDO0lBRUQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUN4QixHQUFHLENBQUMsK0NBQStDLENBQUMsQ0FBQztRQUNyRCxPQUFPLEtBQUssQ0FBQyxDQUFDO0lBQ2xCLENBQUM7SUFFRCxPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUM7QUFDcEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHtcbiAgICBVc2VyQWN0aW9ucyxcbiAgICBVc2VyQWN0aW9uU3RhcnRPcHRpb25zLFxuICAgIFVzZXJBY3Rpb25UcmFja2VyXG59IGZyb20gXCIuLi90eXBlcy9pbmRleC5qc1wiO1xuaW1wb3J0IHsgZ2V0R2xvYmFsIH0gZnJvbSBcIi4vZ2xvYmFsLWFkYXB0ZXIuanNcIjtcbmltcG9ydCB7IGlzVmFsaWRBZ2VudCB9IGZyb20gXCIuL3R5cGUtZ3VhcmRzL2lzLXZhbGlkLWFnZW50LmpzXCI7XG5pbXBvcnQgeyBsb2cgfSBmcm9tIFwiLi9sb2dnaW5nLmpzXCI7XG5cbi8qKlxuICogU2FmZSB3cmFwcGVyIGZvciB7QGxpbmsgZHluYXRyYWNlLnVzZXJBY3Rpb25zLmNyZWF0ZX0gd2hpY2ggcmV2ZXJ0cyB0byBhIG5vb3AgaWYgUlVNIEphdmFTY3JpcHQgb3IgdGhlIHVzZXIgYWN0aW9ucyBtb2R1bGUgaXMgbm90IGF2YWlsYWJsZS5cbiAqXG4gKiBAcGFyYW0gb3B0aW9ucyBBbiBvcHRpb25hbCBvcHRpb25zIG9iamVjdCB0byBjb25maWd1cmUgdGhlIHVzZXIgYWN0aW9uLlxuICogQHJldHVybnMgICAgICAgQSBgVXNlckFjdGlvblRyYWNrZXJgIG9iamVjdCB0aGF0IGNhbiBiZSBzdGFydGVkIGFuZCBjb21wbGV0ZWQsIG9yIGB1bmRlZmluZWRgIGlmIHRoZSB1c2VyIGFjdGlvbnMgbW9kdWxlIGlzIG5vdCBlbmFibGVkLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBpbXBvcnQgKiBhcyB1c2VyQWN0aW9ucyBmcm9tIFwiQGR5bmF0cmFjZS9ydW0tamF2YXNjcmlwdC1zZGsvYXBpL3VzZXItYWN0aW9uc1wiO1xuICogY29uc3QgdXNlckFjdGlvbiA9IHVzZXJBY3Rpb25zLmNyZWF0ZSh7IGNvbXBsZXRlQXV0b21hdGljYWxseTogZmFsc2UgfSk7XG4gKiAvLyBwZXJmb3JtIHdvcmtcbiAqIHVzZXJBY3Rpb24/LmNvbXBsZXRlKCk7XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZShvcHRpb25zPzogVXNlckFjdGlvblN0YXJ0T3B0aW9ucyk6IFVzZXJBY3Rpb25UcmFja2VyIHwgdW5kZWZpbmVkIHtcbiAgICByZXR1cm4gZ3VhcmRVc2VyQWN0aW9ucygodXNlckFjdGlvbnMpID0+IHtcbiAgICAgICAgcmV0dXJuIHVzZXJBY3Rpb25zLmNyZWF0ZShvcHRpb25zKTtcbiAgICB9KTtcbn1cblxuLyoqXG4gKiBTYWZlIHdyYXBwZXIgZm9yIHtAbGluayBkeW5hdHJhY2UudXNlckFjdGlvbnMuc3Vic2NyaWJlfSB3aGljaCByZXZlcnRzIHRvIGEgbm9vcCBpZiBSVU0gSmF2YVNjcmlwdCBvciB0aGUgdXNlciBhY3Rpb25zIG1vZHVsZSBpcyBub3QgYXZhaWxhYmxlLlxuICpcbiAqIEBwYXJhbSBzdWJzY3JpYmVyIEEgY2FsbGJhY2sgZnVuY3Rpb24gdGhhdCBpcyBjYWxsZWQgd2hlbmV2ZXIgRHluYXRyYWNlIGNyZWF0ZXMgYSBuZXcgdXNlciBhY3Rpb24uXG4gKiBAcmV0dXJucyAgICAgICAgICBBbiB1bnN1YnNjcmliZXIgZnVuY3Rpb24gdG8gcmVtb3ZlIHRoZSBzdWJzY3JpcHRpb24sIG9yIHVuZGVmaW5lZCBpZiB0aGUgdXNlciBhY3Rpb25zIG1vZHVsZSBpcyBub3QgZW5hYmxlZC5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogaW1wb3J0ICogYXMgdXNlckFjdGlvbnMgZnJvbSBcIkBkeW5hdHJhY2UvcnVtLWphdmFzY3JpcHQtc2RrL2FwaS91c2VyLWFjdGlvbnNcIjtcbiAqIGNvbnN0IHVuc3Vic2NyaWJlID0gdXNlckFjdGlvbnMuc3Vic2NyaWJlKCh1c2VyQWN0aW9uKSA9PiB7XG4gKiAgICAgY29uc29sZS5sb2coJ05ldyB1c2VyIGFjdGlvbiBjcmVhdGVkJyk7XG4gKiAgICAgdXNlckFjdGlvbi5jb21wbGV0ZUF1dG9tYXRpY2FsbHkgPSBmYWxzZTtcbiAqIH0pO1xuICogLy8gbGF0ZXJcbiAqIHVuc3Vic2NyaWJlPy4oKTtcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gc3Vic2NyaWJlKHN1YnNjcmliZXI6ICh1c2VyQWN0aW9uOiBVc2VyQWN0aW9uVHJhY2tlcikgPT4gdm9pZCk6ICgoKSA9PiB2b2lkKSB8IHVuZGVmaW5lZCB7XG4gICAgcmV0dXJuIGd1YXJkVXNlckFjdGlvbnMoKHVzZXJBY3Rpb25zKSA9PiB7XG4gICAgICAgIHJldHVybiB1c2VyQWN0aW9ucy5zdWJzY3JpYmUoc3Vic2NyaWJlcik7XG4gICAgfSk7XG59XG5cbi8qKlxuICogU2FmZSB3cmFwcGVyIGZvciB7QGxpbmsgZHluYXRyYWNlLnVzZXJBY3Rpb25zLnNldEF1dG9tYXRpY0RldGVjdGlvbn0gd2hpY2ggcmV2ZXJ0cyB0byBhIG5vb3AgaWYgUlVNIEphdmFTY3JpcHQgb3IgdGhlIHVzZXIgYWN0aW9ucyBtb2R1bGUgaXMgbm90IGF2YWlsYWJsZS5cbiAqXG4gKiBAcGFyYW0gYXV0b21hdGljRGV0ZWN0aW9uIElmIGZhbHNlLCBkaXNhYmxlcyBhdXRvbWF0aWMgdXNlciBhY3Rpb24gZGV0ZWN0aW9uLCBvdGhlcndpc2UgZW5hYmxlcyBpdC5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogaW1wb3J0ICogYXMgdXNlckFjdGlvbnMgZnJvbSBcIkBkeW5hdHJhY2UvcnVtLWphdmFzY3JpcHQtc2RrL2FwaS91c2VyLWFjdGlvbnNcIjtcbiAqIHVzZXJBY3Rpb25zLnNldEF1dG9tYXRpY0RldGVjdGlvbihmYWxzZSk7XG4gKiAvLyBtYW51YWwgdXNlciBhY3Rpb24gaGFuZGxpbmdcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gc2V0QXV0b21hdGljRGV0ZWN0aW9uKGF1dG9tYXRpY0RldGVjdGlvbjogYm9vbGVhbik6IHZvaWQge1xuICAgIGd1YXJkVXNlckFjdGlvbnMoKHVzZXJBY3Rpb25zKSA9PiB7XG4gICAgICAgIHVzZXJBY3Rpb25zLnNldEF1dG9tYXRpY0RldGVjdGlvbihhdXRvbWF0aWNEZXRlY3Rpb24pO1xuICAgIH0pO1xufVxuXG4vKipcbiAqIFNhZmUgd3JhcHBlciBmb3Ige0BsaW5rIGR5bmF0cmFjZS51c2VyQWN0aW9ucy5jdXJyZW50fSB3aGljaCByZXR1cm5zIHVuZGVmaW5lZCBpZiBSVU0gSmF2YVNjcmlwdCBvciB0aGUgdXNlciBhY3Rpb25zIG1vZHVsZSBpcyBub3QgYXZhaWxhYmxlLlxuICpcbiAqIEByZXR1cm5zIFRoZSBjdXJyZW50IHVzZXIgYWN0aW9uLCBvciBgdW5kZWZpbmVkYCBpZiBubyB1c2VyIGFjdGlvbiBpcyBpbiBwcm9ncmVzcyBvciB0aGUgdXNlciBhY3Rpb25zIG1vZHVsZSBpcyBub3QgZW5hYmxlZC5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogaW1wb3J0ICogYXMgdXNlckFjdGlvbnMgZnJvbSBcIkBkeW5hdHJhY2UvcnVtLWphdmFzY3JpcHQtc2RrL2FwaS91c2VyLWFjdGlvbnNcIjtcbiAqIGNvbnN0IGN1cnJlbnRBY3Rpb24gPSB1c2VyQWN0aW9ucy5nZXRDdXJyZW50KCk7XG4gKiBpZiAoY3VycmVudEFjdGlvbikge1xuICogICAgIGN1cnJlbnRBY3Rpb24uY29tcGxldGVBdXRvbWF0aWNhbGx5ID0gZmFsc2U7XG4gKiB9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEN1cnJlbnQoKTogVXNlckFjdGlvblRyYWNrZXIgfCB1bmRlZmluZWQge1xuICAgIHJldHVybiBndWFyZFVzZXJBY3Rpb25zKCh1c2VyQWN0aW9ucykgPT4ge1xuICAgICAgICByZXR1cm4gdXNlckFjdGlvbnMuY3VycmVudDtcbiAgICB9KTtcbn1cblxuLyoqXG4gKiBTYWZlIHdyYXBwZXIgZm9yIHZhcmlvdXMgdXNlciBhY3Rpb25zIEFQSSBmdW5jdGlvbnMgd2hpY2ggcmV2ZXJ0cyB0byBhIG5vb3AgaWYgUlVNIEphdmFTY3JpcHQgb3IgdGhlIHVzZXIgYWN0aW9ucyBtb2R1bGUgaXMgbm90IGF2YWlsYWJsZS5cbiAqXG4gKiBAcGFyYW0gZm4gVGhlIGZ1bmN0aW9uIHRvIGJlIGV4ZWN1dGVkIGlmIHRoZSB1c2VyIGFjdGlvbnMgbW9kdWxlIGlzIGF2YWlsYWJsZS5cbiAqIEByZXR1cm5zICBUaGUgcmVzdWx0IG9mIHRoZSBwcm92aWRlZCBmdW5jdGlvbiBjYWxsIGlmIHRoZSB1c2VyIGFjdGlvbnMgbW9kdWxlIGlzIGF2YWlsYWJsZSwgb3RoZXJ3aXNlIHVuZGVmaW5lZC5cbiAqL1xuZnVuY3Rpb24gZ3VhcmRVc2VyQWN0aW9uczxUIGV4dGVuZHMgKHVzZXJBY3Rpb25zOiBVc2VyQWN0aW9ucykgPT4gYW55PihmbjogVCk6IFJldHVyblR5cGU8VD4gfCB1bmRlZmluZWQge1xuICAgIGNvbnN0IGdsb2JhbER0ID0gZ2V0R2xvYmFsKFwiZHluYXRyYWNlXCIpO1xuICAgIGlmICghaXNWYWxpZEFnZW50KGdsb2JhbER0KSkge1xuICAgICAgICBsb2coXCJkeW5hdHJhY2UgaXMgbm90IGF2YWlsYWJsZVwiKTtcbiAgICAgICAgcmV0dXJuIHZvaWQgMDtcbiAgICB9XG5cbiAgICBpZiAoIWdsb2JhbER0LnVzZXJBY3Rpb25zKSB7XG4gICAgICAgIGxvZyhcImR5bmF0cmFjZS51c2VyQWN0aW9ucyBtb2R1bGUgaXMgbm90IGF2YWlsYWJsZVwiKTtcbiAgICAgICAgcmV0dXJuIHZvaWQgMDtcbiAgICB9XG5cbiAgICByZXR1cm4gZm4oZ2xvYmFsRHQudXNlckFjdGlvbnMpO1xufVxuIl19

package/dist/testing/index.d.ts

@@ -1,4 +1,6 @@
 export type { SnapshotOptions, EventIgnorePattern } from "./snapshot.js";
 export { DEFAULT_IGNORED_EVENTS, DEFAULT_IGNORED_FIELDS, DEFAULT_REMOVED_FIELDS, IGNORED_PLACEHOLDER } from "./snapshot.js";
-export type { BeaconRequest, DynatraceConfig, DynatraceTesting, DynatraceTestingFixture, DynatraceTestingWorkerFixture, ExpectOptions, WaitForBeaconsOptions } from "./test.js";
+export type { DynatraceConfig } from "./types/dynatrace-config.js";
+export type { BeaconRequest, DynatraceTesting, ExpectOptions, WaitForBeaconsOptions } from "./types/dynatrace-testing.js";
+export type { DynatraceTestingFixture, DynatraceTestingWorkerFixture } from "./types/dynatrace-testing-fixtures.js";
 export { test } from "./test.js";

package/dist/testing/index.js

@@ -1,3 +1,3 @@
 export { DEFAULT_IGNORED_EVENTS, DEFAULT_IGNORED_FIELDS, DEFAULT_REMOVED_FIELDS, IGNORED_PLACEHOLDER } from "./snapshot.js";
 export { test } from "./test.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQ0gsc0JBQXNCLEVBQ3RCLHNCQUFzQixFQUN0QixzQkFBc0IsRUFDdEIsbUJBQW1CLEVBQ3RCLE1BQU0sZUFBZSxDQUFDO0FBVXZCLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IFNuYXBzaG90T3B0aW9ucywgRXZlbnRJZ25vcmVQYXR0ZXJuIH0gZnJvbSBcIi4vc25hcHNob3QuanNcIjtcbmV4cG9ydCB7XG4gICAgREVGQVVMVF9JR05PUkVEX0VWRU5UUyxcbiAgICBERUZBVUxUX0lHTk9SRURfRklFTERTLFxuICAgIERFRkFVTFRfUkVNT1ZFRF9GSUVMRFMsXG4gICAgSUdOT1JFRF9QTEFDRUhPTERFUlxufSBmcm9tIFwiLi9zbmFwc2hvdC5qc1wiO1xuZXhwb3J0IHR5cGUge1xuICAgIEJlYWNvblJlcXVlc3QsXG4gICAgRHluYXRyYWNlQ29uZmlnLFxuICAgIER5bmF0cmFjZVRlc3RpbmcsXG4gICAgRHluYXRyYWNlVGVzdGluZ0ZpeHR1cmUsXG4gICAgRHluYXRyYWNlVGVzdGluZ1dvcmtlckZpeHR1cmUsXG4gICAgRXhwZWN0T3B0aW9ucyxcbiAgICBXYWl0Rm9yQmVhY29uc09wdGlvbnNcbn0gZnJvbSBcIi4vdGVzdC5qc1wiO1xuZXhwb3J0IHsgdGVzdCB9IGZyb20gXCIuL3Rlc3QuanNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQ0gsc0JBQXNCLEVBQ3RCLHNCQUFzQixFQUN0QixzQkFBc0IsRUFDdEIsbUJBQW1CLEVBQ3RCLE1BQU0sZUFBZSxDQUFDO0FBWXZCLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IFNuYXBzaG90T3B0aW9ucywgRXZlbnRJZ25vcmVQYXR0ZXJuIH0gZnJvbSBcIi4vc25hcHNob3QuanNcIjtcbmV4cG9ydCB7XG4gICAgREVGQVVMVF9JR05PUkVEX0VWRU5UUyxcbiAgICBERUZBVUxUX0lHTk9SRURfRklFTERTLFxuICAgIERFRkFVTFRfUkVNT1ZFRF9GSUVMRFMsXG4gICAgSUdOT1JFRF9QTEFDRUhPTERFUlxufSBmcm9tIFwiLi9zbmFwc2hvdC5qc1wiO1xuZXhwb3J0IHR5cGUgeyBEeW5hdHJhY2VDb25maWcgfSBmcm9tIFwiLi90eXBlcy9keW5hdHJhY2UtY29uZmlnLmpzXCI7XG5leHBvcnQgdHlwZSB7XG4gICAgQmVhY29uUmVxdWVzdCxcbiAgICBEeW5hdHJhY2VUZXN0aW5nLFxuICAgIEV4cGVjdE9wdGlvbnMsXG4gICAgV2FpdEZvckJlYWNvbnNPcHRpb25zXG59IGZyb20gXCIuL3R5cGVzL2R5bmF0cmFjZS10ZXN0aW5nLmpzXCI7XG5leHBvcnQgdHlwZSB7XG4gICAgRHluYXRyYWNlVGVzdGluZ0ZpeHR1cmUsXG4gICAgRHluYXRyYWNlVGVzdGluZ1dvcmtlckZpeHR1cmVcbn0gZnJvbSBcIi4vdHlwZXMvZHluYXRyYWNlLXRlc3RpbmctZml4dHVyZXMuanNcIjtcbmV4cG9ydCB7IHRlc3QgfSBmcm9tIFwiLi90ZXN0LmpzXCI7XG4iXX0=

package/dist/testing/install.js

@@ -19,4 +19,4 @@ export async function fetchRumJavaScript(endpointUrl, appId, token) {
     }
     return response.text();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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