@mparticle/web-sdk 2.60.1 → 2.62.0

package/dist/types/src/stub/mparticle.stub.d.ts

@@ -0,0 +1,182 @@
+export default mParticle;
+declare namespace mParticle {
+    export { voidFunction as endSession };
+    export { returnString as getAppName };
+    export { returnString as getAppVersion };
+    export { returnString as getDeviceId };
+    export { returnString as getEnvironment };
+    export { returnString as getVersion };
+    export { voidFunction as init };
+    export { voidFunction as logError };
+    export { voidFunction as logEvent };
+    export { voidFunction as logForm };
+    export { voidFunction as logLink };
+    export { voidFunction as logPageView };
+    export { voidFunction as ready };
+    export { voidFunction as reset };
+    export { voidFunction as _resetForTests };
+    export { voidFunction as setAppName };
+    export { voidFunction as setAppVersion };
+    export { voidFunction as setLogLevel };
+    export { voidFunction as setOptOut };
+    export { voidFunction as setPosition };
+    export { voidFunction as setSessionAttribute };
+    export { voidFunction as startNewSession };
+    export { voidFunction as startTrackingLocation };
+    export { voidFunction as stopTrackingLocation };
+    export let CommerceEventType: {};
+    export let EventType: {};
+    export let IdentityType: {};
+    export let ProductActionType: {};
+    export let PromotionType: {};
+    export namespace eCommerce {
+        export { returnImpression as createImpression };
+        export { returnProduct as createProduct };
+        export { returnPromotion as createPromotion };
+        export { returnTransactionAttributes as createTransactionAttributes };
+        export { voidFunction as logCheckout };
+        export { voidFunction as logImpression };
+        export { voidFunction as logProductAction };
+        export { voidFunction as logPromotion };
+        export { voidFunction as logPurchase };
+        export { voidFunction as logRefund };
+        export { voidFunction as setCurrencyCode };
+        export let Cart: any;
+    }
+    export namespace Consent {
+        export { createConsentState };
+        export { returnGDPRConsent as createGDPRConsent };
+    }
+    export namespace Identity {
+        export { voidFunction as aliasUsers };
+        export { createAliasRequest };
+        export { returnUser as getCurrentUser };
+        export { returnUser as getUser };
+        export { returnUsers as getUsers };
+        export { voidFunction as identify };
+        export { voidFunction as login };
+        export { voidFunction as logout };
+        export { voidFunction as modify };
+    }
+}
+declare function voidFunction(): void;
+declare function returnString(): string;
+declare function returnImpression(): {
+    Name: string;
+    Product: {
+        Name: string;
+        Sku: string;
+        Price: number;
+        Quantity: number;
+        Brand: string;
+        Variant: string;
+        Category: string;
+        Position: string;
+        CouponCode: string;
+        TotalAmount: number;
+        Attributes: {};
+    };
+};
+declare function returnProduct(): {
+    Name: string;
+    Sku: string;
+    Price: number;
+    Quantity: number;
+    Brand: string;
+    Variant: string;
+    Category: string;
+    Position: string;
+    CouponCode: string;
+    TotalAmount: number;
+    Attributes: {};
+};
+declare function returnPromotion(): {
+    Id: string;
+    Creative: string;
+    Name: string;
+    Position: number;
+};
+declare function returnTransactionAttributes(): {
+    Id: string;
+    Affiliation: string;
+    CouponCode: string;
+    Revenue: number;
+    Shipping: string;
+    Tax: number;
+};
+declare function createConsentState(): {
+    addGDPRConsentState: typeof returnThis;
+    setGDPRConsentState: typeof returnThis;
+    getGDPRConsentState: typeof returnGDPRConsent;
+    removeGDPRConsentState: typeof returnThis;
+};
+declare function returnGDPRConsent(): {
+    ConsentDocument: string;
+    Consented: boolean;
+    HardwareId: string;
+    Location: string;
+    Timestamp: number;
+};
+declare function createAliasRequest(): {
+    sourceMpid: string;
+    destinationMpid: string;
+    startTime: number;
+    endTime: number;
+    scope: string;
+};
+declare function returnUser(): {
+    getUserIdentities: () => {
+        userIdentities: {};
+    };
+    getMPID: typeof returnString;
+    setUserTag: typeof voidFunction;
+    removeUserTag: typeof voidFunction;
+    setUserAttribute: typeof voidFunction;
+    setUserAttributes: typeof voidFunction;
+    removeUserAttribute: typeof voidFunction;
+    setUserAttributeList: typeof voidFunction;
+    removeAllUserAttributes: typeof voidFunction;
+    getUserAttributesLists: typeof returnObject;
+    getAllUserAttributes: typeof returnObject;
+    getCart: typeof Cart;
+    getConsentState: typeof createConsentState;
+    setConsentState: typeof voidFunction;
+};
+declare function returnUsers(): {
+    getUserIdentities: () => {
+        userIdentities: {};
+    };
+    getMPID: typeof returnString;
+    setUserTag: typeof voidFunction;
+    removeUserTag: typeof voidFunction;
+    setUserAttribute: typeof voidFunction;
+    setUserAttributes: typeof voidFunction;
+    removeUserAttribute: typeof voidFunction;
+    setUserAttributeList: typeof voidFunction;
+    removeAllUserAttributes: typeof voidFunction;
+    getUserAttributesLists: typeof returnObject;
+    getAllUserAttributes: typeof returnObject;
+    getCart: typeof Cart;
+    getConsentState: typeof createConsentState;
+    setConsentState: typeof voidFunction;
+}[];
+declare function returnThis(): any;
+declare function returnObject(): {};
+declare function Cart_1(): {
+    add: typeof voidFunction;
+    clear: typeof voidFunction;
+    remove: typeof voidFunction;
+    getCartProducts: () => {
+        Name: string;
+        Sku: string;
+        Price: number;
+        Quantity: number;
+        Brand: string;
+        Variant: string;
+        Category: string;
+        Position: string;
+        CouponCode: string;
+        TotalAmount: number;
+        Attributes: {};
+    }[];
+};

