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

package/dist/types/Tracker.d.ts

@@ -0,0 +1,1418 @@
+import { type AdvertisingIdentifiers, type AdvertisingVendor } from '@schibsted/pulse-cis-sync';
+import { getCommonBuildersOutput, type InputParams } from '@schibsted/tpaas-event-builder';
+import { type IAnonymousViewUIElement, type ICompletedHealthAction, type IEngagementAudio, type IEngagementForm, type IEngagementHealthUIElement, type IEngagementOffer, type IEngagementTeaser, type IEngagementUIElement, type IEngagementVideo, type IEngagementVideoAd, type IEngagementWidget, type IImpressionAdSlot, type IImpressionForm, type IImpressionHealthUIElement, type IImpressionOffer, type IImpressionPlayer, type IImpressionTeaser, type IImpressionUIElement, type IImpressionWidget, type ILeave, type ILeaveArticle, type ILeaveAudioPage, type ILeaveError, type ILeaveFrontpage, type ILeaveLandingpage, type ILeaveListing, type ILeaveLockedArticle, type ILeaveLockedAudio, type ILeaveLockedAudioPage, type ILeaveLockedVideo, type ILeaveLockedVideoPage, type ILeavePage, type ILeaveVideoPage, type ILeaveWeather, type ITpaasEvent, type IViewArticle, type IViewAudio, type IViewAudioPage, type IViewError, type IViewFrontpage, type IViewHealthPage, type IViewLandingpage, type IViewListing, type IViewLockedArticle, type IViewLockedAudio, type IViewLockedAudioPage, type IViewLockedVideo, type IViewLockedVideoPage, type IViewPage, type IViewTitle, type IViewVideo, type IViewVideoPage, type IViewWeather } from '@schibsted/tpaas-schemas';
+import logger from 'loglevel';
+import type { ActorInput, Consents, ConsentsInput, DeviceInput, LocationInput, ObjectInput, OriginInput, ProviderInput, TrackerInput } from './builders';
+import { engagementEvent, identityEvent, routableEvent, trackerEvent } from './builders/events';
+import { anonymousEngagementEvent, anonymousTrackerEvent } from './builders/events-anonymous-node';
+import type { Deferred, ResolvedInput } from './defer';
+import { type Listener } from './EventBus/EventBus';
+import type { LeaveEvent, LeaveEventBuilder, LeaveEventOptions } from './leaveTracking/types';
+import type { AnonymousEventInputTypesByTrackingMethod, EventInput, EventInputTypesByTrackingMethod, TrackViewAudioPageOptions, TrackViewEventOptions, TrackViewVideoPageOptions } from './types';
+import type { ClickUIElementInputProperties } from './wrapper/engagement/ui-element/types';
+import type { BaseEventExperiment } from './wrapper/types';
+import type { ViewArticleInputProperties } from './wrapper/view/article/types';
+import type { ViewFrontpageInputProperties } from './wrapper/view/frontpage/types';
+import type { ViewListingInputProperties } from './wrapper/view/listing/types';
+import type { ViewLoginPosterInputProperties } from './wrapper/view/loginposter/types';
+import type { ViewPageInputProperties } from './wrapper/view/page/types';
+import type { ViewSalesPosterInputProperties } from './wrapper/view/salesposter/types';
+import type { ViewUIElementInputProperties } from './wrapper/view/ui-element/types';
+/**
+ * Builder types for each event type
+ * @internal
+ */
+type EventTrackingMethods = {
+    identity: typeof identityEvent;
+    trackerEvent: typeof trackerEvent;
+    engagementEvent: typeof engagementEvent;
+    routableEvent: typeof routableEvent;
+};
+/**
+ * Builder types for each anonymous event type
+ * @internal
+ */
+type AnonymousEventTrackingMethods = {
+    trackerEvent: typeof anonymousTrackerEvent;
+    engagementEvent: typeof anonymousEngagementEvent;
+};
+/**
+ * Base type for anonymous events
+ */
+export type AnonymousEventType = keyof AnonymousEventTrackingMethods;
+/**
+ * Function type for alternative event handler
+ * @param event Event stringified
+ */
+export type AltEventHandler = (event: string) => void;
+/**
+ * Core config options that are required for the SDK to function.
+ * @internal
+ *
+ * @privateRemarks
+ * These types should be dealt with by the media/marketplace implementation, and not (necessarily)
+ * exposed to the end user/developer.
+ *
+ * Make properties optional.
+ */
+interface FallbackSDKConfig {
+    remoteConfigurationUrl: string;
+    fallbackCisBaseUrl: string;
+    fallbackCollectorBaseUrl: string;
+    schemaLocation: string;
+}
+/**
+ * Possible deployment stages targeted by the SDK api and/or the event routing
+ */
+export type DeployStage = 'dev' | 'pre' | 'pro';
+/**
+ * Override default settings of the SDK
+ *
+ * See `src/config-browser.js` and `src/config.js` for the default values for
+ * browser and no browser environments.
+ *
+ * **Note** that the `username` and `password` is *for Node.js environments only*.
+ */
+export interface SDKConfigInput {
+    /**
+     * Function handler to call in place of the built-in tracker call.
+     * @function
+     * @deprecated This value is automatically populated from `window.pulseEventHandler`
+     */
+    altEventHandler?: AltEventHandler;
+    autoCreateConsents?: boolean;
+    cisBaseUrl?: string;
+    cisEnabled?: boolean;
+    collectorBaseUrl?: string;
+    collectorPath?: string;
+    configurationTag?: string;
+    consents?: Consents | ConsentsInput | Promise<Consents>;
+    deployStage?: DeployStage;
+    deployStageTpaas?: DeployStage;
+    eventDebounce?: number;
+    isHybrid?: boolean;
+    logLevel?: logger.LogLevelDesc;
+    /**
+     * @deprecated This value is automatically populated from window.__nativeJwe__ or window.hermesJwe
+     */
+    nativeJwe?: string;
+    password?: string;
+    requireAdvertisingOptIn?: boolean;
+    trackerId?: string;
+    useBeacon?: boolean;
+    useBeaconWhenAvailable?: boolean;
+    username?: string;
+    vendors?: AdvertisingVendor[];
+    /**
+     * @deprecated Xandr sync and AnId functionality no longer supported.
+     */
+    xandrEnabled?: boolean;
+}
+/**
+ * Internal state of the tracker.
+ *
+ * **Note** that the `username` and `password` is *for Node.js environments
+ * only*.
+ * @internal
+ */
+export type SDKState = {
+    altEventHandler?: AltEventHandler;
+    autoCreateConsents?: boolean;
+    cisBaseUrl?: string;
+    cisEnabled?: boolean;
+    collectorBaseUrl?: string;
+    collectorPath: string;
+    configurationTag?: string;
+    consents?: Consents | ConsentsInput | Promise<Consents>;
+    deployStage: DeployStage;
+    deployStageTpaas: DeployStage;
+    environment: 'node' | 'browser';
+    eventDebounce?: number;
+    includeAdvertising: boolean | Promise<boolean>;
+    isHybrid?: boolean;
+    nativeJwe?: string;
+    pageViewId: string;
+    password?: string;
+    providerId: string;
+    remoteConfigurationUrl: string;
+    requireAdvertisingOptIn?: boolean;
+    schemaLocation: string;
+    trackerId?: string;
+    tpaasCollectorBaseUrl: string;
+    useBeacon?: boolean;
+    useBeaconWhenAvailable?: boolean;
+    username?: string;
+    vendors: AdvertisingVendor[];
+    /**
+     * @deprecated Xandr sync and AnId functionality no longer supported.
+     */
+    xandrEnabled?: boolean;
+} & SDKConfigInput & FallbackSDKConfig;
+/**
+ * Input for event builders. Different events will read and process different
+ * fields.
+ *
+ * You generally can pass any data to any part of the event, only the processed
+ * fields are documented.
+ */
+export type Builders = {
+    actor?: Promise<ActorInput> | ActorInput;
+    provider?: ProviderInput;
+    device?: DeviceInput;
+    object?: ObjectInput;
+    target?: ObjectInput;
+    tracker?: TrackerInput;
+    location?: LocationInput;
+    origin?: OriginInput;
+    experiments?: BaseEventExperiment[];
+};
+/**
+ * Optional option used in `track` and `trackPageView`
+ *
+ * If `resolveOnQueued` is set to true then the promise returned by `track`/`trackPageView` will
+ * resolve when the event is evaluated and added to the internal queue. If it is falsy (default
+ * value us `undefined`) the promise will resolve when the event have been transmitted over the
+ * network.
+ */
+export type TrackOptions = {
+    applyBookmarkKey?: string;
+    bookmarkKey?: string;
+    resolveOnQueued?: boolean;
+};
+export interface TrackCloneOptions {
+    trackerId?: string;
+}
+/**
+ * @internal
+ */
+export declare const BookmarkKeys: {
+    PAGE_VIEW: string;
+};
+export type WebApi = {
+    /**
+     * Global tracker instance
+     * @privateRemarks
+     * Do not mix with `window.pulse`, which is the Autotracker script handler
+     */
+    __pulseTracker?: Promise<Tracker>;
+};
+type EventsToDispatch = {
+    'tracker:ready': {
+        tracker: Tracker;
+    };
+    'tracker:session:new': {
+        sessionId: string;
+    };
+};
+export declare function subscribe<T extends keyof EventsToDispatch>(eventName: T, callback: Listener<EventsToDispatch[T]>): () => void;
+export declare function subscribeOnce<T extends keyof EventsToDispatch>(eventName: T, callback: Listener<EventsToDispatch[T]>): () => void;
+export declare function subscribeWithState<T extends keyof EventsToDispatch>(eventName: T, callback: Listener<EventsToDispatch[T]>): () => void;
+export declare function unsubscribe<T extends keyof EventsToDispatch>(eventName: T, callback: Listener<EventsToDispatch[T]>): void;
+/**
+ * @class Tracker
+ */
+export default class Tracker {
+    /**
+     * @property
+     * @internal
+     */
+    state: SDKState;
+    /**
+     * @property
+     * @internal
+     */
+    builders: Builders;
+    /**
+     * @property
+     * @internal
+     */
+    eventQueue: Array<Deferred>;
+    /**
+     * @property
+     * @internal
+     */
+    anonymousEventQueue: Array<Deferred>;
+    /**
+     * Queue for TPaaS events
+     * @property
+     * @internal
+     */
+    tpaasEventQueue: Array<ITpaasEvent>;
+    /**
+     * Queue for events that have already failed once
+     * @property
+     * @internal
+     */
+    retryEventQueue: Array<EventInput>;
+    /**
+     * Queue for anonymous events that have already failed once
+     * @property
+     * @internal
+     */
+    retryAnonymousEventQueue: Array<EventInput>;
+    /**
+     * Queue for TPaaS events that have already failed once
+     * @property
+     * @internal
+     */
+    retryTpaasEventQueue: Array<ITpaasEvent>;
+    /**
+     * @function
+     * @private
+     */
+    debouncedSend: () => Promise<EventInput[] | undefined>;
+    /**
+     * @function
+     * @private
+     */
+    debouncedSendAnonymous: () => Promise<EventInput[] | undefined>;
+    /**
+     * @function
+     * @private
+     */
+    debouncedSendTpaas: () => Promise<ITpaasEvent[] | undefined>;
+    /**
+     * @property
+     * @private
+     */
+    private bookmark;
+    private legacyVisibilityObservers;
+    private visibilityObservers;
+    private legacyCurrentPage;
+    private currentPage;
+    /**
+     * Promise that resolves when a session ID becomes available
+     * @private
+     */
+    private sessionIdPromise;
+    /**
+     * > [!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: string, config?: SDKConfigInput, builders?: Builders);
+    /**
+     * 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<T extends keyof EventTrackingMethods>(eventType: T, input: EventInputTypesByTrackingMethod[T], options?: TrackOptions): Promise<unknown>;
+    /**
+     * 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
+     */
+    trackAnonymous<T extends AnonymousEventType>(eventType: T, input: AnonymousEventInputTypesByTrackingMethod[T], options?: TrackOptions): Promise<any>;
+    private adaptExperiments;
+    /**
+     *
+     * @private
+     * @category TPaaS Tracking
+     */
+    private prepareAnonymousTpaasEvent;
+    /**
+     *
+     * @private
+     * @category TPaaS Tracking
+     */
+    private prepareTpaasEvent;
+    /**
+     * 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
+     */
+    generateGenericTpaasEvent<T>(input: T): Promise<T & ReturnType<typeof getCommonBuildersOutput>>;
+    /**
+     * 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: BaseEventExperiment[]): void;
+    /**
+     * 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: string, buildEventFromElement: (element: HTMLElement) => ViewUIElementInputProperties): void;
+    /**
+     * 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: string, buildEventFromElement: (element: HTMLElement) => InputParams<IImpressionUIElement>): void;
+    private setPageDefaults;
+    /**
+     * 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: ViewArticleInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * 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: ViewLoginPosterInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * 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: ViewSalesPosterInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * 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: ViewListingInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * 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: ViewFrontpageInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * 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: ViewPageInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * The old trackViewUIElement method from the Media Wrapper.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyViewUIElement(inputProperties: ViewUIElementInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * The old trackClickUIElement method from the Media Wrapper.
+     *
+     * @param inputProperties
+     * @param trackOptions
+     * @category Legacy Tracking
+     */
+    trackLegacyClickUIElement(inputProperties: ClickUIElementInputProperties, trackOptions?: TrackOptions): Promise<unknown>;
+    /**
+     * The following methods are the track methods specific for the TPaaS schemas
+     */
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackAnonymousViewUIElement(input: InputParams<IAnonymousViewUIElement>): Promise<unknown>;
+    private setCurrentPage;
+    trackCompletedHealthAction(input: InputParams<ICompletedHealthAction>): Promise<unknown>;
+    trackEngagementHealthUIElement(input: InputParams<IEngagementHealthUIElement>): Promise<unknown>;
+    trackViewHealthPage(input: InputParams<IViewHealthPage>, options: TrackViewEventOptions): Promise<unknown>;
+    trackImpressionHealthUIElement(input: InputParams<IImpressionHealthUIElement>): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewPage(input: InputParams<IViewPage>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackViewTitle(input: InputParams<IViewTitle>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionWidget(input: InputParams<IImpressionWidget>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionAdSlot(input: InputParams<IImpressionAdSlot>): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewArticle(input: InputParams<IViewArticle>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewAudio(input: InputParams<IViewAudio>): Promise<unknown>;
+    /**
+     * 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
+     */
+    trackViewAudioPage(input: InputParams<IViewAudioPage>, options: TrackViewAudioPageOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewError(input: InputParams<IViewError>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionForm(input: InputParams<IImpressionForm>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionOffer(input: InputParams<IImpressionOffer>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionPlayer(input: InputParams<IImpressionPlayer>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionTeaser(input: InputParams<IImpressionTeaser>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackImpressionUIElement(input: InputParams<IImpressionUIElement>): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewFrontpage(input: InputParams<IViewFrontpage>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewLandingpage(input: InputParams<IViewLandingpage>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewListing(input: InputParams<IViewListing>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewLockedArticle(input: InputParams<IViewLockedArticle>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewLockedAudio(input: InputParams<IViewLockedAudio>): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewLockedAudioPage(input: InputParams<IViewLockedAudioPage>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackViewLockedVideo(input: InputParams<IViewLockedVideo>): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewLockedVideoPage(input: InputParams<IViewLockedVideoPage>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackViewVideo(input: InputParams<IViewVideo>): Promise<unknown>;
+    /**
+     * 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
+     */
+    trackViewVideoPage(input: InputParams<IViewVideoPage>, options: TrackViewVideoPageOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    trackViewWeather(input: InputParams<IViewWeather>, options: TrackViewEventOptions): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveArticle(input: InputParams<ILeaveArticle>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveAudioPage(input: InputParams<ILeaveAudioPage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveError(input: InputParams<ILeaveError>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveFrontpage(input: InputParams<ILeaveFrontpage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveLandingpage(input: InputParams<ILeaveLandingpage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveListing(input: InputParams<ILeaveListing>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveLockedArticle(input: InputParams<ILeaveLockedArticle>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveLockedAudio(input: InputParams<ILeaveLockedAudio>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveLockedAudioPage(input: InputParams<ILeaveLockedAudioPage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveLockedVideo(input: InputParams<ILeaveLockedVideo>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveLockedVideoPage(input: InputParams<ILeaveLockedVideoPage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeavePage(input: InputParams<ILeavePage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveVideoPage(input: InputParams<ILeaveVideoPage>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackLeaveWeather(input: InputParams<ILeaveWeather>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementAudio(input: InputParams<IEngagementAudio>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementForm(input: InputParams<IEngagementForm>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementOffer(input: InputParams<IEngagementOffer>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementTeaser(input: InputParams<IEngagementTeaser>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementUIElement(input: InputParams<IEngagementUIElement>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementVideo(input: InputParams<IEngagementVideo>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementVideoAd(input: InputParams<IEngagementVideoAd>): Promise<unknown>;
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    trackEngagementWidget(input: InputParams<IEngagementWidget>): Promise<unknown>;
+    /**
+     * this is the method that actually sends the event to the server
+     * @private
+     * @category TPaaS Tracking
+     */
+    private sendTpaasEvent;
+    /**
+     * 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
+     */
+    _sendImmediatelyTpaas(): Promise<Array<ITpaasEvent>>;
+    /**
+     * Prepares the received event queue and handles success / failure after sending.
+     *
+     * @param eventQueue
+     * @param retryEventQueue
+     * @private
+     * @category TPaaS Tracking
+     */
+    private prepareQueuesAndSendTpaas;
+    /**
+     * Evaluate all input given to the sdk/this method and pass it through the
+     * appropriate event formatter.
+     * @internal
+     * @category Legacy Tracking
+     */
+    evaluateEvent<T extends keyof EventTrackingMethods>(eventType: T, input: EventInputTypesByTrackingMethod[T], builders?: Builders, options?: TrackOptions): Promise<ReturnType<EventTrackingMethods[T]>>;
+    /**
+     * @param eventType
+     * @param eventInput
+     * @param builders
+     * @param options
+     * @internal
+     * @category Legacy Tracking
+     */
+    evaluateEventInputs<T extends keyof EventTrackingMethods>(eventType: T, eventInput: EventInputTypesByTrackingMethod[T], builders?: Builders, options?: TrackOptions): Promise<any>;
+    /**
+     * Gets user consents from the tracker's state.
+     * @returns {Consents}
+     * @category Consents
+     */
+    getConsents(): Promise<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: Consents): Consents;
+    /**
+     * Return a new Tracker with the current state
+     * @category Tracking
+     */
+    clone({ trackerId }?: TrackCloneOptions): Tracker;
+    /**
+     * 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: EventInput, mergeBuilder?: boolean): void;
+    /**
+     * 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
+     */
+    getUserId(): Promise<string | number | undefined>;
+    /**
+     * 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.
+     */
+    getAdId(): Promise<string | undefined>;
+    /**
+     * @category Identifiers
+     * @deprecated moving away from "Actor" terminology, in favor of "User"
+     */
+    getActor(): Promise<ActorInput | undefined>;
+    /**
+     * 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
+     */
+    getEnvironmentId(): Promise<string | undefined>;
+    /**
+     * 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.
+     */
+    getXandrPPID1(): Promise<string | undefined>;
+    /**
+     * 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.
+     */
+    getXandrPPID2(): Promise<string | undefined>;
+    /**
+     * Returns the Advertising Identifiers for the vendor given in SDK configuration
+     * @category Identifiers
+     * @deprecated Advertising Identifiers methods will be removed in the next major version.
+     */
+    getAdvertisingIdentifiers(): Promise<AdvertisingIdentifiers>;
+    /**
+     * Returns the Advertising Identifiers for the vendor given in SDK configuration
+     * @param [_vendor]
+     * @category Identifiers
+     * @deprecated Advertising Identifiers methods will be removed in the next major version.
+     */
+    getAdvertisingIdentifiers(_vendor?: string[]): Promise<AdvertisingIdentifiers>;
+    /**
+     * Returns the UUID currently used as the page view (will be muted by `newPageView` and `trackPageView`).
+     * @category Tracking
+     */
+    getPageViewId(): string;
+    /**
+     * 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(): Promise<string>;
+    /**
+     * Generate a new page view id. Will be attached to all events until a new id is generated.
+     * @category Tracking
+     */
+    newPageView(): void;
+    /**
+     * Fetches the Remote Configuration, setting the CIS and Collector base urls
+     * @internal
+     * @category Configuration
+     */
+    _applyRemoteConfigEndpoints(): Promise<void>;
+    /**
+     * @param input
+     * @param builders
+     * @internal
+     * @category Configuration
+     */
+    syncRemoteResources(input?: unknown, builders?: Builders): Promise<{
+        adId?: string;
+        doTracking: boolean;
+        environmentId?: string;
+        ppId?: import("@schibsted/pulse-cis-sync").PPIDsByVendor;
+    }>;
+    /**
+     * @internal
+     * @category Configuration
+     */
+    _getCollectorPath(): string;
+    /**
+     * Returns the collector URL for TPaaS events.
+     * Uses the tpaasCollectorBaseUrl when available (driven by deployStageTpaas),
+     *
+     * @internal
+     * @category Configuration
+     */
+    _getTpaasCollectorPath(): string;
+    /**
+     * 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
+     *
+     */
+    _sendImmediately(): Promise<Array<EventInput>>;
+    /**
+     * @param event
+     * @param options
+     * @internal
+     * @category Legacy Tracking
+     */
+    _push(event: EventInput, options?: TrackOptions): Promise<ResolvedInput>;
+    /**
+     * @param bookmarkKey
+     * @internal
+     * @category Legacy Tracking
+     */
+    getBookmarkedEvent(bookmarkKey: string): Record<string, unknown> | undefined;
+    /**
+     * 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
+     */
+    send(): Promise<EventInput[] | undefined | unknown>;
+    /**
+     * 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?: EventInput, options?: TrackOptions): Promise<unknown>;
+    /**
+     * 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: Element, pageElement: Element, eventBuilder?: LeaveEventBuilder, options?: LeaveEventOptions): (leaveEvent: LeaveEvent) => void;
+    /**
+     * 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(): void;
+    /**
+     * 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: Element, pageElement: Element, resetProperties?: boolean): void;
+    /**
+     * 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: Element, pageElement: Element): void;
+    /**
+     * 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: Element, pageElement: Element): void;
+    /**
+     * 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
+     */
+    trackPageLeave(eventInput?: LeaveEvent, eventName?: string): Promise<void>;
+    /**
+     * 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?: LeaveEvent, eventName?: string): void;
+    /**
+     * Check if leave tracking is enabled (if an event will be sent when the user leaves the page)
+     * ```
+     * isLeaveTrackingActive()
+     * ```
+     * @category Leave Event
+     */
+    isLeaveTrackingActive(): boolean;
+    /**
+     * 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: Element, pageElement: Element, resetProperties?: boolean): void;
+    /**
+     * 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: Element, pageElement: Element): void;
+    /**
+     * 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: Element, pageElement: Element): void;
+    /**
+     * 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(): ILeave;
+    /**
+     * 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(): void;
+    /**
+     * Check if leave tracking is enabled (if an event will be sent when the user leaves the page)
+     * ```
+     * isLeaveTpaasTrackingActive()
+     * ```
+     * @category TPaaS Leave Tracking
+     */
+    isLeaveTpaasTrackingActive(): boolean;
+    /**
+     * Start listening for events from the Tracker Proxy clients.
+     * @returns teardown function that stops the listener
+     */
+    exposeToProxyClients(): () => void;
+    /**
+     * @param input
+     * @private
+     */
+    private resolveTrackInput;
+    /**
+     * @private
+     */
+    private resolveTrackGlobals;
+    /**
+     * 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
+     *
+     */
+    private _sendImmediatelyAnonymous;
+    /**
+     * @param event
+     * @param options
+     * @internal
+     */
+    private _pushAnonymous;
+    /**
+     * 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
+     */
+    private sendAnonymous;
+    /**
+     * Prepares the received event queue and handles success / failure after sending.
+     *
+     * @param eventQueue
+     * @param retryEventQueue
+     * @private
+     */
+    private prepareQueuesAndSend;
+    /**
+     * 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
+     */
+    private createEvent;
+    /**
+     * Helper method to resolve any pending session ID promise
+     * @private
+     */
+    private resolveSessionIdPromise;
+    /**
+     * 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
+     */
+    private createAnonymousEvent;
+    /**
+     * applyEventTypeDefaults
+     * @param eventInput
+     * @param eventType
+     * @private
+     */
+    private applyEventTypeDefaults;
+    /**
+     * @param eventInput
+     * @param eventType
+     * @private
+     */
+    private applyAnonymousEventTypeDefaults;
+    /**
+     * applyBookmarkedEvent
+     * @param eventInput
+     * @param bookmarkKey
+     * @private
+     */
+    private applyBookmarkedEvent;
+    /**
+     * applyConsents
+     * @param eventInput
+     * @private
+     */
+    private applyConsents;
+    /**
+     * applyConsentsAnonymous
+     * @param eventInput
+     * @private
+     */
+    private applyConsentsAnonymous;
+    /**
+     * Enriches the event with consent data saved in state.
+     * @private
+     * @category Consents
+     */
+    private evaluateConsents;
+    /**
+     * 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
+     */
+    private evaluateConsentsAnonymous;
+    /**
+     * Private version of {@link setConsents} that works with autoCreateConsents
+     * @param consentsInput
+     * @private
+     * @category Consents
+     */
+    private setConsentsInternal;
+    /**
+     * Get the includeAdvertising flag, set on initialisation.
+     * @see constructor
+     * @private
+     * @category Identifiers
+     */
+    private getIncludeAdvertising;
+}
+export {};