@zoho_apptics/apptics-js-sdk 1.0.2 → 2.0.0-beta.1

package/dist/esm/heatmap/send.d.ts

@@ -0,0 +1,13 @@
+import type { Dict, ServerResult } from '../types.js';
+/**
+ * Sends queued heatmap records to heatmap/add.
+ *
+ * Shaped like the error and engagement senders, because the queue behaves the same way: records
+ * are stored first and sent on the flush timer, a failed send leaves them for the next one, and
+ * `forget` is used on page hide so the last batch survives the page going away.
+ *
+ * Gated on the server's own heatmap flag (getsdkconfig module 18), not on engagement: an app may
+ * want events while declining to have every click's coordinates recorded.
+ */
+export declare function sendHeatmapData(forget?: boolean): Promise<void>;
+export declare function requestToSendHeatmaps(_payload: Dict, forget?: boolean): Promise<ServerResult>;

package/dist/esm/heatmap/send.js

@@ -0,0 +1,79 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { _ZAP } from '../core/state.js';
+import { Console, warnAlways } from '../core/logger.js';
+import { cloneObject } from '../core/utils.js';
+import { heatmap_transactions } from '../core/storage.js';
+import { is_apptics_disabled } from '../core/env.js';
+import { shouldTrackOrSendData } from '../core/consent.js';
+import { defer, clearDefer, withSendLock, freshItems, awaitUnlessClosing, sendBatch } from '../core/batch.js';
+import { isPermanentRefusal } from '../core/transport.js';
+import { hooks } from '../core/hooks.js';
+
+/**
+ * Sends queued heatmap records to heatmap/add.
+ *
+ * Shaped like the error and engagement senders, because the queue behaves the same way: records
+ * are stored first and sent on the flush timer, a failed send leaves them for the next one, and
+ * `forget` is used on page hide so the last batch survives the page going away.
+ *
+ * Gated on the server's own heatmap flag (getsdkconfig module 18), not on engagement: an app may
+ * want events while declining to have every click's coordinates recorded.
+ */
+function sendHeatmapData(forget) {
+    if (is_apptics_disabled() || !shouldTrackOrSendData() || !_ZAP._heatmapTracking) {
+        return Promise.resolve();
+    }
+    if (navigator.onLine == false) {
+        Console.warn('sendHeatmapData: No Network'); // no i18n
+        return Promise.resolve();
+    }
+    if (_ZAP._sending) {
+        defer(sendHeatmapData);
+        return Promise.resolve();
+    }
+    _ZAP._sending = true;
+    clearDefer();
+    return withSendLock('heatmaps', function () {
+        return freshItems(heatmap_transactions, function () { return true; }, 
+        // aged by when the record happened, not when its session began: a tab left open for
+        // days would otherwise make every new record look older than the retention window
+        // and have it dropped unsent
+        function (item) { return (item.triggered_time || item.session_start_time); }).then(function (items) {
+            if (items.length == 0) {
+                return;
+            }
+            var data = [];
+            var sent = [];
+            cloneObject(items).forEach(function (item) {
+                sent.push({ ...item });
+                // `id` is the queue's own key, not something the endpoint declares
+                delete item.id;
+                data.push(item);
+            });
+            return awaitUnlessClosing(requestToSendHeatmaps({ data: data }, forget).then(function () {
+                return heatmap_transactions.remove(sent);
+            }, function (err) {
+                // the server will never accept this batch. Keeping it would block every later
+                // batch behind it for good, so it is dropped and said out loud
+                if (isPermanentRefusal(err)) {
+                    warnAlways('apptics: the server refused these heatmap records, so they were dropped: ' + String(err && err.message)); // no i18n
+                    return heatmap_transactions.remove(sent);
+                }
+                return Promise.reject(err);
+            }), forget, 'sendHeatmapData'); // no i18n
+        });
+    }).catch(function (err) {
+        Console.log('sendHeatmapData:' + err); // no i18n
+    }).then(function () {
+        _ZAP._sending = false;
+    });
+}
+function requestToSendHeatmaps(_payload, forget) {
+    var label = 'requestToSendHeatmaps'; // no i18n
+    return sendBatch('heatmap', label, _payload, forget); // no i18n
+}
+// the scheduler flushes through this, so importing the heatmap entry is what puts heatmap
+// records on the flush timer at all
+hooks.sendHeatmaps = sendHeatmapData;
+
+export { requestToSendHeatmaps, sendHeatmapData };

