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

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/remoteconfig/country.d.ts

@@ -0,0 +1,4 @@
+/** The ISO code of a time zone's country, '' for one with none (UTC) or unknown. */
+export declare function timeZoneCountryCode(timeZone: string): string;
+/** The country: the user's, else the time zone's. '' when neither says. */
+export declare function deviceCountry(): string;

package/dist/esm/remoteconfig/country.js

@@ -0,0 +1,70 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { _ZAP } from '../core/state.js';
+import { getTimeZone } from '../core/env.js';
+import { TZ_COUNTRIES } from './tz-countries.js';
+
+/**
+ * The country of this device, for remote config's `country` criteria, by its English name as the
+ * console lists it ("India").
+ *
+ * The one AppticsUser.setUser registered comes first. Otherwise it is the country of the
+ * browser's time zone, which is the device clock's: Asia/Kolkata (or Chrome's Asia/Calcutta) is
+ * India, whatever language the browser is in. A browser has no other source short of asking for
+ * the user's location, which is a permission prompt. A zone shared by several countries is the
+ * one tzdata names for it.
+ */
+/** Zone -> ISO code, unpacked on first use. */
+var byZone = null;
+function zones() {
+    if (byZone !== null) {
+        return byZone;
+    }
+    var out = {};
+    TZ_COUNTRIES.split(';').forEach(function (entry) {
+        var colon = entry.indexOf(':'); // no i18n
+        var code = entry.slice(0, colon);
+        entry.slice(colon + 1).split('|').forEach(function (group) {
+            // "Area/City,City", or bare names with no area ("Cuba,Egypt")
+            var slash = group.indexOf('/'); // no i18n
+            var area = slash === -1 ? '' : group.slice(0, slash + 1); // no i18n
+            group.slice(area.length).split(',').forEach(function (city) {
+                out[area + city] = code;
+            });
+        });
+    });
+    byZone = out;
+    return out;
+}
+/** The ISO code of a time zone's country, '' for one with none (UTC) or unknown. */
+function timeZoneCountryCode(timeZone) {
+    var all = zones();
+    return Object.prototype.hasOwnProperty.call(all, timeZone) ? all[timeZone] : ''; // no i18n
+}
+/** IN -> India, in English; the code itself where the browser has no region names. */
+function regionName(code) {
+    try {
+        var names = new Intl.DisplayNames(['en'], { type: 'region' }); // no i18n
+        return names.of(code) || code;
+    }
+    catch (err) {
+        return code;
+    }
+}
+/** The country: the user's, else the time zone's. '' when neither says. */
+function deviceCountry() {
+    var named = String(_ZAP._user_info.country || '').trim(); // no i18n
+    if (named !== '') {
+        return named;
+    }
+    var timeZone = ''; // no i18n
+    try {
+        timeZone = String(getTimeZone() || ''); // no i18n
+    }
+    catch (err) {
+        timeZone = ''; // no i18n
+    }
+    var code = timeZoneCountryCode(timeZone);
+    return code === '' ? '' : regionName(code); // no i18n
+}
+
+export { deviceCountry, timeZoneCountryCode };

package/dist/esm/remoteconfig/custom.d.ts

@@ -0,0 +1,10 @@
+/** The values set for a condition, by its name; empty when none are. */
+export declare function customConditionValues(conditionname: string): string[];
+/**
+ * Sets what this device is for a custom condition, by its name, as comma separated values; an
+ * empty value removes it. Re-applies the stored rules once storage is ready, so the next read sees
+ * the new result without a fetch.
+ */
+export declare function setCustomConditionValue(conditionname: string, value: string | number | boolean | null | undefined): void;
+/** reset(): forgets the values set on this page. */
+export declare function clearCustomConditionValues(): void;

package/dist/esm/remoteconfig/custom.js

