@openreplay/tracker 16.4.10 → 16.4.11-beta.1

package/dist/cjs/main/app/canvas.d.ts

@@ -5,6 +5,8 @@ interface Options {
     isDebug?: boolean;
     fixedScaling?: boolean;
     useAnimationFrame?: boolean;
+    framesSupport?: boolean;
+    /** @deprecated webp is the default format for pipeline optimization */
     fileExt?: 'webp' | 'png' | 'jpeg' | 'avif';
 }
 declare class CanvasRecorder {
@@ -12,8 +14,14 @@ declare class CanvasRecorder {
     private readonly options;
     private snapshots;
     private readonly intervals;
+    private readonly observers;
     private readonly interval;
     private readonly fileExt;
+    private uploadQueue;
+    private readonly MAX_CONCURRENT_UPLOADS;
+    private readonly MAX_QUEUE_SIZE;
+    private readonly pendingBatches;
+    private isProcessingQueue;
     constructor(app: App, options: Options);
     startTracking(): void;
     restartTracking: () => void;
@@ -23,6 +31,9 @@ declare class CanvasRecorder {
         data: Blob;
         id: number;
     }[], canvasId: number, createdAt: number): void;
+    private processUploadQueue;
+    private uploadBatch;
+    private cleanupCanvas;
     clear(): void;
 }
 export default CanvasRecorder;

package/dist/cjs/main/app/guards.d.ts

@@ -18,6 +18,7 @@ type TagTypeMap = {
     style: HTMLStyleElement | SVGStyleElement;
     link: HTMLLinkElement;
     canvas: HTMLCanvasElement;
+    slot: HTMLSlotElement;
 };
 export declare function hasTag<T extends keyof TagTypeMap>(el: Node, tagName: T): el is TagTypeMap[typeof tagName];
 export {};

package/dist/cjs/main/app/index.d.ts

@@ -1,6 +1,5 @@
 import type { Options as WebworkerOptions } from '../../common/interaction.js';
 import AttributeSender from '../modules/attributeSender.js';
-import FeatureFlags from '../modules/featureFlags.js';
 import type { Options as NetworkOptions } from '../modules/network.js';
 import Logger, { ILogLevel } from './logger.js';
 import Message from './messages.gen.js';
