@dynatrace/rum-javascript-sdk 1.335.1 → 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

@@ -4,6 +4,9 @@ import type { SendUserInteractionFields } from "../types/index.js";
  * 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.

package/dist/api/interactions.js

@@ -6,6 +6,9 @@ import { log } from "./logging.js";
  * 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.
@@ -45,4 +48,4 @@ function guardInteractions(fn) {
     }
     return fn(globalDt.interactions);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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

@@ -4,6 +4,9 @@ import type { SendUserInteractionFields } from "../../types/index.js";
  * 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.

package/dist/api/promises/interactions.js

@@ -4,6 +4,9 @@ import { waitForInteractions } from "./wait-for-interactions.js";
  * 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.
@@ -16,4 +19,4 @@ export async function sendKeyPressEvent(fields, elementOrEvent, timeout = 10_000
     const interactions = await waitForInteractions(timeout);
     interactions.sendKeyPressEvent(fields, elementOrEvent);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJhY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc291cmNlL2FwaS9wcm9taXNlcy9pbnRlcmFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFakU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxpQkFBaUIsQ0FDbkMsTUFBaUMsRUFDakMsY0FBZ0MsRUFDaEMsVUFBa0IsTUFBTTtJQUV4QixNQUFNLFlBQVksR0FBRyxNQUFNLG1CQUFtQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3hELFlBQVksQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLEVBQUUsY0FBYyxDQUFDLENBQUM7QUFDM0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU2VuZFVzZXJJbnRlcmFjdGlvbkZpZWxkcyB9IGZyb20gXCIuLi8uLi90eXBlcy9pbmRleC5qc1wiO1xuaW1wb3J0IHsgd2FpdEZvckludGVyYWN0aW9ucyB9IGZyb20gXCIuL3dhaXQtZm9yLWludGVyYWN0aW9ucy5qc1wiO1xuXG4vKipcbiAqIEFzeW5jIHdyYXBwZXIgZm9yIHtAbGluayBkeW5hdHJhY2UuaW50ZXJhY3Rpb25zLnNlbmRLZXlQcmVzc0V2ZW50fS5cbiAqIFRoaXMgZnVuY3Rpb24gaXMgb25seSBhdmFpbGFibGUgaWYgdGhlIFVzZXIgSW50ZXJhY3Rpb24gbW9kdWxlIGlzIGVuYWJsZWQuXG4gKlxuICogQHBhcmFtIGZpZWxkcyAgICAgICAgIFRoZSBpbnRlcmFjdGlvbiBmaWVsZHMuIE11c3QgY29udGFpbiBhIGBrZXlzYCBhcnJheSB3aXRoIGF0IGxlYXN0IG9uZSBrZXkuXG4gKiAgICAgICAgICAgICAgICAgICAgICAgVGhlIGZpZWxkcyBvYmplY3QgbXVzdCBiZSBKU09OLXNlcmlhbGl6YWJsZS4gT3B0aW9uYWwgYHVpX2VsZW1lbnQuY3VzdG9tX25hbWVgIGFuZFxuICogICAgICAgICAgICAgICAgICAgICAgIGBldmVudF9wcm9wZXJ0aWVzLipgIGVudHJpZXMgYXJlIGFsbG93ZWQuIFNlZSB7QGxpbmsgU2VuZFVzZXJJbnRlcmFjdGlvbkZpZWxkc30gZm9yIGRldGFpbHMuXG4gKiBAcGFyYW0gZWxlbWVudE9yRXZlbnQgQW4gb3B0aW9uYWwge0BsaW5rIEVsZW1lbnR9IG9yIHtAbGluayBLZXlib2FyZEV2ZW50fSB1c2VkIHRvIGF1dG8tZ2VuZXJhdGUgVUkgZWxlbWVudCBmaWVsZHMuXG4gKiAgICAgICAgICAgICAgICAgICAgICAgV2hlbiBhIHtAbGluayBLZXlib2FyZEV2ZW50fSBpcyBwcm92aWRlZCwgdGhlIHRhcmdldCBlbGVtZW50IGlzIHJlc29sdmVkIGZyb20gdGhlIGV2ZW50LlxuICogQHBhcmFtIHRpbWVvdXQgICAgICAgIFRpbWVvdXQgaW4gbWlsbGlzZWNvbmRzIHRvIHdhaXQgZm9yIHRoZSBSVU0gSmF2YVNjcmlwdCB0byBiZSBhdmFpbGFibGUgKGRlZmF1bHQ6IDEwMDAwKVxuICogQHRocm93cyAgICAgICAgICAgICAgICBBIHtAbGluayBEeW5hdHJhY2VFcnJvcn0gaWYgdGhlIFJVTSBKYXZhU2NyaXB0IG9yIFVzZXIgSW50ZXJhY3Rpb24gbW9kdWxlIGlzIG5vdCBhdmFpbGFibGVcbiAqICAgICAgICAgICAgICAgICAgICAgICAgd2l0aGluIHRoZSB0aW1lb3V0LCBvciB0aGUgbmFtZXNwYWNlIGlzIG92ZXJyaWRkZW4gd2l0aCBhbiBpbmNvbXBhdGlibGUgb2JqZWN0XG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzZW5kS2V5UHJlc3NFdmVudChcbiAgICBmaWVsZHM6IFNlbmRVc2VySW50ZXJhY3Rpb25GaWVsZHMsXG4gICAgZWxlbWVudE9yRXZlbnQ/OiBFbGVtZW50IHwgRXZlbnQsXG4gICAgdGltZW91dDogbnVtYmVyID0gMTBfMDAwXG4pOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCBpbnRlcmFjdGlvbnMgPSBhd2FpdCB3YWl0Rm9ySW50ZXJhY3Rpb25zKHRpbWVvdXQpO1xuICAgIGludGVyYWN0aW9ucy5zZW5kS2V5UHJlc3NFdmVudChmaWVsZHMsIGVsZW1lbnRPckV2ZW50KTtcbn1cbiJdfQ==
+//# 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,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