@mparticle/web-sdk 2.21.2 → 2.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.21.2",
+    "version": "2.22.1",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -82,12 +82,12 @@
         "@babel/preset-env": "^7.6.0",
         "@babel/preset-typescript": "^7.6.0",
         "@mparticle/data-planning-models": "^0.1.0",
-        "@mparticle/event-models": "^1.1.6",
+        "@mparticle/event-models": "^1.1.7",
         "@rollup/plugin-babel": "6.0.3",
-        "@rollup/plugin-commonjs": "22.0.2",
+        "@rollup/plugin-commonjs": "24.1.0",
         "@rollup/plugin-json": "^4.1.0",
-        "@rollup/plugin-node-resolve": "13.3.0",
-        "@rollup/plugin-typescript": "^8.3.3",
+        "@rollup/plugin-node-resolve": "15.1.0",
+        "@rollup/plugin-typescript": "^11.1.0",
         "@semantic-release/changelog": "^5.0.1",
         "@semantic-release/exec": "^5.0.0",
         "@semantic-release/git": "^9.0.0",
@@ -96,7 +96,7 @@
         "@types/jest-expect-message": "^1.1.0",
         "@types/mocha": "^9.0.0",
         "@types/mparticle__web-sdk": "^2.16.1",
-        "@types/node": "^18.7.11",
+        "@types/node": "^20.1.0",
         "babel-preset-minify": "^0.5.1",
         "browser-sync": "^2.26.3",
         "browserify": "^17.0.0",
@@ -131,7 +131,7 @@
         "typescript": "^5.0.2",
         "uglify-js": "^3.4.9",
         "webpack": "^5.36.2",
