kv-test-lib 1.0.0

package/dist/kochava.js

@@ -0,0 +1,436 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import { Log } from "./utils/log";
+import JobQueue from "./jobqueue";
+import * as Kvinit from "./payloads/kvinit";
+import * as Install from "./payloads/install";
+import { DEFAULTS, } from "./interfaces";
+import { deleteAllPersisted, readAndUpdatePersistedValue, updatePersistedValue, PersistKey, checkDuplicateIdLink, addPersistedIdLinks, checkInstallIdChange, readAndUpdateSessionCount, readAndUpdateDeviceId, readAndUpdateUTM, } from "./browser/persist";
+import * as utils from "./utils/utils";
+import { getPageName } from "./browser/browser";
+export class Kochava {
+    // ============================= PUBLIC =============================== //
+    constructor() {
+        this.resetInstance();
+        this.jobQueue = new JobQueue();
+    }
+    /*
+      Set if the SDK should also store persisted values in cookie storage.
+      - Not all values can be persisted in cookies, such as event/idlink queues
+        due to size constraints.
+      - true = yes use cookies
+      - no = no don't use cookies
+      - defaults to false
+    */
+    useCookies(condition = false) {
+        this.instance.useCookies = condition;
+    }
+    /*
+      - Set whether the sdk shouldn't automatically send a page or should.
+      - true = no auto page
+      - false = yes auto page
+      - defaults to false
+    */
+    disableAutoPage(condition = false) {
+        this.instance.disableAutoPage = condition;
+    }
+    /*
+      The primary means for starting the sdk.
+      Responsibilites:
+      - Checks for migrations.
+      - Creates the sdk instance.
+      - Checks for persisted state.
+      - Determines and sends kvinit.
+      - Determines and sends install.
+      - Optionally enqueues an auto_page.
+      - Starts the job queue.
+    */
+    startWithAppGuid(appGuid) {
+        if (!appGuid) {
+            Log.error(`Invalid appGuid ${appGuid}, start failed.`);
+            return;
+        }
+        if (!this.instance)
+            this.resetInstance();
+        if (this.instance.started) {
+            Log.warn("Kochava SDK already started.");
+            return;
+        }
+        Log.diagDebug(`Host called API: Start With App Guid ${appGuid}`);
+        this.instance.started = true;
+        this.checkFirstLaunchAndMigrate();
+        this.initInstance(appGuid);
+        if (!this.instance.disableAutoPage)
+            this.sendPageEvent();
+        this.checkPersistedState();
+        this.checkPersistedKvinit();
+        this.printStartupMsgs(appGuid);
+        this.beginStart();
+    }
+    /*
+      Primary means for stopping the sdk.
+      Will optionally delete all persisted data, and will shutdown the
+      sdk and job queue.
+    */
+    shutdown(deleteData) {
+        Log.diagDebug(`Host called API: Shutdown and ${deleteData ? "delete data" : "keep data"}`);
+        if (deleteData) {
+            Log.debug("Deleting persisted values");
+            deleteAllPersisted();
+        }
+        if (!this.instance.started) {
+            Log.warn("SDK already shutdown.");
+        }
+        Log.info("SDK shutting down.");
+        Kvinit.cancelRetries();
+        Install.cancelRetries();
+        this.jobQueue.stop();
+        // wipe whatever was previously in the queue
+        this.jobQueue = new JobQueue();
+        this.resetInstance();
+    }
+    /*
+      Changes the current logLevel.
+      Options include:
+      - Off   :: No logging whatsoever
+      - Error :: Only critical errors
+      - Warn  :: Only critical errors and non-critical warnings
+      - Info  :: High-level sdk behavior logs (default)
+      - Debug :: More in-depth sdk behavior logs and payload logs
+      - Trace :: Everything, granular detail
+    */
+    setLogLevel(logLevel) {
+        Log.diagDebug(`Host called API: Set Log Level ${logLevel}`);
+        Log.setLogLevel(logLevel);
+    }
+    /*
+      Used internally, for special SDK behavior not utilized by a client.
+      Examples include:
+      - urls    :: purposefully changing an endpoint for testing
+      - wrapper :: overwriting the version of a wrapper
+      several more ...
+    */
+    executeAdvancedInstruction(key, valueStr, callback) {
+        Log.diagDebug(`Host called API: Execute Advanced Instruction ${key}`);
+        switch (key) {
+            case "wrapper":
+                {
+                    const wrapperVersion = JSON.parse(valueStr);
+                    this.instance.version = `${this.instance.version} (${wrapperVersion.name} ${wrapperVersion.version})`;
+                }
+                break;
+            case "urls":
+                {
+                    const overrideUrls = JSON.parse(valueStr);
+                    if (overrideUrls.init)
+                        this.instance.overrideUrls.init = overrideUrls.init;
+                    if (overrideUrls.event)
+                        this.instance.overrideUrls.event = overrideUrls.event;
+                    if (overrideUrls.install)
+                        this.instance.overrideUrls.install = overrideUrls.install;
+                    if (overrideUrls.identityLink)
+                        this.instance.overrideUrls.identityLink = overrideUrls.identityLink;
+                }
+                break;
+            case "urlsRestore":
+                {
+                    const restoreUrls = JSON.parse(valueStr);
+                    for (const url of restoreUrls) {
+                        if (url === "init")
+                            this.instance.overrideUrls.init = DEFAULTS.networking.urls.init;
+                        if (url === "event")
+                            this.instance.overrideUrls.event = DEFAULTS.networking.urls.event;
+                        if (url === "install")
+                            this.instance.overrideUrls.install =
+                                DEFAULTS.networking.urls.install;
+                        if (url === "identityLink")
+                            this.instance.overrideUrls.identityLink =
+                                DEFAULTS.networking.urls.identityLink;
+                    }
+                }
+                break;
+            case "logFilter":
+                {
+                    const disabled = JSON.parse(valueStr);
+                    disabled.forEach((level) => Log.disableLogType(level));
+                }
+                break;
+            case "getInstance":
+                {
+                    const currInstance = JSON.stringify(this.instance);
+                    callback(currInstance);
+                    Log.debug(`capturing instance: ${valueStr}`);
+                }
+                break;
+            case "logObjects":
+                Log.setLogObjects(JSON.parse(valueStr));
+                break;
+            default:
+                break;
+        }
+    }
+    /*
+      Builds and enqueues a kochava event. Must include an event_name string,
+      with optional event_data as either another string or object.
+    */
+    sendEvent(name, data) {
+        Log.diagDebug(`Host called API: Send Event`);
+        if (!name) {
+            Log.warn("Invalid event name, ignoring call.");
+            return;
+        }
+        this.jobQueue.enqueueEvent(this.instance, [name, data]);
+    }
+    /*
+      Wraps the sendEvent call with predefined data specific to page events.
+    */
+    sendPageEvent(pageName, additionalData) {
+        if (pageName)
+            this.sendEvent("page", Object.assign({ page_name: pageName }, additionalData));
+        else
+            this.sendEvent("page", Object.assign({ page_name: getPageName() }, additionalData));
+    }
+    /*
+      - Registers new identity links with the sdk, either to be sent out with
+        the install, or standalone.
+      - Will update an identity link if its key already exists in storage.
+      - A max of 10 identity links are currently allowed to be stored
+        at any one time.
+    */
+    registerIdentityLink(name, identifier) {
+        Log.diagDebug(`Host called API: Register Identity Link ${name}`);
+        if (!name || !identifier) {
+            Log.warn("Invalid identity link, ignoring call.");
+            return;
+        }
+        if (checkDuplicateIdLink(name, identifier)) {
+            Log.debug("Duplicate Identity Link found, ignoring.");
+            return;
+        }
+        const idLink = {};
+        idLink[name] = identifier;
+        addPersistedIdLinks(name, identifier, this.instance.useCookies);
+        if (this.instance.installStarted || this.instance.installDone) {
+            // it will be sent standalone
+            this.jobQueue.enqueueIdLink(this.instance, idLink);
+        }
+        // will be sent in install
+    }
+    // Allows the client to attach arbitrary data to certain payloads. 
+    registerCustomValue(name, value) {
+        Log.diagDebug(`Host called API: Register Custom Value ${name}`);
+        if (!name || !value) {
+            Log.warn("Invalid custom value, ignoring call.");
+            return;
+        }
+        const dataToAdorn = {};
+        dataToAdorn[name] = value;
+        this.instance.customValues.push({ data: dataToAdorn, isDeviceId: false });
+    }
+    // Allows the client to attach arbitrary identifiers to go out in the install. 
+    registerCustomDeviceIdentifier(name, value) {
+        Log.diagDebug(`Host called API: Register Custom Device Identifier ${name}`);
+        if (!name || !value) {
+            Log.warn("Invalid custom device identifier, ignoring call.");
+            return;
+        }
+        const dataToAdorn = {};
+        dataToAdorn[name] = value;
+        this.instance.customValues.push({ data: dataToAdorn, isDeviceId: true });
+    }
+    /*
+      Returns whether or not the sdk is in a "started" state.
+      This basically amounts to if start has been called,
+      not if kvinit is done or the queue is started.
+      Likewise, shutdown will set "started" to false;
+    */
+    getStarted() {
+        return this.instance.started;
+    }
+    /*
+      Returns the current kochavaDeviceId, or "" if called too early.
+    */
+    getDeviceId() {
+        Log.diagDebug(`Host called API: Get Kochava Device Id`);
+        if (this.instance.started)
+            return this.instance.kochavaDeviceId;
+        else
+            return "";
+    }
+    /*
+      Puts the sdk in a "sleep" state. This will stop the sdk from dequeuing
+      new jobs and retrying failed jobs. Different than shutdown, because the
+      current state is not destroyed.
+    */
+    setSleep(sleep) {
+        Log.diagDebug(`Host called API: Sleep ${sleep ? "Stop" : "Start"}`);
+        if (sleep && !this.instance.sleep) {
+            // only pause if it was running
+            this.instance.sleep = sleep;
+            this.jobQueue.pause();
+        }
+        else if (!sleep && this.instance.sleep) {
+            // only resume queueing if it was paused
+            this.instance.sleep = sleep;
+            this.beginStart();
+        }
+    }
+    // ============================= PRIVATE =============================== //
+    // Unintialized/invalid state.
+    // start must be called before these values will be correct.
+    resetInstance() {
+        this.instance = {
+            appGuid: "",
+            started: false,
+            installStarted: false,
+            kvinitDone: false,
+            installDone: false,
+            disableAutoPage: false,
+            useCookies: false,
+            sleep: false,
+            version: "Web 3.0.0",
+            buildDate: "",
+            overrideUrls: {
+                init: "",
+                install: "",
+                event: "",
+                identityLink: "",
+            },
+            customValues: [],
+            kochavaSession: "",
+            retryWaterfall: [],
+            startTimeMS: 0,
+            utm: "",
+            kochavaDeviceId: "",
+            kochavaInstallId: "",
+            kochavaSessionCount: -1,
+            kochavaInstallDate: -1,
+            kochavaConfig: undefined,
+        };
+    }
+    initInstance(appGuid) {
+        // init instance with defaults
+        this.instance.appGuid = appGuid;
+        this.instance.disableAutoPage = this.instance.disableAutoPage || false;
+        this.instance.useCookies = this.instance.useCookies || false;
+        this.instance.version = "Web 3.0.0";
+        this.instance.buildDate = "kbd: 3/29/2022, 9:27:29 AM";
+        this.instance.kochavaSession = utils.uuidv4().substring(0, 5);
+        this.instance.startTimeMS = utils.getCurrTimeMS();
+        this.instance.retryWaterfall = [7, 30, 300, 1800];
+        this.instance.kochavaConfig = JSON.parse(JSON.stringify(DEFAULTS));
+    }
+    checkFirstLaunchAndMigrate() {
+        // If this is our first launch ever, set it in persistence.
+        if (!readAndUpdatePersistedValue(PersistKey.FirstStartDate, this.instance.useCookies)) {
+            updatePersistedValue(PersistKey.FirstStartDate, String(utils.getCurrTimeSec()), this.instance.useCookies);
+            /*
+              On a first launch of the v3 sdk, we need to migrate old persisted kv_id
+              from v2.2, v2.3, and v2.5
+            */
+            // perform migration
+            const oldKvId = readAndUpdatePersistedValue(PersistKey.OldKvid, this.instance.useCookies);
+            if (oldKvId) {
+                updatePersistedValue(PersistKey.DeviceId, oldKvId, this.instance.useCookies);
+                updatePersistedValue(PersistKey.InstallSentDate, JSON.stringify(utils.getCurrTimeSec()), this.instance.useCookies);
+            }
+        }
+    }
+    checkPersistedKvinit() {
+        // check if persisted kvinit
+        let persistedKvinit = {};
+        const persistedKvinitStr = readAndUpdatePersistedValue(PersistKey.LastKvinit, this.instance.useCookies);
+        if (persistedKvinitStr) {
+            persistedKvinit = JSON.parse(persistedKvinitStr);
+            if (persistedKvinit) {
+                // if persisted kvinit, apply it
+                Log.trace("Found persisted kvinit.", persistedKvinit);
+                Kvinit.applyKvinitResp(this.instance, persistedKvinit);
+                Log.trace("KochavaConfig after persistedKvinit:", JSON.parse(JSON.stringify(this.instance.kochavaConfig)));
+            }
+        }
+        // check refresh minimum too
+        const persistedKvinitDateStr = readAndUpdatePersistedValue(PersistKey.KvinitSentDate, this.instance.useCookies);
+        if (persistedKvinitDateStr) {
+            const lastKvinitDate = JSON.parse(persistedKvinitDateStr);
+            if (lastKvinitDate) {
+                const refreshMin = this.instance.kochavaConfig.config.refresh_minimum;
+                if (utils.getCurrTimeSec() - lastKvinitDate < refreshMin)
+                    this.instance.kvinitDone = true;
+            }
+        }
+    }
+    checkPersistedState() {
+        this.instance.installDone =
+            readAndUpdatePersistedValue(PersistKey.InstallSentDate, this.instance.useCookies).length > 0;
+        this.instance.kochavaInstallId = readAndUpdatePersistedValue(PersistKey.InstallId, this.instance.useCookies);
+        this.instance.kochavaDeviceId = readAndUpdateDeviceId(this.instance.useCookies);
+        this.instance.kochavaSessionCount = readAndUpdateSessionCount(this.instance.useCookies);
+        this.instance.utm = readAndUpdateUTM(this.instance.appGuid, this.instance.useCookies);
+    }
+    printStartupMsgs(appGuid) {
+        Log.diagInfo(`Started SDK ${this.instance.version}
+      published ${this.instance.buildDate}`);
+        Log.diagInfo(`The log level is set to ${Log.getLogLevel()}`);
+        Log.diagDebug(`This ${!this.instance.installDone ? "is" : "is not"} the first tracker SDK launch`);
+        Log.diagDebug(`The kochava device id is ${this.instance.kochavaDeviceId}`);
+        Log.diagDebug(`The kochava app GUID provided was ${appGuid}`);
+    }
+    async beginStart() {
+        // if we need to send a new kvinit, send it
+        if (!this.instance.kvinitDone) {
+            Log.diagDebug(`A new kvinit will be sent`);
+            await this.performNewKvinit();
+        }
+        else {
+            Log.diagDebug(`A new kvinit will not be sent`);
+        }
+        // if the install_id changed and thus a new install must go out
+        if (this.checkResendId())
+            this.instance.installDone = false;
+        Log.diagDebug(`The install ${this.instance.installDone ? "has already" : "has not yet"} been sent`);
+        if (this.instance.sleep)
+            return;
+        if (!this.instance.installDone) {
+            await this.performInstall();
+        }
+        if (this.instance.kvinitDone && this.instance.installDone) {
+            await this.jobQueue.start(this.instance);
+        }
+    }
+    async performNewKvinit() {
+        this.instance.kvinitDone = await Kvinit.send(this.instance, this.instance.retryWaterfall);
+        updatePersistedValue(PersistKey.KvinitSentDate, String(utils.getCurrTimeSec()), this.instance.useCookies);
+        // if new kvinit, apply it
+        let newKvinit = {};
+        const newKvinitStr = readAndUpdatePersistedValue(PersistKey.LastKvinit, this.instance.useCookies);
+        if (newKvinitStr) {
+            newKvinit = JSON.parse(newKvinitStr);
+        }
+        Kvinit.applyKvinitResp(this.instance, newKvinit);
+        Log.trace("KochavaConfig after new Kvinit:", JSON.parse(JSON.stringify(this.instance.kochavaConfig)));
+    }
+    checkResendId() {
+        let resendId = "";
+        if (this.instance.kochavaConfig.install) {
+            resendId = this.instance.kochavaConfig.install.resend_id;
+        }
+        const needsNewInstall = checkInstallIdChange(resendId, this.instance.useCookies);
+        if (needsNewInstall) {
+            Log.debug(`resend_id ${resendId} found, forcing new install`);
+        }
+        return needsNewInstall;
+    }
+    async performInstall() {
+        const request = Install.build(this.instance);
+        this.instance.installDone = await Install.send(this.instance, request);
+        if (!this.instance.installDone)
+            return;
+        // If the install succeeded, remove all idLink that were passed to it
+        Install.onSuccess(this.instance);
+        updatePersistedValue(PersistKey.IdLinkQueue, JSON.stringify(this.jobQueue.idLinkQueue), false);
+    }
+}
+window.kochava = new Kochava();