package/dist/types/src/types.d.ts

@@ -0,0 +1,154 @@
+export declare const MessageType: {
+    SessionStart: 1;
+    SessionEnd: 2;
+    PageView: 3;
+    PageEvent: 4;
+    CrashReport: 5;
+    OptOut: 6;
+    AppStateTransition: 10;
+    Profile: 14;
+    Commerce: 16;
+    Media: 20;
+    UserAttributeChange: 17;
+    UserIdentityChange: 18;
+};
+export declare const EventType: {
+    Unknown: 0;
+    Navigation: 1;
+    Location: 2;
+    Search: 3;
+    Transaction: 4;
+    UserContent: 5;
+    UserPreference: 6;
+    Social: 7;
+    Other: 8;
+    Media: 9;
+    getName(id: number): string;
+};
+export declare const CommerceEventType: {
+    ProductAddToCart: 10;
+    ProductRemoveFromCart: 11;
+    ProductCheckout: 12;
+    ProductCheckoutOption: 13;
+    ProductClick: 14;
+    ProductViewDetail: 15;
+    ProductPurchase: 16;
+    ProductRefund: 17;
+    PromotionView: 18;
+    PromotionClick: 19;
+    ProductAddToWishlist: 20;
+    ProductRemoveFromWishlist: 21;
+    ProductImpression: 22;
+};
+export declare const IdentityType: any;
+export declare const ProductActionType: {
+    Unknown: 0;
+    AddToCart: 1;
+    RemoveFromCart: 2;
+    Checkout: 3;
+    CheckoutOption: 4;
+    Click: 5;
+    ViewDetail: 6;
+    Purchase: 7;
+    Refund: 8;
+    AddToWishlist: 9;
+    RemoveFromWishlist: 10;
+    getName: (id: number) => string;
+    getExpansionName: (id: number) => "add_to_cart" | "remove_from_cart" | "checkout" | "checkout_option" | "click" | "view_detail" | "purchase" | "refund" | "add_to_wishlist" | "remove_from_wishlist" | "unknown";
+};
+export declare const PromotionActionType: {
+    Unknown: 0;
+    PromotionView: 1;
+    PromotionClick: 2;
+    getName: (id: number) => string;
+    getExpansionName: (id: number) => string;
+};
+export declare const ProfileMessageType: {
+    Logout: 3;
+};
+export declare const ApplicationTransitionType: {
+    AppInit: 1;
+};
+export declare const PerformanceMarkType: {
+    SdkStart: "mp:sdkStart";
+    JointSdkSelectPlacements: "mp:jointSdkSelectPlacements";
+    JointSdkRoktKitInit: "mp:jointSdkRoktKitInit";
+};
+declare const _default: {
+    readonly MessageType: {
+        SessionStart: 1;
+        SessionEnd: 2;
+        PageView: 3;
+        PageEvent: 4;
+        CrashReport: 5;
+        OptOut: 6;
+        AppStateTransition: 10;
+        Profile: 14;
+        Commerce: 16;
+        Media: 20;
+        UserAttributeChange: 17;
+        UserIdentityChange: 18;
+    };
+    readonly EventType: {
+        Unknown: 0;
+        Navigation: 1;
+        Location: 2;
+        Search: 3;
+        Transaction: 4;
+        UserContent: 5;
+        UserPreference: 6;
+        Social: 7;
+        Other: 8;
+        Media: 9;
+        getName(id: number): string;
+    };
+    readonly CommerceEventType: {
+        ProductAddToCart: 10;
+        ProductRemoveFromCart: 11;
+        ProductCheckout: 12;
+        ProductCheckoutOption: 13;
+        ProductClick: 14;
+        ProductViewDetail: 15;
+        ProductPurchase: 16;
+        ProductRefund: 17;
+        PromotionView: 18;
+        PromotionClick: 19;
+        ProductAddToWishlist: 20;
+        ProductRemoveFromWishlist: 21;
+        ProductImpression: 22;
+    };
+    readonly IdentityType: any;
+    readonly ProfileMessageType: {
+        Logout: 3;
+    };
+    readonly ApplicationTransitionType: {
+        AppInit: 1;
+    };
+    readonly ProductActionType: {
+        Unknown: 0;
+        AddToCart: 1;
+        RemoveFromCart: 2;
+        Checkout: 3;
+        CheckoutOption: 4;
+        Click: 5;
+        ViewDetail: 6;
+        Purchase: 7;
+        Refund: 8;
+        AddToWishlist: 9;
+        RemoveFromWishlist: 10;
+        getName: (id: number) => string;
+        getExpansionName: (id: number) => "add_to_cart" | "remove_from_cart" | "checkout" | "checkout_option" | "click" | "view_detail" | "purchase" | "refund" | "add_to_wishlist" | "remove_from_wishlist" | "unknown";
+    };
+    readonly PromotionActionType: {
+        Unknown: 0;
+        PromotionView: 1;
+        PromotionClick: 2;
+        getName: (id: number) => string;
+        getExpansionName: (id: number) => string;
+    };
+    readonly Environment: {
+        readonly Development: "development";
+        readonly Production: "production";
+    };
+};
+export default _default;