@@ -0,0 +1,54 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { storageReady } from '../core/storage.js';
+import { Console } from '../core/logger.js';
+import { reresolve } from './store.js';
+
+/**
+ * Custom condition values: a console condition on the custom criteria (`custom_sdk_value`) is
+ * answered by what the app says this device is for that condition, by the condition's name:
+ *
+ *   AppticsRemoteConfig.setCustomConditionValue('is_custom', 'custom_color');
+ *   AppticsRemoteConfig.setCustomConditionValue('is_custom', 'gold,platinum');   // several
+ *
+ * The condition matches when one of the comma separated values is one of the values it lists.
+ * Values are for this page: an app sets them as it starts, as it would any other app state.
+ */
+var mine = {};
+/** The values set for a condition, by its name; empty when none are. */
+function customConditionValues(conditionname) {
+    var name = String(conditionname || '').trim(); // no i18n
+    return Object.prototype.hasOwnProperty.call(mine, name) ? mine[name] : [];
+}
+/**
+ * Sets what this device is for a custom condition, by its name, as comma separated values; an
+ * empty value removes it. Re-applies the stored rules once storage is ready, so the next read sees
+ * the new result without a fetch.
+ */
+function setCustomConditionValue(conditionname, value) {
+    var name = typeof conditionname === 'string' ? conditionname.trim() : ''; // no i18n
+    if (name === '') { // no i18n
+        Console.warn('AppticsRemoteConfig.setCustomConditionValue: a condition name is required'); // no i18n
+        return;
+    }
+    var values = (value === null || value === undefined ? '' : String(value)).split(',') // no i18n
+        .map(function (one) { return one.trim(); })
+        .filter(function (one, i, all) { return one !== '' && all.indexOf(one) === i; }); // no i18n
+    if (values.length === 0) {
+        delete mine[name];
+    }
+    else {
+        mine[name] = values;
+    }
+    storageReady().then(function (backend) {
+        // only once storage has loaded: re-resolving before it would read an empty rule set and keep it
+        if (backend) {
+            reresolve();
+        }
+    });
+}
+/** reset(): forgets the values set on this page. */
+function clearCustomConditionValues() {
+    mine = {};
+}
+
+export { clearCustomConditionValues, customConditionValues, setCustomConditionValue };

package/dist/esm/remoteconfig/evaluate.d.ts

@@ -0,0 +1,24 @@
+import type { Dict } from '../types.js';
+/** Forgets what has been complained about, so a new rule set is judged afresh. */
+export declare function resetEvaluationWarnings(): void;
+/**
+ * Whether a condition holds: every one of its criteria must. The template requires at least one
+ * (`array-size=">=1"`), so a condition with none is malformed and does not match — rather than
+ * matching vacuously, which would apply it to every device.
+ */
+export declare function conditionMatches(condition: Dict): boolean;
+/**
+ * The value of one parameter on this device, as the string the server stores it as.
+ *
+ * `conditions` is `all_condition` as the server sent it: its order is the order they are tried
+ * in. The parameter's own `conditions` say which of them apply to it, and with what value.
+ */
+export declare function resolve(parameter: Dict, conditions: Dict[]): string;
+/**
+ * Every parameter resolved against this device, as a flat name -> value map.
+ *
+ * Built in one pass and kept, rather than resolved per read: the rule set only changes when a
+ * fetch brings a new one, and an app reading twenty flags during a render should not walk every
+ * condition twenty times.
+ */
+export declare function resolveAll(remoteconfig: Dict): Record<string, string>;

package/dist/esm/remoteconfig/evaluate.js

