@dynatrace/rum-javascript-sdk 1.329.2

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

@@ -0,0 +1,319 @@
+import type { ApiCreatedEventPropertiesEvent, ApiCreatedSessionPropertiesEvent, JSONEvent, JSONObject } from "../rum-events/json-event.js";
+import type { EventContext } from "../rum-events/event-context/event-context.js";
+import type { UserActionStartOptions } from "../user-actions/user-action-start-options.js";
+import type { UserActionTracker } from "../user-actions/user-action-tracker.js";
+/**
+ * A method which deactivates behavior when invoked.
+ * See the returning method's API for more details.
+ *
+ * @inline
+ * @ignore
+ */
+export type Unsubscriber = () => void;
+/**
+ * The configuration object provided to the runHealthCheck API.
+ *
+ * @see runHealthCheck
+ * @inline
+ * @ignore
+ */
+export interface HealthCheckConfig {
+    logVerbose?: boolean;
+    returnDiagnosticData?: boolean;
+    runDetailedOverrideCheck?: boolean;
+}
+/**
+ * @category API
+ */
+export declare namespace dynatrace {
+    /**
+     * Sends an event with the provided fields.
+     *
+     * @example
+     * ```typescript
+     * dynatrace.sendEvent({
+     *     "event_properties.prop": "value",
+     *     "duration": 123,
+     *     "event_properties.url": "www.dynatrace.com",
+     *     "event_properties.id": "123456789",
+     * });
+     *
+     * // Using context:
+     * document.addEventListener("load", (event) => {
+     *     dynatrace.sendEvent({
+     *          "event_properties.prop": "value",
+     *          "duration": 123,
+     *          "event_properties.url": "www.dynatrace.com",
+     *          "event_properties.id": "123456789",
+     *     }, event); // add the event context here
+     * });
+     *```
+     * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+     *                     values, otherwise they will be replaced with null. The `fields` need to be serializable
+     *                     using JSON.stringify. The resulting event will contain the provided `fields`, and is
+     *                     modified with additional properties, thus also empty objects are valid. Only properties
+     *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+     *                     allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
+     *                     All event property keys must contain only alphabetic characters, numbers,
+     *                     underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
+     *                     must be followed by an alphabetic character or number.
+     * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the
+     *                     result event within the modification callback.
+     */
+    function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown): void;
+    /**
+     * Send a Business Event.
+     *
+     * With sendBizEvent, you can report a business event. These standalone events are being sent detached from user
+     * actions or sessions.
+     *
+     * Note: Business events are currently only supported on Dynatrace SaaS deployments.
+     *
+     * @example
+     * ```typescript
+     * dynatrace.sendBizEvent("type", {
+     *     prop: "value",
+     *     name: "biz event name",
+     *     timestamp: 123,
+     *     url: "www.dynatrace.com",
+     *     page_id: "123456789",
+     *     "window.orientation": "diagonal"
+     * });
+     *
+     * // Using context:
+     * document.addEventListener("load", (event) => {
+     *     dynatrace.sendBizEvent("type", {
+     *         prop: "value",
+     *         name: "biz event name",
+     *         timestamp: 123,
+     *         url: "www.dynatrace.com",
+     *         page_id: "123456789",
+     *         "window.orientation": "diagonal"
+     *     }, event); // add the event context here
+     * });
+     *```
+     *
+     * @internal
+     * @param type         Mandatory event type
+     * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+     *                     values, otherwise they will be replaced with null. The `fields` need to be serializable
+     *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and
+     *                     modified with additional properties, thus also empty objects are valid.
+     * @param eventContext An optional context (see {@link dynatrace.addEventModifier}) that can be used to manipulate the
+     *                     result event within the modification callback. Will be provided as CustomEventContext TODO
+     */
+    function sendBizEvent(type: string, fields: JSONObject, eventContext?: unknown): void;
+    /**
+     * Modifies future events with the provided modifier function. Returning a non-object or `null` discards this event
+     * and prevents future mutator functions to be executed.
+     *
+     * Certain reserved fields and namespaces can’t be modified in any way (added, removed or overridden), while others are open for modification.
+     * See the public documentation for a detailed list of reserved/open fields (link will be added in the future).
+     *
+     * The context differs based on the processed event and availability of data.
+     * For events sent with {@link dynatrace.sendEvent}, the optionally provided context will be provided as custom context.
+     * The context object contains a "type" and optionally a "sub_type" parameter, which can be used to distinguish them.
+     *
+     * @example
+     * ```typescript
+     * dynatrace.addEventModifier(function (event) {
+     *     if (event["event.type"] !== "click") {
+     *         return event;
+     *     }
+     *     return {
+     *         ...event,
+     *         "event_properties.prop": "value",
+     *         "url.full": "www.dynatrace.com",
+     *         "view.detected_name": "123456789",
+     *     }
+     * });
+     *
+     * // Using context:
+     * dynatrace.addEventModifier(function (event, context) {
+     *     if (event["event.type"] !== "click") {
+     *         return event;
+     *     }
+     *     if (context?.additionalData) {
+     *         return {
+     *           ...event,
+     *           "event_properties.extra_data": `received extra data: ${context.additionalData}`
+     *         };
+     *     }
+     *     return event;
+     * });
+     *
+     * // Discarding an event:
+     * dynatrace.addEventModifier(function (event) {
+     *   if (event["event.type"] === "click") {
+     *     return null;
+     *   }
+     *   return event;
+     * });
+     * ```
+     *
+     * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context
+     *                      depending on the type of event, if available. The returned event must be a new object, otherwise
+     *                      modification will be ignored. Modification is only allowed for fields declared in
+     *                      {@link AllowedModificationFields}.
+     * @returns             The unsubscriber function to turn off event modification.
+     */
+    function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null): Unsubscriber;
+    /**
+     * If not already enabled, dynamically loads the Health Check module which will read accumulated health check data
+     * and present it in the browser developer tools console.
+     *
+     * @param config                          The optional configuration object for the health check.
+     * @param config.logVerbose               If true, verbose information is included in the health check.
+     * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.
+     * @param config.runDetailedOverrideCheck if true, additional information will be logged to the console for overridden native APIs.
+     * @returns                               A promise that settles as soon as the health check has been performed.
+     */
+    function runHealthCheck(config?: HealthCheckConfig): Promise<unknown[] | undefined>;
+    /**
+     * Enables debug logging.
+     *
+     * @internal not public yet
+     * @param    loggingInformation An object that specifies what should be logged
+     * @returns                     A promise that settles as soon as debug logging has been enabled
+     */
+    function enableDebugLogging(loggingInformation: Record<string, boolean>): Promise<void> | void;
+    /**
+     * Use to identify individual users across different browsers, devices, and user sessions.
+     *
+     * @param value The name of the user. For example, use a name, userid, or your user's email address.
+     *
+     * @example
+     * ```typescript
+     * dynatrace.identifyUser("john.doe@example.com");
+     * ```
+     */
+    function identifyUser(value: string): void;
+    /**
+     * Sends a sessionPropertyEvent.
+     *
+     * @example
+     * ```typescript
+     * dynatrace.sendSessionPropertyEvent({
+     *     "session_properties.some_custom": true,
+     *     "session_properties.my_id": "m123456",
+     *     "session_properties.my_other_id_2": "x123",
+     *     "session_properties.my_fully_other.id3": "id007",
+     * });
+     *```
+     * @param fields Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+     *               values, otherwise they will be replaced with null. The `fields` need to be serializable
+     *               using JSON.stringify. The resulting event will be populated with `fields` parameter, and
+     *               is modified with additional properties, thus also empty objects are valid. Only properties
+     *               prefixed with `session_properties.`, the `duration` property and the `start_time` property are
+     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off. All
+     *               session property keys must contain only alphabetic characters, numbers, underscores or
+     *               dots. Each dot must be followed by an alphabetic character. Each underscore must be followed by an
+     *               alphabetic character or number.
+     */
+    function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void;
+    /**
+     * This function is only available if the Error module is enabled
+     *
+     * @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.
+     * @param fields Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+     *               values, otherwise they will be replaced with null. The `fields` need to be serializable
+     *               using JSON.stringify. The resulting event will contain the provided `fields`, and is
+     *               modified with additional properties, thus also empty objects are valid. Only properties
+     *               prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+     *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
+     *               All event property keys must contain only alphabetic characters, numbers,
+     *               underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
+     *               must be followed by an alphabetic character or number.
+     */
+    let sendExceptionEvent: ((error: Error, fields?: ApiCreatedEventPropertiesEvent) => void) | undefined;
+    /**
+     * This property is `undefined` if the User Actions module is disabled.
+     *
+     * @experimental
+     */
+    let userActions: UserActions | undefined;
+}
+/**
+ * @experimental
+ * @category User Actions
+ */
+export interface UserActions {
+    /**
+     * Creates a new controllable user action.
+     *
+     * @example
+     * ```typescript
+     * const userAction = dynatrace.userActions.create({ autoClose: false });
+     * const unsubscribe = userAction.subscribe(currentUserAction => {
+     *     console.log(`User action would have been completed due to ${currentUserAction.completeReason}`, event);
+     * });
+     * // execute user actions
+     * userAction.finish();
+     * unsubscribe();
+     * ```
+     *
+     * @experimental
+     * @param options           An optional options object to configure the user action.
+     * @param options.autoClose If true, automatically stops the user action using RUM JavaScript user action rules.
+     *                          If false, the user action remains active until the next call to `create(...)` or to `userAction.finish()`.
+     * @returns                 An `UserActionTracker` object that can be started and finished, or `undefined` if the user action module is not enabled.
+     */
+    create(this: void, options?: UserActionStartOptions): UserActionTracker;
+    /**
+     * Subscribes to user actions.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = dynatrace.userActions?.subscribe(userAction => {
+     *     // Disable automatic userAction completion
+     *     userAction.autoClose = false;
+     *     // Execute some requests or mutations, then finish the user action
+     *     userAction.finish();
+     * });
+     * // Some time later if you don't want to listen to userActions anymore
+     * unsubscribe();
+     * ```
+     *
+     * @experimental
+     * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.
+     * @returns          An unsubscriber function to remove the subscription.
+     */
+    subscribe(this: void, subscriber: (userAction: UserActionTracker) => void): Unsubscriber;
+    /**
+     * Disables automatic user action detection. Useful in case it interferes with manual user action handling.
+     *
+     * @example
+     * ```typescript
+     * dynatrace.userActions?.setAutomaticDetection(false);
+     *
+     * async function handleClick(router) {
+     *     const userAction = dynatrace.userActions?.create({ autoClose: false });
+     *     // this would normally create an user action that would finish this manual user action
+     *     await router.redirect("home");
+     *     userAction.finish();
+     * }
+     * ```
+     *
+     * @experimental
+     * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.
+     */
+    setAutomaticDetection(this: void, automaticDetection: boolean): void;
+    /**
+     * The current user action, or `undefined` if no user action is in progress.
+     *
+     * @experimental
+     * @example
+     * ```typescript
+     * async function postMessageChannel(message, channel) {
+     *   const currentUserAction = dynatrace.userActions?.current;
+     *   if (currentUserAction) {
+     *      currentUserAction.autoClose = false;
+     *   }
+     *   const response = await channel.send(message);
+     *   currentUserAction?.finish();
+     *   return response;
+     * }
+     * ```
+     */
+    current: UserActionTracker | undefined;
+}

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

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

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

