@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/ejs/Tracker.js

@@ -0,0 +1,2455 @@
+import { parsePulseCookies } from '@schibsted/pulse-cis-sync';
+import { evaluateAndFlatten, isBrowser, isFunction, isPromise, isString, pulseMerge, throttle, } from '@schibsted/pulse-utils';
+import { buildAnonymousViewUIElementEvent, buildCompletedHealthActionEvent, buildEngagementAudioEvent, buildEngagementFormEvent, buildEngagementHealthUIElementEvent, buildEngagementOfferEvent, buildEngagementTeaserEvent, buildEngagementUIElementEvent, buildEngagementVideoAdEvent, buildEngagementVideoEvent, buildEngagementWidgetEvent, buildImpressionAdSlotEvent, buildImpressionFormEvent, buildImpressionHealthUIElementEvent, buildImpressionOfferEvent, buildImpressionPlayerEvent, buildImpressionTeaserEvent, buildImpressionUIElementEvent, buildImpressionWidgetEvent, buildLeaveArticleEvent, buildLeaveAudioPageEvent, buildLeaveErrorEvent, buildLeaveFrontpageEvent, buildLeaveLandingpageEvent, buildLeaveListingEvent, buildLeaveLockedArticleEvent, buildLeaveLockedAudioEvent, buildLeaveLockedAudioPageEvent, buildLeaveLockedVideoEvent, buildLeaveLockedVideoPageEvent, buildLeavePageEvent, buildLeaveVideoPageEvent, buildLeaveWeatherEvent, buildViewArticleEvent, buildViewAudioEvent, buildViewAudioPageEvent, buildViewErrorEvent, buildViewFrontpageEvent, buildViewHealthPageEvent, buildViewLandingpageEvent, buildViewListingEvent, buildViewLockedArticleEvent, buildViewLockedAudioEvent, buildViewLockedAudioPageEvent, buildViewLockedVideoEvent, buildViewLockedVideoPageEvent, buildViewPageEvent, buildViewTitleEvent, buildViewVideoEvent, buildViewVideoPageEvent, buildViewWeatherEvent, getCommonBuildersOutput, } from '@schibsted/tpaas-event-builder';
+import { LeaveArticle, LeaveAudioPage, LeaveError, LeaveFrontpage, LeaveLandingpage, LeaveListing, LeaveLockedArticle, LeaveLockedAudioPage, LeaveLockedVideoPage, LeavePage, LeaveVideoPage, LeaveWeather, ViewArticle, ViewError, ViewFrontpage, ViewListing, ViewLockedArticle, ViewLockedVideo, ViewPage, ViewTitle, } from '@schibsted/tpaas-schemas';
+import logger from 'loglevel';
+import { v4 } from 'uuid';
+import { getDefaultAltHandler, getDefaultNativeJwe } from './app-integration';
+import { provider, session as sessionBuilder } from './builders';
+import { getConsentsWaitForAnalytics, getFallbackConsents } from './builders/consent-manager';
+import { applyAdvertisingConsent, applyAdvertisingConsentSync, } from './builders/consents';
+import { engagementEvent, identityEvent, routableEvent, trackerEvent } from './builders/events';
+import { anonymousEngagementEvent, anonymousTrackerEvent } from './builders/events-anonymous-node';
+import { readSession } from './builders/session-browser';
+import { baseConfig as defaultConfig } from './config';
+import { CISEndpoints, collectorEndpoints, remoteConfig } from './config-browser';
+import defer from './defer';
+import { createEventBus } from './EventBus/EventBus';
+import * as identity from './identity';
+import { addPageLeaveTracking, leaveTrackingIsActive, removePageLeaveTracking, resetViewedContent, trackActivePageLeave, trackPageLeave, updatePageLeaveEvent, updatePageLeaveTracking, updateViewedContent, } from './leaveTracking';
+import { addTpaasLeaveTracking, getTpaasLeaveObject, leaveTpaasTrackingIsActive, resetTpaasViewedContent, shouldEnableLeaveTracking, trackTpaasActiveLeave, updateTpaasLeaveTracking, updateTpaasViewedContent, } from './leaveTrackingTpaas';
+import send from './network';
+import * as config from './remoteConfig';
+import { startProxyProviderListener } from './tracker-proxy/proxy-provider';
+import version from './version.json';
+import { VisibilityObserver } from './visibility-observer';
+import warnOnce from './warnOnce';
+import { buildClickUIElementEvent } from './wrapper/engagement/ui-element/event-builder';
+import { pageFromPageView } from './wrapper/utils/page-from-page-view';
+import { buildLegacyViewArticleEvent } from './wrapper/view/article/event-builder';
+import { buildLegacyViewFrontpageEvent } from './wrapper/view/frontpage/event-builder';
+import { buildLegacyViewListingEvent } from './wrapper/view/listing/event-builder';
+import { buildViewLoginPosterEvent } from './wrapper/view/loginposter/event-builder';
+import { buildLegacyViewPageEvent } from './wrapper/view/page/event-builder';
+import { buildViewSalesPosterEvent } from './wrapper/view/salesposter/event-builder';
+import { buildLegacyViewUIElementEvent } from './wrapper/view/ui-element/event-builder';
+const { generateProviderSDRN: providerSdrn } = provider;
+/**
+ * Event Builder lookup
+ * @internal
+ */
+const events = {
+    identity: identityEvent,
+    trackerEvent: trackerEvent,
+    engagementEvent: engagementEvent,
+    routableEvent: routableEvent,
+};
+/**
+ * @typeParam T Type of event to track
+ * @param name
+ * @internal
+ */
+function getEventBuilder(name) {
+    return name in events ? events[name] : events.trackerEvent;
+}
+/**
+ * Event Builder lookup for anonymous events
+ * @internal
+ */
+const anonymousEvents = {
+    trackerEvent: anonymousTrackerEvent,
+    engagementEvent: anonymousEngagementEvent,
+};
+/**
+ * @typeParam T Type of event to track
+ * @param name
+ * @internal
+ */
+function getAnonymousEventBuilder(name) {
+    return name in anonymousEvents ? anonymousEvents[name] : anonymousEvents.trackerEvent;
+}
+/**
+ * Determines if the SDK is running in a Hybrid (WebView) environment.
+ *
+ * @remarks
+ *
+ * Historically, we have detected the presence of "nativeJwe" config coming from the native app to flag that setup.
+ * Additionally, a config param can be passed to explicitly indicate that the tracker was initialised in a mobile WebView.
+ *
+ * @param config {SDKConfigInput}
+ * @internal
+ */
+const isHybrid = (config) => Boolean(config?.isHybrid) || Boolean(config?.nativeJwe);
+/**
+ * @internal
+ * Used to register whether the Collector and CIS base urls are set in the config params, before the state is populated
+ * with the default values.
+ */
+let isCollectorInConfig = false;
+let isCisInConfig = false;
+/**
+ * @internal
+ */
+export const BookmarkKeys = {
+    PAGE_VIEW: 'page-view',
+};
+const eventBus = createEventBus({
+    namespace: 'pulse',
+    domBridge: true,
+    preventBridgeEcho: true,
+});
+export function subscribe(eventName, callback) {
+    return eventBus.on(eventName, callback);
+}
+export function subscribeOnce(eventName, callback) {
+    return eventBus.once(eventName, callback);
+}
+export function subscribeWithState(eventName, callback) {
+    return eventBus.onWithState(eventName, callback);
+}
+export function unsubscribe(eventName, callback) {
+    eventBus.off(eventName, callback);
+}
+/**
+ * @class Tracker
+ */
+export default class Tracker {
+    /**
+     * > [!WARNING]
+     * >
+     * > For legacy reasons the `providerId` parameter is called so, but it is actually the
+     * > `CLIENT-ID` of the site or app.
+     * > Do not mix it up with a full `SDRN` Provider ID. Ex:<br/>
+     * > * `PROVIDER-ID` = `sdrn:schibsted:client:my-client-id`<br/>
+     * > * `CLIENT-ID` = `my-client-id` = `config.providerId`
+     *
+     * @param providerId `CLIENT-ID` of the site or app.
+     * @param config Options to set the SDK with
+     * @param builders Initial values for event properties that will be persisted across events
+     */
+    constructor(providerId, config, builders) {
+        // we have separated observers for legacy and tpaas events in order to allow
+        // the tracking of the same element with both old and new events at the same time
+        this.legacyVisibilityObservers = new Map();
+        this.visibilityObservers = new Map();
+        this.legacyCurrentPage = {
+            id: 'undefined-id',
+            type: 'Page',
+            url: typeof window !== 'undefined' ? window.location.href : '',
+        };
+        this.currentPage = undefined;
+        /**
+         * Promise that resolves when a session ID becomes available
+         * @private
+         */
+        this.sessionIdPromise = null;
+        this.setPageDefaults = (pageViewEvent) => {
+            this.legacyCurrentPage = pageFromPageView(pageViewEvent);
+            if (pageViewEvent.origin) {
+                const pageDefaults = { origin: pageViewEvent.origin };
+                this.update(pageDefaults, true);
+            }
+        };
+        this.setCurrentPage = (id, type) => {
+            this.currentPage = {
+                pageId: id,
+                pageType: type,
+                url: isBrowser ? window.location.href : undefined,
+            };
+        };
+        logger.setLevel(config?.logLevel ?? logger.levels.ERROR);
+        // runtime check for providerId inconsistency
+        if (!providerId || !(typeof providerId === 'string')) {
+            throw new Error('Required parameter `providerId` missing');
+        }
+        let includeAdvertising;
+        if (isBrowser && config?.autoCreateConsents) {
+            config.consents = getConsentsWaitForAnalytics((consents) => {
+                logger.debug('Consents received from CMP', consents);
+                return this.setConsentsInternal(consents);
+            });
+        }
+        if (isPromise(config?.consents)) {
+            includeAdvertising = applyAdvertisingConsent(config?.consents, config?.requireAdvertisingOptIn);
+        }
+        else {
+            includeAdvertising = applyAdvertisingConsentSync(config?.consents, config?.requireAdvertisingOptIn);
+        }
+        // TODO: this check should not be necessary. The config should be mandatory as a type, fix it in the future
+        if (config) {
+            config.nativeJwe = getDefaultNativeJwe(config);
+            config.altEventHandler = getDefaultAltHandler(config);
+        }
+        isCisInConfig = Boolean(config?.cisBaseUrl);
+        isCollectorInConfig = Boolean(config?.collectorBaseUrl);
+        identity.clearCookieJweIfStale(config?.nativeJwe);
+        const deployStage = config?.deployStage || 'pro';
+        const deployStageTpaas = config?.deployStageTpaas || 'pre';
+        this.state = pulseMerge({}, defaultConfig, {
+            collectorBaseUrl: collectorEndpoints[deployStage],
+            deployStage,
+            deployStageTpaas,
+            fallbackCisBaseUrl: CISEndpoints[deployStage],
+            fallbackCollectorBaseUrl: collectorEndpoints[deployStage],
+            includeAdvertising,
+            isHybrid: isHybrid(config),
+            pageViewId: v4(),
+            providerId,
+            remoteConfigurationUrl: remoteConfig[deployStage],
+            schemaLocation: 'schema.schibsted.com',
+            tpaasCollectorBaseUrl: collectorEndpoints[deployStageTpaas],
+            trackerId: v4(),
+            vendors: config?.vendors?.length ? [] : ['xandr'],
+        }, config);
+        // Move to default config?
+        this.builders = pulseMerge({}, builders, {
+            provider: {
+                id: providerId,
+            },
+            tracker: {
+                version: version.SDK_VERSION,
+            },
+        });
+        this.bookmark = new Map();
+        // Replace with a linked list of Promises?
+        this.eventQueue = [];
+        this.retryEventQueue = [];
+        this.tpaasEventQueue = [];
+        this.anonymousEventQueue = [];
+        this.retryAnonymousEventQueue = [];
+        this.retryTpaasEventQueue = [];
+        if (this.state.environment === 'browser') {
+            // @ts-expect-error
+            if (isBrowser && window.navigator?.sendBeacon) {
+                const originalUseBeacon = this.state.useBeacon;
+                window.addEventListener('pagehide', () => {
+                    this.state.useBeacon = true;
+                    this._sendImmediately().then(() => {
+                        void 0;
+                    });
+                }, { capture: true });
+                window.addEventListener('pageshow', () => {
+                    this.state.useBeacon = originalUseBeacon;
+                });
+            }
+        }
+        // @ts-expect-error
+        this.debouncedSend = throttle(async () => {
+            try {
+                return await this._sendImmediately();
+            }
+            catch (err) {
+                return err;
+            }
+        }, this.state.eventDebounce);
+        // @ts-expect-error
+        this.debouncedSendAnonymous = throttle(async () => {
+            try {
+                return await this._sendImmediatelyAnonymous();
+            }
+            catch (err) {
+                return err;
+            }
+        }, this.state.eventDebounce);
+        // @ts-expect-error
+        this.debouncedSendTpaas = throttle(async () => {
+            try {
+                return await this._sendImmediatelyTpaas();
+            }
+            catch (err) {
+                return err;
+            }
+        }, this.state.eventDebounce);
+        eventBus.emit('tracker:ready', { tracker: this });
+    }
+    /**
+     * Add event to the tracker event queue
+     *
+     * The input can be objects, arrays, primitives or promises. The
+     * order of calls to the method is not guaranteed to be sent in the same
+     * sequence.
+     *
+     * ```
+     * tracker.track('trackerEvent', {
+     * actor: new Promise(resolve => setTimeout(() => resolve('person@example.org'), 2000))
+     * });
+     * tracker.track('trackerEvent', { type: 'Engagement '});
+     *
+     * ```
+     *
+     * The second call to `track` will be added to the event queue before the
+     * first since all input to events are resolved before being added to the
+     * internal queue. Setting the future value in the SDK state will block all
+     * events and events will be added to the queue in order.
+     *
+     * ```
+     * tracker.update({
+     * actor: new Promise(resolve =>
+     * setTimeout(() => resolve('person@example.org'), 2000)) })
+     * tracker.track('trackerEvent', { type: 'View' });
+     * tracker.track('trackerEvent', { type: 'Engagement' });
+     * ```
+     *
+     * Both of these events will be blocked for two seconds and executed in order.
+     *
+     * @typeParam T Type of event to track
+     * @param eventType. See [spt-tracking/pulse-event-builders]() for
+     * available event types
+     * @param input. input input to the given event. The given input and the
+     * persisted input in the tracker will be merged before passing it to the event
+     * function.
+     * @param {TrackOptions} options
+     * @category Legacy Tracking
+     */
+    track(eventType, input, options) {
+        const currentBuilders = { ...this.builders };
+        const _track = async (trackResponse) => {
+            const createdEvent = this.createEvent(input);
+            return this.evaluateEvent(eventType, createdEvent, currentBuilders, options).then(async (event) => {
+                if (options?.bookmarkKey) {
+                    this.bookmark.set(options.bookmarkKey, event);
+                }
+                // if we have an alternative handler defined, send events there
+                // instead of pushing them onto the queue.
+                if (this.state.altEventHandler) {
+                    const handler = this.state.altEventHandler;
+                    handler(JSON.stringify(event));
+                    return Promise.resolve(trackResponse);
+                }
+                const queuedEvent = this._push(event, options).then(() => void 0);
+                await this.send();
+                return queuedEvent.then((result) => result);
+            });
+        };
+        return this.syncRemoteResources(input, currentBuilders).then(_track, _track);
+    }
+    /**
+     * Add anonymous event to the tracker anonymous event queue
+     *
+     * The input can be objects, arrays, primitives or promises. The
+     * order of calls to the method is not guaranteed to be sent in the same
+     * sequence.
+     *
+     * ```
+     * tracker.trackAnonymous('trackerEvent', { type: 'Engagement'});
+     * ```
+     *
+     * Anonymous events will not contain: `session`, `actor`, `device`, `location`, `pageViewId`.
+     *
+     * Anonymous events will always have the `isAnonymous` field set to true.
+     *
+     * Anonymous events will not await for consents. They will be applied if available, otherwise it will fall back to `unknown`.
+     *
+     * Considering the above, you should *not* add custom fields that can break anonymity.
+     *
+     * If you are missing consents, you're also not allowed to interact with storage or cookies for the purpose of these events.
+     * @typeParam T Type of event to track
+     * @param eventType.
+     * @param input. input input to the given event. The given input and the
+     * persisted input in the tracker will be merged before passing it to the event
+     * function.
+     * @param {TrackOptions} options
+     * @category Tracking Anonymous
+     */
+    async trackAnonymous(eventType, input, options) {
+        // We must create the event as soon as possible, as it defines the creationDate.
+        const newEvent = this.createAnonymousEvent(input);
+        // Remote config values ----------------
+        await this._applyRemoteConfigEndpoints();
+        // Resolve all available properties ----------------
+        const resolvedOutput = await Promise.all([this.resolveTrackInput(newEvent), this.resolveTrackGlobals()]);
+        let eventOutput = resolvedOutput.reduce((acc, p) => pulseMerge(acc, p), {});
+        eventOutput = this.applyAnonymousEventTypeDefaults(eventOutput, eventType);
+        // Leave Events ----------------
+        // they require (most) properties of the previous PageView event, which was saved under a bookmark key when tracked
+        eventOutput = this.applyBookmarkedEvent(eventOutput, options?.applyBookmarkKey);
+        // TCF Consents ----------------
+        eventOutput = this.applyConsentsAnonymous(eventOutput);
+        // Build the entire event----------------
+        // Depending on the event type, like Tracker or Engagement.
+        eventOutput = getAnonymousEventBuilder(eventType)({
+            eventInput: eventOutput,
+            sdkConfig: this.state,
+        });
+        if (options?.bookmarkKey) {
+            this.bookmark.set(options.bookmarkKey, eventOutput);
+        }
+        // Dispatch ----------------
+        // The Hybrid use case implements a "bridged" event method, injected into the window scope,
+        // which is used to send events through the native app.
+        if (this.state.altEventHandler) {
+            this.state.altEventHandler(JSON.stringify(eventOutput));
+            return eventOutput;
+        }
+        const queuedEvent = this._pushAnonymous(eventOutput, options);
+        await this.sendAnonymous();
+        return queuedEvent;
+    }
+    async adaptExperiments(baseExperiments = []) {
+        return baseExperiments.map((exp) => {
+            return {
+                name: exp.name || exp.id,
+                variant: exp.variant || '',
+            };
+        });
+    }
+    /**
+     *
+     * @private
+     * @category TPaaS Tracking
+     */
+    async prepareAnonymousTpaasEvent() {
+        try {
+            await this._applyRemoteConfigEndpoints();
+        }
+        catch (ex) {
+            logger.trace('Failed to sync remote config', ex);
+        }
+        return {
+            autoTrackerVersion: this.builders.tracker?.autoTrackerVersion,
+            version: version.SDK_VERSION,
+            isHybrid: !!this.state.isHybrid,
+            pageviewId: this.state.pageViewId,
+            providerId: this.state.providerId,
+            experiments: await this.adaptExperiments(this.builders.experiments),
+        };
+    }
+    /**
+     *
+     * @private
+     * @category TPaaS Tracking
+     */
+    async prepareTpaasEvent() {
+        try {
+            await this.syncRemoteResources(undefined, { ...this.builders });
+        }
+        catch (ex) {
+            logger.trace('Failed to sync remote resources', ex);
+            // remote config and CIS failures are also ignored for the old track() method. doing the same here
+        }
+        function adaptActorToNewFormat(actor) {
+            // this is a temporary solution to adapt the actor to the new format
+            // it should be removed once we have new methods in place to get the actor
+            if (!actor) {
+                return;
+            }
+            return {
+                id: actor.id?.toString() || '',
+                realm: actor.realm || '',
+                hasAnySubscription: !!actor.hasAnySubscription,
+                region: isString(actor.region) ? actor.region : undefined,
+            };
+        }
+        function adaptConsentsToNewFormat(consents) {
+            if (!consents) {
+                return;
+            }
+            const { purposes, source } = consents;
+            const { CMP_ADVERTISING, CMP_ANALYTICS, CMP_MARKETING, CMP_PERSONALIZATION } = purposes;
+            function adaptStatusOrOptIn({ status, optIn }) {
+                // doing an unnecessary check for status here
+                // because otherwise the code after the switch will be marked as unreachable in the IDE
+                if (status) {
+                    switch (status) {
+                        case 'accepted':
+                            return 'Accepted';
+                        case 'rejected':
+                            return 'Rejected';
+                        case 'unknown':
+                            return 'Unknown';
+                    }
+                }
+                if (optIn === true) {
+                    return 'Accepted';
+                }
+                if (optIn === false) {
+                    return 'Rejected';
+                }
+                return 'Unknown';
+            }
+            return {
+                advertising: adaptStatusOrOptIn(CMP_ADVERTISING),
+                analytics: adaptStatusOrOptIn(CMP_ANALYTICS),
+                marketing: adaptStatusOrOptIn(CMP_MARKETING),
+                personalization: adaptStatusOrOptIn(CMP_PERSONALIZATION),
+                source: source || 'unknown',
+            };
+        }
+        const [actor, consents, experiments] = await Promise.all([
+            this.getActor(),
+            this.getConsents(),
+            this.adaptExperiments(this.builders.experiments),
+        ]);
+        const { environmentId, jwe } = parsePulseCookies();
+        return {
+            autoTrackerVersion: this.builders.tracker?.autoTrackerVersion,
+            version: version.SDK_VERSION,
+            isHybrid: !!this.state.isHybrid,
+            user: adaptActorToNewFormat(actor),
+            consents: adaptConsentsToNewFormat(consents),
+            providerId: this.state.providerId,
+            pageviewId: this.state.pageViewId,
+            currentPage: this.currentPage,
+            experiments,
+            environmentId,
+            jwe,
+        };
+    }
+    /**
+     * Generate a generic TPaaS event with common builders output
+     * The method should be used for experiments, not for real production work.
+     * It doesn't have any real TPaaS schema associated with it.
+     * The method doesn't queue or send the event, it just returns the merged object.
+     * The method can be removed at any time in the future, so use it with caution.
+     *
+     * @param input - The input object to merge with the common builders output
+     * @returns A promise that resolves to the merged object
+     * @private
+     * @category TPaaS Tracking
+     */
+    async generateGenericTpaasEvent(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        return pulseMerge({}, input, getCommonBuildersOutput(new Date(), dependencies));
+    }
+    /**
+     * This method extends the list of base experiments that will be automatically included in every event sent by the tracker.
+     *
+     * It accepts:
+     * - An array of experiments and/or promises resolving to the experiments
+     * - A Promise resolving to an array of experiments
+     *
+     * This allows to easily manage experiments without having to repeat them in every tracking call. For example:
+     *
+     * ```ts
+     * const experiments = [{ id: 'experiment-A', variant: 'blue-button' }];
+     *
+     * tracker.addExperiments(experiments);
+     * ```
+  
+      Calling the method multiple times concatenates all given experiments and stores them as base experiments. Experiments can be either direct values or Promises, and they will be included in all future tracking events.
+  
+     * @param experiments
+     * @category Tracking
+     */
+    addExperiments(experiments) {
+        this.update({ experiments }, true);
+    }
+    /**
+     * The `addUIElementVisibilityTracking` function provides an interface for sending tracking events when specific UI elements become visible within the viewport.
+     * It is built on the `VisibilityObserver` class, which efficiently detects visibility changes in DOM elements.
+     * When an element becomes at least 2/3 visible, a callback is triggered to process the element and create a tracking event.
+     * It leverages the [Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API) for viewport tracking
+     * and the [Mutation Observer API](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) to monitor lazy-loaded elements.
+     *
+     * Example usage:
+     *
+     * ```ts
+     * addUIElementVisibilityTracking('[data-pulse-entity-id]', (element) => {
+     * const target = createPulseTarget(element);
+     * const object = createPulseObject(element);
+     *
+     * return { object, target };
+     * });
+     * ```
+     *
+     * @param {string} selector - CSS selector for elements to track.
+     * @param {Function} buildEventFromElement - Function to build event object when element is visible.
+     * @deprecated This only works for legacy events. For TPaaS events, use `addUIElementVisibilityTracking` instead.
+     * @category Legacy Tracking
+     */
+    addLegacyUIElementVisibilityTracking(selector, buildEventFromElement) {
+        if (this.legacyVisibilityObservers.has(selector)) {
+            console.warn(`Cannot add UI Element visibility tracking for selector "${selector}" as it is already being tracked.`);
+            return;
+        }
+        this.legacyVisibilityObservers.set(selector, new VisibilityObserver((element) => {
+            const viewUIElementInputProperties = buildEventFromElement(element);
+            this.trackLegacyViewUIElement(viewUIElementInputProperties);
+        }));
+        this.legacyVisibilityObservers.get(selector)?.observe(selector);
+    }
+    /**
+     * The `addUIElementVisibilityTracking` function provides an interface for sending tracking events when specific UI elements become visible within the viewport.
+     * It is built on the `VisibilityObserver` class, which efficiently detects visibility changes in DOM elements.
+     * When an element becomes at least 2/3 visible, a callback is triggered to process the element and create a tracking event.
+     * It leverages the [Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API) for viewport tracking
+     * and the [Mutation Observer API](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) to monitor lazy-loaded elements.
+     *
+     * Example usage:
+     *
+     * ```ts
+     * addUIElementVisibilityTracking('[data-pulse-entity-id]', (element) => {
+     *   const eventInput = createEventInput(element);
+     *
+     *   return eventInput;
+     * });
+     * ```
+     *
+     * @param {string} selector - CSS selector for elements to track.
+     * @param {Function} buildEventFromElement - Function to build event object when element is visible.
+     * @category Tracking
+     */
+    addUIElementVisibilityTracking(selector, buildEventFromElement) {
+        if (this.visibilityObservers.has(selector)) {
+            console.warn(`Cannot add UI Element visibility tracking for selector "${selector}" as it is already being tracked.`);
+            return;
+        }
+        this.visibilityObservers.set(selector, new VisibilityObserver((element) => {
+            const eventInput = buildEventFromElement(element);
+            this.trackImpressionUIElement(eventInput);
+        }));
+        this.visibilityObservers.get(selector)?.observe(selector);
+    }
+    /**
+     * The old trackViewArticle method from the Media Wrapper.
+     * When triggering this page-view function, both the "page" object and "origin"
+     * will be stored and re-used across subsequent events.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewArticle(inputProperties, trackOptions) {
+        const viewArticleEventData = buildLegacyViewArticleEvent(inputProperties);
+        this.setPageDefaults(viewArticleEventData);
+        return this.trackPageView(viewArticleEventData, trackOptions);
+    }
+    /**
+     * The old trackViewLoginPoster method from the Media Wrapper.
+     * When triggering this page-view function, both the "page" object and "origin"
+     * will be stored and re-used across subsequent events.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewLoginPoster(inputProperties, trackOptions) {
+        const viewLoginPosterEventData = buildViewLoginPosterEvent(inputProperties);
+        this.setPageDefaults(viewLoginPosterEventData);
+        return this.trackPageView(viewLoginPosterEventData, trackOptions);
+    }
+    /**
+     * The old trackViewSalesPoster method from the Media Wrapper.
+     * When triggering this page-view function, both the "page" object and "origin"
+     * will be stored and re-used across subsequent events.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewSalesPoster(inputProperties, trackOptions) {
+        const viewSalesposterEventData = buildViewSalesPosterEvent(inputProperties);
+        this.setPageDefaults(viewSalesposterEventData);
+        return this.trackPageView(viewSalesposterEventData, trackOptions);
+    }
+    /**
+     * The old trackViewListing method from the Media Wrapper.
+     * When triggering this page-view function, both the "page" object and "origin"
+     * will be stored and re-used across subsequent events.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewListing(inputProperties, trackOptions) {
+        const viewListingEventData = buildLegacyViewListingEvent(inputProperties);
+        this.setPageDefaults(viewListingEventData);
+        return this.trackPageView(viewListingEventData, trackOptions);
+    }
+    /**
+     * The old trackViewFrontpage method from the Media Wrapper.
+     * When triggering this page-view function, both the "page" object and "origin"
+     * will be stored and re-used across subsequent events.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewFrontpage(inputProperties, trackOptions) {
+        const viewFrontpageEventData = buildLegacyViewFrontpageEvent(inputProperties);
+        this.setPageDefaults(viewFrontpageEventData);
+        return this.trackPageView(viewFrontpageEventData, trackOptions);
+    }
+    /**
+     * The old trackViewPage method from the Media Wrapper.
+     * When triggering this page-view function, both the "page" object and "origin"
+     * will be stored and re-used across subsequent events.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewPage(inputProperties, trackOptions) {
+        const pageViewEventData = buildLegacyViewPageEvent(inputProperties);
+        this.setPageDefaults(pageViewEventData);
+        return this.trackPageView(pageViewEventData, trackOptions);
+    }
+    /**
+     * The old trackViewUIElement method from the Media Wrapper.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewUIElement(inputProperties, trackOptions) {
+        const viewUIElementEventData = buildLegacyViewUIElementEvent(inputProperties, this.legacyCurrentPage);
+        return this.track('trackerEvent', viewUIElementEventData, trackOptions);
+    }
+    /**
+     * The old trackClickUIElement method from the Media Wrapper.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyClickUIElement(inputProperties, trackOptions) {
+        const clickUIElementEventData = buildClickUIElementEvent(inputProperties, this.legacyCurrentPage);
+        return this.track('trackerEvent', clickUIElementEventData, trackOptions);
+    }
+    /**
+     * The following methods are the track methods specific for the TPaaS schemas
+     */
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackAnonymousViewUIElement(input) {
+        const dependencies = await this.prepareAnonymousTpaasEvent();
+        const event = buildAnonymousViewUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    async trackCompletedHealthAction(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildCompletedHealthActionEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    async trackEngagementHealthUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementHealthUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    async trackViewHealthPage(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, 'Page'); // ViewHealthPage.object.objectType is HealthPage, which is not allowed as a pageType
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewHealthPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            // HealthView Page is a bit special, in the sense that in doesn't have a dedicated Leave event.
+            // Instead, we need to reuse the generic Leave Page event, but adapt the input accordingly.
+            // This means omitting some fields from HealthView Page that are not part of Leave Page schema.
+            const { experiments, metrics, object, ...restInput } = input;
+            const { category, custom, intent, name, tags, ...restObject } = input.object;
+            const leavePageCallback = (leave) => {
+                this.trackLeavePage({
+                    leave,
+                    ...restInput,
+                    object: {
+                        ...restObject,
+                        title: restObject.title || '',
+                    },
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                objectResizable,
+                heightBuilder,
+                schema: LeavePage.object.objectType,
+                trackMethod: leavePageCallback,
+            });
+        }
+        return result;
+    }
+    async trackImpressionHealthUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionHealthUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewPage(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewPage.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leavePageCallback = (leave) => {
+                this.trackLeavePage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                objectResizable,
+                heightBuilder,
+                schema: LeavePage.object.objectType,
+                trackMethod: leavePageCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackViewTitle(input) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewTitle.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewTitleEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+        // there's no Leave Title event
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionWidget(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionWidgetEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionAdSlot(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionAdSlotEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewArticle(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewArticle.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewArticleEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveArticleCallback = (leave) => {
+                this.trackLeaveArticle({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveArticle.object.objectType,
+                trackMethod: leaveArticleCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewAudio(input) {
+        // despite the View event type, this is not a page view event, but rather a media object view event
+        // so we shouldn't reset the page view ID here or enable leave tracking
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewAudioEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * Tracks a View AudioPage event and automatically fires a Leave AudioPage event when the user
+     * navigates away.
+     *
+     * The Leave AudioPage event requires audio engagement statistics (`leaveAudio`) that the SDK
+     * cannot compute on its own. Provide a `leaveAudioBuilder` callback in the `leaveTracking`
+     * options — it is called at leave time (not at registration time), so it always captures the
+     * latest state. If no builder is supplied all audio engagement fields default to `0`.
+     *
+     * `activityDurationMs` and `durationMs` are computed by the leave tracking system and must
+     * **not** be included in the value returned by `leaveAudioBuilder`.
+     *
+     * @example
+     * ```ts
+     * // Minimal — leave fires with zeroed audio stats
+     * await tracker.trackViewAudioPage(input, {
+     *   leaveTracking: { objectElement: document.getElementById('audio-player')! },
+     * });
+     *
+     * // With leaveAudioBuilder — capture live playback stats at leave time
+     * await tracker.trackViewAudioPage(input, {
+     *   leaveTracking: {
+     *     objectElement: document.getElementById('audio-player')!,
+     *     leaveAudioBuilder: () => ({
+     *       audioStarted: player.tracksStarted,
+     *       audioCompleted: player.tracksCompleted,
+     *       maxPlaylistPosition: player.maxPosition,
+     *       playlistPositionPercentage: player.positionPercentage,
+     *     }),
+     *   },
+     * });
+     *
+     * // Disable leave tracking entirely
+     * await tracker.trackViewAudioPage(input, { leaveTracking: false });
+     * ```
+     *
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewAudioPage(input, options) {
+        this.newPageView();
+        this.setCurrentPage(input.object.objectId, 'Audio'); // ViewAudioPage.object.objectType is AudioPage, which is not allowed as a pageType
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewAudioPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable, leaveAudioBuilder } = options.leaveTracking;
+            const leaveAudioPageCallback = (leave) => {
+                const leaveAudioInput = leaveAudioBuilder?.() ?? {
+                    audioCompleted: 0,
+                    audioStarted: 0,
+                    maxPlaylistPosition: 0,
+                    playlistPositionPercentage: 0,
+                };
+                this.trackLeaveAudioPage({
+                    leave,
+                    leaveAudio: {
+                        ...leaveAudioInput,
+                        activityDurationMs: leave.activityDurationMs,
+                        durationMs: leave.durationMs,
+                    },
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveAudioPage.object.objectType,
+                trackMethod: leaveAudioPageCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewError(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewError.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewErrorEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveErrorCallback = (leave) => {
+                this.trackLeaveError({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveError.object.objectType,
+                trackMethod: leaveErrorCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionForm(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionFormEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionOffer(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionOfferEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionPlayer(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionPlayerEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionTeaser(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionTeaserEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewFrontpage(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewFrontpage.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewFrontpageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveFrontpageCallback = (leave) => {
+                this.trackLeaveFrontpage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                objectResizable,
+                heightBuilder,
+                schema: LeaveFrontpage.object.objectType,
+                trackMethod: leaveFrontpageCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewLandingpage(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, 'LandingPage' /* TODO: ViewLandingpage.object.type once the schema is fixed */);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewLandingpageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveLandingpageCallback = (leave) => {
+                this.trackLeaveLandingpage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveLandingpage.object.objectType,
+                trackMethod: leaveLandingpageCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewListing(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewListing.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewListingEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveListingCallback = (leave) => {
+                this.trackLeaveListing({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveListing.object.objectType,
+                trackMethod: leaveListingCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewLockedArticle(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewLockedArticle.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewLockedArticleEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveLockedArticleCallback = (leave) => {
+                this.trackLeaveLockedArticle({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                objectResizable,
+                heightBuilder,
+                schema: LeaveLockedArticle.object.objectType,
+                trackMethod: leaveLockedArticleCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewLockedAudio(input) {
+        // despite the View event type, this is not a page view event, but rather a media object view event
+        // so we shouldn't reset the page view ID here or enable leave tracking
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewLockedAudioEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewLockedAudioPage(input, options) {
+        this.newPageView();
+        this.setCurrentPage(input.object.objectId, 'Audio'); // ViewLockedAudioPage.object.objectType is AudioPage, which is not allowed as a pageType
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewLockedAudioPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveLockedAudioPageCallback = (leave) => {
+                this.trackLeaveLockedAudioPage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveLockedAudioPage.object.objectType,
+                trackMethod: leaveLockedAudioPageCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackViewLockedVideo(input) {
+        // despite the name, this is not a page-level event. trackViewLockedVideoPage is a page-level event
+        // as such, we don't support (yet) automatic leave event enabling
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewLockedVideoEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewLockedVideoPage(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, ViewLockedVideo.object.objectType);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewLockedVideoPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveLockedVideoPageCallback = (leave) => {
+                this.trackLeaveLockedVideoPage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveLockedVideoPage.object.objectType,
+                trackMethod: leaveLockedVideoPageCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackViewVideo(input) {
+        // despite the View event type, this is not a page view event, but rather a media object view event
+        // so we shouldn't reset the page view ID here or enable leave tracking
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewVideoEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * Tracks a View VideoPage event and automatically fires a Leave VideoPage event when the user
+     * navigates away.
+     *
+     * The Leave VideoPage event supports an optional `leaveStories` field containing story carousel
+     * statistics that the SDK cannot compute. Provide a `leaveStoriesBuilder` callback in the
+     * `leaveTracking` options — it is called at leave time (not at registration time), so it always
+     * captures the latest state. If no builder is supplied `leaveStories` is omitted from the Leave
+     * VideoPage event.
+     *
+     * `activityDurationMs` and `durationMs` are computed by the leave tracking system and must
+     * **not** be included in the value returned by `leaveStoriesBuilder`.
+     *
+     * @example
+     * ```ts
+     * // Without story stats — leaveStories is omitted from the Leave VideoPage event
+     * await tracker.trackViewVideoPage(input, {
+     *   leaveTracking: { objectElement: document.getElementById('video-player')! },
+     * });
+     *
+     * // With leaveStoriesBuilder — capture live story stats at leave time
+     * await tracker.trackViewVideoPage(input, {
+     *   leaveTracking: {
+     *     objectElement: document.getElementById('video-player')!,
+     *     leaveStoriesBuilder: () => ({
+     *       storiesCompleted: stories.completed,
+     *       storiesStarted: stories.started,
+     *       maxPlaylistPosition: stories.maxPosition,
+     *       playlistPositionPercentage: stories.positionPercentage,
+     *       adCount: stories.adCount,
+     *     }),
+     *   },
+     * });
+     *
+     * // Disable leave tracking entirely
+     * await tracker.trackViewVideoPage(input, { leaveTracking: false });
+     * ```
+     *
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewVideoPage(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, 'Video'); // ViewVideoPage.object.type is VideoPage, which is not allowed as a pageType
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewVideoPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable, leaveStoriesBuilder } = options.leaveTracking;
+            const leaveVideoCallback = (leave) => {
+                const leaveStoriesInput = leaveStoriesBuilder?.();
+                this.trackLeaveVideoPage({
+                    leave,
+                    leaveStories: leaveStoriesInput && {
+                        ...leaveStoriesInput,
+                        activityDurationMs: leave.activityDurationMs,
+                        durationMs: leave.durationMs,
+                    },
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveVideoPage.object.objectType,
+                trackMethod: leaveVideoCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewWeather(input, options) {
+        this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
+        this.setCurrentPage(input.object.objectId, 'Page' /* TODO: ViewWeather.object.type once the schema is fixed */);
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewWeatherEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
+            const leaveWeatherCallback = (leave) => {
+                this.trackLeaveWeather({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                objectElement,
+                pageElement,
+                heightBuilder,
+                objectResizable,
+                schema: LeaveWeather.object.objectType,
+                trackMethod: leaveWeatherCallback,
+            });
+        }
+        return result;
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveArticle(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveArticleEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveAudioPage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveAudioPageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveError(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveErrorEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveFrontpage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveFrontpageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveLandingpage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveLandingpageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveListing(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveListingEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveLockedArticle(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveLockedArticleEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveLockedAudio(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveLockedAudioEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveLockedAudioPage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveLockedAudioPageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveLockedVideo(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveLockedVideoEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveLockedVideoPage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveLockedVideoPageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeavePage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeavePageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveVideoPage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveVideoPageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveWeather(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveWeatherEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementAudio(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementAudioEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementForm(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementFormEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementOffer(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementOfferEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementTeaser(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementTeaserEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementVideo(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementVideoEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementVideoAd(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementVideoAdEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementWidget(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementWidgetEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * this is the method that actually sends the event to the server
+     * @private
+     * @category TPaaS Tracking
+     */
+    async sendTpaasEvent(event) {
+        // Resolve any pending session ID promises
+        // (session was created when the event was built)
+        this.resolveSessionIdPromise();
+        // The Hybrid use case implements a "bridged" event method, injected into the window scope,
+        // which is used to send events through the native app.
+        if (isFunction(this.state.altEventHandler)) {
+            this.state.altEventHandler(JSON.stringify(event));
+            return event;
+        }
+        this.tpaasEventQueue.push(event);
+        if (this.state.useBeacon) {
+            try {
+                return await this._sendImmediatelyTpaas();
+            }
+            catch (err) {
+                return err;
+            }
+        }
+        return this.debouncedSendTpaas();
+    }
+    /**
+     * Send all events that are in the internal event queue.
+     *
+     * The returned Promise will resolve with the array of events that was
+     * successfully transmitted. These events will have been removed from the event
+     * queue. If the promise rejects, it means that the event queue could not be
+     * sent and the promise rejection will contain the events that failed (will be
+     * the entire queue initial call). Events that are unsuccessfully sent will
+     * remain in the event queue.
+     *
+     * @internal
+     * @category TPaaS Tracking
+     */
+    async _sendImmediatelyTpaas() {
+        if (this.tpaasEventQueue.length + this.retryTpaasEventQueue.length <= 0) {
+            return [];
+        }
+        return this.prepareQueuesAndSendTpaas(this.tpaasEventQueue, this.retryTpaasEventQueue);
+    }
+    /**
+     * Prepares the received event queue and handles success / failure after sending.
+     *
+     * @param eventQueue
+     * @param retryEventQueue
+     * @private
+     * @category TPaaS Tracking
+     */
+    async prepareQueuesAndSendTpaas(eventQueue, retryEventQueue) {
+        const eventsToBeSent = eventQueue.splice(0);
+        const eventsToRetry = retryEventQueue.splice(0);
+        eventQueue.length = 0;
+        retryEventQueue.length = 0;
+        const url = this._getTpaasCollectorPath();
+        const data = [...eventsToBeSent, ...eventsToRetry];
+        async function onFailedSend() {
+            // We retry an event once, but discard already retried events
+            retryEventQueue.push(...eventsToBeSent);
+            return Promise.reject(eventsToBeSent);
+        }
+        try {
+            // for TPaaS events, we set the sentAt time to the current date, just before sending the events
+            const currentDate = new Date().toISOString();
+            for (const event of data) {
+                event.time.sentAt = currentDate;
+            }
+            const response = await send(url, data, this.state);
+            if (response.status >= 400) {
+                onFailedSend();
+            }
+            return eventsToBeSent;
+        }
+        catch (_ex) {
+            return onFailedSend();
+        }
+    }
+    /**
+     * Evaluate all input given to the sdk/this method and pass it through the
+     * appropriate event formatter.
+     * @internal
+     * @category Legacy Tracking
+     */
+    async evaluateEvent(eventType, input, builders = this.builders, options) {
+        const eventBuilder = getEventBuilder(eventType);
+        return this.evaluateEventInputs(eventType, input, builders, options).then((evaluatedInput) => {
+            const data = eventBuilder({
+                eventInput: evaluatedInput,
+                sdkConfig: this.state,
+            });
+            return evaluateAndFlatten(data);
+        });
+    }
+    /**
+     * @param eventType
+     * @param eventInput
+     * @param builders
+     * @param options
+     * @internal
+     * @category Legacy Tracking
+     */
+    async evaluateEventInputs(eventType, eventInput, builders = this.builders, options) {
+        const buildersOutput = await Promise.all([evaluateAndFlatten(builders), evaluateAndFlatten(eventInput)]);
+        let eventOutput = buildersOutput.reduce((acc, p) => pulseMerge(acc, p), {});
+        eventOutput = this.applyEventTypeDefaults(eventOutput, eventType);
+        eventOutput = this.applyBookmarkedEvent(eventOutput, options?.applyBookmarkKey);
+        eventOutput = await this.applyConsents(eventOutput);
+        return eventOutput;
+    }
+    /**
+     * Gets user consents from the tracker's state.
+     * @returns {Consents}
+     * @category Consents
+     */
+    async getConsents() {
+        return (await this.evaluateConsents()).consents;
+    }
+    /**
+     * Sets user consents to be sent with each event.
+     * Given that User's consent for Advertising changed, the next call to get Advertising Identifiers must be forced, and
+     * not retrieve values from cache. The flag is passed with the trackers state, and updated to a "non-forcing" state
+     * right after, characterising the "force once" behaviour.
+     * accessing Advertising Identifiers directly must clear this flag.
+     * Not usable with autoCreateConsents option
+     * @param consentsInput
+     * @returns {Consents}
+     * @category Consents
+     */
+    setConsents(consentsInput) {
+        if (this.state.autoCreateConsents) {
+            warnOnce('setConsents', 'setConsents is not allowed when autoCreateConsents is enabled');
+            return { ...this.state.consents };
+        }
+        return this.setConsentsInternal(consentsInput);
+    }
+    /**
+     * Return a new Tracker with the current state
+     * @category Tracking
+     */
+    clone({ trackerId } = {}) {
+        return new Tracker(this.state.providerId, {
+            ...this.state,
+            trackerId: trackerId || v4(),
+        }, {
+            ...this.builders,
+        });
+    }
+    /**
+     * Update the persisted state that is passed to all events
+     *
+     * Calling
+     * ```
+     * tracker.update({ actor: 'person@example.org' });
+     * tracker.trackPageView();
+     * tracker.trackPageView();
+     * ```
+     *
+     * is equivalent of doing
+     *
+     * ```
+     * tracker.trackPageView({ actor: 'person@example.org' });
+     * tracker.trackPageView({ actor: 'person@example.org' });
+     * ```
+     *
+     * @param builder data passed to event functions
+     * @param mergeBuilder the given data will be merged deeply with the
+     * existing state. False will result in the previous state being overwritten
+     * @category Legacy Tracking
+     */
+    update(builder, mergeBuilder = false) {
+        if (mergeBuilder) {
+            this.builders = pulseMerge({}, this.builders, builder);
+        }
+        else {
+            this.builders = Object.assign({}, this.builders, builder);
+        }
+    }
+    /**
+     * Get the actor id (userId) from the current browser. A promise is returned
+     * because a call may be made to complete the login process.
+     *
+     * *Note*: This method will return a Promise that is always rejected on node
+     environments.
+     @category Identifiers
+     */
+    async getUserId() {
+        await this._applyRemoteConfigEndpoints();
+        return identity.getUserId(this.builders);
+    }
+    /**
+     * Get the advertisement id (adId) from the current browser. A promise is returned
+     * because a CIS call is done to generate a new adId if no cookie is
+     * found.
+     *
+     * *Note*: This method will return a Promise that is always rejected on node
+     * environments.
+     * @category Identifiers
+     * @deprecated Advertising Identifiers methods will be removed in the next major version.
+     */
+    async getAdId() {
+        warnOnce('getAdId', 'Deprecated method: getAdId');
+        await this._applyRemoteConfigEndpoints();
+        return identity.getAdId(this.builders, this.state);
+    }
+    /**
+     * @category Identifiers
+     * @deprecated moving away from "Actor" terminology, in favor of "User"
+     */
+    async getActor() {
+        await this._applyRemoteConfigEndpoints();
+        return identity.getActor(this.builders);
+    }
+    /**
+     * Get the environment id from the current browser. A promise is returned
+     * because a CIS call is done to generate a new environmentId if no cookie is
+     * found.
+     *
+     * *Note*: This method will return a Promise that is always rejected on node
+     * environments.
+     * @category Identifiers
+     */
+    async getEnvironmentId() {
+        await this._applyRemoteConfigEndpoints();
+        return identity.getEnvironmentId(this.builders, this.state);
+    }
+    /**
+     * Returns the PPID1 value for Xandr integration.
+     * This is the "logged in identifier".
+     * @category Identifiers
+     * @deprecated Advertising Identifiers methods will be removed in the next major version.
+     */
+    async getXandrPPID1() {
+        warnOnce('getXandrPPID1', 'Deprecated method: getXandrPPID1');
+        const { xandr } = await identity.getAdvertisingIdentifiers(this.builders, { ...this.state });
+        return xandr?.ppId1;
+    }
+    /**
+     * Returns the PPID2 value for Xandr integration.
+     * This is the "not logged in identifier".
+     * @category Identifiers
+     * @deprecated Advertising Identifiers methods will be removed in the next major version.
+     */
+    async getXandrPPID2() {
+        warnOnce('getXandrPPID2', 'Deprecated method: getXandrPPID2');
+        const { xandr } = await identity.getAdvertisingIdentifiers(this.builders, { ...this.state });
+        return xandr?.ppId2;
+    }
+    async getAdvertisingIdentifiers(_vendor) {
+        warnOnce('getAdvertisingIdentifiers', 'Deprecated method: getAdvertisingIdentifiers');
+        if (_vendor) {
+            warnOnce('getAdvertisingIdentifiers-no-vendor', 'getAdvertisingIdentifiers no longer accepts vendors as input, the vendors given in SDK constructor is used');
+        }
+        await this._applyRemoteConfigEndpoints();
+        return identity.getAdvertisingIdentifiers(this.builders, { ...this.state });
+    }
+    /**
+     * Returns the UUID currently used as the page view (will be muted by `newPageView` and `trackPageView`).
+     * @category Tracking
+     */
+    getPageViewId() {
+        return this.state.pageViewId;
+    }
+    /**
+     * Returns the current session ID.
+     * If a session exists, returns the session ID immediately.
+     * If no session exists yet, returns a promise that resolves with the session ID
+     * when it gets created (typically when the first non-anonymous tracking event is sent).
+     *
+     * Note: Anonymous events (such as those sent via {@link trackAnonymous} or {@link trackAnonymousViewUIElement})
+     * do not create sessions and will not resolve pending session ID promises. The promise will only resolve when a
+     * non-anonymous tracking event is sent.
+     *
+     * It is possible the promise will never get resolved if there are no non-anonymous events being tracked after calling this method.
+     *
+     * @category Tracking
+     * @returns The session ID, or a promise that resolves to the session ID
+     */
+    getSessionId() {
+        const session = readSession();
+        if (session?.id) {
+            return Promise.resolve(session.id);
+        }
+        // No session exists yet, create or return existing promise
+        if (!this.sessionIdPromise) {
+            this.sessionIdPromise = new Promise((resolve) => {
+                const callback = ({ sessionId }) => {
+                    resolve(sessionId);
+                    this.sessionIdPromise = null; // reset the promise so that future calls to getSessionId will create a new one if needed
+                    eventBus.off('tracker:session:new', callback);
+                };
+                eventBus.on('tracker:session:new', callback);
+            });
+        }
+        return this.sessionIdPromise;
+    }
+    /**
+     * Generate a new page view id. Will be attached to all events until a new id is generated.
+     * @category Tracking
+     */
+    newPageView() {
+        this.state.pageViewId = v4();
+    }
+    /**
+     * Fetches the Remote Configuration, setting the CIS and Collector base urls
+     * @internal
+     * @category Configuration
+     */
+    async _applyRemoteConfigEndpoints() {
+        const { fallbackCisBaseUrl, fallbackCollectorBaseUrl, environment, configurationTag, remoteConfigurationUrl } = this.state;
+        if (environment === 'browser') {
+            const remoteServiceConfig = await config.syncRemoteConfig(configurationTag, remoteConfigurationUrl);
+            if (!isCollectorInConfig) {
+                this.state.collectorBaseUrl = remoteServiceConfig?.collector || fallbackCollectorBaseUrl;
+            }
+            if (!isCisInConfig) {
+                this.state.cisBaseUrl = remoteServiceConfig?.cis || fallbackCisBaseUrl;
+            }
+        }
+    }
+    /**
+     * @param input
+     * @param builders
+     * @internal
+     * @category Configuration
+     */
+    async syncRemoteResources(input, builders) {
+        await this._applyRemoteConfigEndpoints();
+        return identity.cisSync(input, builders, { ...this.state });
+    }
+    /**
+     * @internal
+     * @category Configuration
+     */
+    _getCollectorPath() {
+        const { providerId, environment } = this.state;
+        let { collectorPath, collectorBaseUrl } = this.state;
+        /**
+         * We want to support all of these cases:
+         * collectorPath: /api/v1/track, baseUrl: domain.tld => domain.tld/api/v1/track
+         * collectorPath: api/v1/track, baseUrl: domain.tld => domain.tld/api/v1/track
+         * collectorPath: /api/v1/track, baseUrl: domain.tld/ => domain.tld/api/v1/track
+         * collectorPath: api/v1/track, baseUrl: domain.tld/ => domain.tld/api/v1/track
+         * collectorPath: /api/v1/track, baseUrl: domain.tld/something => domain.tld/something/api/v1/track
+         * collectorPath: api/v1/track, baseUrl: domain.tld/something => domain.tld/something/api/v1/track
+         * collectorPath: /api/v1/track, baseUrl: domain.tld/something/ => domain.tld/something/api/v1/track
+         * collectorPath: api/v1/track, baseUrl: domain.tld/something/ => domain.tld/something/api/v1/track
+         * The collectorPath and collectorBaseUrl manipulating below is to support all these cases
+         */
+        if (collectorPath.startsWith('/')) {
+            // Remove leading slash
+            collectorPath = collectorPath.slice(1);
+        }
+        if (!collectorBaseUrl?.endsWith('/')) {
+            // Add trailing slash
+            collectorBaseUrl = `${collectorBaseUrl}/`;
+        }
+        if (environment === 'node') {
+            return new URL(collectorPath, collectorBaseUrl).toString();
+        }
+        const _provider = providerId || this.state.providerId;
+        if (typeof _provider === 'string' && _provider.indexOf('sdrn') === 0) {
+            return new URL(`${collectorPath}/${_provider}`, collectorBaseUrl).toString();
+        }
+        return new URL(`${collectorPath}/${providerSdrn(_provider)}`, collectorBaseUrl).toString();
+    }
+    /**
+     * Returns the collector URL for TPaaS events.
+     * Uses the tpaasCollectorBaseUrl when available (driven by deployStageTpaas),
+     *
+     * @internal
+     * @category Configuration
+     */
+    _getTpaasCollectorPath() {
+        const { providerId } = this.state;
+        let { collectorPath, tpaasCollectorBaseUrl } = this.state;
+        if (collectorPath.startsWith('/')) {
+            // Remove leading slash
+            collectorPath = collectorPath.slice(1);
+        }
+        if (!tpaasCollectorBaseUrl.endsWith('/')) {
+            // Add trailing slash
+            tpaasCollectorBaseUrl = `${tpaasCollectorBaseUrl}/`;
+        }
+        if (typeof providerId === 'string' && providerId.indexOf('sdrn') === 0) {
+            return new URL(`${collectorPath}/${providerId}`, tpaasCollectorBaseUrl).toString();
+        }
+        return new URL(`${collectorPath}/${providerSdrn(providerId)}`, tpaasCollectorBaseUrl).toString();
+    }
+    /**
+     * Send all events that are in the internal event queue.
+     *
+     * The returned Promise will resolve with the array of events that was
+     * successfully transmitted. These events will have been removed from the event
+     * queue. If the promise rejects, it means that the event queue could not be
+     * sent and the promise rejection will contain the events that failed (will be
+     * the entire queue initial call). Events that are unsuccessfully sent will
+     * remain in the event queue.
+     *
+     * @internal
+     * @category Legacy Tracking
+     *
+     */
+    async _sendImmediately() {
+        if (this.eventQueue.length + this.retryEventQueue.length <= 0) {
+            return [];
+        }
+        const { doTracking } = await identity.cisSync({}, this.builders, this.state);
+        if (!doTracking) {
+            return [];
+        }
+        return this.prepareQueuesAndSend(this.eventQueue, this.retryEventQueue);
+    }
+    /**
+     * @param event
+     * @param options
+     * @internal
+     * @category Legacy Tracking
+     */
+    _push(event, options = {}) {
+        const deferredEvent = defer(event);
+        this.eventQueue.push(deferredEvent);
+        if (options.resolveOnQueued) {
+            deferredEvent.resolve(event);
+        }
+        return deferredEvent.promise;
+    }
+    /**
+     * @param bookmarkKey
+     * @internal
+     * @category Legacy Tracking
+     */
+    getBookmarkedEvent(bookmarkKey) {
+        return this.bookmark.get(bookmarkKey);
+    }
+    /**
+     * Send the current event queue to the back end event receiver. This event is
+     * debounced, @see {SDKConfigInput} to override the default timing.
+     *
+     * This method is called by `track()` so it is not necessary to call after
+     * adding events to the queue.
+     * @internal
+     * @category Legacy Tracking
+     */
+    async send() {
+        if (this.state.useBeacon) {
+            try {
+                return await this._sendImmediately();
+            }
+            catch (err) {
+                return err;
+            }
+        }
+        return this.debouncedSend();
+    }
+    /**
+     * A convenience method which first updates the current pageViewId in the
+     * tracker state and then sends a `tracker-event` with `@type: View` and the
+     * merged result of the given data and the data saved in the tracker.
+     *
+     * Equivalent to
+     *
+     * ```ts
+     * tracker.newPageView();
+     * tracker.track('trackerEvent', { type: 'View', ...data });
+     * ```
+     * @category Legacy Tracking
+     */
+    trackPageView(data = {}, options = {}) {
+        this.newPageView();
+        return this.track('trackerEvent', { type: 'View', ...data }, { ...options, bookmarkKey: BookmarkKeys.PAGE_VIEW });
+    }
+    /**
+     * Start sending events when users leave a page.
+     * This will register handlers on the browser events 'pagehide', 'popstate', 'beforeunload' and 'visibilitychange'
+     * and will send a Leave event when these are triggered. The leave event will be a copy of the last sent view-event
+     * + engagement values. The fields in the default
+     * event can be found here: https://pages.github.schibsted.io/mpt-data/pulse-standard/#leave-article.
+     * The Leave event can be expanded further by passing an event-builder as the third param, but this is not recommended.
+     *
+     * Example usage:
+     *
+     * ```ts
+     *  const pageElement = document.querySelector('#application') || document.body;
+     *  const articleElement = document.getElementById('article-element');
+     *  tracker.addPageLeaveTracking(articleElement, pageElement);
+     * ```
+     *
+     * Passing '\{ objectResizable: true \}' as the 4th param makes the SDK re-calculate the object height whenever it changes,
+     * which is useful for when the page or object changes size after loading, by ex
+     * ```
+     *  ...
+     *  tracker.addPageLeaveTracking(articleElement, pageElement, undefined, {
+     *    objectResizable: true,
+     *  });
+     * ```
+     *
+     * Keep in mind that the Beacon API is used to send events to page leave, and in order to guarantee as good as
+     * possible that these events are sent, the event creator parameter should be synchronous.
+     *
+     * For the same reasons, we advise that the event creator parameter returns an event that does not contain any promises.
+     *
+     * @param {Element} objectElement The DOM element that is used to calculate various view-related fields in the default event.
+     * @param {Element} pageElement The DOM element that represents the page that the user is currently on.
+     * @param {LeaveEventBuilder} eventBuilder Function that returns an event to send when user leaves the page.
+     * @param {LeaveEventOptions} options
+     * @returns {(leaveEvent: LeaveEvent) => void} A function to update the event to send on page leave.
+     * @category Leave Event
+     */
+    addPageLeaveTracking(objectElement, pageElement, eventBuilder, options = {}) {
+        addPageLeaveTracking(this, objectElement, pageElement, eventBuilder, options);
+        return updatePageLeaveEvent;
+    }
+    /**
+     * Stop sending events when users leave a page.
+     * Removes all event handlers, meaning that to event will be sent if the user leaves the page.
+     * @category Leave Event
+     */
+    removePageLeaveTracking() {
+        removePageLeaveTracking(this);
+    }
+    /**
+     * Update leave tracking.
+     * Updates the DOM element used to calculate the default fields in the Leave event.
+     * @param objectElement The DOM element that is used to calculate various view-related fields in the default event.
+     * @param pageElement The DOM element that represents the page that the user is currently on.
+     * @param resetProperties A flag that decided whether the engagement properties of the Leave event should
+     * be reset when the tracking is updated. Defaults to false.
+     * @category Leave Event
+     */
+    updatePageLeaveTracking(objectElement, pageElement, resetProperties = false) {
+        updatePageLeaveTracking(objectElement, pageElement, resetProperties);
+    }
+    /**
+     * Manually trigger a viewed content recalculation including resetting max-values
+     * @param objectElement The DOM element that is used to calculate various view-related fields in the
+     * default event.
+     * @param pageElement The DOM element that represents the page that the user is currently on.
+     * @category Leave Event
+     */
+    resetPageLeaveViewedContent(objectElement, pageElement) {
+        resetViewedContent();
+        updateViewedContent(objectElement, pageElement);
+    }
+    /**
+     * Manually trigger a viewed content recalculation without resetting max-values
+     * @param objectElement The DOM element that is used to calculate various view-related fields in the
+     * default event.
+     * @param pageElement The DOM element that represents the page that the user is currently on.
+     * @category Leave Event
+     */
+    updatePageLeaveViewedContent(objectElement, pageElement) {
+        updateViewedContent(objectElement, pageElement);
+    }
+    /**
+     * Manually trigger a Leave event
+     * Useful if for example the consuming website is an SPA and the normal browser events are not triggered.
+     * is generated internally in the SDK.
+     * @param eventInput
+     * @param eventName The optional name of the browser event to simulate.
+     * @category Leave Event
+     */
+    async trackPageLeave(eventInput, eventName) {
+        await trackPageLeave(this, eventInput, eventName);
+    }
+    /**
+     * Manually trigger a Leave event only if Page Leave tracking is active in the SDK
+     * This method works similarly to
+     * ```
+     * trackPageLeave(event: LeaveEvent, eventName?: string)
+     * ```
+     * with the added guarantee that a second Leave event will not be triggered if one already has been sent.
+     * is generated internally in the SDK.
+     * @param eventInput
+     * @param eventName The optional name of the browser event to simulate.
+     * @category Leave Event
+     */
+    trackActivePageLeave(eventInput, eventName) {
+        trackActivePageLeave(this, eventInput, eventName);
+    }
+    /**
+     * Check if leave tracking is enabled (if an event will be sent when the user leaves the page)
+     * ```
+     * isLeaveTrackingActive()
+     * ```
+     * @category Leave Event
+     */
+    isLeaveTrackingActive() {
+        return leaveTrackingIsActive();
+    }
+    /**
+     * Update leave tracking.
+     * Updates the DOM element used to calculate the default fields in the Leave event.
+     * @param {Element} objectElement The DOM element that is used to calculate various view-related fields in the default event.
+     * @param {Element} pageElement The DOM element that represents the page that the user is currently on.
+     * @param {boolean} resetProperties A flag that decided whether the engagement properties of the Leave event should
+     * be reset when the tracking is updated. Defaults to false.
+     * @category TPaaS Leave Tracking
+     */
+    updateTpaasLeaveTracking(objectElement, pageElement, resetProperties = false) {
+        updateTpaasLeaveTracking(objectElement, pageElement, resetProperties);
+    }
+    /**
+     * Manually trigger a viewed content recalculation including resetting max-values
+     * @param {Element} objectElement The DOM element that is used to calculate various view-related fields in the
+     * default event.
+     * @param {Element} pageElement The DOM element that represents the page that the user is currently on.
+     * @category TPaaS Leave Tracking
+     */
+    resetTpaasLeaveViewedContent(objectElement, pageElement) {
+        resetTpaasViewedContent();
+        updateTpaasViewedContent(objectElement, pageElement);
+    }
+    /**
+     * Manually trigger a viewed content recalculation without resetting max-values
+     * @param {Element} objectElement The DOM element that is used to calculate various view-related fields in the
+     * default event.
+     * @param {Element} pageElement The DOM element that represents the page that the user is currently on.
+     * @category TPaaS Leave Tracking
+     */
+    updateTpaasLeaveViewedContent(objectElement, pageElement) {
+        updateTpaasViewedContent(objectElement, pageElement);
+    }
+    /**
+     * Get the current Leave object. Useful to fetch before manually sending a leave event using one of the trackLeaveX TPaaS methods.
+     * @returns {ILeave} The current Leave event object.
+     * @category TPaaS Leave Tracking
+     */
+    getTpaasLeaveObject() {
+        return getTpaasLeaveObject();
+    }
+    /**
+     * Manually trigger a Leave event only if Page Leave tracking is active in the SDK
+     * This method works similarly to the track TPaaS methods trackLeaveX
+     * ```
+     * trackLeavePage(input: InputParams<ILeavePage>)
+     * ```
+     * with the added guarantee that a second Leave event will not be triggered if one already has been sent.
+     * @category TPaaS Leave Tracking
+     */
+    trackTpaasActiveLeave() {
+        trackTpaasActiveLeave();
+    }
+    /**
+     * Check if leave tracking is enabled (if an event will be sent when the user leaves the page)
+     * ```
+     * isLeaveTpaasTrackingActive()
+     * ```
+     * @category TPaaS Leave Tracking
+     */
+    isLeaveTpaasTrackingActive() {
+        return leaveTpaasTrackingIsActive();
+    }
+    /**
+     * Start listening for events from the Tracker Proxy clients.
+     * @returns teardown function that stops the listener
+     */
+    exposeToProxyClients() {
+        return startProxyProviderListener(this);
+    }
+    /**
+     * @param input
+     * @private
+     */
+    async resolveTrackInput(input) {
+        return evaluateAndFlatten(input);
+    }
+    /**
+     * @private
+     */
+    async resolveTrackGlobals() {
+        return evaluateAndFlatten({ ...this.builders });
+    }
+    /**
+     * Send all anonymous events that are in the internal anonymous event queue.
+     *
+     * The returned Promise will resolve with the array of anonymous events that was
+     * successfully transmitted. These anonymous events will have been removed from the anonymous event
+     * queue. If the promise rejects, it means that the anonymous event queue could not be
+     * sent and the promise rejection will contain the anonymous events that failed.
+     * Anonymous events that are unsuccessfully sent will remain in the anonymous event queue.
+     *
+     * @internal
+     *
+     */
+    async _sendImmediatelyAnonymous() {
+        if (this.anonymousEventQueue.length + this.retryAnonymousEventQueue.length <= 0) {
+            return [];
+        }
+        // Anonymous events are sent without any user identifiers, independently of CIS, so no waiting for CIS sync here
+        return this.prepareQueuesAndSend(this.anonymousEventQueue, this.retryAnonymousEventQueue);
+    }
+    /**
+     * @param event
+     * @param options
+     * @internal
+     */
+    _pushAnonymous(event, options = {}) {
+        const deferredEvent = defer(event);
+        this.anonymousEventQueue.push(deferredEvent);
+        if (options.resolveOnQueued) {
+            deferredEvent.resolve(event);
+        }
+        return deferredEvent.promise;
+    }
+    /**
+     * Send the current anonymous event queue to the back end event receiver. This event is
+     * debounced, @see {SDKConfigInput} to override the default timing.
+     *
+     * This method is called by `trackAnonymous()` so it is not necessary to call after
+     * adding events to the queue.
+     *
+     * @internal
+     */
+    async sendAnonymous() {
+        if (this.state.useBeacon) {
+            try {
+                return await this._sendImmediatelyAnonymous();
+            }
+            catch (err) {
+                return err;
+            }
+        }
+        return this.debouncedSendAnonymous();
+    }
+    /**
+     * Prepares the received event queue and handles success / failure after sending.
+     *
+     * @param eventQueue
+     * @param retryEventQueue
+     * @private
+     */
+    async prepareQueuesAndSend(eventQueue, retryEventQueue) {
+        const promisesToBeSent = eventQueue.splice(0);
+        const eventsToBeSent = promisesToBeSent.map((p) => p.inputValue);
+        const eventsToRetry = retryEventQueue;
+        eventQueue.length = 0;
+        retryEventQueue.length = 0;
+        const evaluatedEvents = await Promise.all(eventsToBeSent);
+        const url = this._getCollectorPath();
+        const data = [...evaluatedEvents, ...eventsToRetry];
+        // biome-ignore lint/suspicious/noExplicitAny: -
+        async function onFailedSend(response) {
+            // We retry an event once, but discard already retried events
+            retryEventQueue.push(...evaluatedEvents);
+            for (const promise of promisesToBeSent) {
+                promise.reject(response);
+            }
+            return Promise.reject(evaluatedEvents);
+        }
+        try {
+            const response = await send(url, data, this.state);
+            if (response.status >= 400) {
+                return onFailedSend(response);
+            }
+            for (const promise of promisesToBeSent) {
+                promise.resolve(response);
+            }
+            return evaluatedEvents;
+        }
+        catch (error) {
+            return onFailedSend(error);
+        }
+    }
+    /**
+     * Creates a new event with values that are global to all event types, and are resolved internally by the sdk.
+     * `creationDate` and `session` are defined as early as possible in the event lifecycle, ensuring they are aligned
+     * and consistent across all events.
+     *
+     * @category Tracker
+     * @private
+     */
+    createEvent(eventInput) {
+        const creationDate = new Date();
+        const session = sessionBuilder({}, creationDate);
+        // Resolve any pending session ID promises
+        this.resolveSessionIdPromise();
+        return pulseMerge({}, eventInput, {
+            '@id': v4(),
+            creationDate: creationDate.toISOString(),
+            session,
+        });
+    }
+    /**
+     * Helper method to resolve any pending session ID promise
+     * @private
+     */
+    resolveSessionIdPromise() {
+        const session = readSession();
+        if (session?.id) {
+            eventBus.emit('tracker:session:new', {
+                sessionId: session.id,
+            });
+        }
+    }
+    /**
+     * Creates a new anonymous event with values that are global to all event types, and are resolved internally by the sdk.
+     * `creationDate` is defined as early as possible in the event lifecycle, ensuring it is aligned and consistent across all events.
+     *
+     * Note: anonymous events do not have a `session` object.
+     *
+     * @category Tracker
+     * @private
+     */
+    createAnonymousEvent(eventInput) {
+        const creationDate = new Date();
+        return pulseMerge({}, eventInput, {
+            '@id': v4(),
+            creationDate: creationDate.toISOString(),
+        });
+    }
+    /**
+     * applyEventTypeDefaults
+     * @param eventInput
+     * @param eventType
+     * @private
+     */
+    applyEventTypeDefaults(eventInput, eventType) {
+        const eventDefaults = getEventBuilder(eventType).defaults;
+        return pulseMerge({}, eventDefaults(), eventInput);
+    }
+    /**
+     * @param eventInput
+     * @param eventType
+     * @private
+     */
+    applyAnonymousEventTypeDefaults(eventInput, eventType) {
+        const eventDefaults = getAnonymousEventBuilder(eventType).defaults;
+        return pulseMerge({}, eventDefaults(), eventInput);
+    }
+    /**
+     * applyBookmarkedEvent
+     * @param eventInput
+     * @param bookmarkKey
+     * @private
+     */
+    applyBookmarkedEvent(eventInput, bookmarkKey) {
+        if (!bookmarkKey) {
+            return eventInput;
+        }
+        const eventOutput = Object.assign({}, eventInput);
+        const bookmarkedPageViewEvent = this.bookmark.get(bookmarkKey) ?? {};
+        const { '@id': _id, '@type': _type, creationDate: _creationDate, ...coreEvent } = bookmarkedPageViewEvent;
+        return pulseMerge({}, eventOutput, coreEvent);
+    }
+    /**
+     * applyConsents
+     * @param eventInput
+     * @private
+     */
+    async applyConsents(eventInput) {
+        return pulseMerge({}, eventInput, await this.evaluateConsents());
+    }
+    /**
+     * applyConsentsAnonymous
+     * @param eventInput
+     * @private
+     */
+    applyConsentsAnonymous(eventInput) {
+        return pulseMerge({}, eventInput, this.evaluateConsentsAnonymous());
+    }
+    /**
+     * Enriches the event with consent data saved in state.
+     * @private
+     * @category Consents
+     */
+    async evaluateConsents() {
+        const consents = await this.state.consents;
+        this.state.consents = consents; // replace state consents with resolved value; helps anonymous tracking, because that doesn't await consent promises
+        return {
+            ...(consents && { consents }),
+        };
+    }
+    /**
+     * Enriches the anonymous event with consent data saved in state.
+     *
+     * If the consents are a promise, it will return a fallback consent object, instead of waiting for consents to resolve
+     * @private
+     * @category Consents
+     */
+    evaluateConsentsAnonymous() {
+        const consents = isPromise(this.state.consents) ? getFallbackConsents() : this.state.consents;
+        return {
+            ...(consents && { consents }),
+        };
+    }
+    /**
+     * Private version of {@link setConsents} that works with autoCreateConsents
+     * @param consentsInput
+     * @private
+     * @category Consents
+     */
+    setConsentsInternal(consentsInput) {
+        const currentIncludeAdvertising = this.state.includeAdvertising;
+        const updatedIncludeAdvertising = applyAdvertisingConsentSync(consentsInput, this.state.requireAdvertisingOptIn);
+        this.state.includeAdvertising = updatedIncludeAdvertising;
+        this.state.consents = consentsInput;
+        // Only require a CIS sync if the user has changed their advertising consent
+        if (currentIncludeAdvertising !== updatedIncludeAdvertising) {
+            identity.requireCisSyncCallForAdvertisingIds();
+        }
+        logger.debug('Consents set', consentsInput);
+        return { ...this.state.consents };
+    }
+    /**
+     * Get the includeAdvertising flag, set on initialisation.
+     * @see constructor
+     * @private
+     * @category Identifiers
+     */
+    async getIncludeAdvertising() {
+        await this._applyRemoteConfigEndpoints();
+        return identity.getIncludeAdvertising(this.state);
+    }
+}