package/dist/payloads/event.d.ts

@@ -0,0 +1,6 @@
+import { Json } from "../interfaces";
+import { KochavaInstance } from "../kochava";
+import { PreStartBody, PostStartBody } from "./payload";
+export declare const constructPreStart: (instance: KochavaInstance, eventName: string, eventData?: Json | string) => PreStartBody;
+export declare const constructPostStart: (instance: KochavaInstance, preStartBody: PreStartBody) => PostStartBody;
+export declare const send: (instance: KochavaInstance, preStartBody: PreStartBody, postStartBody: PostStartBody) => Promise<boolean>;

package/dist/payloads/event.js

@@ -0,0 +1,92 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import * as http from "../http";
+import * as utils from "../utils/utils";
+import * as browser from "../browser/browser";
+import { Log } from "../utils/log";
+import { constructCommonData } from "./payload";
+export const constructPreStart = (instance, eventName, eventData) => {
+    const preStart = {
+        action: "event",
+        sdk_version: instance.version,
+        sdk_protocol: "17",
+        data: {
+            event_name: eventName,
+            event_data: eventData,
+            device_orientation: browser.getDeviceOrientation(),
+            disp_w: browser.getDeviceWidth(),
+            disp_h: browser.getDeviceHeight(),
+        },
+    };
+    if (instance.kochavaConfig)
+        preStart.init_token = (instance.kochavaConfig.config.init_token) || undefined;
+    return preStart;
+};
+export const constructPostStart = (instance, preStartBody) => {
+    const postStartBody = {
+        kochava_app_id: instance.appGuid,
+        kochava_device_id: instance.kochavaDeviceId,
+        nt_id: `${instance.kochavaSession}-${instance.kochavaSessionCount}-${utils.uuidv4()}`,
+    };
+    postStartBody.data = Object.assign(Object.assign({}, constructCommonData(instance)), preStartBody.data);
+    instance.customValues.forEach((custom) => {
+        if (!custom.isDeviceId) {
+            const customKey = Object.keys(custom.data)[0];
+            if (instance.kochavaConfig.privacy) {
+                let keyAllowed = false;
+                for (const allowed of instance.kochavaConfig.privacy.allow_custom_ids) {
+                    if (customKey === allowed) {
+                        keyAllowed = true;
+                    }
+                }
+                if (keyAllowed)
+                    postStartBody.data = Object.assign(Object.assign({}, custom.data), postStartBody.data);
+            }
+        }
+    });
+    return postStartBody;
+};
+const build = (instance, preStartBody, postStartBody) => {
+    const payload = Object.assign(Object.assign({}, preStartBody), postStartBody);
+    Log.debug("Event Payload", JSON.stringify(payload));
+    if (instance.kochavaConfig.privacy) {
+        instance.kochavaConfig.privacy.deny_datapoints.forEach(denyPoint => {
+            for (const point in payload.data) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload.data[key];
+            }
+            for (const point in payload) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload[key];
+            }
+        });
+    }
+    return payload;
+};
+export const send = async (instance, preStartBody, postStartBody) => {
+    const payload = build(instance, preStartBody, postStartBody);
+    const respStr = await http.sendRequest(payload, (instance.overrideUrls.event) ?
+        instance.overrideUrls.event : instance.kochavaConfig.networking.urls.event);
+    let resp;
+    let success = false;
+    try {
+        Log.trace("Event Response string:", respStr);
+        resp = JSON.parse(respStr);
+        Log.debug("Event Response:", respStr);
+        success = http.wasRespSuccess(resp.success);
+    }
+    catch (e) {
+        Log.error("Error parsing Event Response", e);
+        success = false;
+    }
+    if (success) {
+        Log.info("Event success!");
+        return true;
+    }
+    Log.error("Event failed!");
+    return false;
+};