@@ -0,0 +1 @@
+export * from "./dynatrace-api-types.js";

package/dist/types/api/index.js

@@ -0,0 +1,2 @@
+export * from "./dynatrace-api-types.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvdHlwZXMvYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9keW5hdHJhY2UtYXBpLXR5cGVzLmpzXCI7XG4iXX0=

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

@@ -0,0 +1,31 @@
+export * from "./api/dynatrace-api-types.js";
+export * from "./user-actions/user-action-tracker.js";
+export * from "./user-actions/user-action-end-event.js";
+export * from "./user-actions/user-action-start-options.js";
+export * from "./rum-events/event-context/event-context.js";
+export * from "./rum-events/rum-event.js";
+export * from "./rum-events/event-updates.js";
+export * from "./rum-events/json-event.js";
+export * from "./rum-events/rum-biz-event.js";
+export * from "./rum-events/schema-versions.js";
+export * from "./rum-events/rum-user-action-event.js";
+export * from "./rum-events/rum-long-task-event.js";
+export * from "./rum-events/rum-web-request-event.js";
+export * from "./rum-events/rum-page-summary-event.js";
+export * from "./rum-events/rum-selfmonitoring-event.js";
+export * from "./rum-events/rum-user-interaction-event.js";
+export * from "./rum-events/rum-visibility-change-event.js";
+export * from "./rum-events/rum-session-properties-event.js";
+export * from "./rum-events/rum-standalone-exception-event.js";
+export * from "./rum-events/rum-standalone-navigation-event.js";
+export * from "./rum-events/rum-internal-selfmonitoring-event.js";
+export * from "./rum-events/rum-standalone-csp-rule-violation-event.js";
+export * from "./rum-events/shared-namespaces-and-fields/csp-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/http-namespace.js";
+export * from "./rum-events/shared-namespaces-and-fields/request-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/exception-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/navigation-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/page-source-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/view-source-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/general-rum-error-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/general-rum-event-fields.js";

