@mparticle/web-sdk 2.19.3 → 2.20.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.19.3",
+    "version": "2.20.1",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -78,7 +78,7 @@
         "@mparticle/event-models": "^1.1.6",
         "@rollup/plugin-json": "^4.1.0",
         "@rollup/plugin-typescript": "^8.3.3",
-        "@rollup/plugin-babel": "5.3.1",
+        "@rollup/plugin-babel": "6.0.3",
         "@rollup/plugin-commonjs": "22.0.2",
         "@rollup/plugin-node-resolve": "13.3.0",
         "@semantic-release/changelog": "^5.0.1",
@@ -93,8 +93,8 @@
         "browserify": "^17.0.0",
         "chai": "^4.2.0",
         "cross-env": "^7.0.3",
-        "eslint": "^7.32.0",
-        "eslint-config-prettier": "8.3.0",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "8.8.0",
         "eslint-plugin-prettier": "3.4.1",
         "fetch-mock": "^7.5.1",
         "gts": "^3.1.0",
@@ -116,7 +116,7 @@
         "should": "^7.1.0",
         "sinon": "^11.0.0",
         "tslib": "^2.1.0",
-        "typescript": "^4.2.4",
+        "typescript": "^5.0.2",
         "uglify-js": "^3.4.9",
         "webpack": "^5.36.2",
         "webpack-cli": "^4.6.0"

package/src/apiClient.ts

@@ -8,7 +8,7 @@ import {
     SDKEvent,
 } from './sdkRuntimeModels';
 import KitBlocker from './kitBlocking';
-import { Dictionary } from './utils';
+import { Dictionary, getRampNumber } from './utils';
 import { IUploadObject } from './serverModel';
 
 const Messages = Constants.Messages;
@@ -67,9 +67,7 @@ export default function APIClient(
             return false;
         }
 
-        const rampNumber = mpInstance._Helpers.getRampNumber(
-            mpInstance._Store.deviceId
-        );
+        const rampNumber = getRampNumber(mpInstance._Store.deviceId);
         return eventsV3Percentage >= rampNumber;
     };
 

package/src/configAPIClient.ts