package/dist/types/src/uploaders.d.ts

@@ -0,0 +1,21 @@
+export interface IFetchPayload {
+    method: string;
+    headers: {
+        Accept: string;
+        'Content-Type'?: string;
+        'rokt-account-id'?: string;
+    };
+    body?: string;
+}
+export declare abstract class AsyncUploader {
+    url: string;
+    abstract upload(fetchPayload: IFetchPayload, url?: string): Promise<Response>;
+    constructor(url: string);
+}
+export declare class FetchUploader extends AsyncUploader {
+    upload(fetchPayload: IFetchPayload, _url?: string): Promise<Response>;
+}
+export declare class XHRUploader extends AsyncUploader {
+    upload(fetchPayload: IFetchPayload): Promise<Response>;
+    private makeRequest;
+}

package/dist/types/src/user-utils.d.ts

@@ -0,0 +1,5 @@
+import { IMParticleUser, IdentityResultBody } from './identity-user-interfaces';
+import { SDKEvent } from './sdkRuntimeModels';
+export declare function hasMPIDAndUserLoginChanged(previousUser: IMParticleUser, newUser: IMParticleUser): boolean;
+export declare function hasMPIDChanged(prevUser: IMParticleUser, identityApiResult: IdentityResultBody): boolean;
+export declare function appendUserInfo(user: IMParticleUser, event: SDKEvent): void;