package/dist/types/index-typedoc.js

@@ -0,0 +1,32 @@
+export * from "./api/dynatrace-api-types.js";
+export * from "./user-actions/user-action-tracker.js";
+export * from "./user-actions/user-action-end-event.js";
+export * from "./user-actions/user-action-start-options.js";
+export * from "./rum-events/event-context/event-context.js";
+export * from "./rum-events/rum-event.js";
+export * from "./rum-events/event-updates.js";
+export * from "./rum-events/json-event.js";
+export * from "./rum-events/rum-biz-event.js";
+export * from "./rum-events/schema-versions.js";
+export * from "./rum-events/rum-user-action-event.js";
+export * from "./rum-events/rum-long-task-event.js";
+export * from "./rum-events/rum-web-request-event.js";
+export * from "./rum-events/rum-page-summary-event.js";
+export * from "./rum-events/rum-selfmonitoring-event.js";
+export * from "./rum-events/rum-user-interaction-event.js";
+export * from "./rum-events/rum-visibility-change-event.js";
+export * from "./rum-events/rum-session-properties-event.js";
+export * from "./rum-events/rum-standalone-exception-event.js";
+export * from "./rum-events/rum-standalone-navigation-event.js";
+export * from "./rum-events/rum-internal-selfmonitoring-event.js";
+export * from "./rum-events/rum-standalone-csp-rule-violation-event.js";
+export * from "./rum-events/shared-namespaces-and-fields/csp-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/http-namespace.js";
+export * from "./rum-events/shared-namespaces-and-fields/request-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/exception-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/navigation-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/page-source-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/view-source-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/general-rum-error-fields.js";
+export * from "./rum-events/shared-namespaces-and-fields/general-rum-event-fields.js";
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+import type { dynatrace as DtApi } from "./api/dynatrace-api-types.js";
+declare global {
+    var dynatrace: typeof DtApi | undefined;
+    interface Window {
+        dynatrace: typeof DtApi | undefined;
+    }
+}
+export * from "./user-actions/index.js";
+export * from "./api/index.js";
+export * from "./rum-events/index.js";
+export * from "./internal/index.js";

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export * from "./user-actions/index.js";
+export * from "./api/index.js";
+export * from "./rum-events/index.js";
+export * from "./internal/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgZHluYXRyYWNlIGFzIER0QXBpIH0gZnJvbSBcIi4vYXBpL2R5bmF0cmFjZS1hcGktdHlwZXMuanNcIjtcblxuZGVjbGFyZSBnbG9iYWwge1xuICAgIHZhciBkeW5hdHJhY2U6IHR5cGVvZiBEdEFwaSB8IHVuZGVmaW5lZDsgLy8gTk9TT05BUlxuICAgIGludGVyZmFjZSBXaW5kb3cge1xuICAgICAgICBkeW5hdHJhY2U6IHR5cGVvZiBEdEFwaSB8IHVuZGVmaW5lZDtcbiAgICB9XG59XG5cbmV4cG9ydCAqIGZyb20gXCIuL3VzZXItYWN0aW9ucy9pbmRleC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXBpL2luZGV4LmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ydW0tZXZlbnRzL2luZGV4LmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnRlcm5hbC9pbmRleC5qc1wiO1xuIl19