package/dist/payloads/identityLink.d.ts

@@ -0,0 +1,7 @@
+import { IdentityLink } from "../interfaces";
+import { KochavaInstance } from "../kochava";
+import { PostStartBody, PreStartBody } from "./payload";
+import { IdLinkJob } from "../jobqueue";
+export declare const constructPreStart: (instance: KochavaInstance, idLink: IdentityLink) => PreStartBody;
+export declare const constructPostStart: (instance: KochavaInstance, preStartBody: PreStartBody) => PostStartBody;
+export declare const send: (instance: KochavaInstance, job: IdLinkJob) => Promise<boolean>;

package/dist/payloads/identityLink.js

@@ -0,0 +1,73 @@
+/*
+  Authored by Brett Barinaga on 11/18/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import * as http from "../http";
+import * as utils from "../utils/utils";
+import { Log } from "../utils/log";
+import { constructCommonData } from "./payload";
+export const constructPreStart = (instance, idLink) => {
+    const preStart = {
+        action: "identityLink",
+        sdk_version: instance.version,
+        sdk_protocol: "17",
+        data: {
+            identity_link: Object.assign({}, idLink),
+        },
+    };
+    if (instance.kochavaConfig)
+        preStart.init_token = (instance.kochavaConfig.config.init_token) || undefined;
+    return preStart;
+};
+export const constructPostStart = (instance, preStartBody) => {
+    const postStartBody = {
+        kochava_app_id: instance.appGuid,
+        kochava_device_id: instance.kochavaDeviceId,
+        nt_id: `${instance.kochavaSession}-${instance.kochavaSessionCount}-${utils.uuidv4()}`,
+    };
+    postStartBody.data = Object.assign(Object.assign({}, preStartBody.data), constructCommonData(instance));
+    return postStartBody;
+};
+const build = (instance, job) => {
+    const payload = Object.assign(Object.assign({}, job.preStartBody), job.postStartBody);
+    Log.debug("IdentityLink Payload", JSON.stringify(payload));
+    Log.diagDebug(`IdentityLink to be sent as stand alone`);
+    if (instance.kochavaConfig.privacy) {
+        instance.kochavaConfig.privacy.deny_datapoints.forEach(denyPoint => {
+            for (const point in payload.data) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload.data[key];
+            }
+            for (const point in payload) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload[key];
+            }
+        });
+    }
+    return payload;
+};
+export const send = async (instance, job) => {
+    const payload = build(instance, job);
+    const respStr = await http.sendRequest(payload, (instance.overrideUrls.identityLink) ?
+        instance.overrideUrls.identityLink : instance.kochavaConfig.networking.urls.identityLink);
+    let resp;
+    let success = false;
+    try {
+        Log.trace("IdentityLink Response string:", respStr);
+        resp = JSON.parse(respStr);
+        Log.debug("IdentityLink Response:", respStr);
+        success = http.wasRespSuccess(resp.success);
+    }
+    catch (e) {
+        Log.error("Error parsing IdentityLink Response", e);
+        success = false;
+    }
+    if (success) {
+        Log.info("IdentityLink success!");
+        return true;
+    }
+    Log.error("IdentityLink failed!");
+    return false;
+};

package/dist/payloads/install.d.ts

@@ -0,0 +1,6 @@
+import { KochavaInstance } from "../kochava";
+import { Payload } from "./payload";
+export declare const build: (instance: KochavaInstance) => Payload;
+export declare const cancelRetries: () => void;
+export declare const send: (instance: KochavaInstance, payload: Payload, retries?: number) => Promise<boolean>;
+export declare const onSuccess: (instance: KochavaInstance) => void;