-        "webpack-cli": "^4.6.0"
+        "webpack-cli": "^5.0.2"
     },
     "dependencies": {
         "@babel/runtime": "^7.6.0",

package/src/configAPIClient.ts

@@ -14,7 +14,7 @@ export type SDKCompleteInitCallback = (
     mpInstance: MParticleWebSDK
 ) => void;
 
-export interface IKitConfigs {
+export interface IKitConfigs extends IKitFilterSettings {
     name: string;
     moduleId: number;
     isDebug: boolean;
@@ -22,30 +22,39 @@ export interface IKitConfigs {
     isDebugString: BooleanStringLowerCase;
     hasDebugString: BooleanStringLowerCase;
     settings: Dictionary;
+    eventSubscriptionId: number;
+    excludeAnonymousUser: boolean;
+}
+
+export interface IKitFilterSettings {
+    eventTypeFilters: number[];
+    eventNameFilters: number[];
     screenNameFilters: number[];
     screenAttributeFilters: number[];
     userIdentityFilters: number[];
     userAttributeFilters: number[];
-    eventNameFilters: number[];
-    eventTypeFilters: number[];
     attributeFilters: number[];
-    filteringEventAttributeValue: IFilteringAttributeValue;
-    filteringUserAttributeValue: IFilteringAttributeValue;
-    filteringConsentRuleValues: IFilteringConsentRulesValue;
+    filteringEventAttributeValue?: IFilteringEventAttributeValue;
+    filteringUserAttributeValue?: IFilteringUserAttributeValue;
+    filteringConsentRuleValues?: IFilteringConsentRuleValues;
     consentRegulationFilters: number[];
     consentRegulationPurposeFilters: number[];
     messageTypeFilters: number[];
     messageTypeStateFilters: number[];
-    eventSubscriptionId: number;
-    excludeAnonymousUser: boolean;
 }
 
-export interface IFilteringAttributeValue {
+export interface IFilteringEventAttributeValue {
     eventAttributeName: string;
     eventAttributeValue: string;
     includeOnMatch: boolean
 }
-export interface IFilteringConsentRulesValue {
+
+export interface IFilteringUserAttributeValue {
+    userAttributeName: string;
+    userAttributeValue: string;
+    includeOnMatch: boolean
+}
+export interface IFilteringConsentRuleValues {
     includeOnMatch: boolean;
     values: IConsentRuleValue[];
 }

package/src/consent.ts

@@ -6,9 +6,10 @@ import {
 } from '@mparticle/web-sdk';
 import { MParticleUser, MParticleWebSDK } from './sdkRuntimeModels';
 import { Dictionary, isObject } from './utils';
+import KitFilterHelper from './kitFilterHelper';
+import Constants from './constants';
 
-// Specifies to compiler that CCPAPurpose can only be one specific value
-export const CCPAPurpose = 'data_sale_opt_out' as const;
+const { CCPAPurpose } = Constants;
 
 export interface IMinifiedConsentJSONObject {
     gdpr?: Dictionary<IPrivacyV2DTO>;
@@ -144,15 +145,13 @@ export default function Consent(this: IConsent, mpInstance: MParticleWebSDK) {
             // GDPR - '1' + purpose name
             // CCPA - '2data_sale_opt_out' (there is only 1 purpose of data_sale_opt_out for CCPA)
             const GDPRConsentHashPrefix = '1';
-            const CCPAHashString = '2' + CCPAPurpose;
+            const CCPAHashPrefix = '2';
 
             const gdprConsentState = consentState.getGDPRConsentState();
             if (gdprConsentState) {
                 for (const purpose in gdprConsentState) {
                     if (gdprConsentState.hasOwnProperty(purpose)) {
-                        purposeHash = mpInstance._Helpers
-                            .generateHash(GDPRConsentHashPrefix + purpose)
-                            .toString();
+                        purposeHash = KitFilterHelper.hashConsentPurposeConditionalForwarding(GDPRConsentHashPrefix, purpose);
                         purposeHashes[purposeHash] =
                             gdprConsentState[purpose].Consented;
                     }
@@ -160,9 +159,7 @@ export default function Consent(this: IConsent, mpInstance: MParticleWebSDK) {
             }
             const CCPAConsentState = consentState.getCCPAConsentState();
             if (CCPAConsentState) {
-                purposeHash = mpInstance._Helpers
-                    .generateHash(CCPAHashString)
-                    .toString();
+                purposeHash = KitFilterHelper.hashConsentPurposeConditionalForwarding(CCPAHashPrefix, CCPAPurpose);
                 purposeHashes[purposeHash] = CCPAConsentState.Consented;
             }
         }

package/src/constants.ts

@@ -163,6 +163,7 @@ const Constants = {
         OfflineStorage: 'offlineStorage',
     },
     DefaultInstance: 'default_instance',
+    CCPAPurpose: 'data_sale_opt_out'
 } as const;
 
 export default Constants;

package/src/forwarders.js

@@ -1,6 +1,7 @@
 import Types from './types';
 import filteredMparticleUser from './filteredMparticleUser';
 import { isEmpty } from './utils';
+import KitFilterHelper from './kitFilterHelper';
 
 export default function Forwarders(mpInstance, kitBlocker) {
     var self = this;
@@ -110,12 +111,12 @@ export default function Forwarders(mpInstance, kitBlocker) {
             ) {
                 for (var attrName in userAttributes) {
                     if (userAttributes.hasOwnProperty(attrName)) {
-                        attrHash = mpInstance._Helpers
-                            .generateHash(attrName)
-                            .toString();
-                        valueHash = mpInstance._Helpers
-                            .generateHash(userAttributes[attrName])
-                            .toString();
+                        attrHash = KitFilterHelper.hashAttributeConditionalForwarding(
+                            attrName
+                        );
+                        valueHash = KitFilterHelper.hashAttributeConditionalForwarding(
+                            userAttributes[attrName]
+                        );
 
                         if (
                             attrHash === filterObject.userAttributeName &&
@@ -177,7 +178,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
                         if (
                             mpInstance._Helpers.inArray(
                                 filterList,
-                                userIdentity.Type
+                                KitFilterHelper.hashUserIdentity(
+                                    userIdentity.Type
+                                )
                             )
                         ) {
                             event.UserIdentities.splice(i, 1);
@@ -198,8 +201,10 @@ export default function Forwarders(mpInstance, kitBlocker) {
 
                 for (var attrName in event.EventAttributes) {
                     if (event.EventAttributes.hasOwnProperty(attrName)) {
-                        hash = mpInstance._Helpers.generateHash(
-                            event.EventCategory + event.EventName + attrName
+                        hash = KitFilterHelper.hashEventAttributeKey(
+                            event.EventCategory,
+                            event.EventName,
+                            attrName
                         );
 
                         if (mpInstance._Helpers.inArray(filterList, hash)) {
@@ -227,10 +232,11 @@ export default function Forwarders(mpInstance, kitBlocker) {
             !mpInstance._Store.webviewBridgeEnabled &&
             mpInstance._Store.activeForwarders
         ) {
-            hashedEventName = mpInstance._Helpers.generateHash(
-                event.EventCategory + event.EventName
+            hashedEventName = KitFilterHelper.hashEventName(
+                event.EventName,
+                event.EventCategory
             );
-            hashedEventType = mpInstance._Helpers.generateHash(
+            hashedEventType = KitFilterHelper.hashEventType(
                 event.EventCategory
             );
 
@@ -261,9 +267,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
                     if (event.EventAttributes) {
                         for (var prop in event.EventAttributes) {
                             var hashedEventAttributeName;
-                            hashedEventAttributeName = mpInstance._Helpers
-                                .generateHash(prop)
-                                .toString();
+                            hashedEventAttributeName = KitFilterHelper.hashAttributeConditionalForwarding(
+                                prop
+                            );
 
                             if (
                                 hashedEventAttributeName ===
@@ -273,11 +279,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
                             ) {
                                 foundProp = {
                                     name: hashedEventAttributeName,
-                                    value: mpInstance._Helpers
-                                        .generateHash(
-                                            event.EventAttributes[prop]
-                                        )
-                                        .toString(),
+                                    value: KitFilterHelper.hashAttributeConditionalForwarding(
+                                        event.EventAttributes[prop]
+                                    ),
                                 };
                             }
 
@@ -620,7 +624,14 @@ export default function Forwarders(mpInstance, kitBlocker) {
                 // which is typed { kits: Dictionary<constructor> }.
                 // The constructors are keyed by the name of the kit.
                 config.sideloadedKits.forEach(function(sideloadedKit) {
-                    sideloadedKit.register(sideloadedKits);
+                    try {
+                        sideloadedKit.kitInstance.register(sideloadedKits);
+                    } catch (e) {
+                        console.error(
+                            'Error registering sideloaded kit ' +
+                                sideloadedKit.kitInstance.name
+                        );
+                    }
                 });
 
                 // Then configure each kit
@@ -629,6 +640,12 @@ export default function Forwarders(mpInstance, kitBlocker) {
                         sideloadedKits.kits[registeredKitKey];
                     self.configureSideloadedKit(kitConstructor);
                 }
+
+                // If Sideloaded Kits are successfully registered,
+                // record this in the Store.
+                if (!isEmpty(sideloadedKits.kits)) {
+                    mpInstance._Store.isUsingSideloadedKits = true;
+                }
             }
         } catch (e) {
             mpInstance.Logger.error(

package/src/helpers.js

@@ -2,6 +2,7 @@ import Types from './types';
 import Constants from './constants';
 import * as utils from './utils';
 import Validators from './validators';
+import KitFilterHelper from './kitFilterHelper';
 
 var StorageNames = Constants.StorageNames;
 
@@ -306,13 +307,13 @@ export default function Helpers(mpInstance) {
         userIdentitiesObject,
         filterList
     ) {
-        var filteredUserIdentities = {};
+        const filteredUserIdentities = {};
 
         if (userIdentitiesObject && Object.keys(userIdentitiesObject).length) {
-            for (var userIdentityName in userIdentitiesObject) {
+            for (const userIdentityName in userIdentitiesObject) {
                 if (userIdentitiesObject.hasOwnProperty(userIdentityName)) {
-                    var userIdentityType = Types.IdentityType.getIdentityType(
-                        userIdentityName
+                    const userIdentityType = KitFilterHelper.hashUserIdentity(
+                        Types.IdentityType.getIdentityType(userIdentityName)
                     );
                     if (!self.inArray(filterList, userIdentityType)) {
                         filteredUserIdentities[userIdentityName] =
@@ -331,7 +332,9 @@ export default function Helpers(mpInstance) {
         if (userAttributes && Object.keys(userAttributes).length) {
             for (var userAttribute in userAttributes) {
                 if (userAttributes.hasOwnProperty(userAttribute)) {
-                    var hashedUserAttribute = self.generateHash(userAttribute);
+                    const hashedUserAttribute = KitFilterHelper.hashUserAttribute(
+                        userAttribute
+                    );
                     if (!self.inArray(filterList, hashedUserAttribute)) {
                         filteredUserAttributes[userAttribute] =
                             userAttributes[userAttribute];
@@ -344,7 +347,9 @@ export default function Helpers(mpInstance) {
     };
 
     this.isFilteredUserAttribute = function(userAttributeKey, filterList) {
-        const hashedUserAttribute = self.generateHash(userAttributeKey);
+        const hashedUserAttribute = KitFilterHelper.hashUserAttribute(
+            userAttributeKey
+        );
         return filterList && self.inArray(filterList, hashedUserAttribute);
     };
 

package/src/kitFilterHelper.ts

@@ -0,0 +1,47 @@
+import { generateHash } from "./utils";
+// TODO: https://mparticle-eng.atlassian.net/browse/SQDSDKS-5381
+import { EventTypeEnum, IdentityType } from "./types.interfaces";
+import Constants from './constants';
+
+export default class KitFilterHelper {
+    static hashEventType(eventType: EventTypeEnum): number {
+        return generateHash(eventType as unknown as string);
+    };
+
+    static hashEventName(eventName: string, eventType: EventTypeEnum): number {
+        return generateHash(eventType + eventName);
+    };
+
+    static hashEventAttributeKey(eventType: EventTypeEnum, eventName: string, customAttributeName: string): number {
+        return generateHash(eventType + eventName + customAttributeName);
+    }
+    
+    static hashUserAttribute(userAttributeKey: string): number {
+        return generateHash(userAttributeKey);
+    }
+
+    // User Identities are not actually hashed, this method is named this way to
+    // be consistent with the filter class. UserIdentityType is also a number
+    static hashUserIdentity(userIdentity: IdentityType): IdentityType {
+        return userIdentity;
+    }
+
+    static hashConsentPurpose(prefix: string, purpose: string){
+        return generateHash(prefix + purpose)
+
+    }
+
+    // The methods below are for conditional forwarding, a type of filter
+    // hashAttributeCondiitonalForwarding is used for both User and Event
+    // attribute keys and attribute values
+    // The backend returns the hashes as strings for conditional forwarding
+    // but returns "regular" filters as arrays of numbers
+    // See IFilteringEventAttributeValue in configApiClient.ts as an example
+    static hashAttributeConditionalForwarding(attribute: string): string {
+        return generateHash(attribute).toString();
+    }
+
+    static hashConsentPurposeConditionalForwarding(prefix: string, purpose: string): string {
+        return this.hashConsentPurpose(prefix, purpose).toString();
+    }
+}

package/src/mockBatchCreator.ts

@@ -5,6 +5,7 @@ import { SDKEvent, BaseEvent, MParticleWebSDK } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import * as EventsApi from '@mparticle/event-models';
 import { Batch } from '@mparticle/event-models';
+import { IMPSideloadedKit} from './sideloadedKit';
 
 const mockFunction = function() {
     return null;
@@ -31,6 +32,7 @@ export default class _BatchValidator {
             },
             _resetForTests: mockFunction,
             _APIClient: null,
+            MPSideloadedKit: null,
             _Consent: null,
             _Forwarders: null,
             _NativeSdkHelpers: null,
@@ -109,6 +111,7 @@ export default class _BatchValidator {
             getAppVersion: mockFunction,
             getAppName: mockFunction,
             getInstance: mockFunction,
+            getDeviceId: mockFunction,
             init: mockFunction,
             logBaseEvent: mockFunction,
             logEvent: mockFunction,

package/src/mparticle-instance-manager.js

@@ -3,6 +3,7 @@ import Types from './types';
 import Constants from './constants';
 import mParticleInstance from './mp-instance.js';
 import _BatchValidator from './mockBatchCreator';
+import MPSideloadedKit from './sideloadedKit';
 
 if (!Array.prototype.forEach) {
     Array.prototype.forEach = Polyfill.forEach;
@@ -30,6 +31,8 @@ function mParticle() {
     this.CommerceEventType = Types.CommerceEventType;
     this.PromotionType = Types.PromotionActionType;
     this.ProductActionType = Types.ProductActionType;
+    this.MPSideloadedKit = MPSideloadedKit;
+
     if (typeof window !== 'undefined') {
         this.isIOS =
             window.mParticle && window.mParticle.isIOS

package/src/persistence.js

@@ -194,10 +194,18 @@ export default function _Persistence(mpInstance) {
                     obj.gs.cgid ||
                     mpInstance._Store.clientId ||
                     mpInstance._Helpers.generateUniqueId();
+
+                // For most persistence values, we prioritize localstorage/cookie values over
+                // Store. However, we allow device ID to be overriden via a config value and
+                // thus the priority of the deviceId value is
+                // 1. value passed via config.deviceId
+                // 2. previous value in persistence
+                // 3. generate new guid
                 mpInstance._Store.deviceId =
-                    obj.gs.das ||
                     mpInstance._Store.deviceId ||
+                    obj.gs.das ||
                     mpInstance._Helpers.generateUniqueId();
+
                 mpInstance._Store.integrationAttributes = obj.gs.ia || {};
                 mpInstance._Store.context =
                     obj.gs.c || mpInstance._Store.context;

package/src/sdkRuntimeModels.ts

@@ -8,7 +8,7 @@ import { IServerModel } from './serverModel';
 import { IKitConfigs } from './configAPIClient';
 import { SDKConsentApi, SDKConsentState } from './consent';
 import { IPersistence } from './persistence.interfaces';
-
+import { IMPSideloadedKit } from './sideloadedKit';
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
 
@@ -130,6 +130,7 @@ export interface MParticleWebSDK {
     addForwarder(mockForwarder: MPForwarder): void;
     Identity: SDKIdentityApi;
     Logger: SDKLoggerApi;
+    MPSideloadedKit: IMPSideloadedKit;
     _APIClient: any; // TODO: Set up API Client
     _Store: IStore;
     _Forwarders: any;
@@ -150,6 +151,7 @@ export interface MParticleWebSDK {
     init(apiKey: string, config: SDKInitConfig, instanceName?: string): void;
     getAppName(): string;
     getAppVersion(): string;
+    getDeviceId(): string;
     getInstance(): MParticleWebSDK; // TODO: Create a new type for MParticleWebSDKInstance
     ServerModel();
     upload();

package/src/sdkToEventsApiConverter.ts

@@ -66,11 +66,16 @@ export function convertEvents(
         events: uploadEvents,
         mp_deviceid: lastEvent.DeviceId,
         sdk_version: lastEvent.SDKVersion,
+
+        // TODO: Refactor this to read from _Store or a global config
         application_info: {
             application_version: lastEvent.AppVersion,
             application_name: lastEvent.AppName,
             package: lastEvent.Package,
+            is_using_sideloaded_kits:
+                mpInstance._Store.isUsingSideloadedKits || undefined,
         },
+
         device_info: {
             platform: EventsApi.DeviceInformationPlatformEnum.web,
             screen_width: window.screen.width,

package/src/sideloadedKit.ts

@@ -0,0 +1,124 @@
+import KitFilterHelper from './kitFilterHelper';
+import {
+    IFilteringConsentRuleValues,
+    IFilteringEventAttributeValue,
+    IFilteringUserAttributeValue,
+    IKitFilterSettings,
+} from './configAPIClient';
+import { UnregisteredKit } from './forwarders.interfaces';
+import { EventTypeEnum, IdentityType } from './types.interfaces';
+
+export interface IMPSideloadedKit {
+    kitInstance: UnregisteredKit;
+    filterDictionary: IKitFilterSettings;
+
+    addEventTypeFilter(eventType: EventTypeEnum): void;
+    addEventNameFilter(eventType: EventTypeEnum, eventName: string): void;
+    addEventAttributeFilter(
+        eventType: EventTypeEnum,
+        eventName: string,
+        customAttributeKey: string
+    ): void;
+    addScreenNameFilter(screenName: string): void;
+    addScreenAttributeFilter(screenName: string, screenAttribute: string): void;
+    addUserIdentityFilter(userIdentity: IdentityType): void;
+    addUserAttributeFilter(userAttributeKey: string): void;
+}
+
+// This constructor is necessary to be able ot call new on mParticle.SideloadedKit
+// https://stackoverflow.com/questions/13407036/how-does-interfaces-with-construct-signatures-work
+export interface IMPSideloadedKitConstructor {
+    new(unregisteredKitInstance: UnregisteredKit): IMPSideloadedKit;
+}
+
+export default class MPSideloadedKit implements IMPSideloadedKit{
+    public kitInstance: UnregisteredKit;
+    public filterDictionary: IKitFilterSettings = {
+        eventTypeFilters: [],
+        eventNameFilters: [],
+        screenNameFilters: [],
+        screenAttributeFilters: [],
+        userIdentityFilters: [],
+        userAttributeFilters: [],
+        attributeFilters: [],
+        consentRegulationFilters: [],
+        consentRegulationPurposeFilters: [],
+        messageTypeFilters: [],
+        messageTypeStateFilters: [],
+
+        // The below filtering members are optional, but we instantiate them
+        // to simplify public method assignment
+        filteringEventAttributeValue: {} as IFilteringEventAttributeValue,
+        filteringUserAttributeValue: {} as IFilteringUserAttributeValue,
+        filteringConsentRuleValues: {} as IFilteringConsentRuleValues,
+    };
+
+    constructor(unregisteredKitInstance: UnregisteredKit) {
+        this.kitInstance = unregisteredKitInstance;
+    }
+
+    public addEventTypeFilter(eventType: EventTypeEnum): void {
+        const hashedEventType = KitFilterHelper.hashEventType(eventType);
+        this.filterDictionary.eventTypeFilters.push(hashedEventType);
+    }
+
+    public addEventNameFilter(
+        eventType: EventTypeEnum,
+        eventName: string
+    ): void {
+        const hashedEventName = KitFilterHelper.hashEventName(
+            eventName,
+            eventType
+        );
+        this.filterDictionary.eventNameFilters.push(hashedEventName);
+    }
+
+    public addEventAttributeFilter(
+        eventType: EventTypeEnum,
+        eventName: string,
+        customAttributeKey: string
+    ): void {
+        const hashedEventAttribute = KitFilterHelper.hashEventAttributeKey(
+            eventType,
+            eventName,
+            customAttributeKey
+        );
+        this.filterDictionary.attributeFilters.push(hashedEventAttribute);
+    }
+
+    public addScreenNameFilter(screenName: string): void {
+        const hashedScreenName = KitFilterHelper.hashEventName(
+            screenName,
+            EventTypeEnum.Unknown
+        );
+        this.filterDictionary.screenNameFilters.push(hashedScreenName);
+    }
+
+    public addScreenAttributeFilter(
+        screenName: string,
+        screenAttribute: string
+    ): void {
+        const hashedScreenAttribute = KitFilterHelper.hashEventAttributeKey(
+            EventTypeEnum.Unknown,
+            screenName,
+            screenAttribute
+        );
+        this.filterDictionary.screenAttributeFilters.push(
+            hashedScreenAttribute
+        );
+    }
+
+    public addUserIdentityFilter(userIdentity: IdentityType): void {
+        const hashedIdentityType = KitFilterHelper.hashUserIdentity(
+            userIdentity
+        );
+        this.filterDictionary.userIdentityFilters.push(hashedIdentityType);
+    }
+
+    public addUserAttributeFilter(userAttributeKey: string): void {
+        const hashedUserAttributeKey = KitFilterHelper.hashUserAttribute(
+            userAttributeKey
+        );
+        this.filterDictionary.userAttributeFilters.push(hashedUserAttributeKey);
+    }
+}

package/src/store.ts

@@ -139,6 +139,7 @@ export interface IStore {
     nonCurrentUserMPIDs: Record<MPID, Dictionary>;
     identifyCalled: boolean;
     isLoggedIn: boolean;
+    isUsingSideloadedKits?: boolean;
     cookieSyncDates: Dictionary<number>;
     integrationAttributes: IntegrationAttributes;
     requireDelay: boolean;

package/src/types.interfaces.ts

@@ -0,0 +1,52 @@
+export enum EventTypeEnum {
+    Unknown,
+    Navigation,
+    Location,
+    Search,
+    Transaction,
+    UserContent,
+    UserPreference,
+    Social,
+    Other,
+    Media,
+}
+
+// TODO: https://mparticle-eng.atlassian.net/browse/SQDSDKS-5403
+export enum MessageType {
+    SessionStart = 1,
+    SessionEnd = 2,
+    PageView = 3,
+    PageEvent = 4,
+    CrashReport = 5,
+    OptOut = 6,
+    AppStateTransition = 10,
+    Profile = 14,
+    Commerce = 16,
+    UserAttributeChange = 17,
+    UserIdentityChange = 18,
+    Media = 20,
+};
+
+export enum IdentityType {
+    Other = 0,
+    CustomerId = 1,
+    Facebook = 2,
+    Twitter = 3,
+    Google = 4,
+    Microsoft = 5,
+    Yahoo = 6,
+    Email = 7,
+    FacebookCustomAudienceId = 9,
+    Other2 = 10,
+    Other3 = 11,
+    Other4 = 12,
+    Other5 = 13,
+    Other6 = 14,
+    Other7 = 15,
+    Other8 = 16,
+    Other9 = 17,
+    Other10 = 18,
+    MobileNumber = 19,
+    PhoneNumber2 = 20,
+    PhoneNumber3 = 21,
+}