package/dist/types/internal/beacon-query.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @internal
+ */
+export declare const enum BeaconQueryKeys {
+    APPLICATION_ID = "ai",
+    BEACON_TYPE = "ty",
+    BODY_CRC = "bc",
+    CONFIGURATION_REVISION = "cr",
+    CONTENT_TYPE = "cy",
+    END = "end",
+    ENVIRONMENT = "en",
+    FRONTEND_AGENT_VERSION = "av",
+    PROTOCOL_VERSION = "pv",
+    QUERY_CRC = "qc",
+    SENDING_CAUSE = "sc",
+    SENDING_STRATEGY = "ss",
+    TIMESTAMP = "st"
+}
+/**
+ * @internal
+ */
+export declare const enum OptionalBeaconQueryKeys {
+    COMPRESSION = "co",
+    DT_ADK = "da",// unused until further notice
+    PRIORITY = "pr",
+    RETRY_COUNT = "rc",
+    RETRY_REASON = "rr",
+    SESSION_INFORMATION = "si"
+}

package/dist/types/internal/beacon-query.js

@@ -0,0 +1,32 @@
+/**
+ * @internal
+ */
+export var BeaconQueryKeys;
+(function (BeaconQueryKeys) {
+    BeaconQueryKeys["APPLICATION_ID"] = "ai";
+    BeaconQueryKeys["BEACON_TYPE"] = "ty";
+    BeaconQueryKeys["BODY_CRC"] = "bc";
+    BeaconQueryKeys["CONFIGURATION_REVISION"] = "cr";
+    BeaconQueryKeys["CONTENT_TYPE"] = "cy";
+    BeaconQueryKeys["END"] = "end";
+    BeaconQueryKeys["ENVIRONMENT"] = "en";
+    BeaconQueryKeys["FRONTEND_AGENT_VERSION"] = "av";
+    BeaconQueryKeys["PROTOCOL_VERSION"] = "pv";
+    BeaconQueryKeys["QUERY_CRC"] = "qc";
+    BeaconQueryKeys["SENDING_CAUSE"] = "sc";
+    BeaconQueryKeys["SENDING_STRATEGY"] = "ss";
+    BeaconQueryKeys["TIMESTAMP"] = "st";
+})(BeaconQueryKeys || (BeaconQueryKeys = {}));
+/**
+ * @internal
+ */
+export var OptionalBeaconQueryKeys;
+(function (OptionalBeaconQueryKeys) {
+    OptionalBeaconQueryKeys["COMPRESSION"] = "co";
+    OptionalBeaconQueryKeys["DT_ADK"] = "da";
+    OptionalBeaconQueryKeys["PRIORITY"] = "pr";
+    OptionalBeaconQueryKeys["RETRY_COUNT"] = "rc";
+    OptionalBeaconQueryKeys["RETRY_REASON"] = "rr";
+    OptionalBeaconQueryKeys["SESSION_INFORMATION"] = "si";
+})(OptionalBeaconQueryKeys || (OptionalBeaconQueryKeys = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVhY29uLXF1ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc291cmNlL3R5cGVzL2ludGVybmFsL2JlYWNvbi1xdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFrQixlQWNqQjtBQWRELFdBQWtCLGVBQWU7SUFDN0Isd0NBQXFCLENBQUE7SUFDckIscUNBQWtCLENBQUE7SUFDbEIsa0NBQWUsQ0FBQTtJQUNmLGdEQUE2QixDQUFBO0lBQzdCLHNDQUFtQixDQUFBO0lBQ25CLDhCQUFXLENBQUE7SUFDWCxxQ0FBa0IsQ0FBQTtJQUNsQixnREFBNkIsQ0FBQTtJQUM3QiwwQ0FBdUIsQ0FBQTtJQUN2QixtQ0FBZ0IsQ0FBQTtJQUNoQix1Q0FBb0IsQ0FBQTtJQUNwQiwwQ0FBdUIsQ0FBQTtJQUN2QixtQ0FBZ0IsQ0FBQTtBQUNwQixDQUFDLEVBZGlCLGVBQWUsS0FBZixlQUFlLFFBY2hDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBa0IsdUJBT2pCO0FBUEQsV0FBa0IsdUJBQXVCO0lBQ3JDLDZDQUFrQixDQUFBO0lBQ2xCLHdDQUFhLENBQUE7SUFDYiwwQ0FBZSxDQUFBO0lBQ2YsNkNBQWtCLENBQUE7SUFDbEIsOENBQW1CLENBQUE7SUFDbkIscURBQTBCLENBQUE7QUFDOUIsQ0FBQyxFQVBpQix1QkFBdUIsS0FBdkIsdUJBQXVCLFFBT3hDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNvbnN0IGVudW0gQmVhY29uUXVlcnlLZXlzIHtcbiAgICBBUFBMSUNBVElPTl9JRCA9IFwiYWlcIixcbiAgICBCRUFDT05fVFlQRSA9IFwidHlcIixcbiAgICBCT0RZX0NSQyA9IFwiYmNcIixcbiAgICBDT05GSUdVUkFUSU9OX1JFVklTSU9OID0gXCJjclwiLFxuICAgIENPTlRFTlRfVFlQRSA9IFwiY3lcIixcbiAgICBFTkQgPSBcImVuZFwiLFxuICAgIEVOVklST05NRU5UID0gXCJlblwiLFxuICAgIEZST05URU5EX0FHRU5UX1ZFUlNJT04gPSBcImF2XCIsXG4gICAgUFJPVE9DT0xfVkVSU0lPTiA9IFwicHZcIixcbiAgICBRVUVSWV9DUkMgPSBcInFjXCIsXG4gICAgU0VORElOR19DQVVTRSA9IFwic2NcIixcbiAgICBTRU5ESU5HX1NUUkFURUdZID0gXCJzc1wiLFxuICAgIFRJTUVTVEFNUCA9IFwic3RcIlxufVxuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgY29uc3QgZW51bSBPcHRpb25hbEJlYWNvblF1ZXJ5S2V5cyB7XG4gICAgQ09NUFJFU1NJT04gPSBcImNvXCIsXG4gICAgRFRfQURLID0gXCJkYVwiLCAvLyB1bnVzZWQgdW50aWwgZnVydGhlciBub3RpY2VcbiAgICBQUklPUklUWSA9IFwicHJcIixcbiAgICBSRVRSWV9DT1VOVCA9IFwicmNcIixcbiAgICBSRVRSWV9SRUFTT04gPSBcInJyXCIsXG4gICAgU0VTU0lPTl9JTkZPUk1BVElPTiA9IFwic2lcIlxufVxuIl19

package/dist/types/internal/data-dt-config-scope.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+export declare const enum DataDtConfigScope {
+    APP_CONFIG = "data-appconfig",
+    BASE_CONFIG = "data-config",
+    DEBUG_CONFIG = "data-debugconfig",
+    ENV_CONFIG = "data-envconfig",
+    SYNTHETIC_CONFIG = "data-syntheticconfig"
+}

package/dist/types/internal/data-dt-config-scope.js

@@ -0,0 +1,12 @@
+/**
+ * @internal
+ */
+export var DataDtConfigScope;
+(function (DataDtConfigScope) {
+    DataDtConfigScope["APP_CONFIG"] = "data-appconfig";
+    DataDtConfigScope["BASE_CONFIG"] = "data-config";
+    DataDtConfigScope["DEBUG_CONFIG"] = "data-debugconfig";
+    DataDtConfigScope["ENV_CONFIG"] = "data-envconfig";
+    DataDtConfigScope["SYNTHETIC_CONFIG"] = "data-syntheticconfig";
+})(DataDtConfigScope || (DataDtConfigScope = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1kdC1jb25maWctc2NvcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvdHlwZXMvaW50ZXJuYWwvZGF0YS1kdC1jb25maWctc2NvcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBa0IsaUJBTWpCO0FBTkQsV0FBa0IsaUJBQWlCO0lBQy9CLGtEQUE2QixDQUFBO0lBQzdCLGdEQUEyQixDQUFBO0lBQzNCLHNEQUFpQyxDQUFBO0lBQ2pDLGtEQUE2QixDQUFBO0lBQzdCLDhEQUF5QyxDQUFBO0FBQzdDLENBQUMsRUFOaUIsaUJBQWlCLEtBQWpCLGlCQUFpQixRQU1sQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBjb25zdCBlbnVtIERhdGFEdENvbmZpZ1Njb3BlIHtcbiAgICBBUFBfQ09ORklHID0gXCJkYXRhLWFwcGNvbmZpZ1wiLFxuICAgIEJBU0VfQ09ORklHID0gXCJkYXRhLWNvbmZpZ1wiLFxuICAgIERFQlVHX0NPTkZJRyA9IFwiZGF0YS1kZWJ1Z2NvbmZpZ1wiLFxuICAgIEVOVl9DT05GSUcgPSBcImRhdGEtZW52Y29uZmlnXCIsXG4gICAgU1lOVEhFVElDX0NPTkZJRyA9IFwiZGF0YS1zeW50aGV0aWNjb25maWdcIlxufVxuIl19

package/dist/types/internal/feature-hashes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @internal
+ */
+export declare const enum FeatureHashes {
+    F1_CORE_GEN3 = "1",
+    F3_HEALTH_CHECK = "3",
+    F5_ERRORS = "5",
+    F8_FETCH_DETECTION = "8",
+    F9_PAGE_SUMMARY = "9",
+    FH_TEST_HELPER = "H",
+    FM_METADATA_CAPTURING = "M",
+    FP_NAVIGATION = "P",
+    FR_RESOURCE_TIMINGS = "R",
+    Fs_SESSIONS = "s",
+    FT_USER_ACTIONS = "T",
+    FU_USER_INTERACTION = "U",
+    FX_XHR_DETECTION = "X",
+    FY_SYNTHETIC = "Y"
+}

package/dist/types/internal/feature-hashes.js

@@ -0,0 +1,22 @@
+/**
+ * @internal
+ */
+export var FeatureHashes;
+(function (FeatureHashes) {
+    FeatureHashes["F1_CORE_GEN3"] = "1";
+    FeatureHashes["F3_HEALTH_CHECK"] = "3";
+    FeatureHashes["F5_ERRORS"] = "5";
+    FeatureHashes["F8_FETCH_DETECTION"] = "8";
+    FeatureHashes["F9_PAGE_SUMMARY"] = "9";
+    FeatureHashes["FH_TEST_HELPER"] = "H";
+    FeatureHashes["FM_METADATA_CAPTURING"] = "M";
+    FeatureHashes["FP_NAVIGATION"] = "P";
+    FeatureHashes["FR_RESOURCE_TIMINGS"] = "R";
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- need to follow feature hash name
+    FeatureHashes["Fs_SESSIONS"] = "s";
+    FeatureHashes["FT_USER_ACTIONS"] = "T";
+    FeatureHashes["FU_USER_INTERACTION"] = "U";
+    FeatureHashes["FX_XHR_DETECTION"] = "X";
+    FeatureHashes["FY_SYNTHETIC"] = "Y";
+})(FeatureHashes || (FeatureHashes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVhdHVyZS1oYXNoZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvdHlwZXMvaW50ZXJuYWwvZmVhdHVyZS1oYXNoZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBa0IsYUFnQmpCO0FBaEJELFdBQWtCLGFBQWE7SUFDM0IsbUNBQWtCLENBQUE7SUFDbEIsc0NBQXFCLENBQUE7SUFDckIsZ0NBQWUsQ0FBQTtJQUNmLHlDQUF3QixDQUFBO0lBQ3hCLHNDQUFxQixDQUFBO0lBQ3JCLHFDQUFvQixDQUFBO0lBQ3BCLDRDQUEyQixDQUFBO0lBQzNCLG9DQUFtQixDQUFBO0lBQ25CLDBDQUF5QixDQUFBO0lBQ3pCLG9HQUFvRztJQUNwRyxrQ0FBaUIsQ0FBQTtJQUNqQixzQ0FBcUIsQ0FBQTtJQUNyQiwwQ0FBeUIsQ0FBQTtJQUN6Qix1Q0FBc0IsQ0FBQTtJQUN0QixtQ0FBa0IsQ0FBQTtBQUN0QixDQUFDLEVBaEJpQixhQUFhLEtBQWIsYUFBYSxRQWdCOUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgY29uc3QgZW51bSBGZWF0dXJlSGFzaGVzIHtcbiAgICBGMV9DT1JFX0dFTjMgPSBcIjFcIixcbiAgICBGM19IRUFMVEhfQ0hFQ0sgPSBcIjNcIixcbiAgICBGNV9FUlJPUlMgPSBcIjVcIixcbiAgICBGOF9GRVRDSF9ERVRFQ1RJT04gPSBcIjhcIixcbiAgICBGOV9QQUdFX1NVTU1BUlkgPSBcIjlcIixcbiAgICBGSF9URVNUX0hFTFBFUiA9IFwiSFwiLFxuICAgIEZNX01FVEFEQVRBX0NBUFRVUklORyA9IFwiTVwiLFxuICAgIEZQX05BVklHQVRJT04gPSBcIlBcIixcbiAgICBGUl9SRVNPVVJDRV9USU1JTkdTID0gXCJSXCIsXG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvbiAtLSBuZWVkIHRvIGZvbGxvdyBmZWF0dXJlIGhhc2ggbmFtZVxuICAgIEZzX1NFU1NJT05TID0gXCJzXCIsXG4gICAgRlRfVVNFUl9BQ1RJT05TID0gXCJUXCIsXG4gICAgRlVfVVNFUl9JTlRFUkFDVElPTiA9IFwiVVwiLFxuICAgIEZYX1hIUl9ERVRFQ1RJT04gPSBcIlhcIixcbiAgICBGWV9TWU5USEVUSUMgPSBcIllcIlxufVxuIl19

package/dist/types/internal/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./beacon-query.js";
+export * from "./data-dt-config-scope.js";
+export * from "./feature-hashes.js";

package/dist/types/internal/index.js

@@ -0,0 +1,4 @@
+export * from "./beacon-query.js";
+export * from "./data-dt-config-scope.js";
+export * from "./feature-hashes.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvdHlwZXMvaW50ZXJuYWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9iZWFjb24tcXVlcnkuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RhdGEtZHQtY29uZmlnLXNjb3BlLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9mZWF0dXJlLWhhc2hlcy5qc1wiO1xuIl19