package/dist/esm/heatmap/track.d.ts

@@ -0,0 +1,4 @@
+/** Turns capture on or off. Listeners are passive, so they never delay a click or a scroll. */
+export declare function trackHeatmap(status?: boolean): void;
+/** Forgets what this visit recorded. reset() calls it; the cap starts again from zero. */
+export declare function resetHeatmapSession(): void;

package/dist/esm/heatmap/track.js

@@ -0,0 +1,445 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { AP_LOG_MODULE, AP_CONFIG, AP_TRACKING_STATUS } from '../core/constants.js';
+import { getConfig, _ZAP } from '../core/state.js';
+import { Console, logFailure } from '../core/logger.js';
+import { nowMs, isEmpty, getNewUUID } from '../core/utils.js';
+import { heatmap_transactions } from '../core/storage.js';
+import { commitPendingSession } from '../engagement/session.js';
+import { getConnectionType, getNetworkStatus, getOrientation } from '../core/env.js';
+import { canTrackHeatmap, getTrackingStatus } from '../core/consent.js';
+import { screenForRecord } from '../engagement/track.js';
+import { hooks } from '../core/hooks.js';
+import { noteDebugActivity } from '../core/debug.js';
+
+/**
+ * Where people click and how far they scroll.
+ *
+ * Two shapes of record, and they behave very differently. A click is one discrete thing and is
+ * recorded as it happens. Scrolling fires continuously — hundreds of events for one flick of a
+ * wheel — so it is coalesced into one record per gesture: a burst of scrolling that ends when the
+ * page has been still for a moment. Recording every scroll event would swamp the queue, the
+ * batch and the user's bandwidth, and would say nothing a single record per gesture does not.
+ */
+/** How long the page must be still before a scroll burst counts as one finished gesture. */
+const SCROLL_IDLE_MS = 150;
+/**
+ * How much of the viewport, each way, an element must cover for its scrolling to be the page's.
+ * An app whose layout scrolls a content pane instead of the window (most dashboards do) still
+ * gets a scroll map; a dropdown list or a small table scrolling on its own is not the page moving.
+ */
+const PAGE_SCROLLER_SHARE = 0.5;
+/** Clicks closer than this in time and space count as one angry repetition. */
+const RAGE_WINDOW_MS = 1000;
+const RAGE_RADIUS_PX = 30;
+const RAGE_COUNT = 3;
+/** How long a click has to change something before it is called dead. */
+const DEAD_CLICK_MS = 1500;
+/** Longest element label we keep; enough to identify a control, short enough not to be content. */
+const LABEL_MAX = 80;
+/** heatMapObjectSDK caps screen, url_path and element_label at 500 characters. */
+const FIELD_MAX = 500;
+var installed = false;
+var recorded = 0;
+/** Recent clicks, for spotting a rage burst. */
+var recentClicks = [];
+var scrollStart = 0;
+var scrollStartX = 0;
+var scrollStartY = 0;
+var scrollTimer = null;
+/** What the gesture in progress scrolls: null for the window, else the page's content pane. */
+var scrolling = null;
+/** Where each content pane was after its last gesture, as lastX / lastY are for the window. */
+var paneAt = new WeakMap();
+/**
+ * Where the page was before the current gesture began.
+ *
+ * A scroll event fires *after* the position has already changed, so the first event of a burst
+ * reports somewhere the page has moved to, not where it started. Measuring from that loses the
+ * first increment of every gesture, and loses a single-event jump — an anchor link or a "back to
+ * top" button — completely, which is exactly the movement worth seeing on a scroll map.
+ */
+var lastX = 0;
+var lastY = 0;
+/** Whether a record may still be stored, or the visit has produced enough. */
+function underCap() {
+    var cap = getConfig('heatmap_max_per_session');
+    if (typeof cap !== 'number' || cap <= 0) {
+        cap = AP_CONFIG.heatmap_max_per_session;
+    }
+    if (recorded >= cap) {
+        if (recorded === cap) {
+            recorded++; // said once, not on every event for the rest of the visit
+            Console.log('apptics.heatmap: reached ' + cap + ' records for this session, pausing capture'); // no i18n
+        }
+        return false;
+    }
+    return true;
+}
+/** The page's full scrollable height, which is what a scroll depth is a fraction of. */
+function contentHeight() {
+    var doc = document.documentElement;
+    var body = document.body;
+    return Math.max(doc ? doc.scrollHeight : 0, body ? body.scrollHeight : 0, doc ? doc.clientHeight : 0);
+}
+/**
+ * A 0-1 fraction, to three decimals.
+ *
+ * Clamped because the inputs can exceed each other: a page that has not laid out yet reports a
+ * content height of 0, and a rubber-band scroll puts the viewport bottom past the document end.
+ * Both produce a "fraction" far outside 0-1, which is meaningless on a heatmap.
+ */
+function fraction(part, whole) {
+    if (!whole || whole <= 0) {
+        return 0;
+    }
+    var value = part / whole;
+    if (value < 0) {
+        value = 0;
+    }
+    if (value > 1) {
+        value = 1;
+    }
+    return Math.round(value * 1000) / 1000;
+}
+function viewportWidth() {
+    return window.innerWidth || (document.documentElement ? document.documentElement.clientWidth : 0) || 1;
+}
+/** Whether the element, or something it sits inside, is meant to be clicked. */
+function clickableAncestor(node) {
+    var depth = 0;
+    while (node && depth < 10) {
+        var tag = node.tagName ? node.tagName.toLowerCase() : ''; // no i18n
+        var role = node.getAttribute ? node.getAttribute('role') : null; // no i18n
+        if (tag === 'a' || tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea' // no i18n
+            || tag === 'summary' || tag === 'label' // no i18n
+            || role === 'button' || role === 'link' || role === 'tab' || role === 'menuitem' // no i18n
+            || (node.hasAttribute && node.hasAttribute('onclick'))) { // no i18n
+            return node;
+        }
+        node = node.parentElement;
+        depth++;
+    }
+    return null;
+}
+/**
+ * A name for the element that was clicked.
+ *
+ * Attributes an author chose come first, because they are deliberate and stable. Visible text is
+ * the last resort and is skipped entirely when the user has opted out of PII: the text of a
+ * control can be a person's name, an email address or the contents of their cart.
+ */
+function labelFor(node) {
+    if (!node) {
+        return ''; // no i18n
+    }
+    var attributes = ['data-ap-label', 'apeventaction', 'data-apeventaction', 'aria-label', 'name', 'id', 'title']; // no i18n
+    for (var i = 0; i < attributes.length; i++) {
+        var value = node.getAttribute ? node.getAttribute(attributes[i]) : null;
+        if (!isEmpty(value)) {
+            return String(value).slice(0, LABEL_MAX);
+        }
+    }
+    var tag = node.tagName ? node.tagName.toLowerCase() : 'element'; // no i18n
+    if (getTrackingStatus() !== AP_TRACKING_STATUS.USAGE_TRACKING_WITH_PII) {
+        // without consent for PII the shape of the control is all we say
+        var role = node.getAttribute ? node.getAttribute('role') : null; // no i18n
+        return isEmpty(role) ? tag : tag + '[' + role + ']'; // no i18n
+    }
+    var text = (node.textContent || '').replace(/\s+/g, ' ').trim(); // no i18n
+    return isEmpty(text) ? tag : text.slice(0, LABEL_MAX);
+}
+/**
+ * A stable number for the element, so the console can group every click on one control together.
+ * Derived from its position in the tree rather than from its text, so it survives a label change
+ * and carries nothing a person typed.
+ */
+function triggeredId(node) {
+    if (!node) {
+        return 0;
+    }
+    var path = ''; // no i18n
+    var current = node;
+    var depth = 0;
+    while (current && depth < 12) {
+        var parent = current.parentElement;
+        var index = 0;
+        if (parent) {
+            var children = parent.children;
+            for (var i = 0; i < children.length; i++) {
+                if (children[i] === current) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        path = '/' + (current.tagName || '?') + ':' + index + path; // no i18n
+        current = parent;
+        depth++;
+    }
+    // FNV-1a, kept positive: a short stable number, not a cryptographic digest
+    var hash = 2166136261;
+    for (var c = 0; c < path.length; c++) {
+        hash ^= path.charCodeAt(c);
+        hash = (hash * 16777619) >>> 0;
+    }
+    return hash;
+}
+/** Whether this click is part of a burst of repeated clicks in the same spot. */
+function isRageClick(x, y, at) {
+    recentClicks = recentClicks.filter(function (click) { return at - click.at <= RAGE_WINDOW_MS; });
+    recentClicks.push({ at: at, x: x, y: y });
+    var near = recentClicks.filter(function (click) {
+        return Math.abs(click.x - x) <= RAGE_RADIUS_PX && Math.abs(click.y - y) <= RAGE_RADIUS_PX;
+    });
+    return near.length >= RAGE_COUNT;
+}
+/** The fields every record carries, whatever kind it is. */
+function common() {
+    return {
+        id: getNewUUID(),
+        session_start_time: _ZAP._current_session.starttime || nowMs(),
+        // without this the server has no way to order records within a session: session_start_time
+        // is the same for every one of them
+        triggered_time: nowMs(),
+        // the screen inScreen() or automatic screen tracking last named, or else the page, named
+        // as automatic tracking would name it and recorded as a screen view so engagement/add has it
+        screen: String(screenForRecord()).slice(0, FIELD_MAX),
+        url_path: String(window.location.pathname).slice(0, FIELD_MAX),
+        screen_width: window.screen ? window.screen.width : 0,
+        screen_height: window.screen ? window.screen.height : 0,
+        content_height: contentHeight(),
+        orientation: getOrientation(),
+        network_status: getNetworkStatus(),
+        edge_type: _ZAP._device_info.connectionType || getConnectionType(),
+        scroll_offset_x: Math.round(window.scrollX || window.pageXOffset || 0),
+        scroll_offset_y: Math.round(window.scrollY || window.pageYOffset || 0),
+    };
+}
+function store(record) {
+    recorded++;
+    noteDebugActivity();
+    // a heatmap record is worth a session in the same way an event is
+    commitPendingSession();
+    heatmap_transactions.add(record);
+    Console.dir(record);
+}
+function onPointerDown(event) {
+    if (!canTrackHeatmap('heatmap') || !underCap()) { // no i18n
+        return;
+    }
+    try {
+        var at = nowMs();
+        var target = event.target;
+        var clickable = clickableAncestor(target);
+        var named = clickable || target;
+        var x = Math.round(event.clientX);
+        var y = Math.round(event.clientY);
+        var height = contentHeight() || 1;
+        var pointerType = event.pointerType;
+        var record = Object.assign(common(), {
+            // TODO: send 'buttonclick' for a clickable target once the server accepts it. Held at
+            // 'default' for now while heatmap/add is still refusing payloads; `is_clickable`
+            // already carries the same information, so nothing is lost meanwhile.
+            triggered_type: 'default', // no i18n
+            gesture_type: 'click', // no i18n
+            gesture_duration: 0,
+            input_type: isEmpty(pointerType) ? 'mouse' : String(pointerType), // no i18n
+            element_label: labelFor(named),
+            triggered_id: triggeredId(named),
+            coordinate_x: x,
+            coordinate_y: y,
+            normalized_x: fraction(x, viewportWidth()),
+            normalized_y: fraction((window.scrollY || 0) + y, height),
+            velocity: 0,
+            is_clickable: clickable ? 1 : 0,
+            is_rage_click: isRageClick(x, y, at) ? 1 : 0,
+            is_dead_click: 0,
+        });
+        store(record);
+        watchForDeadClick(record, target);
+    }
+    catch (err) {
+        logFailure(AP_LOG_MODULE.HEATMAP, 'apptics.heatmap: click capture failed: ' + String(err)); // no i18n
+    }
+}
+/**
+ * A click on something that was not clickable and changed nothing is a click someone expected to
+ * work. Decided after the fact: the record is already stored, and is updated in place if nothing
+ * happened, so the click is never lost waiting to find out.
+ */
+function watchForDeadClick(record, target) {
+    if (record.is_clickable === 1 || typeof MutationObserver !== 'function') { // no i18n
+        return;
+    }
+    var changed = false;
+    var url = window.location.href;
+    var observer = new MutationObserver(function () { changed = true; });
+    try {
+        observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true });
+    }
+    catch (err) {
+        return;
+    }
+    setTimeout(function () {
+        observer.disconnect();
+        if (!changed && window.location.href === url) {
+            record.is_dead_click = 1;
+            heatmap_transactions.update(record);
+        }
+    }, DEAD_CLICK_MS);
+}
+/**
+ * What a scroll event moved, as a gesture counts it: null for the window (the event's target is
+ * the document), the element when it is big enough to be the page's own scrolling, and undefined
+ * for anything smaller, which is not recorded.
+ */
+function scrollerOf(target) {
+    var doc = document;
+    // the window and the document are not elements: either is the page itself scrolling
+    if (!target || target.nodeType !== 1 || target === doc.documentElement || target === doc.body) {
+        return null;
+    }
+    var el = target;
+    var big = el.clientHeight >= (window.innerHeight || 0) * PAGE_SCROLLER_SHARE
+        && el.clientWidth >= viewportWidth() * PAGE_SCROLLER_SHARE;
+    return big ? el : undefined;
+}
+/** Where a scroller is now. */
+function positionOf(scroller) {
+    return scroller === null
+        ? { x: Math.round(window.scrollX || window.pageXOffset || 0), y: Math.round(window.scrollY || window.pageYOffset || 0) }
+        : { x: Math.round(scroller.scrollLeft || 0), y: Math.round(scroller.scrollTop || 0) };
+}
+/**
+ * Where a scroller was before this gesture: what the last one left. A content pane seen for the
+ * first time is taken to have been at its top, which is where a pane starts.
+ */
+function startOf(scroller) {
+    if (scroller === null) {
+        return { x: lastX, y: lastY };
+    }
+    return paneAt.get(scroller) || { x: 0, y: 0 };
+}
+function onScroll(event) {
+    if (!canTrackHeatmap('heatmap') || !underCap()) { // no i18n
+        return;
+    }
+    var scroller = scrollerOf(event ? event.target : null);
+    if (scroller === undefined) {
+        return;
+    }
+    if (scrollTimer !== null && scroller !== scrolling) {
+        // another scroller started moving: the gesture on the first one is over
+        clearTimeout(scrollTimer);
+        endScrollGesture();
+    }
+    if (scrollTimer === null) {
+        scrolling = scroller;
+        var start = startOf(scroller);
+        scrollStart = nowMs();
+        scrollStartX = start.x;
+        scrollStartY = start.y;
+    }
+    else {
+        clearTimeout(scrollTimer);
+    }
+    scrollTimer = setTimeout(endScrollGesture, SCROLL_IDLE_MS);
+}
+/** One record for the whole burst, once the page has been still for SCROLL_IDLE_MS. */
+function endScrollGesture() {
+    scrollTimer = null;
+    var scroller = scrolling;
+    scrolling = null;
+    try {
+        var end = positionOf(scroller);
+        var endX = end.x;
+        var endY = end.y;
+        var dx = endX - scrollStartX;
+        var dy = endY - scrollStartY;
+        if (scroller === null) {
+            lastX = endX;
+            lastY = endY;
+        }
+        else {
+            paneAt.set(scroller, end);
+        }
+        if (dx === 0 && dy === 0) {
+            return;
+        }
+        var duration = Math.max(1, nowMs() - scrollStart);
+        var distance = Math.sqrt(dx * dx + dy * dy);
+        var direction = Math.abs(dy) >= Math.abs(dx)
+            ? (dy > 0 ? 'down-scroll' : 'up-scroll') // no i18n
+            : (dx > 0 ? 'right-scroll' : 'left-scroll'); // no i18n
+        // the depth is of what scrolled: the document, or the content pane and its own content
+        var height = (scroller === null ? contentHeight() : scroller.scrollHeight) || 1;
+        var visible = scroller === null ? (window.innerHeight || 0) : scroller.clientHeight;
+        store(Object.assign(common(), scroller === null ? {} : {
+            content_height: scroller.scrollHeight,
+            scroll_offset_x: endX,
+            scroll_offset_y: endY,
+        }, {
+            // the server accepts only event|default|buttonclick here; what kind of movement it
+            // was belongs in gesture_type. input_type is left off rather than invented: a wheel
+            // carries no pointer type, and the intended vocabulary has no value for "unknown"
+            triggered_type: 'default', // no i18n
+            gesture_type: direction,
+            gesture_duration: Math.round(duration),
+            element_label: '', // no i18n
+            triggered_id: 0,
+            coordinate_x: endX,
+            coordinate_y: endY,
+            normalized_x: 0,
+            // how far down the page the gesture left them, which is what a scroll map reads
+            normalized_y: fraction(endY + visible, height),
+            velocity: Math.round((distance / duration) * 1000),
+            is_clickable: 0,
+            is_rage_click: 0,
+            is_dead_click: 0,
+        }));
+    }
+    catch (err) {
+        logFailure(AP_LOG_MODULE.HEATMAP, 'apptics.heatmap: scroll capture failed: ' + String(err)); // no i18n
+    }
+}
+/** Turns capture on or off. Listeners are passive, so they never delay a click or a scroll. */
+function trackHeatmap(status) {
+    var wanted = typeof status === 'boolean' ? status : true; // no i18n
+    if (wanted === installed) {
+        return;
+    }
+    if (wanted) {
+        // where the page already is, so the first gesture is measured from here and not from 0
+        lastX = Math.round(window.scrollX || 0);
+        lastY = Math.round(window.scrollY || 0);
+        window.addEventListener('pointerdown', onPointerDown, { capture: true, passive: true }); // no i18n
+        window.addEventListener('scroll', onScroll, { capture: true, passive: true }); // no i18n
+        installed = true;
+        Console.log('apptics.heatmap: capturing clicks and scrolls'); // no i18n
+        return;
+    }
+    window.removeEventListener('pointerdown', onPointerDown, true); // no i18n
+    window.removeEventListener('scroll', onScroll, true); // no i18n
+    // a gesture still settling when capture stops (a single-page app leaving a heatmap page) is
+    // recorded as it stands, not dropped: it was the visitor's last scroll on that page
+    if (scrollTimer !== null) {
+        clearTimeout(scrollTimer);
+        endScrollGesture();
+    }
+    scrolling = null;
+    installed = false;
+    Console.log('apptics.heatmap: capture stopped'); // no i18n
+}
+/** Forgets what this visit recorded. reset() calls it; the cap starts again from zero. */
+function resetHeatmapSession() {
+    recorded = 0;
+    recentClicks = [];
+    lastX = 0;
+    lastY = 0;
+    paneAt = new WeakMap();
+}
+// init() and reset() drive capture through these, so neither has to import this module
+hooks.trackHeatmap = trackHeatmap;
+hooks.resetHeatmap = resetHeatmapSession;
+
+export { resetHeatmapSession, trackHeatmap };