@@ -29,8 +29,9 @@ export interface IKitConfigs {
     eventNameFilters: number[];
     eventTypeFilters: number[];
     attributeFilters: number[];
-    filteringEventAttributeValue: Dictionary;
-    filteringConsentRuleValues: Dictionary;
+    filteringEventAttributeValue: IFilteringAttributeValue;
+    filteringUserAttributeValue: IFilteringAttributeValue;
+    filteringConsentRuleValues: IFilteringConsentRulesValue;
     consentRegulationFilters: number[];
     consentRegulationPurposeFilters: number[];
     messageTypeFilters: number[];
@@ -39,6 +40,22 @@ export interface IKitConfigs {
     excludeAnonymousUser: boolean;
 }
 
+export interface IFilteringAttributeValue {
+    eventAttributeName: string;
+    eventAttributeValue: string;
+    includeOnMatch: boolean
+}
+export interface IFilteringConsentRulesValue {
+    includeOnMatch: boolean;
+    values: IConsentRuleValue[];
+}
+
+export interface IConsentRuleValue {
+    consentPurpose: string;
+    hasConsented: boolean
+}
+
+
 export interface IPixelConfig {
     name: string;
     moduleId: number;

package/src/forwarders.interfaces.ts

@@ -0,0 +1,61 @@
+import { MParticleUser, SDKEvent, SDKEventCustomFlags, SDKUserIdentity } from './sdkRuntimeModels';
+import { Dictionary } from './utils';
+import { IKitConfigs } from './configAPIClient';
+import { UserAttributes } from './persistence.interfaces';
+import { IdentityApiData } from '@mparticle/web-sdk';
+
+// The state of the kit when accessed via window.KitName via CDN
+// or imported as an NPM package
+export interface UnregisteredKit {
+    register(config): void;
+}
+
+// The state of the kit after being added to forwarderConstructors in the CDN 
+// or after registered to SDKConfig.kits via NPM
+export interface RegisteredKit {
+    constructor(): void;
+    name: string;
+    getId(): number;
+}
+
+// The state of the kit after being configured. This is what the kit looks like when acted on.
+export interface ConfiguredKit
+    extends Omit<IKitConfigs, 'isDebugString' | 'hasDebugString'> {
+    common: Dictionary<unknown>;
+    init(
+        settings: Dictionary<unknown>,
+        service: forwardingStatsCallback,
+        testMode: boolean,
+        trackerId: string | null,
+        userAttributes: UserAttributes,
+        userIdentities: SDKUserIdentity,
+        appVersion: string,
+        appName: string,
+        customFlags: SDKEventCustomFlags,
+        clientId: string): string;
+    onIdentifyComplete(user: MParticleUser, filteredIdentityRequest: IdentityApiData): string | KitMappedMethodFailure;
+    onLoginComplete(user: MParticleUser, filteredIdentityRequest: IdentityApiData): string | KitMappedMethodFailure;
+    onLogoutComplete(user: MParticleUser, filteredIdentityRequest: IdentityApiData): string | KitMappedMethodFailure;
+    onModifyComplete(user: MParticleUser, filteredIdentityRequest: IdentityApiData): string | KitMappedMethodFailure;
+    onUserIdentified(user: MParticleUser): string | KitMappedMethodFailure;
+    process(event: SDKEvent): string;
+    setOptOut(isOptingOut: boolean): string | KitMappedMethodFailure;
+    removeUserAttribute(key: string): string;
+    setUserAttribute(key: string, value:string): string;
+
+    // TODO: Convert type to enum during Identity migration
+    // https://go.mparticle.com/work/SQDSDKS-5218
+    setUserIdentity(id: UserIdentityId, type: UserIdentityType): void;
+
+    // TODO: https://go.mparticle.com/work/SQDSDKS-5156
+    isSandbox: boolean;  
+    hasSandbox: boolean;
+}
+export interface KitMappedMethodFailure {
+    error: string
+}
+
+export type UserIdentityId = string;
+export type UserIdentityType = number;
+
+export type forwardingStatsCallback = (forwarder: ConfiguredKit, event: SDKEvent) => void;

package/src/forwarders.js

@@ -1,5 +1,6 @@
 import Types from './types';
 import filteredMparticleUser from './filteredMparticleUser';
+import { isEmpty } from './utils';
 
 export default function Forwarders(mpInstance, kitBlocker) {
     var self = this;
@@ -59,7 +60,6 @@ export default function Forwarders(mpInstance, kitBlocker) {
                         user ? user.getAllUserAttributes() : {},
                         forwarder.userAttributeFilters
                     );
-
                     if (!forwarder.initialized) {
                         forwarder.logger = mpInstance.Logger;
                         forwarder.init(
@@ -524,19 +524,59 @@ export default function Forwarders(mpInstance, kitBlocker) {
         mpInstance._Persistence.forwardingStatsBatches.forwardingStatsEventQueue = queue;
     };
 
-    this.configureForwarder = function(configuration) {
+    // Processing forwarders is a 2 step process:
+    //   1. Configure the kit
+    //   2. Initialize the kit
+    // There are 2 types of kits:
+    //   1. UI-enabled kits
+    //   2. Sideloaded kits.
+    this.processForwarders = function(config, forwardingStatsCallback) {
+        if (!config) {
+            mpInstance.Logger.warning(
+                'No config was passed. Cannot process forwarders'
+            );
+        } else {
+            this.processUIEnabledKits(config);
+            this.processSideloadedKits(config);
+
+            self.initForwarders(
+                mpInstance._Store.SDKConfig.identifyRequest.userIdentities,
+                forwardingStatsCallback
+            );
+        }
+    };
+
+    // These are kits that are enabled via the mParticle UI.
+    // A kit that is UI-enabled will have a kit configuration that returns from
+    // the server, or in rare cases, is passed in by the developer.
+    // The kit configuration will be compared with the kit constructors to determine
+    // if there is a match before being initialized.
+    // Only kits that are configured properly can be active and used for kit forwarding.
+    this.processUIEnabledKits = function(config) {
+        try {
+            if (Array.isArray(config.kitConfigs) && config.kitConfigs.length) {
+                config.kitConfigs.forEach(function(kitConfig) {
+                    self.configureUIEnabledKit(kitConfig);
+                });
+            }
+        } catch (e) {
+            mpInstance.Logger.error(
+                'MP Kits not configured propertly. Kits may not be initialized. ' +
+                    e
+            );
+        }
+    };
+
+    this.configureUIEnabledKit = function(configuration) {
         var newForwarder = null,
             config = configuration,
             forwarders = {};
 
-        // if there are kits inside of mpInstance._Store.SDKConfig.kits, then mParticle is self hosted
-        if (
-            mpInstance._Helpers.isObject(mpInstance._Store.SDKConfig.kits) &&
-            Object.keys(mpInstance._Store.SDKConfig.kits).length > 0
-        ) {
+        // If there are kits inside of mpInstance._Store.SDKConfig.kits, then mParticle is self hosted
+        if (!isEmpty(mpInstance._Store.SDKConfig.kits)) {
             forwarders = mpInstance._Store.SDKConfig.kits;
             // otherwise mParticle is loaded via script tag
-        } else if (mpInstance._preInit.forwarderConstructors.length > 0) {
+        } else if (!isEmpty(mpInstance._preInit.forwarderConstructors)) {
             mpInstance._preInit.forwarderConstructors.forEach(function(
                 forwarder
             ) {
@@ -552,38 +592,10 @@ export default function Forwarders(mpInstance, kitBlocker) {
                     config.isSandbox ===
                         mpInstance._Store.SDKConfig.isDevelopmentMode
                 ) {
-                    newForwarder = new forwarders[name].constructor();
-
-                    newForwarder.id = config.moduleId;
-                    newForwarder.isSandbox = config.isDebug || config.isSandbox;
-                    newForwarder.hasSandbox = config.hasDebugString === 'true';
-                    newForwarder.isVisible = config.isVisible;
-                    newForwarder.settings = config.settings;
-
-                    newForwarder.eventNameFilters = config.eventNameFilters;
-                    newForwarder.eventTypeFilters = config.eventTypeFilters;
-                    newForwarder.attributeFilters = config.attributeFilters;
-
-                    newForwarder.screenNameFilters = config.screenNameFilters;
-                    newForwarder.screenNameFilters = config.screenNameFilters;
-                    newForwarder.screenAttributeFilters =
-                        config.screenAttributeFilters;
-
-                    newForwarder.userIdentityFilters =
-                        config.userIdentityFilters;
-                    newForwarder.userAttributeFilters =
-                        config.userAttributeFilters;
-
-                    newForwarder.filteringEventAttributeValue =
-                        config.filteringEventAttributeValue;
-                    newForwarder.filteringUserAttributeValue =
-                        config.filteringUserAttributeValue;
-                    newForwarder.eventSubscriptionId =
-                        config.eventSubscriptionId;
-                    newForwarder.filteringConsentRuleValues =
-                        config.filteringConsentRuleValues;
-                    newForwarder.excludeAnonymousUser =
-                        config.excludeAnonymousUser;
+                    newForwarder = this.returnConfiguredKit(
+                        forwarders[name],
+                        config
+                    );
 
                     mpInstance._Store.configuredForwarders.push(newForwarder);
                     break;
@@ -592,6 +604,84 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
+    // Sideloaded kits are not configured in the UI and do not have kit configurations
+    // They are automatically added to active forwarders.
+
+    // TODO: Sideloading kits currently requires the use of a register method
+    // which requires an object on which to be registered.
+    // In the future, when all kits are moved to the config rather than
+    // there being a separate process for MP configured kits and
+    // sideloaded kits, this will need to be refactored.
+    this.processSideloadedKits = function(config) {
+        try {
+            if (Array.isArray(config.sideloadedKits)) {
+                const sideloadedKits = { kits: {} };
+                // First register each kit's constructor onto sideloadedKits,
+                // which is typed { kits: Dictionary<constructor> }.
+                // The constructors are keyed by the name of the kit.
+                config.sideloadedKits.forEach(function(sideloadedKit) {
+                    sideloadedKit.register(sideloadedKits);
+                });
+
+                // Then configure each kit
+                for (const registeredKitKey in sideloadedKits.kits) {
+                    const kitConstructor =
+                        sideloadedKits.kits[registeredKitKey];
+                    self.configureSideloadedKit(kitConstructor);
+                }
+            }
+        } catch (e) {
+            mpInstance.Logger.error(
+                'Sideloaded Kits not configured propertly. Kits may not be initialized. ' +
+                    e
+            );
+        }
+    };
+
+    // kits can be included via mParticle UI, or via sideloaded kit config API
+    this.configureSideloadedKit = function(kitConstructor) {
+        mpInstance._Store.configuredForwarders.push(
+            this.returnConfiguredKit(kitConstructor)
+        );
+    };
+
+    this.returnConfiguredKit = function(forwarder, config = {}) {
+        const newForwarder = new forwarder.constructor();
+        newForwarder.id = config.moduleId;
+
+        // TODO: isSandbox, hasSandbox is never used in any kit or in core SDK.
+        // isVisible.  Investigate is only used in 1 place. It is always true if
+        // it is sent to JS. Investigate further to determine if these can be removed.
+        // https://go.mparticle.com/work/SQDSDKS-5156
+        newForwarder.isSandbox = config.isDebug || config.isSandbox;
+        newForwarder.hasSandbox = config.hasDebugString === 'true';
+        newForwarder.isVisible = config.isVisible || true;
+        newForwarder.settings = config.settings || {};
+
+        newForwarder.eventNameFilters = config.eventNameFilters || [];
+        newForwarder.eventTypeFilters = config.eventTypeFilters || [];
+        newForwarder.attributeFilters = config.attributeFilters || [];
+
+        newForwarder.screenNameFilters = config.screenNameFilters || [];
+        newForwarder.screenAttributeFilters =
+            config.screenAttributeFilters || [];
+
+        newForwarder.userIdentityFilters = config.userIdentityFilters || [];
+        newForwarder.userAttributeFilters = config.userAttributeFilters || [];
+
+        newForwarder.filteringEventAttributeValue =
+            config.filteringEventAttributeValue || {};
+        newForwarder.filteringUserAttributeValue =
+            config.filteringUserAttributeValue || {};
+        newForwarder.eventSubscriptionId = config.eventSubscriptionId || null;
+        newForwarder.filteringConsentRuleValues =
+            config.filteringConsentRuleValues || {};
+        newForwarder.excludeAnonymousUser =
+            config.excludeAnonymousUser || false;
+
+        return newForwarder;
+    };
+
     this.configurePixel = function(settings) {
         if (
             settings.isDebug ===
@@ -603,39 +693,18 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
-    this.processForwarders = function(config, forwardingStatsCallback) {
-        if (!config) {
-            mpInstance.Logger.warning(
-                'No config was passed. Cannot process forwarders'
-            );
-        } else {
-            try {
-                if (
-                    Array.isArray(config.kitConfigs) &&
-                    config.kitConfigs.length
-                ) {
-                    config.kitConfigs.forEach(function(kitConfig) {
-                        self.configureForwarder(kitConfig);
-                    });
-                }
-
-                if (
-                    Array.isArray(config.pixelConfigs) &&
-                    config.pixelConfigs.length
-                ) {
-                    config.pixelConfigs.forEach(function(pixelConfig) {
-                        self.configurePixel(pixelConfig);
-                    });
-                }
-                self.initForwarders(
-                    mpInstance._Store.SDKConfig.identifyRequest.userIdentities,
-                    forwardingStatsCallback
-                );
-            } catch (e) {
-                mpInstance.Logger.error(
-                    'Config was not parsed propertly. Forwarders may not be initialized.'
-                );
+    this.processPixelConfigs = function(config) {
+        try {
+            if (!isEmpty(config.pixelConfigs)) {
+                config.pixelConfigs.forEach(function(pixelConfig) {
+                    self.configurePixel(pixelConfig);
+                });
             }
+        } catch (e) {
+            mpInstance.Logger.error(
+                'Cookie Sync configs not configured propertly. Cookie Sync may not be initialized. ' +
+                    e
+            );
         }
     };
 }

package/src/helpers.js

@@ -26,17 +26,6 @@ export default function Helpers(mpInstance) {
         return null;
     };
 
-    /**
-     * Returns a value between 1-100 inclusive.
-     */
-    this.getRampNumber = function(deviceId) {
-        if (!deviceId) {
-            return 100;
-        }
-        var hash = self.generateHash(deviceId);
-        return Math.abs(hash % 100) + 1;
-    };
-
     this.invokeCallback = function(
         callback,
         code,
@@ -284,39 +273,6 @@ export default function Helpers(mpInstance) {
         return xhr;
     };
 
-    function generateRandomValue(a) {
-        var randomValue;
-        if (window.crypto && window.crypto.getRandomValues) {
-            randomValue = window.crypto.getRandomValues(new Uint8Array(1)); // eslint-disable-line no-undef
-        }
-        if (randomValue) {
-            return (a ^ (randomValue[0] % 16 >> (a / 4))).toString(16);
-        }
-
-        return (a ^ ((Math.random() * 16) >> (a / 4))).toString(16);
-    }
-
-    this.generateUniqueId = function(a) {
-        // https://gist.github.com/jed/982883
-        // Added support for crypto for better random
-
-        return a // if the placeholder was passed, return
-            ? generateRandomValue(a) // a random number
-            : // or otherwise a concatenated string:
-              (
-                  [1e7] + // 10000000 +
-                  -1e3 + // -1000 +
-                  -4e3 + // -4000 +
-                  -8e3 + // -80000000 +
-                  -1e11
-              ) // -100000000000,
-                  .replace(
-                      // replacing
-                      /[018]/g, // zeroes, ones, and eights with
-                      self.generateUniqueId // random hex digits
-                  );
-    };
-
     this.filterUserIdentities = function(userIdentitiesObject, filterList) {
         var filteredUserIdentities = [];
 
@@ -403,37 +359,6 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.generateHash = function(name) {
-        var hash = 0,
-            i = 0,
-            character;
-
-        if (name === undefined || name === null) {
-            return 0;
-        }
-
-        name = name.toString().toLowerCase();
-
-        if (Array.prototype.reduce) {
-            return name.split('').reduce(function(a, b) {
-                a = (a << 5) - a + b.charCodeAt(0);
-                return a & a;
-            }, 0);
-        }
-
-        if (name.length === 0) {
-            return hash;
-        }
-
-        for (i = 0; i < name.length; i++) {
-            character = name.charCodeAt(i);
-            hash = (hash << 5) - hash + character;
-            hash = hash & hash;
-        }
-
-        return hash;
-    };
-
     this.sanitizeAttributes = function(attrs, name) {
         if (!attrs || !self.isObject(attrs)) {
             return null;
@@ -501,6 +426,8 @@ export default function Helpers(mpInstance) {
         }
     };
 
+    // TODO: Refactor SDK to directly use these methods
+    // https://go.mparticle.com/work/SQDSDKS-5239
     // Utility Functions
     this.converted = utils.converted;
     this.findKeyInObject = utils.findKeyInObject;
@@ -510,6 +437,8 @@ export default function Helpers(mpInstance) {
     this.decoded = utils.decoded;
     this.returnConvertedBoolean = utils.returnConvertedBoolean;
     this.parseStringOrNumber = utils.parseStringOrNumber;
+    this.generateHash = utils.generateHash;
+    this.generateUniqueId = utils.generateUniqueId;
 
     // Imported Validators
     this.Validators = Validators;

package/src/mockBatchCreator.ts

@@ -40,6 +40,7 @@ export default class _BatchValidator {
             _SessionManager: null,
             _Store: {
                 sessionId: 'mockSessionId',
+                sideloadedKits: [],
                 devToken: 'test_dev_token',
                 isFirstRun: true,
                 isEnabled: true,

package/src/mp-instance.js

@@ -1421,6 +1421,8 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
             mpInstance._APIClient.prepareForwardingStats
         );
 
+        mpInstance._Forwarders.processPixelConfigs(config);
+
         mpInstance._SessionManager.initialize();
         mpInstance._Events.logAST();
 

package/src/persistence.interfaces.ts

@@ -0,0 +1,138 @@
+import { Context } from '@mparticle/event-models';
+import {
+    AllUserAttributes,
+    ConsentState,
+    IdentityApiData,
+    MPID,
+    Product,
+    UserIdentities,
+} from '@mparticle/web-sdk';
+import { ForwardingStatsData } from './apiClient';
+import {
+    IntegrationAttributes,
+    ServerSettings,
+    SessionAttributes,
+} from './store';
+import { Dictionary } from './utils';
+
+export type CookieSyncDate = Dictionary<string>;
+export type UploadsTable = Dictionary<any>;
+export interface iForwardingStatsBatches {
+    uploadsTable: UploadsTable;
+    forwardingStatsEventQueue: ForwardingStatsData[];
+}
+
+// TODO: Migrate this to @types/mparticle__web-sdk
+//       https://go.mparticle.com/work/SQDSDKS-5196
+export type UserAttributes = AllUserAttributes;
+
+export interface IGlobalStoreV2MinifiedKeys {
+    sid: string; // Session ID
+    ie: boolean; // Is Enabled
+    sa: SessionAttributes;
+    ss: ServerSettings;
+    dt: string; // Dev Token
+    av: string; // App Version
+    cgid: string; // Client Generated ID
+    das: string; // Device ID/ Device Application String
+    ia: IntegrationAttributes;
+    c: Context;
+    csm: MPID[]; // Current Session MPIDs
+    les: number; // Last Event Sent Timestamp
+    ssd: number; // Session Start Date
+}
+
+export interface IPersistenceMinified extends Dictionary {
+    cu: MPID; // Current User MPID
+    gs: IGlobalStoreV2MinifiedKeys;
+    l: false; // IsLoggedIn
+
+    // Persistence Minified can also store optional dictionaries with
+    // an idex of MPID
+    // [mpid: MPID]: Dictionary<any>;
+
+    // For Example:
+    // {
+    //     cu: '123345',
+    //     gs: {
+    //         sid: '123',
+    //         ie: false,
+    //         sa: {},
+    //         ss: {},
+    //         dt: '',
+    //         av: '',
+    //         cgid: '123',
+    //         das: 'das',
+    //         ia: {},
+    //         c: null,
+    //         csm: ['123'],
+    //         les: 0,
+    //         ssd: 0,
+    //     },
+    //     l: false,
+    //     MPID1: {
+    //         csd: [],
+    //         ui: {
+    //             customerid: '12346',
+    //         },
+    //     },
+    // };
+}
+
+export interface IPersistence {
+    useLocalStorage(): boolean;
+    initializeStorage(): void;
+    update(): void;
+    storeProductsInMemory(products: Product[], mpid: MPID): void;
+    storeDataInMemory(obj: IPersistenceMinified, currentMPID: MPID): void;
+    determineLocalStorageAvailability(storage: Storage): boolean;
+    getUserProductsFromLS(mpid: MPID): Product[];
+    getAllUserProductsFromLS(): Product[];
+    setLocalStorage(): void;
+    getLocalStorage(): IPersistenceMinified | null;
+    expireCookies(cookieName: string): void;
+    getCookie(): IPersistenceMinified | null;
+    setCookie(): void;
+    reduceAndEncodePersistence(
+        persistence: IPersistenceMinified,
+        expires: string,
+        domain: string,
+        maxCookieSize: number
+    ): void;
+    findPrevCookiesBasedOnUI(identityApiData: IdentityApiData): void;
+    encodePersistence(persistance: IPersistenceMinified): string;
+    decodePersistence(persistance: IPersistenceMinified): string;
+    replaceCommasWithPipes(string: string): string;
+    replacePipesWithCommas(string: string): string;
+    replaceApostrophesWithQuotes(string: string): string;
+    replaceQuotesWithApostrophes(string: string): string;
+    createCookieString(string: string): string;
+    revertCookieString(string: string): string;
+    getCookieDomain(): string;
+    getDomain(doc: string, locationHostname: string): string;
+    getUserIdentities(mpid: MPID): UserIdentities;
+    getAllUserAttributes(mpid: MPID): AllUserAttributes;
+    getCartProducts(mpid: MPID): Product[];
+    setCartProducts(allProducts: Product[]): void;
+    saveUserIdentitiesToPersistence(
+        mpid: MPID,
+        userIdentities: UserIdentities
+    ): void;
+    saveUserAttributesToPersistence(
+        mpid: MPID,
+        userAttributes: UserAttributes
+    ): void;
+    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDate): void;
+    saveUserConsentStateToCookies(mpid, consentState: ConsentState): void;
+    savePersistence(persistance: IPersistenceMinified): void;
+    getPersistence(): IPersistenceMinified;
+    getConsentState(mpid: MPID): ConsentState | null;
+    getFirstSeenTime(mpid: MPID): string | null;
+    setFirstSeenTime(mpid: MPID, time: number): void;
+    getLastSeenTime(mpid: MPID): number | null;
+    setLastSeenTime(mpid: MPID, time: number): void;
+    getDeviceId(): string;
+    setDeviceId(guid: string): void;
+    resetPersistence(): void;
+    forwardingStatsBatches: iForwardingStatsBatches;
+}