package/dist/types/src/utils.d.ts

@@ -0,0 +1,82 @@
+import { MPID } from '@mparticle/web-sdk';
+import Constants from './constants';
+import { SDKInitConfig } from './sdkRuntimeModels';
+import { IKitConfigs } from './configAPIClient';
+type valueof<T> = T[keyof T];
+type AttributeValue = string | number | boolean | null | undefined;
+export type Dictionary<V = any> = Record<string, V>;
+export type Environment = valueof<typeof Constants.Environment>;
+declare const createCookieString: (value: string) => string;
+declare const revertCookieString: (value: string) => string;
+declare const inArray: (items: any[], name: any) => boolean;
+declare const findKeyInObject: (obj: any, key: string) => string;
+declare const generateDeprecationMessage: (methodName: string, isDeprecated?: boolean, alternateMethod?: string, docsUrl?: string) => string;
+declare function generateHash(name: string): number;
+declare const generateUniqueId: (a?: string) => string;
+/**
+ * Returns a value between 1-100 inclusive.
+ */
+declare const getRampNumber: (value?: string) => number;
+declare const isObject: (value: any) => boolean;
+declare const parseNumber: (value: string | number) => number;
+declare const parseSettingsString: (settingsString: string) => Dictionary<string>[];
+declare const parseStringOrNumber: (value: string | number) => string | number | null;
+declare const replaceCommasWithPipes: (value: string) => string;
+declare const replacePipesWithCommas: (value: string) => string;
+declare const replaceApostrophesWithQuotes: (value: string) => string;
+declare const replaceQuotesWithApostrophes: (value: string) => string;
+declare const replaceMPID: (value: string, mpid: MPID) => string;
+declare const replaceAmpWithAmpersand: (value: string) => string;
+declare const createCookieSyncUrl: (mpid: MPID, pixelUrl: string, redirectUrl?: string, domain?: string) => string;
+declare const returnConvertedBoolean: (data: string | boolean | number) => boolean;
+declare const decoded: (s: string) => string;
+declare const converted: (s: string) => string;
+declare const isString: (value: any) => boolean;
+declare const isNumber: (value: any) => boolean;
+declare const isFunction: (fn: any) => boolean;
+declare const isValidAttributeValue: (value: any) => boolean;
+declare const isValidCustomFlagProperty: (value: any) => boolean;
+declare const toDataPlanSlug: (value: any) => string;
+declare const isDataPlanSlug: (str: string) => boolean;
+declare const isStringOrNumber: (value: any) => boolean;
+declare const isEmpty: (value: Dictionary<any> | string | null | undefined) => boolean;
+declare const mergeObjects: <T extends object>(...objects: T[]) => T;
+declare const moveElementToEnd: <T>(array: T[], index: number) => T[];
+declare const queryStringParser: (url: string, keys?: string[]) => Dictionary<string>;
+declare const getCookies: (keys?: string[]) => Dictionary<string>;
+declare const getHref: () => string;
+declare const filterDictionaryWithHash: <T>(dictionary: Dictionary<T>, filterList: any[], hashFn: (key: string) => any) => Dictionary<T>;
+declare const parseConfig: (config: SDKInitConfig, moduleName: string, moduleId: number) => IKitConfigs | null;
+/**
+ * Obfuscates an object by replacing all primitive values with their type names,
+ * while preserving the structure of nested objects and arrays.
+ * This is useful for logging data structures without exposing PII.
+ *
+ * @param value - The value to obfuscate
+ * @returns The obfuscated value with types instead of actual values
+ *
+ * @example
+ * obfuscateData({ email: 'user@email.com', age: 30 })
+ * // Returns: { email: 'string', age: 'number' }
+ *
+ * obfuscateData({ tags: ['premium', 'verified'] })
+ * // Returns: { tags: ['string', 'string'] }
+ */
+declare const obfuscateData: (value: any) => any;
+/**
+ * For verbose logging: returns raw data when isDevelopmentMode is true, else obfuscated data.
+ * Used when logging payloads so PII is not exposed in production.
+ *
+ * @param data - The value to log
+ * @param isDevelopmentMode - When true, returns data unchanged, when false or undefined, returns obfuscated data
+ * @returns Raw data when isDevelopmentMode is true, otherwise obfuscated structure
+ *
+ * @example
+ * obfuscateDevData({ email: 'user@email.com' }, true)
+ * // Returns: { email: 'user@email.com' }
+ *
+ * obfuscateDevData({ email: 'user@email.com' }, false)
+ * // Returns: { email: 'string' }
+ */
+declare const obfuscateDevData: (data: any, isDevelopmentMode?: boolean) => any;
+export { createCookieString, revertCookieString, createCookieSyncUrl, valueof, AttributeValue, converted, decoded, obfuscateDevData, filterDictionaryWithHash, findKeyInObject, generateDeprecationMessage, generateHash, generateUniqueId, getRampNumber, inArray, isObject, isStringOrNumber, obfuscateData, parseConfig, parseNumber, parseSettingsString, parseStringOrNumber, replaceCommasWithPipes, replacePipesWithCommas, replaceApostrophesWithQuotes, replaceQuotesWithApostrophes, returnConvertedBoolean, toDataPlanSlug, isString, isNumber, isFunction, isDataPlanSlug, isEmpty, isValidAttributeValue, isValidCustomFlagProperty, mergeObjects, moveElementToEnd, queryStringParser, getCookies, getHref, replaceMPID, replaceAmpWithAmpersand, };