@@ -0,0 +1,179 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { Console } from '../core/logger.js';
+import { _ZAP } from '../core/state.js';
+import { isEmpty } from '../core/utils.js';
+import { customConditionValues } from './custom.js';
+import { deviceCountry } from './country.js';
+
+/**
+ * Working out what a parameter is worth on this device.
+ *
+ * The server sends the whole rule set, not an answer: every parameter with its default, every
+ * condition with its criteria, and the mapping between them. Resolving it here rather than on
+ * the server is what lets a value be read with no network at all on the next visit.
+ *
+ * A parameter resolves by walking the conditions in the order of `all_condition`, the console's
+ * own order, and taking the value the parameter maps to the first one that both applies to it and
+ * matches this device. A condition matches when every one of its criteria does. Nothing matches,
+ * or nothing is mapped: the parameter's default value.
+ *
+ * Criteria are answered from what the browser knows about itself (app version, device type,
+ * country...), except a custom one (`custom_sdk_value`): that is answered by what the app set with
+ * setCustomConditionValue(conditionname, 'a,b'), and matches when one of those values is listed.
+ *
+ * Everything fails closed. An operator we do not recognise, a criteria key we cannot answer, a
+ * condition the parameter names but the server did not send: each one means "does not match",
+ * never "matches". A config system that guesses hands an app a value its author never chose, on
+ * a device they cannot see, and that is far worse than falling back to the default.
+ */
+/**
+ * Criteria operators, by the code the server sends in `status`.
+ *
+ * Only `1` is confirmed, from the one worked example we have: key `appversion`, status `"1"`,
+ * value `["1.1"]`, meaning the version is one of the listed values. The rest of the series is
+ * not written down anywhere we can see, so an unrecognised code is treated as no match and said
+ * once in the log — rather than guessed at, which would silently hand out the wrong value.
+ */
+const OPERATORS = Object.freeze({
+    '1': 'in', // no i18n
+});
+/** Criteria keys this SDK can answer about a browser. */
+const FACTS = Object.freeze({
+    appversion: function () { return String(_ZAP._defaultoptions.appversion || ''); }, // no i18n
+    platform: function () { return String(_ZAP._platform || ''); }, // no i18n
+    browser: function () { return String(_ZAP._device_info.browser || ''); }, // no i18n
+    browserversion: function () { return String(_ZAP._device_info.browserversion || ''); }, // no i18n
+    osversion: function () { return String(_ZAP._device_info.osversion || ''); }, // no i18n
+    devicetype: function () { return String(_ZAP._device_info.devicetype || ''); }, // no i18n
+    language: function () { return String(navigator.language || ''); }, // no i18n
+    country: deviceCountry,
+    customergroupid: function () { return String(_ZAP._user_info.groupid || ''); }, // no i18n
+    userid: function () { return String(_ZAP._user_info.userid || ''); }, // no i18n
+});
+/** The criteria key of a custom condition, answered by setCustomConditionValue. */
+const CUSTOM_KEY = 'custom_sdk_value'; // no i18n
+/** Codes and keys already complained about, so one unknown rule is not a log per read. */
+var reported = {};
+function sayOnce(key, message) {
+    if (reported[key]) {
+        return;
+    }
+    reported[key] = true;
+    Console.warn(message);
+}
+/** Forgets what has been complained about, so a new rule set is judged afresh. */
+function resetEvaluationWarnings() {
+    reported = {};
+}
+/** The values of a criteria, as strings: the template types them as an array of safe_string. */
+function valuesOf(criteria) {
+    var raw = criteria.value;
+    if (!Array.isArray(raw)) {
+        return isEmpty(raw) ? [] : [String(raw)];
+    }
+    return raw.map(function (one) { return String(one); });
+}
+/** Whether one criteria holds on this device; `conditionname` answers a custom criteria. */
+function criteriaMatches(criteria, conditionname) {
+    var key = String(criteria.key || ''); // no i18n
+    var operator = OPERATORS[String(criteria.status)];
+    if (operator === undefined) {
+        sayOnce('op:' + criteria.status, 'AppticsRemoteConfig: unknown criteria operator "' + criteria.status // no i18n
+            + '", so conditions using it will not match'); // no i18n
+        return false;
+    }
+    var listed = valuesOf(criteria);
+    if (key === CUSTOM_KEY) {
+        var mine = customConditionValues(conditionname);
+        if (mine.length === 0) {
+            sayOnce('custom:' + conditionname, 'AppticsRemoteConfig: no value for the custom condition "' + conditionname // no i18n
+                + '"; set one with setCustomConditionValue, or it will not match'); // no i18n
+            return false;
+        }
+        // 'in': one of the values the app set is one of the listed ones
+        return mine.some(function (one) { return listed.indexOf(one) !== -1; });
+    }
+    var fact = FACTS[key];
+    if (fact === undefined) {
+        // not something a browser knows about itself
+        sayOnce('key:' + key, 'AppticsRemoteConfig: unknown criteria "' + key // no i18n
+            + '", so conditions using it will not match'); // no i18n
+        return false;
+    }
+    var actual = fact();
+    if (actual === '') {
+        return false;
+    }
+    // 'in': the device's value is one of the listed ones. Compared as strings because that is
+    // what both sides are - '1.1' is a version, not the number 1.1
+    return listed.indexOf(actual) !== -1;
+}
+/**
+ * Whether a condition holds: every one of its criteria must. The template requires at least one
+ * (`array-size=">=1"`), so a condition with none is malformed and does not match — rather than
+ * matching vacuously, which would apply it to every device.
+ */
+function conditionMatches(condition) {
+    var criterias = condition && condition.criterias;
+    if (!Array.isArray(criterias) || criterias.length === 0) {
+        return false;
+    }
+    for (var i = 0; i < criterias.length; i++) {
+        if (!criteriaMatches(criterias[i], String(condition.conditionname || ''))) { // no i18n
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * The value of one parameter on this device, as the string the server stores it as.
+ *
+ * `conditions` is `all_condition` as the server sent it: its order is the order they are tried
+ * in. The parameter's own `conditions` say which of them apply to it, and with what value.
+ */
+function resolve(parameter, conditions) {
+    var links = {};
+    (Array.isArray(parameter.conditions) ? parameter.conditions : []).forEach(function (link) {
+        links[String(link.conditionid)] = link;
+    });
+    var sent = {};
+    for (var i = 0; i < conditions.length; i++) {
+        var condition = conditions[i];
+        var id = String(condition.conditionid);
+        sent[id] = true;
+        var link = links[id];
+        if (link !== undefined && conditionMatches(condition)) {
+            return String(link.value === undefined || link.value === null ? '' : link.value);
+        }
+    }
+    Object.keys(links).forEach(function (id) {
+        if (!sent[id]) {
+            // the parameter points at a condition the answer did not include
+            sayOnce('missing:' + id, 'AppticsRemoteConfig: parameter "' + parameter.paramname // no i18n
+                + '" uses condition ' + id + ', which the server did not send'); // no i18n
+        }
+    });
+    return String(parameter.defaultvalue === undefined || parameter.defaultvalue === null ? '' : parameter.defaultvalue);
+}
+/**
+ * Every parameter resolved against this device, as a flat name -> value map.
+ *
+ * Built in one pass and kept, rather than resolved per read: the rule set only changes when a
+ * fetch brings a new one, and an app reading twenty flags during a render should not walk every
+ * condition twenty times.
+ */
+function resolveAll(remoteconfig) {
+    var out = {};
+    var parameters = Array.isArray(remoteconfig.all_parameter) ? remoteconfig.all_parameter : [];
+    var conditions = Array.isArray(remoteconfig.all_condition) ? remoteconfig.all_condition : [];
+    parameters.forEach(function (parameter) {
+        var name = String(parameter.paramname || ''); // no i18n
+        if (name === '') {
+            return;
+        }
+        out[name] = resolve(parameter, conditions);
+    });
+    return out;
+}
+
+export { conditionMatches, resetEvaluationWarnings, resolve, resolveAll };

package/dist/esm/remoteconfig/fetch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Asks for the rule set, if anything has changed since the last one.
+ *
+ * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
+ * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
+ * normal case and not a failure.
+ *
+ * A second caller joins the first rather than making another request.
+ */
+export declare function fetchRemoteConfig(): Promise<Record<string, unknown>>;
+/**
+ * reset(): forgets the rule set, its values and what the server last reported, and disowns a
+ * request still in flight, whose answer would otherwise put the old rule set back.
+ */
+export declare function resetRemoteConfig(): void;
+/**
+ * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
+ * CACHE_MS. Resolves true when they are, false when the fetch failed or could not be made — the
+ * caller then decides whether stored values will do. Never rejects.
+ *
+ * Waits for start-up and for the device to be registered, which a first visit is still doing
+ * when ready() resolves: getupdates is refused without the device ids.
+ */
+export declare function obtain(): Promise<boolean>;

package/dist/esm/remoteconfig/fetch.js

@@ -0,0 +1,196 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { SDK_MODULE } from '../core/constants.js';
+import { hooks } from '../core/hooks.js';
+import { _ZAP } from '../core/state.js';
+import { Console } from '../core/logger.js';
+import { nowMs } from '../core/utils.js';
+import { rejectIfOffline, rejectIfNoDeviceIds, postToApptics, apiHeaders } from '../core/transport.js';
+import { deviceReady } from '../device/index.js';
+import { ready } from '../lifecycle.js';
+import { clearCustomConditionValues } from './custom.js';
+import { store, storeUnchanged, flagtime, reresolve, clearRemoteConfig } from './store.js';
+
+/**
+ * The getupdates call.
+ *
+ * getupdates is not a synonym for getsdkconfig. It takes a body naming the modules being asked
+ * about and answers with their payloads — remote config's rule set among them — while
+ * getsdkconfig answers only with which modules are on at all.
+ *
+ * getsdkconfig stays the source of truth for that. getupdates also reports a `tracking_status`,
+ * but only for modules that have something to say in that answer, and it can disagree with
+ * getsdkconfig when the two are in flight together: an app update prompt shown by one and
+ * switched off moments later by the other. Where they disagree, getsdkconfig wins; what
+ * getupdates says is used for one thing only, which is to stop asking about a module it has
+ * reported off.
+ */
+const LABEL = 'AppticsRemoteConfig'; // no i18n
+/** getupdatesobj caps moduleids at nine entries; this SDK asks about one. */
+const MODULES = [Number(SDK_MODULE.REMOTE_CONFIG)];
+var inFlight = null;
+/** Bumped by reset(); an answer to a request made before it is not stored. */
+var generation = 0;
+/**
+ * How long a fetch that succeeded on this page answers for later ones, as on Android: a value
+ * read on every render must not be a request on every render.
+ */
+const CACHE_MS = 5 * 60 * 1000;
+/** When a fetch on this page last succeeded; 0 until one has. */
+var fetchedAt = 0;
+/**
+ * Whether remote config is still worth asking about.
+ *
+ * Two switches, and they are not the same one. getsdkconfig's module flag is the authority and
+ * is read from `_ZAP._remoteConfigEnabled`; `_remoteConfigReported` is what the last getupdates
+ * answer said, which exists only so that a module reported off is dropped from the next
+ * request's `moduleids` rather than asked about again.
+ */
+function wanted() {
+    return _ZAP._remoteConfigEnabled !== false && _ZAP._remoteConfigReported !== false;
+}
+/**
+ * The body. appversionid and flagtime are the two keys getupdatesobj declares mandatory.
+ *
+ * osversionid and apilevel are left out on purpose: both are declared, and both are Android's —
+ * an int api level means nothing in a browser, and the osversionid a browser holds is a server
+ * id for "macOS 15", not the small int this template types. languagecode is sent when there is
+ * one, since safe_string cannot match an empty string.
+ */
+function body() {
+    var payload = {
+        appversionid: String(_ZAP._device_info.appversionid || ''), // no i18n
+        moduleids: MODULES,
+        flagtime: flagtime(),
+    };
+    var language = String(navigator.language || '').slice(0, 10); // no i18n
+    if (language !== '') {
+        payload.languagecode = language; // no i18n
+    }
+    return JSON.stringify(payload);
+}
+/**
+ * Reads the module flags getupdates reports.
+ *
+ * Only to stop asking: getsdkconfig decides whether the feature is on. A module reported off
+ * here is dropped from the next request, which is what the API asks for.
+ */
+function applyReportedModules(data) {
+    var status = data.tracking_status;
+    if (!status || typeof status !== 'object') {
+        return;
+    }
+    var entry = status[SDK_MODULE.REMOTE_CONFIG];
+    if (entry && typeof entry === 'object') {
+        _ZAP._remoteConfigReported = entry.enabled !== false;
+    }
+}
+/**
+ * Asks for the rule set, if anything has changed since the last one.
+ *
+ * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
+ * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
+ * normal case and not a failure.
+ *
+ * A second caller joins the first rather than making another request.
+ */
+function fetchRemoteConfig() {
+    if (inFlight !== null) {
+        return inFlight;
+    }
+    if (!wanted()) {
+        Console.log(LABEL + ': switched off by the server, not asking'); // no i18n
+        return Promise.resolve({});
+    }
+    var blocked = rejectIfOffline(LABEL) || rejectIfNoDeviceIds(LABEL);
+    if (blocked) {
+        return blocked;
+    }
+    var asked = generation;
+    var request = postToApptics('getupdates', body(), apiHeaders(), LABEL).then(function (result) {
+        var data = (result.data || {});
+        if (asked !== generation) {
+            // asked before a reset(): the answer is about the device and app that were just forgotten
+            return data;
+        }
+        applyReportedModules(data);
+        var rules = data.remoteconfig;
+        var at = nowMs();
+        fetchedAt = at;
+        if (rules && typeof rules === 'object') {
+            store(rules, at);
+        }
+        else {
+            // nothing has changed since our flagtime, which is the answer most of the time
+            storeUnchanged(at);
+            Console.log(LABEL + ': no changes since ' + flagtime()); // no i18n
+        }
+        return data;
+    }).then(function (data) {
+        settle();
+        return data;
+    }, function (err) {
+        settle();
+        return Promise.reject(err);
+    });
+    // a request reset() has disowned must not clear the in-flight slot of one made after it
+    function settle() {
+        if (inFlight === request) {
+            inFlight = null;
+        }
+    }
+    inFlight = request;
+    return inFlight;
+}
+/**
+ * reset(): forgets the rule set, its values and what the server last reported, and disowns a
+ * request still in flight, whose answer would otherwise put the old rule set back.
+ */
+function resetRemoteConfig() {
+    generation++;
+    inFlight = null;
+    fetchedAt = 0;
+    _ZAP._remoteConfigReported = true;
+    clearCustomConditionValues();
+    clearRemoteConfig();
+}
+/**
+ * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
+ * CACHE_MS. Resolves true when they are, false when the fetch failed or could not be made — the
+ * caller then decides whether stored values will do. Never rejects.
+ *
+ * Waits for start-up and for the device to be registered, which a first visit is still doing
+ * when ready() resolves: getupdates is refused without the device ids.
+ */
+function obtain() {
+    return ready().then(function (running) {
+        if (!running) {
+            return false;
+        }
+        var now = nowMs();
+        if (fetchedAt > 0 && now - fetchedAt < CACHE_MS) {
+            return true;
+        }
+        return deviceReady().then(function () {
+            return fetchRemoteConfig();
+        }).then(function () {
+            return true;
+        }, function (err) {
+            Console.log(LABEL + ': fetch failed: ' + String(err)); // no i18n
+            return false;
+        });
+    });
+}
+/** Start-up's own fetch, so values are this session's without the app asking. */
+function fetchOnStart() {
+    obtain();
+}
+hooks.resetRemoteConfig = resetRemoteConfig;
+hooks.remoteConfigStarted = fetchOnStart;
+// a condition on the customer group answers differently once AppticsUser.setUser has named one
+hooks.remoteConfigUserChanged = reresolve;
+// imported after start-up has already finished (a lazy import, say): fetch now, as start-up would have
+if (_ZAP._ready) {
+    fetchOnStart();
+}
+
+export { fetchRemoteConfig, obtain, resetRemoteConfig };

package/dist/esm/remoteconfig/index.d.ts

@@ -0,0 +1,15 @@
+/** AppticsRemoteConfig: fetchValue, fetchValues and setCustomConditionValue, each with the parameter names the console shows. */
+export declare const AppticsRemoteConfig: {
+    fetchValue: (name: string, callback?: (value: string | null) => void) => Promise<string | null>;
+    /** The parameters named, or every parameter when none are: name -> value, null when there is none. */
+    fetchValues: {
+        (names?: string[], callback?: (values: Record<string, string | null>) => void): Promise<Record<string, string | null>>;
+        (callback: (values: Record<string, string | null>) => void): Promise<Record<string, string | null>>;
+    };
+    /**
+     * What this device is for a custom condition, by the condition's name, as comma separated
+     * values: it matches when one of them is listed. An empty value removes it.
+     */
+    setCustomConditionValue: (conditionname: string, value: string | number | boolean | null) => void;
+};
+export default AppticsRemoteConfig;