@@ -152,13 +151,11 @@ export default class App {
     private readonly version;
     private worker?;
     attributeSender: AttributeSender;
-    featureFlags: FeatureFlags;
     socketMode: boolean;
     private compressionThreshold;
     private readonly bc;
     private readonly contextId;
     private canvasRecorder;
-    private uxtManager;
     private conditionsManager;
     private readonly tagWatcher;
     private canStart;
@@ -166,7 +163,6 @@ export default class App {
     private pageFrames;
     private frameOderNumber;
     private frameLevel;
-    private features;
     private emptyBatchCounter;
     constructor(projectKey: string, sessionToken: string | undefined, options: Partial<Options>, signalError: (error: string, apis: string[]) => void, insideIframe: boolean);
     /** used by child iframes for crossdomain only */
@@ -192,6 +188,7 @@ export default class App {
     allowAppStart(): void;
     private checkNodeId;
     private initWorker;
+    private restart;
     private handleWorkerMsg;
     private _debug;
     send: (message: Message, urgent?: boolean) => void;
@@ -253,7 +250,7 @@ export default class App {
      * user 30 seconds to "activate" and record session by calling `start()` on conditional trigger,
      * and we will then send buffered batch, so it won't get lost
      * */
-    coldStart: (startOpts?: StartOptions, conditional?: boolean) => Promise<void>;
+    coldStart(startOpts?: StartOptions, conditional?: boolean): Promise<void>;
     private setupConditionalStart;
     onSessionSent: () => void;
     /**
@@ -261,7 +258,7 @@ export default class App {
      * @param {Object} startOpts - options for session start, same as .start()
      * @param {Function} onSessionSent - callback that will be called once session is fully sent
      * */
-    offlineRecording: (startOpts: StartOptions | undefined, onSessionSent: () => void) => {
+    offlineRecording(startOpts: StartOptions | undefined, onSessionSent: () => void): {
         saveBuffer: () => void;
         getBuffer: () => Message[];
         setBuffer: (buffer: Message[]) => void;
@@ -273,15 +270,15 @@ export default class App {
      *
      * Keeping the size of local storage reasonable is up to the end users of this library
      * */
-    saveBuffer: () => void;
+    saveBuffer(): void;
     /**
      * @returns buffer with stored messages for offline recording
      * */
-    getBuffer: () => Message[];
+    getBuffer(): Message[];
     /**
      * Used to set a buffer with messages array
      * */
-    setBuffer: (buffer: Message[]) => void;
+    setBuffer(buffer: Message[]): void;
     /**
      * Uploads the stored session buffer to backend
      * @returns promise that resolves once messages are loaded, it has to be awaited
@@ -294,9 +291,6 @@ export default class App {
     private _start;
     restartCanvasTracking: () => void;
     flushBuffer: (buffer: Message[]) => Promise<unknown>;
-    onUxtCb: never[];
-    addOnUxtCb(cb: (id: number) => void): void;
-    getUxtId(): number | null;
     waitStart(): Promise<unknown>;
     waitStarted(): Promise<unknown>;
     waitStatus(status: ActivityState): Promise<unknown>;

package/dist/cjs/main/app/messages.gen.d.ts

@@ -27,9 +27,7 @@ export declare function UserAnonymousID(id: string): Messages.UserAnonymousID;
 export declare function Metadata(key: string, value: string): Messages.Metadata;
 export declare function StringDictGlobal(key: number, value: string): Messages.StringDictGlobal;
 export declare function SetNodeAttributeDictGlobal(id: number, name: number, value: number): Messages.SetNodeAttributeDictGlobal;
-export declare function CSSInsertRule(id: number, rule: string, index: number): Messages.CSSInsertRule;
-export declare function CSSDeleteRule(id: number, index: number): Messages.CSSDeleteRule;
-export declare function Fetch(method: string, url: string, request: string, response: string, status: number, timestamp: number, duration: number): Messages.Fetch;
+export declare function NodeAnimationResult(id: number, styles: string): Messages.NodeAnimationResult;
 export declare function Profiler(name: string, duration: number, args: string, result: string): Messages.Profiler;
 export declare function OTable(key: string, value: string): Messages.OTable;
 export declare function StateAction(type: string): Messages.StateAction;
@@ -43,17 +41,16 @@ export declare function StringDictDeprecated(key: number, value: string): Messag
 export declare function SetNodeAttributeDictDeprecated(id: number, nameKey: number, valueKey: number): Messages.SetNodeAttributeDictDeprecated;
 export declare function StringDict(key: string, value: string): Messages.StringDict;
 export declare function SetNodeAttributeDict(id: number, name: string, value: string): Messages.SetNodeAttributeDict;
-export declare function ResourceTimingDeprecated(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string): Messages.ResourceTimingDeprecated;
+export declare function ResourceTimingDeprecatedDeprecated(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string): Messages.ResourceTimingDeprecatedDeprecated;
 export declare function ConnectionInformation(downlink: number, type: string): Messages.ConnectionInformation;
 export declare function SetPageVisibility(hidden: boolean): Messages.SetPageVisibility;
 export declare function LoadFontFace(parentID: number, family: string, source: string, descriptors: string): Messages.LoadFontFace;
 export declare function SetNodeFocus(id: number): Messages.SetNodeFocus;
-export declare function LongTask(timestamp: number, duration: number, context: number, containerType: number, containerSrc: string, containerId: string, containerName: string): Messages.LongTask;
 export declare function SetNodeAttributeURLBased(id: number, name: string, value: string, baseURL: string): Messages.SetNodeAttributeURLBased;
 export declare function SetCSSDataURLBased(id: number, data: string, baseURL: string): Messages.SetCSSDataURLBased;
 export declare function TechnicalInfo(type: string, value: string): Messages.TechnicalInfo;
 export declare function CustomIssue(name: string, payload: string): Messages.CustomIssue;
-export declare function CSSInsertRuleURLBased(id: number, rule: string, index: number, baseURL: string): Messages.CSSInsertRuleURLBased;
+export declare function SetNodeSlot(id: number, slotID: number): Messages.SetNodeSlot;
 export declare function MouseClick(id: number, hesitationTime: number, label: string, selector: string, normalizedX: number, normalizedY: number): Messages.MouseClick;
 export declare function MouseClickDeprecated(id: number, hesitationTime: number, label: string, selector: string): Messages.MouseClickDeprecated;
 export declare function CreateIFrameDocument(frameID: number, id: number): Messages.CreateIFrameDocument;
@@ -68,11 +65,14 @@ export declare function BatchMetadata(version: number, pageNo: number, firstInde
 export declare function PartitionedMessage(partNo: number, partTotal: number): Messages.PartitionedMessage;
 export declare function NetworkRequest(type: string, method: string, url: string, request: string, response: string, status: number, timestamp: number, duration: number, transferredBodySize: number): Messages.NetworkRequest;
 export declare function WSChannel(chType: string, channelName: string, data: string, timestamp: number, dir: string, messageType: string): Messages.WSChannel;
+export declare function ResourceTiming(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string, transferredSize: number, cached: boolean, queueing: number, dnsLookup: number, initialConnection: number, ssl: number, contentDownload: number, total: number, stalled: number): Messages.ResourceTiming;
+export declare function Incident(label: string, startTime: number, endTime: number): Messages.Incident;
+export declare function LongAnimationTask(name: string, duration: number, blockingDuration: number, firstUIEventTimestamp: number, startTime: number, scripts: string): Messages.LongAnimationTask;
 export declare function InputChange(id: number, value: string, valueMasked: boolean, label: string, hesitationTime: number, inputDuration: number): Messages.InputChange;
 export declare function SelectionChange(selectionStart: number, selectionEnd: number, selection: string): Messages.SelectionChange;
 export declare function MouseThrashing(timestamp: number): Messages.MouseThrashing;
 export declare function UnbindNodes(totalRemovedPercent: number): Messages.UnbindNodes;
-export declare function ResourceTiming(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string, transferredSize: number, cached: boolean): Messages.ResourceTiming;
+export declare function ResourceTimingDeprecated(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string, transferredSize: number, cached: boolean): Messages.ResourceTimingDeprecated;
 export declare function TabChange(tabId: string): Messages.TabChange;
 export declare function TabData(tabId: string): Messages.TabData;
 export declare function CanvasNode(nodeId: string, timestamp: number): Messages.CanvasNode;

package/dist/cjs/main/app/observer/observer.d.ts

@@ -2,6 +2,7 @@ import App from '../index.js';
 export declare function parseUseEl(useElement: SVGUseElement, mode: 'inline' | 'dataurl' | 'svgtext', domParser: DOMParser): Promise<any>;
 interface Options {
     disableSprites?: boolean;
+    disableThrottling?: boolean;
     inlineRemoteCss?: boolean;
     inlinerOptions?: {
         forceFetch?: boolean;
@@ -17,6 +18,7 @@ export default abstract class Observer {
     private readonly indexes;
     private readonly attributesMap;
     private readonly textSet;
+    private readonly slotMap;
     private readonly disableSprites;
     /**
      * this option means that, instead of using link element with href to load css,
@@ -35,6 +37,8 @@ export default abstract class Observer {
      */
     private handleIframeSrcChange;
     private sendNodeAttribute;
+    throttling: boolean;
+    private throttledSetNodeData;
     private sendNodeData;
     private bindNode;
     private bindTree;

package/dist/cjs/main/app/observer/top_observer.d.ts

@@ -2,11 +2,12 @@ import Observer from './observer.js';
 import { Offset } from './iframe_offsets.js';
 import App from '../index.js';
 export declare enum InlineCssMode {
+    Unset = -1,
     /** default behavior -- will parse and cache the css file on backend */
     Disabled = 0,
     /** will attempt to record the linked css file as AdoptedStyleSheet object */
     Inline = 1,
-    /** will fetch the file, then simulated AdoptedStyleSheets behavior programmaticaly for the replay */
+    /** will fetch the file, then simulate AdoptedStyleSheets behavior programmaticaly for the replay */
     InlineFetched = 2,
     /** will fetch the file, then save it as plain css inside <style> node */
     PlainFetched = 3
@@ -22,6 +23,7 @@ export interface Options {
      * @default InlineCssMode.None = 0
      * */
     inlineCss: InlineCssMode;
+    disableThrottling?: boolean;
 }
 type Context = Window & typeof globalThis;
 type ContextCallback = (context: Context) => void;

package/dist/cjs/main/app/session.d.ts

@@ -45,6 +45,7 @@ export default class Session {
     getPageNumber: () => number | undefined;
     incPageNo: () => number;
     getSessionToken: (projectKey?: string) => string | undefined;
+    getRawTokenWithProject: () => string | null;
     setSessionToken: (token: string, projectKey: string) => void;
     applySessionHash(hash: string): void;
     getSessionHash(): string | undefined;

package/dist/cjs/main/entry.d.ts

@@ -1,5 +1,6 @@
-import TrackerClass from './index.js';
-export { default as App } from './app/index.js';
-export { SanitizeLevel, Messages, Options } from './index.js';
-export { default as tracker } from './singleton.js';
+import TrackerClass from './index';
+export { default as App } from './app/index';
+export { default as tracker, default as openReplay } from './singleton';
+export { SanitizeLevel, Messages, Options } from './index';
+export { default as Analytics } from './modules/analytics/index';
 export default TrackerClass;

package/dist/cjs/main/index.d.ts

@@ -1,9 +1,9 @@
-import App from './app/index.js';
+import App from './app/index';
 export { default as App } from './app/index.js';
 import * as _Messages from './app/messages.gen.js';
 export declare const Messages: typeof _Messages;
 export { SanitizeLevel } from './app/sanitizer.js';
-import FeatureFlags, { IFeatureFlag } from './modules/featureFlags.js';
+import AnalyticsSDK from './modules/analytics/index.js';
 import type { Options as AppOptions } from './app/index.js';
 import type { Options as ConsoleOptions } from './modules/console.js';
 import type { Options as ExceptionOptions } from './modules/exception.js';
@@ -14,10 +14,12 @@ import type { Options as NetworkOptions } from './modules/network.js';
 import type { MouseHandlerOptions } from './modules/mouse.js';
 import type { SessionInfo } from './app/session.js';
 import type { CssRulesOptions } from './modules/cssrules.js';
+import type { LATOptions } from './modules/longAnimationTask.js';
+import type { Options as WapOptions } from './modules/webAnimations.js';
 import type { Options as ViewportOptions } from './modules/viewport.js';
 import type { StartOptions } from './app/index.js';
 import type { StartPromiseReturn } from './app/index.js';
-export type Options = Partial<AppOptions & ConsoleOptions & ExceptionOptions & InputOptions & PerformanceOptions & TimingOptions> & {
+export type Options = Partial<AppOptions & ConsoleOptions & ExceptionOptions & InputOptions & PerformanceOptions & TimingOptions & LATOptions> & {
     projectID?: number;
     projectKey: string;
     sessionToken?: string;
@@ -26,27 +28,24 @@ export type Options = Partial<AppOptions & ConsoleOptions & ExceptionOptions & I
     resetTabOnWindowOpen?: boolean;
     network?: Partial<NetworkOptions>;
     mouse?: Partial<MouseHandlerOptions>;
-    flags?: {
-        onFlagsLoad?: (flags: IFeatureFlag[]) => void;
-    };
+    customAttributes?: string[];
     __DISABLE_SECURE_MODE?: boolean;
     css: CssRulesOptions;
+    webAnimations?: WapOptions;
     urls?: Partial<ViewportOptions>;
+    analytics?: {
+        ingestPoint?: string;
+        active?: boolean;
+    };
 };
 export default class API {
     readonly options: Partial<Options>;
-    featureFlags: FeatureFlags;
     private readonly app;
+    readonly analytics: AnalyticsSDK | null;
     private readonly crossdomainMode;
     constructor(options: Partial<Options>);
     checkDoNotTrack: () => boolean | undefined;
     signalStartIssue: (reason: string, missingApi: string[]) => void;
-    isFlagEnabled(flagName: string): boolean;
-    onFlagsLoad(callback: (flags: IFeatureFlag[]) => void): void;
-    clearPersistFlags(): void;
-    reloadFlags(): Promise<void> | undefined;
-    getFeatureFlag(flagName: string): IFeatureFlag | undefined;
-    getAllFeatureFlags(): IFeatureFlag[] | undefined;
     restartCanvasTracking: () => void;
     use<T>(fn: (app: App | null, options?: Partial<Options>) => T): T;
     isActive(): boolean;
@@ -98,13 +97,16 @@ export default class API {
     getSessionInfo(): SessionInfo | null;
     getSessionID(): string | null | undefined;
     getTabId(): string | null;
-    getUxId(): number | null;
     sessionID(): string | null | undefined;
-    getSessionURL(options?: {
+    getSessionURL: (options?: {
         withCurrentTime?: boolean;
-    }): string | undefined;
-    setUserID(id: string): void;
-    userID(id: string): void;
+    }) => string | undefined;
+    setUserID: (id: string) => void;
+    identify: (id: string) => void;
+    track: ((eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void) | undefined;
+    userID: (id: string) => void;
     setUserAnonymousID(id: string): void;
     userAnonymousID(id: string): void;
     setMetadata(key: string, value: string): void;
@@ -112,4 +114,15 @@ export default class API {
     event(key: string, payload?: any, issue?: boolean): void;
     issue(key: string, payload?: any): void;
     handleError: (e: Error | ErrorEvent | PromiseRejectionEvent, metadata?: Record<string, any>) => void;
+    incident: (options: {
+        label?: string;
+        startTime: number;
+        endTime?: number;
+    }) => void;
+    private analyticsToken;
+    /**
+     * Use custom token for analytics events without session recording
+     * */
+    setAnalyticsToken: (token: string) => void;
+    getAnalyticsToken: () => string;
 }

package/dist/cjs/main/modules/analytics/batcher.d.ts

@@ -0,0 +1,45 @@
+interface PeopleEvent {
+    type: string;
+    timestamp: number;
+    payload: Record<string, any>;
+}
+interface Event {
+    name: string;
+    payload: Record<string, any>;
+    timestamp: number;
+}
+/**
+ * Creates batches of events, then sends them at intervals.
+ */
+declare class Batcher {
+    private readonly backendUrl;
+    private readonly getToken;
+    private readonly init;
+    private readonly autosendInterval;
+    private readonly retryTimeout;
+    private readonly retryLimit;
+    private readonly apiEdp;
+    private batch;
+    private intervalId;
+    constructor(backendUrl: string, getToken: () => string | null, init: () => Promise<void>);
+    getBatches(): {
+        data: {
+            user_actions: PeopleEvent[];
+            events: Event[];
+        };
+    };
+    addEvent(event: any): void;
+    sendImmediately(event: any): void;
+    /**
+     *
+     * Essentially we're dividing the batch by identify events and squash all same category events into one in each part,
+     * taking priority to the last one
+     */
+    dedupePeopleEvents(): PeopleEvent[];
+    private squashPeopleEvents;
+    private sendBatch;
+    startAutosend(): void;
+    flush(): void;
+    stop(): void;
+}
+export default Batcher;

package/dist/cjs/main/modules/analytics/constantProperties.d.ts

@@ -0,0 +1,53 @@
+export interface StorageLike {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+}
+export default class ConstantProperties {
+    private readonly localStorage;
+    private readonly sessionStorage;
+    os: string;
+    osVersion: string;
+    browser: string;
+    browserVersion: string;
+    platform: string;
+    screenHeight: number;
+    screenWidth: number;
+    initialReferrer: string;
+    utmSource: string | null;
+    utmMedium: string | null;
+    utmCampaign: string | null;
+    deviceId: string;
+    searchEngine: string | null;
+    user_id: string | null;
+    constructor(localStorage: StorageLike, sessionStorage: StorageLike);
+    get all(): {
+        os: string;
+        os_version: string;
+        browser: string;
+        browser_version: string;
+        platform: string;
+        screen_height: number;
+        screen_width: number;
+        initial_referrer: string;
+        utm_source: string | null;
+        utm_medium: string | null;
+        utm_campaign: string | null;
+        user_id: string | null;
+        distinct_id: string;
+        sdk_edition: string;
+        sdk_version: string;
+        timezone: string;
+        search_engine: string | null;
+    };
+    setUserId: (user_id: string | null) => void;
+    resetUserId: (hard?: boolean) => void;
+    get defaultPropertyKeys(): string[];
+    get distinctId(): string;
+    private getDistinctDeviceId;
+    private getReferrer;
+    private parseUTM;
+    private getSearchEngine;
+    getSuperProperties: () => Record<string, any>;
+    saveSuperProperties: (props: Record<string, any>) => void;
+    clearSuperProperties: () => void;
+}

package/dist/cjs/main/modules/analytics/events.d.ts

@@ -0,0 +1,37 @@
+import Batcher from './batcher.js';
+import ConstantProperties from './constantProperties.js';
+export default class Events {
+    private readonly constantProperties;
+    private readonly getTimestamp;
+    private readonly batcher;
+    ownProperties: Record<string, any>;
+    constructor(constantProperties: ConstantProperties, getTimestamp: () => number, batcher: Batcher);
+    /**
+     * Add event to batch with option to send it immediately,
+     * properties are optional and will not be saved as super prop
+     * */
+    sendEvent: (eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void;
+    /**
+     * creates super property for all events
+     * */
+    setProperty: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    /**
+     * set super property only if it doesn't exist yet
+     * */
+    setPropertiesOnce: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    /**
+     * removes properties from list of super properties
+     * */
+    unsetProperties: (properties: string | string[]) => void;
+    /** clears all super properties */
+    reset: () => void;
+    /** mixpanel compatibility */
+    register: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    register_once: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    unregister: (properties: string | string[]) => void;
+    track: (eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void;
+}

package/dist/cjs/main/modules/analytics/index.d.ts

@@ -0,0 +1,73 @@
+import ConstantProperties from './constantProperties.js';
+import type { StorageLike } from './constantProperties.js';
+import Events from './events.js';
+import People from './people.js';
+interface Options {
+    ingestPoint: string;
+    projectKey: string;
+    /** Storage class for persistent data */
+    localStorage?: StorageLike;
+    /** Storage class for data on a per-session basis */
+    sessionStorage?: StorageLike;
+    /** Used to request a custom session token when in not-standalone mode */
+    getToken?: () => string;
+    /** Used to get current timestamp when not in standalone mode */
+    getTimestamp?: () => number;
+    /** Callback for people.identify */
+    setUserId?: (user_id: string) => void;
+    /** automatically set when used inside openreplay tracker */
+    notStandalone?: boolean;
+}
+export default class Analytics {
+    readonly events: Events;
+    readonly constantProperties: ConstantProperties;
+    readonly people: People;
+    private token;
+    private readonly batcher;
+    private readonly backendUrl;
+    private readonly projectKey;
+    private readonly localStorage;
+    private readonly sessionStorage;
+    private readonly getToken;
+    private readonly getTimestamp;
+    private readonly setUserId;
+    private readonly standalone;
+    /**
+     * @param localStorage Class or Object that implements Storage-like interface that stores
+     * values persistently like window.localStorage or any other file-based storage
+     *
+     * @param sessionStorage Class or Object that implements Storage-like interface that stores values
+     * on per-session basis like window.sessionStorage or any other in-memory storage
+     *
+     * @param getToken Function that returns token to bind events to a session
+     *
+     * @param getTimestamp returns current timestamp
+     *
+     * @param setUserId callback for people.identify
+     *
+     * @param standalone if true, analytics will manage its own token (instead of using with openreplay tracker session)
+     * */
+    constructor(options: Options);
+    _getToken: () => string | null;
+    _getTimestamp: () => number;
+    init: () => Promise<void>;
+    reset: () => void;
+    /**
+     * COMPATIBILITY LAYER
+     * */
+    /**
+     * Identify a user with an id (e.g. email, username, etc.)
+     * will bind all events and properties (including device_id) to this user
+     *
+     * you will need to manually call people.reset() to clear the id on logout event
+     * */
+    identify: (user_id: string) => void;
+    /**
+     * Add event to batch with option to send it immediately,
+     * properties are optional and will not be saved as super prop
+     * */
+    track: (eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void;
+}
+export {};

package/dist/cjs/main/modules/analytics/people.d.ts

@@ -0,0 +1,51 @@
+import Batcher from './batcher.js';
+import ConstantProperties from './constantProperties.js';
+type Value = string | number;
+export default class People {
+    private readonly constantProperties;
+    private readonly getTimestamp;
+    private readonly onId;
+    private readonly batcher;
+    ownProperties: Record<string, Value | Value[]>;
+    constructor(constantProperties: ConstantProperties, getTimestamp: () => number, onId: (user_id: string) => void, batcher: Batcher);
+    identify: (user_id: string, options?: {
+        fromTracker: boolean;
+    }) => void;
+    /** Resets user id and own properties
+     *
+     * !hard reset will destroy persistent device id!
+     * */
+    reset: (hard?: boolean) => void;
+    get user_id(): string | null;
+    /**
+     *  Will delete user and its data from backend, then reset all local properties
+     */
+    deleteUser: () => void;
+    /**
+     * set user properties, overwriting existing ones
+     * */
+    setProperties: (propertyOrObj: Record<string, string | number> | string, value?: string) => void;
+    /**
+     * Set property if it doesn't exist yet
+     * */
+    setPropertiesOnce: (properties: Record<string, string | number>) => void;
+    /**
+     * Add value to property (will turn string prop into array)
+     * */
+    appendValues: (key: string, value: string | number) => void;
+    /**
+     * Add unique values to property (will turn string prop into array)
+     * */
+    appendUniqueValues: (key: string, value: string | number) => void;
+    /**
+     * Adds value (incl. negative) to existing numerical property
+     * */
+    increment: (key: string, value: number) => void;
+    /** mixpanel compatibility */
+    union: (key: string, value: string | number) => void;
+    set: (propertyOrObj: Record<string, string | number> | string, value?: string) => void;
+    set_once: (properties: Record<string, string | number>) => void;
+    append: (key: string, value: string | number) => void;
+    incrementBy: (key: string, value: number) => void;
+}
+export {};

package/dist/cjs/main/modules/analytics/types.d.ts

@@ -0,0 +1,32 @@
+export declare const mutationTypes: {
+    identity: string;
+    deleteUser: string;
+    setProperty: string;
+    setPropertyOnce: string;
+    appendProperty: string;
+    appendUniqueProperty: string;
+    incrementProperty: string;
+};
+export declare const categories: {
+    readonly people: "user_actions";
+    readonly events: "events";
+};
+export declare const createEvent: (category: (typeof categories)[keyof typeof categories], type?: (typeof mutationTypes)[keyof typeof mutationTypes], timestamp?: number, payload?: Record<string, any>) => {
+    category: "user_actions";
+    data: {
+        type: string | undefined;
+        user_id: any;
+        payload: any;
+        timestamp: number | undefined;
+        name?: undefined;
+    };
+} | {
+    category: "events";
+    data: {
+        name: any;
+        payload: any;
+        timestamp: number | undefined;
+        type?: undefined;
+        user_id?: undefined;
+    };
+};

package/dist/cjs/main/modules/analytics/utils.d.ts

@@ -0,0 +1,19 @@
+interface ClientData {
+    screen: string;
+    width: number;
+    height: number;
+    browser: string;
+    browserVersion: string;
+    browserMajorVersion: number;
+    mobile: boolean;
+    os: string;
+    osVersion: string;
+    cookies: boolean;
+}
+/**
+ * Detects client browser, OS, and device information
+ */
+export declare function uaParse(sWindow: Window & typeof globalThis): ClientData;
+export declare function isObject(item: any): boolean;
+export declare function getUTCOffsetString(): string;
+export {};