package/dist/types/src/validators.d.ts

@@ -0,0 +1,18 @@
+import { valueof } from './utils';
+import Constants from './constants';
+import { IdentityApiData } from '@mparticle/web-sdk';
+import { IdentityAPIMethod } from './identity.interfaces';
+type ValidationIdentitiesReturn = {
+    valid: boolean;
+    error?: valueof<typeof Constants.Messages.ValidationMessages>;
+};
+declare const Validators: {
+    isNumber: (value: any) => boolean;
+    isFunction: (fn: any) => boolean;
+    isStringOrNumber: (value: any) => boolean;
+    isValidAttributeValue: (value: any) => boolean;
+    isValidKeyValue: (key: any) => boolean;
+    removeFalsyIdentityValues: (identityApiData: IdentityApiData, logger: any) => IdentityApiData;
+    validateIdentities: (identityApiData: IdentityApiData, method?: IdentityAPIMethod) => ValidationIdentitiesReturn;
+};
+export default Validators;

package/dist/types/src/vault.d.ts

@@ -0,0 +1,41 @@
+export declare abstract class BaseVault<StorableItem> {
+    contents: StorableItem;
+    protected readonly _storageKey: string;
+    protected storageObject: Storage;
+    /**
+     *
+     * @param {string} storageKey the local storage key string
+     * @param {Storage} storageObject Web API Storage object that is being used
+     */
+    constructor(storageKey: string, storageObject: Storage);
+    /**
+     * Stores a StorableItem to Storage
+     * @method store
+     * @param item {StorableItem}
+     */
+    store(item: StorableItem): void;
+    /**
+     * Retrieve StorableItem from Storage
+     * @method retrieve
+     * @returns {StorableItem}
+     */
+    retrieve(): StorableItem | null;
+    /**
+     * Removes all persisted data from Storage based on this vault's `key`
+     * Will remove storage key from Storage as well
+     * @method purge
+     */
+    purge(): void;
+}
+export declare class LocalStorageVault<StorableItem> extends BaseVault<StorableItem> {
+    constructor(storageKey: string);
+}
+export declare class SessionStorageVault<StorableItem> extends BaseVault<StorableItem> {
+    constructor(storageKey: string);
+}
+export declare class DisabledVault<StorableItem> extends BaseVault<StorableItem> {
+    constructor(storageKey: string);
+    store(_item: StorableItem): void;
+    retrieve(): StorableItem | null;
+    purge(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.60.1",
+    "version": "2.62.0",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -12,6 +12,7 @@
         "dist/mparticle.common.js",
         "dist/mparticle.esm.js",
         "dist/mparticle.js",
+        "dist/types/",
         "src/"
     ],
     "publishConfig": {
@@ -21,9 +22,18 @@
     },
     "main": "dist/mparticle.common.js",
     "module": "dist/mparticle.esm.js",
+    "types": "dist/types/src/public-types.d.ts",
+    "typesVersions": {
+        "*": {
+            "internal": [
+                "dist/types/src/internal-types.d.ts"
+            ]
+        }
+    },
     "repository": "https://github.com/mParticle/mparticle-web-sdk",
     "scripts": {
-        "build": "cross-env ENVIRONMENT=prod BUILDALL=true rollup --config rollup.config.js",
+        "build": "cross-env ENVIRONMENT=prod BUILDALL=true rollup --config rollup.config.js && npm run build:types",
+        "build:types": "rm -rf dist/types && (tsc -p tsconfig.types.json || true) && test -f dist/types/src/public-types.d.ts && test -f dist/types/src/internal-types.d.ts",
         "build:cbt": "rollup --config test/cross-browser-testing/rollup.CBT.config.js",
         "build:dev": "cross-env ENVIRONMENT=dev BUILD=iife rollup --config rollup.config.js",
         "build:iife": "cross-env ENVIRONMENT=prod BUILD=iife rollup --config rollup.config.js",
@@ -65,7 +75,7 @@
         "test:karma:rollup:cjs": "cross-env BUNDLER=rollup karma start test/integrations/cjs/karma.rollup.config.js",
         "test:karma:webpack:module": "cross-env BUNDLER=webpack karma start test/integrations/module/karma.webpack.config.js",
         "test:karma:rollup:module": "cross-env BUNDLER=rollup karma start test/integrations/module/karma.rollup.config.js",
-        "test:jest": "npm run build && jest --config jest.config.js",
+        "test:jest": "jest --config jest.config.js",
         "test:jest:watch": "jest --config jest.config.js --watch",
         "watch": "cross-env ENVIRONMENT=dev BUILD=iife rollup --config rollup.config.js -w",
         "watch:all": "cross-env ENVIRONMENT=prod BUILDALL=true rollup --config rollup.config.js -w",
@@ -148,6 +158,9 @@
         "webpack": "^5.36.2",
         "webpack-cli": "^5.0.2"
     },
+    "peerDependencies": {
+        "@mparticle/event-models": "^1.1.9"
+    },
     "dependencies": {
         "@babel/runtime": "^7.23.2"
     }

package/src/apiClient.ts

@@ -176,7 +176,7 @@ export default function APIClient(
         // https://go.mparticle.com/work/SQDSDKS-6935
         // While Event Name is 'usually' a string, there are some cases where it is a number
         // in that it could be a type of MessageType Enum
-        if (event.EventName as unknown as number !== Types.MessageType.AppStateTransition) {
+        if (event.EventName !== String(Types.MessageType.AppStateTransition)) {
             if (kitBlocker && kitBlocker.kitBlockingEnabled) {
                 event = kitBlocker.createBlockedEvent(event);
             }

package/src/constants.ts

@@ -139,8 +139,6 @@ const Constants = {
         identityUrl: 'identity.mparticle.com/v1/',
         aliasUrl: 'jssdks.mparticle.com/v1/identity/',
         userAudienceUrl: 'nativesdks.mparticle.com/v1/',
-        loggingUrl: 'apps.rokt-api.com/v1/log',
-        errorUrl: 'apps.rokt-api.com/v1/errors',
     },
     // These are the paths that are used to construct the CNAME urls
     CNAMEUrlPaths: {
@@ -150,8 +148,6 @@ const Constants = {
         configUrl: '/tags/JS/v2/',
         identityUrl: '/identity/v1/',
         aliasUrl: '/webevents/v1/identity/',
-        loggingUrl: '/v1/log',
-        errorUrl: '/v1/errors',
     },
     Base64CookieKeys: {
         csm: 1,

package/src/forwarders.interfaces.ts

@@ -2,6 +2,8 @@ import { SDKEvent, SDKEventCustomFlags } from './sdkRuntimeModels';
 import { Dictionary } from './utils';
 import { IKitConfigs, IKitFilterSettings } from './configAPIClient';
 import { IdentityApiData, IdentityType } from '@mparticle/web-sdk';
+import { Batch } from '@mparticle/event-models';
+
 import {
     IMParticleUser,
     ISDKUserIdentity,
@@ -89,6 +91,46 @@ export interface ConfiguredKit
     hasSandbox: boolean;
 }
 
+export interface KitInterface {
+    id: number;
+    name: string;
+    init(
+        settings: Dictionary<unknown>,
+        service: forwardingStatsCallback,
+        testMode?: boolean,
+        trackerId?: string | null,
+        userAttributes?: UserAttributes,
+        userIdentities?: ISDKUserIdentity,
+        appVersion?: string,
+        appName?: string,
+        customFlags?: SDKEventCustomFlags,
+        clientId?: string
+    ): string;
+    onIdentifyComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onLoginComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onLogoutComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onModifyComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onUserIdentified?(user: IMParticleUser): string;
+    process?(event: SDKEvent): string;
+    processBatch?(batch: Batch): string;
+    setOptOut?(isOptingOut: boolean): string;
+    removeUserAttribute?(key: string): string;
+    setUserAttribute?(key: string, value: string): string;
+    setUserIdentity?(id: UserIdentityId, type: UserIdentityType): void;
+}
+
 export type UserIdentityId = string;
 export type UserIdentityType = number;
 export type UserAttributeFilters = number[];

package/src/identityApiClient.ts

@@ -25,7 +25,7 @@ import {
     IIdentityResponse,
 } from './identity-user-interfaces';
 import { IMParticleWebSDKInstance } from './mp-instance';
-import { ErrorCodes } from './logging/types';
+import { ErrorCodes, WSDKErrorSeverity } from './reporting/types';
 
 const { HTTPCodes, Messages, IdentityMethods } = Constants;
 
@@ -201,7 +201,7 @@ export default function IdentityAPIClient(
         }
         
         const { invokeCallback } = mpInstance._Helpers;
-        const { Logger } = mpInstance;
+        const { Logger, _ErrorReportingDispatcher: errorReporter } = mpInstance;
         Logger.verbose(Messages.InformationMessages.SendIdentityBegin);
         if (!identityApiRequest) {
             Logger.error(Messages.ErrorMessages.APIRequestEmpty);
@@ -339,10 +339,13 @@ export default function IdentityAPIClient(
             }
 
             const errorMessage = (err as Error).message || err.toString();
-            Logger.error(
-                'Error sending identity request to servers' + ' - ' + errorMessage,
-                ErrorCodes.IDENTITY_REQUEST
-            );
+            const msg = 'Error sending identity request to servers' + ' - ' + errorMessage;
+            Logger.error(msg);
+            errorReporter?.report({
+                message: msg,
+                code: ErrorCodes.IDENTITY_REQUEST,
+                severity: WSDKErrorSeverity.ERROR,
+            });
 
             mpInstance.processQueueOnIdentityFailure?.();
             invokeCallback(callback, HTTPCodes.noHttpCoverage, errorMessage);