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

package/dist/cjs/device/index.js

@@ -0,0 +1,472 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('../core/constants.js');
+var state = require('../core/state.js');
+var logger = require('../core/logger.js');
+var utils = require('../core/utils.js');
+var storage = require('../core/storage.js');
+var locks = require('../core/locks.js');
+var env = require('../core/env.js');
+var consent = require('../core/consent.js');
+var transport = require('../core/transport.js');
+var hooks = require('../core/hooks.js');
+var appversion = require('./appversion.js');
+
+/** Server-assigned ids, never sent back in device payloads. */
+/**
+ * Exactly the keys deviceInfoWebSDKV2 declares, which is exactly what device/add accepts.
+ *
+ * An allow-list rather than an exclusion list: the template is a closed set of eleven mandatory
+ * keys, so anything else on device_info is refused as EXTRA_PARAM_FOUND and takes the whole
+ * registration with it. v1 carried `frameworkid` in the body; v2 moved it to a query param, and
+ * `platformid` — which v1 left out — became mandatory here. It comes from app/addversion, which
+ * is why that call has to land first.
+ */
+const DEVICE_BODY_KEYS = ['devicetype', 'osversion', 'timezone', 'screenheight', 'screenwidth', 'referrer', 'referringdomain', 'browser', 'browserversion', 'donottrackenabled', 'platformid']; // no i18n
+/** The ones the template types as int, so an empty value has to become 0 rather than ''. */
+const DEVICE_BODY_NUMERIC = ['screenheight', 'screenwidth', 'donottrackenabled', 'platformid']; // no i18n
+/**
+ * The device/add body: all eleven declared keys, always.
+ *
+ * Every one is min-occurrences="1", so a key is sent even when its value is empty — `referrer` is
+ * empty on any direct visit, and leaving it out would refuse the registration over a blank the
+ * server is happy to receive.
+ */
+function deviceBody(info) {
+    var out = {};
+    DEVICE_BODY_KEYS.forEach(function (key) {
+        var value = info[key];
+        var numeric = DEVICE_BODY_NUMERIC.indexOf(key) !== -1;
+        out[key] = utils.isEmpty(value) ? (numeric ? 0 : '') : value; // no i18n
+    });
+    return JSON.stringify(out);
+}
+/**
+ * The fields that describe the device itself, and so the only ones worth a device/add when they
+ * change: a browser or OS upgrade, a new screen, a move between timezones, a do-not-track switch.
+ *
+ * `referrer` and `connectionType` are deliberately absent. Both change constantly — the referrer on
+ * most navigations, the connection on every network switch — so including them would send a
+ * device/add on nearly every page load. The server-assigned ids are absent for the opposite reason:
+ * they arrive from the server, so comparing them would report a change the moment registration
+ * fills them in.
+ */
+const DEVICE_IDENTITY_KEYS = ['osversion', 'browser', 'browserversion', 'devicetype', 'screenheight', 'screenwidth', 'timezone', 'donottrackenabled',
+    // the SDK build this device runs: an upgrade to a new SDK version is a change the server is told about
+    'frameworkid']; // no i18n
+/** The identity fields alone, for comparing one stored device_info against a fresh one. */
+function deviceIdentity(info) {
+    var identity = {};
+    DEVICE_IDENTITY_KEYS.forEach(function (key) {
+        identity[key] = info ? info[key] : undefined;
+    });
+    return identity;
+}
+function checkAndUpdateDeviceInfo() {
+    // read the stored info before it is overwritten below: addOrUpdateDeviceID compares the two to
+    // decide whether the server needs telling, and cannot do that once the new info has replaced it
+    var previous = storage.user_defaults.item('device_info'); // no i18n
+    // params -> https://help.apptics.com/hc/en-us/articles/115004613766-Default-Properties-Collected-by-apptics
+    state._ZAP._device_info = {
+        osversion: env.getOS(),
+        browser: env.getBrowser(),
+        browserversion: String(env.getBrowserVersion()),
+        donottrackenabled: consent.hasDoNotTrackEnabled() ? 1 : 0, // no i18n
+        devicetype: env.getDevice(),
+        screenheight: screen.height,
+        screenwidth: screen.width,
+        referrer: env.getReferringURL(),
+        connectionType: env.getConnectionType(),
+        referringdomain: window.location.hostname || '', // no i18n
+        deviceid: storage.getKeyFromDeviceInfo('deviceid'), // no i18n
+        anonymousid: storage.getKeyFromDeviceInfo('anonymousid'), // no i18n
+        // the id of the SDK build running now, never the stored one: a stored id is the build this
+        // device first registered with, and every later SDK version would go on reporting it
+        frameworkid: state._ZAP._frameworkID,
+        mapid: storage.getKeyFromDeviceInfo('mapid'), // no i18n
+        aaid: storage.getKeyFromDeviceInfo('aaid'), // no i18n
+        apid: storage.getKeyFromDeviceInfo('apid'), // no i18n
+        appversionid: storage.getKeyFromDeviceInfo('appversionid'), // no i18n
+        platformid: storage.getKeyFromDeviceInfo('platformid'), // no i18n
+        devicetypeid: storage.getKeyFromDeviceInfo('devicetypeid'), // no i18n
+        osversionid: storage.getKeyFromDeviceInfo('osversionid'), // no i18n
+        timezoneid: storage.getKeyFromDeviceInfo('timezoneid'), // no i18n
+        // metaWebSDKV2 needs both of these on every call: modelid comes from device/add,
+        // appreleaseversionid from app/addversion
+        modelid: storage.getKeyFromDeviceInfo('modelid'), // no i18n
+        appreleaseversionid: storage.getKeyFromDeviceInfo('appreleaseversionid'), // no i18n
+        timezone: env.getTimeZone(),
+        // kept here rather than as keys of their own: the id the browser is registered under, and
+        // whether it has had a session (a session's firstsession says so)
+        uuid: state._ZAP._uuid || storage.getKeyFromDeviceInfo('uuid'), // no i18n
+        hadsession: storage.getKeyFromDeviceInfo('hadsession') === true ? true : undefined, // no i18n
+    };
+    // the rebuild above starts from browser facts, so the ids app/addversion returned are put
+    // back before anything is stored or compared
+    appversion.applyStoredAppVersion();
+    storage.user_defaults.add('device_info', state._ZAP._device_info); // no i18n
+    addOrUpdateDeviceID(state._ZAP._device_info, previous);
+}
+function addOrUpdateDeviceID(device_info, previous) {
+    var old_device_info = previous !== undefined ? previous : storage.user_defaults.item('device_info') || {}; // no i18n
+    // Compare the old and new device infos and update the server if anything changed in the new.
+    if (device_info.deviceid == null || device_info.frameworkid == null || device_info.anonymousid == null) {
+        device_info.frameworkid = state._ZAP._frameworkID;
+        logger.Console.log('addOrUpdateDeviceID: Initiated register the device'); // no i18n
+        registerDeviceWithApptics().then(function (result_device_info) {
+            if (utils.isSuccess(result_device_info)) {
+                logger.Console.log('addOrUpdateDeviceID: Success register the device ' + JSON.stringify(result_device_info.data)); // no i18n
+                logger.Console.dir(result_device_info.data);
+            }
+            else {
+                logger.Console.log('addOrUpdateDeviceID: Error registering the device: ' + result_device_info); // no i18n
+            }
+        }).catch(function (err) {
+            logger.Console.log('addOrUpdateDeviceID: Error registering the device: ' + err); // no i18n
+        });
+    }
+    else if (!utils.isEmpty(old_device_info) && !utils.compareTwoObjects(deviceIdentity(device_info), deviceIdentity(old_device_info))) {
+        // the device itself changed — a browser or OS upgrade, a new screen, a different timezone.
+        // The update carries the stored deviceid as a param and the stored uuid as a header, so the
+        // server amends this device rather than creating another one: same device, new details
+        logger.Console.log('addOrUpdateDeviceID: Device info changed, so updating new changes'); // no i18n
+        logger.Console.dir(deviceIdentity(device_info));
+        updateDeviceWithApptics(device_info).catch(function (err) {
+            logger.Console.log('addOrUpdateDeviceID: Error updating the device: ' + err); // no i18n
+        });
+    }
+}
+/**
+ * The ids device/add is allowed to set. Each is taken only when the answer actually carries it.
+ *
+ * device/add is not the only source of these: app/addversion runs first and is the *only* source
+ * of aaid, mapid, appversionid and appreleaseversionid. Its answer is already on _device_info by
+ * the time registration replies, and v2's device/add does not repeat all of it - it answers about
+ * the device, not the build. Assigning every key unconditionally therefore overwrote ids we had
+ * with undefined, which is how aaid and appversionid reached metaWebSDKV2 as null and mapid went
+ * out as an empty header.
+ */
+const DEVICE_RESPONSE_KEYS = ['deviceid', 'anonymousid', 'aaid', 'apid', 'mapid', 'appversionid', 'osversionid', 'timezoneid', 'platformid', 'devicetypeid', 'modelid']; // no i18n
+/** Copies server-assigned ids into state and persists device info; resolves once it is stored. */
+function applyDeviceResponse(data) {
+    DEVICE_RESPONSE_KEYS.forEach(function (key) {
+        // an id the answer does not mention is one we already hold, or one we never had:
+        // either way what is on _device_info is better than undefined
+        if (!utils.isEmpty(data[key])) {
+            state._ZAP._device_info[key] = data[key];
+        }
+    });
+    // apid and mapid are also read straight off state for the request headers
+    if (!utils.isEmpty(data.apid)) {
+        state._ZAP._apid = data.apid;
+    }
+    if (!utils.isEmpty(data.mapid)) {
+        state._ZAP._mapid = data.mapid;
+    }
+    // stored before the registration counts as done, so another tab waiting to register reads it
+    return storage.user_defaults.save('device_info', state._ZAP._device_info); // no i18n
+}
+/**
+ * The browser's uuid: the one in storage, or a new one stored now. Every tab of the site uses the
+ * same one, because the device is registered under it.
+ */
+function useStoredUuid() {
+    // kept in device_info: it is the id this browser is registered under
+    var uuid = storage.getKeyFromDeviceInfo('uuid'); // no i18n
+    if (utils.isEmpty(uuid)) {
+        uuid = utils.getNewUUID();
+        storage.setDeviceInfoKey('uuid', uuid); // no i18n
+    }
+    state._ZAP._uuid = uuid;
+}
+/**
+ * The ids another tab of this site registered after this one loaded its settings: those are in
+ * storage but not in this tab's copy. Resolves with them, applied to this tab, or null when the
+ * browser is still unregistered and this tab has to register it.
+ */
+function adoptRegisteredDevice() {
+    return storage.reloadSettings(['device_info']).then(function () {
+        var stored = storage.user_defaults.item('device_info') || {}; // no i18n
+        if (utils.isEmpty(stored.deviceid) || utils.isEmpty(stored.anonymousid)) {
+            return null;
+        }
+        // the device is registered under the uuid the other tab sent
+        if (!utils.isEmpty(stored.uuid)) {
+            state._ZAP._uuid = stored.uuid;
+        }
+        logger.Console.log('registerDeviceWithApptics: another tab registered this browser, using its device ' + stored.deviceid); // no i18n
+        return applyDeviceResponse(stored).then(function () {
+            return { result: 'success', data: stored }; // no i18n
+        });
+    });
+}
+/**
+ * Sets up this browser's device at start-up: the uuid, the device info, and a registration when
+ * the browser has none.
+ *
+ * Settings are this tab's own copy, loaded when it started. On a browser with no device yet, two
+ * tabs started together would each register it and store two devices, so the first visit runs
+ * under a lock shared by every tab of the site: the tab that gets it re-reads storage, registers
+ * only when no other tab has, and keeps the lock until the new ids are stored. The next tab then
+ * finds them. Start-up goes on as soon as the device info is set, without waiting for the server.
+ */
+function prepareDevice() {
+    var cached = storage.user_defaults.item('device_info') || {}; // no i18n
+    if (!utils.isEmpty(cached.deviceid) && !utils.isEmpty(cached.anonymousid)) {
+        useStoredUuid();
+        checkAndUpdateDeviceInfo();
+        return Promise.resolve();
+    }
+    return new Promise(function (resolve) {
+        locks.withLock('device', function () {
+            return storage.reloadSettings(['device_info']).then(function () {
+                useStoredUuid();
+                checkAndUpdateDeviceInfo();
+                resolve();
+                // held until a registration this started is stored, or has failed
+                return deviceReady();
+            });
+        }).catch(function (err) {
+            logger.Console.log('prepareDevice: ' + err); // no i18n
+        }).then(function () {
+            resolve();
+        });
+    });
+}
+/** True while the device has no server ids, so nothing can be sent yet. */
+function needsDevice() {
+    // the app ids from app/addversion, and the deviceid from device/add: either missing, and the
+    // device is registered before anything stored is sent
+    return (utils.isEmpty(transport.getHeaderParams('apid')) && utils.isEmpty(transport.getHeaderParams('mapid'))) || !transport.hasDeviceId(); // no i18n
+}
+/**
+ * Resolves once a registration that is in flight has settled, succeeded or not, and right away
+ * when none is running. Callers use it to wait for the ids rather than poll for them.
+ */
+function deviceReady() {
+    if (!state._ZAP._regDeviceSending) {
+        return Promise.resolve();
+    }
+    return new Promise(function (resolve) {
+        state._ZAP._regDeviceResolve.push(function () { resolve(); });
+        state._ZAP._regDeviceReject.push(function () { resolve(); });
+    });
+}
+/** Ends an in-flight registration: clears the flag and settles every caller that waited on it. */
+function settleRegistration(ok, value) {
+    var waiters = ok ? state._ZAP._regDeviceResolve : state._ZAP._regDeviceReject;
+    state._ZAP._regDeviceSending = false;
+    state._ZAP._regDeviceResolve = [];
+    state._ZAP._regDeviceReject = [];
+    waiters.forEach(function (fn) {
+        fn(value);
+    });
+}
+// Function to register the device
+function registerDeviceWithApptics() {
+    var label = 'registerDeviceWithApptics'; // no i18n
+    var blocked = transport.rejectIfDisabled(label);
+    if (blocked) {
+        return blocked;
+    }
+    if (!state._ZAP._token) {
+        logger.Console.warn(label + ': You must call Apptics.init() first'); // no i18n
+        return Promise.reject(label + ': You must call Apptics.init() first'); // no i18n
+    }
+    var offline = transport.rejectIfOffline(label);
+    if (offline) {
+        return offline;
+    }
+    if (state._ZAP._device_info.deviceid && state._ZAP._device_info.anonymousid) {
+        return Promise.resolve(state._ZAP._device_info);
+    }
+    return new Promise((resolve, reject) => {
+        if (state._ZAP._regDeviceSending) {
+            // a registration is already in flight; settle together with it
+            state._ZAP._regDeviceResolve.push(resolve);
+            state._ZAP._regDeviceReject.push(reject);
+            return;
+        }
+        state._ZAP._regDeviceSending = true;
+        adoptRegisteredDevice().then(function (adopted) {
+            if (adopted) {
+                return adopted;
+            }
+            var payload = deviceBody(state._ZAP._device_info);
+            // device/add is the one url that allows all four: zak and uuid identify the caller,
+            // apid and mapid the app. app/addversion has already answered with apid and mapid by
+            // the time registration runs, so the first call can carry them like every later one.
+            var headers = { zak: transport.getHeaderParams('zak'), uuid: transport.getHeaderParams('uuid'), ...transport.apiHeaders() }; // no i18n
+            return transport.postToApptics('regdevice', payload, headers, label).then(function (result) {
+                return applyDeviceResponse(result.data || {}).then(function () {
+                    return result;
+                });
+            });
+        }).then(function (result) {
+            settleRegistration(true, result);
+            resolve(result);
+            // first visit: the ids exist now, so fetch the server settings right away
+            refreshServerSettings();
+        }).catch(function (err) {
+            settleRegistration(false, err);
+            reject(err);
+        });
+    });
+}
+// Function to update the device
+function updateDeviceWithApptics(device_info) {
+    var label = 'updateDeviceWithApptics'; // no i18n
+    var blocked = transport.rejectIfDisabled(label) || transport.rejectIfOffline(label);
+    if (blocked) {
+        return blocked;
+    }
+    var payload = deviceBody(device_info);
+    var headers = { zak: transport.getHeaderParams('zak'), uuid: transport.getHeaderParams('uuid'), ...transport.apiHeaders() }; // no i18n
+    return transport.postToApptics('regdevice', payload, headers, label).then(function (result) {
+        applyDeviceResponse(result.data || {});
+        return result;
+    });
+}
+// Function to get updates from the server
+function getUpdatesFromServer() {
+    var label = 'getUpdatesFromServer'; // no i18n
+    var blocked = transport.rejectIfOffline(label) || transport.rejectIfNoDeviceIds(label);
+    if (blocked) {
+        return blocked;
+    }
+    // getsdkconfig takes no body: the ids it needs are parameters
+    return transport.postToApptics('sdkconfig', '', transport.apiHeaders(), label).then(function (result) {
+        var data = result.data || {};
+        applyServerFlags(data);
+        // the visitor's tracking status lives in trackinfo too, and is not the server's to replace
+        var saved = storage.storedTrackingStatus();
+        storage.user_defaults.add('trackinfo', saved === undefined ? state._ZAP._trackinfo : Object.assign({}, state._ZAP._trackinfo, { tracking_status: saved })); // no i18n
+        logger.Console.log('getUpdatesFromServer: ' + JSON.stringify(state._ZAP._trackinfo)); // no i18n
+        return data;
+    });
+}
+/**
+ * Whether getsdkconfig says a module is on.
+ *
+ * Absent means on: a server that does not report a module has not turned it off, and an SDK that
+ * went quiet because of a key it had never heard of would be impossible to diagnose.
+ */
+function moduleEnabled(status, id) {
+    var entry = status[id];
+    if (!entry || typeof entry !== 'object') {
+        return true;
+    }
+    return entry.enabled !== false;
+}
+/**
+ * Applies the server's tracking flags, from a getsdkconfig response or the saved trackinfo.
+ *
+ * v2 reports a flag per module, keyed by a numeric id, rather than the loose booleans getupdates
+ * answered with. Both shapes are read: the stored trackinfo from a previous version of this SDK
+ * is in the old shape, and discarding it would mean a visit tracking things the server had
+ * already said to stop.
+ */
+function applyServerFlags(data) {
+    var status = (data.tracking_status && typeof data.tracking_status === 'object'
+        ? data.tracking_status : {});
+    var hasModules = Object.keys(status).length > 0;
+    if (data.hasOwnProperty('tracking_enabled')) { // no i18n
+        state._ZAP._shouldTrack = data.tracking_enabled !== false;
+    }
+    else {
+        // the old shape: archived versions and untracked customer groups
+        var versionArchived = !data.hasOwnProperty('versionarchivestatus') || utils.isEmpty(data.versionarchivestatus)
+            ? true : data.versionarchivestatus;
+        var customerGroupTracking = !data.hasOwnProperty('customergrouptracking') || utils.isEmpty(data.customergrouptracking)
+            ? true : data.customergrouptracking;
+        state._ZAP._shouldTrack = versionArchived || !customerGroupTracking;
+    }
+    if (hasModules) {
+        // sessions carry screens, events and api calls, so module 11 gates all of engagement
+        state._ZAP._engagementTracking = moduleEnabled(status, constants.SDK_MODULE.SESSION);
+        state._ZAP._errorTracking = moduleEnabled(status, constants.SDK_MODULE.CRASH);
+        state._ZAP._heatmapTracking = moduleEnabled(status, constants.SDK_MODULE.HEATMAP);
+        state._ZAP._remoteLoggerEnabled = moduleEnabled(status, constants.SDK_MODULE.REMOTE_LOGGER);
+        state._ZAP._feedbackEnabled = moduleEnabled(status, constants.SDK_MODULE.FEEDBACK);
+        // getsdkconfig is the authority on this one: getupdates reports it too and the two can
+        // disagree while both are in flight, so what is read here wins
+        state._ZAP._remoteConfigEnabled = moduleEnabled(status, constants.SDK_MODULE.REMOTE_CONFIG);
+    }
+    else {
+        state._ZAP._engagementTracking = data.engagementtracking !== false;
+        state._ZAP._errorTracking = data.errortracking !== false;
+        state._ZAP._heatmapTracking = data.heatmaptracking !== false;
+        state._ZAP._remoteLoggerEnabled = data.remoteloggerenabled !== false;
+        state._ZAP._feedbackEnabled = data.feedbackenabled !== false;
+    }
+    // screen recording, set up in the console: everything the form needs comes from here
+    var quartz = (data.quartz && typeof data.quartz === 'object' ? data.quartz : {});
+    var text = function (value) {
+        return typeof value === 'string' ? value.trim() : ''; // no i18n
+    };
+    state._ZAP._quartz = {
+        enabled: quartz.hasOwnProperty('quartz_enabled') ? quartz.quartz_enabled === true : data.quartzenabled === true, // no i18n
+        workspace: text(quartz.quartz_workspace),
+        department: text(quartz.quartz_department),
+        domain: text(quartz.quartz_domain),
+        cdnUrl: text(quartz.quartz_cdn_url),
+    };
+    // when to ask again, which replaces polling on a fixed interval
+    if (typeof data.next_check_after === 'number' && data.next_check_after > 0) {
+        state._ZAP._nextConfigCheck = data.next_check_after;
+    }
+    state._ZAP._trackinfo = {
+        engagementtracking: state._ZAP._engagementTracking,
+        errortracking: state._ZAP._errorTracking,
+        heatmaptracking: state._ZAP._heatmapTracking,
+        remoteloggerenabled: state._ZAP._remoteLoggerEnabled,
+        feedbackenabled: state._ZAP._feedbackEnabled,
+        // in the server's own shape, so restoring it on the next visit reads it the same way
+        quartz: {
+            quartz_enabled: state._ZAP._quartz.enabled,
+            quartz_workspace: state._ZAP._quartz.workspace,
+            quartz_department: state._ZAP._quartz.department,
+            quartz_domain: state._ZAP._quartz.domain,
+            quartz_cdn_url: state._ZAP._quartz.cdnUrl,
+        },
+        shouldtrack: state._ZAP._shouldTrack,
+        next_check_after: state._ZAP._nextConfigCheck
+    };
+}
+/**
+ * Start-up: applies the server settings saved by the last getupdates, so a "stop tracking"
+ * answer holds across page loads instead of resetting to "on" until the next check.
+ */
+function restoreServerSettings() {
+    var saved = storage.user_defaults.item('trackinfo'); // no i18n
+    if (saved && typeof saved === 'object') { // no i18n
+        applyServerFlags(saved);
+        logger.Console.log('restoreServerSettings: ' + JSON.stringify(state._ZAP._trackinfo)); // no i18n
+    }
+}
+/**
+ * Fetches the server settings now if the device is registered. On a first visit the ids don't
+ * exist yet; registerDeviceWithApptics calls this as soon as device/add succeeds.
+ */
+function refreshServerSettings() {
+    if (utils.isEmpty(transport.getHeaderParams('apid')) && utils.isEmpty(transport.getHeaderParams('mapid'))) { // no i18n
+        return;
+    }
+    getUpdatesFromServer().catch(function (err) {
+        logger.Console.log(err);
+    });
+}
+hooks.hooks.updateDevice = updateDeviceWithApptics;
+hooks.hooks.refreshDeviceInfo = checkAndUpdateDeviceInfo;
+
+exports.addOrUpdateDeviceID = addOrUpdateDeviceID;
+exports.checkAndUpdateDeviceInfo = checkAndUpdateDeviceInfo;
+exports.deviceReady = deviceReady;
+exports.getUpdatesFromServer = getUpdatesFromServer;
+exports.needsDevice = needsDevice;
+exports.prepareDevice = prepareDevice;
+exports.refreshServerSettings = refreshServerSettings;
+exports.registerDeviceWithApptics = registerDeviceWithApptics;
+exports.restoreServerSettings = restoreServerSettings;
+exports.updateDeviceWithApptics = updateDeviceWithApptics;