package/dist/esm/index.d.ts

@@ -0,0 +1,22 @@
+import './heatmap/send.js';
+import type { AppticsSdk } from './types.js';
+export type { AppticsSdk, AppticsConfig, ErrorLike, FeedbackType, Properties, TrackingStatus, UserInfo, UserValidationResult, } from './types.js';
+/** Android's Apptics: starting the SDK, and what applies to all of it. */
+export declare const Apptics: AppticsSdk['Apptics'];
+export declare const AppticsEvent: AppticsSdk['AppticsEvent'];
+export type { DefinedEvent } from './engagement/defined-events.js';
+/** Android's AppticsScreenTracker: inScreen(name) returns the view's id, outScreen(id) ends it. */
+export declare const AppticsScreen: AppticsSdk['AppticsScreen'];
+/** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
+export declare const AppticsApi: AppticsSdk['AppticsApi'];
+export type { ApiTrackingConfig } from './engagement/api-rules.js';
+/** Errors: the ones the app caught, and the switch for the uncaught ones tracked on their own. */
+export declare const AppticsError: AppticsSdk['AppticsError'];
+/** Android's AppticsUser: the signed-in user, and the builder for their properties. */
+export declare const AppticsUser: AppticsSdk['AppticsUser'];
+/** Heatmap capture: AppticsHeatmap.trackHeatmap() starts or stops recording clicks and scrolls. */
+export declare const AppticsHeatmap: AppticsSdk['AppticsHeatmap'];
+/** Android's AppticsSettings: what the SDK may track for this visitor. */
+export declare const AppticsSettings: AppticsSdk['AppticsSettings'];
+declare const apptics: AppticsSdk;
+export default apptics;