package/dist/cjs/engagement/api-rules.d.ts

@@ -0,0 +1,49 @@
+/** The rules, as ApiTrackingBuilder.build() returns them. Every list may be empty. */
+export interface ApiTrackingConfig {
+    /** URLs recorded, exactly; with any allow rule, only calls matching one are recorded. */
+    allowEquals: string[];
+    /** URLs never recorded, exactly. */
+    ignoreEquals: string[];
+    /** Regular expressions a recorded URL may match; with any allow rule, it must match one. */
+    allowRegex: RegExp[];
+    /** Regular expressions whose URLs are never recorded. */
+    ignoreRegex: RegExp[];
+}
+/**
+ * A URL as the rules compare it: `scheme://host[:port]/path`, the scheme and host lower-cased,
+ * the default port dropped, the query, fragment and a trailing slash removed. '' when it is not
+ * an absolute http(s) URL.
+ */
+export declare function ruleUrl(raw: string): string;
+/**
+ * Builds the rules configure takes. Each method may be called more than once, and takes any number
+ * of values: `new ApiTrackingBuilder().allowEquals(a, b).ignoreRegex(/x/).build()`.
+ */
+export declare class ApiTrackingBuilder {
+    private rules;
+    /** Records only these URLs (and those any allowRegex matches): `https://api.example.com/orders`. */
+    allowEquals(...urls: string[]): this;
+    /** Never records these URLs: `https://api.example.com/health`. */
+    ignoreEquals(...urls: string[]): this;
+    /** Records only URLs these match (and those any allowEquals names): `/^https:\/\/api\.example\.com\//`. */
+    allowRegex(...patterns: Array<RegExp | string>): this;
+    /** Never records URLs these match: `/\/internal\//`. */
+    ignoreRegex(...patterns: Array<RegExp | string>): this;
+    build(): ApiTrackingConfig;
+}
+/**
+ * Applies the rules, replacing any given before. Takes what build() returned, or the builder
+ * itself. Call it once, before the requests it should cover; it works before init().
+ */
+export declare function configureApiTracking(config: ApiTrackingConfig | ApiTrackingBuilder): void;
+/** The rules in force, for tests and the playground. */
+export declare function apiTrackingConfig(): ApiTrackingConfig;
+/**
+ * Whether a call to `url` is recorded. Ignore rules are tried first and always win; then, when
+ * there are allow rules, the URL must match one. A URL that cannot be read is not recorded.
+ */
+export declare function urlTracked(url: string): boolean;
+/** The path without its query string or fragment, which is where ids and tokens travel. */
+export declare function withoutQuery(path: string): string;
+/** The path a call is recorded under: the query goes, and numeric ids, UUIDs and JWTs become `*`. */
+export declare function normalizeApiPath(path: string): string;