@mparticle/web-sdk 2.61.0 → 2.62.0

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

@@ -0,0 +1,52 @@
+export default function Ecommerce(mpInstance: any): void;
+export default class Ecommerce {
+    constructor(mpInstance: any);
+    convertTransactionAttributesToProductAction: (transactionAttributes: any, productAction: any) => void;
+    getProductActionEventName: (productActionType: any) => "AddToCart" | "AddToWishlist" | "Checkout" | "CheckoutOption" | "Click" | "Purchase" | "Refund" | "RemoveFromCart" | "RemoveFromWishlist" | "ViewDetail" | "Unknown";
+    getPromotionActionEventName: (promotionActionType: any) => "Unknown" | "PromotionClick" | "PromotionView";
+    convertProductActionToEventType: (productActionType: any) => 0 | 20 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 21;
+    convertPromotionActionToEventType: (promotionActionType: any) => 18 | 19;
+    generateExpandedEcommerceName: (eventName: any, plusOne: any) => string;
+    extractProductAttributes: (attributes: any, product: any) => void;
+    extractTransactionId: (attributes: any, productAction: any) => void;
+    extractActionAttributes: (attributes: any, productAction: any) => void;
+    extractPromotionAttributes: (attributes: any, promotion: any) => void;
+    buildProductList: (event: any, product: any) => any;
+    createProduct: (name: any, sku: any, price: any, quantity: any, variant: any, category: any, brand: any, position: any, couponCode: any, attributes: any) => {
+        Name: string;
+        Sku: any;
+        Price: any;
+        Quantity: any;
+        Brand: any;
+        Variant: any;
+        Category: any;
+        Position: any;
+        CouponCode: any;
+        TotalAmount: number;
+        Attributes: any;
+    };
+    createPromotion: (id: any, creative: any, name: any, position: any) => {
+        Id: any;
+        Creative: any;
+        Name: any;
+        Position: any;
+    };
+    createImpression: (name: any, product: any) => {
+        Name: string;
+        Product: any;
+    };
+    createTransactionAttributes: (id: any, affiliation: any, couponCode: any, revenue: any, shipping: any, tax: any) => {
+        Id: any;
+        Affiliation: any;
+        CouponCode: any;
+        Revenue: any;
+        Shipping: any;
+        Tax: any;
+    };
+    expandProductImpression: (commerceEvent: any) => any[];
+    expandCommerceEvent: (event: any) => any[];
+    expandPromotionAction: (commerceEvent: any) => any[];
+    expandProductAction: (commerceEvent: any) => any[];
+    createCommerceEventObject: (customFlags: any, options: any) => any;
+    sanitizeAmount: (amount: any, category: any) => any;
+}

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

@@ -0,0 +1,78 @@
+import { ProductAction, Product, Promotion, CommerceEvent } from '@mparticle/event-models';
+import { SDKEventAttrs, SDKEventOptions, TransactionAttributes } from '@mparticle/web-sdk';
+import { valueof } from './utils';
+import { ProductActionType, PromotionActionType, CommerceEventType, EventType } from './types';
+import { SDKEvent, SDKEventCustomFlags, SDKImpression, SDKProduct, SDKProductImpression, SDKPromotion } from './sdkRuntimeModels';
+interface IECommerceShared {
+    createProduct(name: string, sku: string | number, price: string | number, quantity?: string | number, variant?: string, category?: string, brand?: string, position?: number, couponCode?: string, attributes?: SDKEventAttrs): SDKProduct | null;
+    createImpression(name: string, product: Product): SDKImpression | null;
+    createPromotion(id: string | number, creative?: string, name?: string, position?: number): SDKPromotion | null;
+    createTransactionAttributes(id: string | number, affiliation?: string, couponCode?: string, revenue?: string | number, shipping?: string | number, tax?: number): TransactionAttributes | null;
+    expandCommerceEvent(event: CommerceEvent): SDKEvent[] | null;
+}
+export interface SDKCart {
+    add(product: SDKProduct | SDKProduct[], logEvent?: boolean): void;
+    remove(product: SDKProduct | SDKProduct[], logEvent?: boolean): void;
+    clear(): void;
+}
+export interface SDKECommerceAPI extends IECommerceShared {
+    logCheckout(step: number, option?: string, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags): void;
+    logImpression(impression: SDKProductImpression, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): void;
+    logProductAction(productActionType: valueof<typeof ProductActionType>, product: SDKProduct | SDKProduct[], attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, transactionAttributes?: TransactionAttributes, eventOptions?: SDKEventOptions): void;
+    logPromotion(type: valueof<typeof PromotionActionType>, promotion: SDKPromotion, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): void;
+    setCurrencyCode(code: string): void;
+    Cart: SDKCart;
+    logPurchase(transactionAttributes: TransactionAttributes, product: SDKProduct | SDKProduct[], clearCart?: boolean, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags): void;
+    logRefund(transactionAttributes: TransactionAttributes, product: SDKProduct | SDKProduct[], clearCart?: boolean, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags): void;
+}
+interface ExtractedActionAttributes {
+    Affiliation?: string;
+    'Coupon Code'?: string;
+    'Total Amount'?: number;
+    'Shipping Amount'?: number;
+    'Tax Amount'?: number;
+    'Checkout Option'?: string;
+    'Checkout Step'?: number;
+    'Transaction ID'?: string;
+}
+interface ExtractedProductAttributes {
+    'Coupon Code'?: string;
+    Brand?: string;
+    Category?: string;
+    Name?: string;
+    Id?: string;
+    'Item Price'?: number;
+    Quantity?: number;
+    Position?: number;
+    Variant?: string;
+    'Total Product Amount': number;
+}
+interface ExtractedPromotionAttributes {
+    Id?: string;
+    Creative?: string;
+    Name?: string;
+    Position?: number;
+}
+interface ExtractedTransactionId {
+    'Transaction ID'?: string;
+}
+export interface IECommerce extends IECommerceShared {
+    buildProductList(event: SDKEvent, product: Product | Product[]): Product[];
+    convertProductActionToEventType(productActionType: valueof<typeof ProductActionType>): // https://go.mparticle.com/work/SQDSDKS-4801
+    typeof CommerceEventType | typeof EventType | null;
+    convertPromotionActionToEventType(promotionActionType: valueof<typeof PromotionActionType>): typeof CommerceEventType | null;
+    convertTransactionAttributesToProductAction(transactionAttributes: TransactionAttributes, productAction: ProductAction): void;
+    createCommerceEventObject(customFlags: SDKEventCustomFlags, options?: SDKEventOptions): SDKEvent | null;
+    expandProductAction(commerceEvent: CommerceEvent): SDKEvent[];
+    expandProductImpression(commerceEvent: CommerceEvent): SDKEvent[];
+    expandPromotionAction(commerceEvent: CommerceEvent): SDKEvent[];
+    extractActionAttributes(attributes: ExtractedActionAttributes, productAction: ProductAction): void;
+    extractProductAttributes(attributes: ExtractedProductAttributes, product: Product): void;
+    extractPromotionAttributes(attributes: ExtractedPromotionAttributes, promotion: Promotion): void;
+    extractTransactionId(attributes: ExtractedTransactionId, productAction: ProductAction): void;
+    generateExpandedEcommerceName(eventName: string, plusOne: boolean): string;
+    getProductActionEventName(productActionType: valueof<typeof ProductActionType>): string;
+    getPromotionActionEventName(promotionActionType: valueof<typeof PromotionActionType>): string;
+    sanitizeAmount(amount: string | number, category: string): number;
+}
+export {};

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

@@ -0,0 +1,17 @@
+export default function Events(mpInstance: any): void;
+export default class Events {
+    constructor(mpInstance: any);
+    logEvent: (event: any, options: any) => void;
+    startTracking: (callback: any) => void;
+    stopTracking: () => void;
+    logOptOut: () => void;
+    logAST: () => void;
+    logCheckoutEvent: (step: any, option: any, attrs: any, customFlags: any) => void;
+    logProductActionEvent: (productActionType: any, product: any, customAttrs: any, customFlags: any, transactionAttributes: any, options: any) => void;
+    logPurchaseEvent: (transactionAttributes: any, product: any, attrs: any, customFlags: any) => void;
+    logRefundEvent: (transactionAttributes: any, product: any, attrs: any, customFlags: any) => void;
+    logPromotionEvent: (promotionType: any, promotion: any, attrs: any, customFlags: any, eventOptions: any) => void;
+    logImpressionEvent: (impression: any, attrs: any, customFlags: any, options: any) => void;
+    logCommerceEvent: (commerceEvent: any, attrs: any, options: any) => void;
+    addEventHandler: (domEvent: any, selector: any, eventName: any, data: any, eventType: any) => void;
+}

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

@@ -0,0 +1,21 @@
+import { Callback, SDKEventAttrs, SDKEventOptions, TransactionAttributes } from '@mparticle/web-sdk';
+import { BaseEvent, SDKEvent, SDKEventCustomFlags, SDKProduct, SDKProductImpression, SDKPromotion } from './sdkRuntimeModels';
+import { valueof } from './utils';
+import { EventType, ProductActionType, PromotionActionType } from './types';
+type EventHandlerFunction<T> = (element: HTMLLinkElement | HTMLFormElement) => T;
+export interface IEvents {
+    addEventHandler(domEvent: string, selector: string | Node, eventName: EventHandlerFunction<string> | string, data: EventHandlerFunction<SDKEventAttrs> | SDKEventAttrs, eventType: valueof<typeof EventType>): void;
+    logAST(): void;
+    logCheckoutEvent(step: number, option?: string, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags): void;
+    logCommerceEvent(commerceEvent: SDKEvent, attrs?: SDKEventAttrs, options?: SDKEventOptions): void;
+    logEvent(event: BaseEvent, eventOptions?: SDKEventOptions): void;
+    logImpressionEvent(impression: SDKProductImpression, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): any;
+    logOptOut(): void;
+    logProductActionEvent(productActionType: valueof<typeof ProductActionType>, product: SDKProduct | SDKProduct[], attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, transactionAttributes?: TransactionAttributes, eventOptions?: SDKEventOptions): void;
+    logPromotionEvent(promotionType: valueof<typeof PromotionActionType>, promotion: SDKPromotion, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): void;
+    logPurchaseEvent(transactionAttributes: TransactionAttributes, product: SDKProduct | SDKProduct[], attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags): void;
+    logRefundEvent(transactionAttributes: TransactionAttributes, product: SDKProduct | SDKProduct[], attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags): void;
+    startTracking(callback: Callback): void;
+    stopTracking(): void;
+}
+export {};

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

@@ -0,0 +1,8 @@
+export default function filteredMparticleUser(mpid: any, forwarder: any, mpInstance: any, kitBlocker: any): {
+    getUserIdentities: () => {
+        userIdentities: {};
+    };
+    getMPID: () => any;
+    getUserAttributesLists: (forwarder: any) => {};
+    getAllUserAttributes: () => {};
+};

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

@@ -0,0 +1,21 @@
+export default class ForegroundTimeTracker {
+    private noFunctional;
+    private isTrackerActive;
+    private localStorageName;
+    private timerVault;
+    startTime: number;
+    totalTime: number;
+    constructor(timerKey: string, noFunctional?: boolean);
+    private addHandlers;
+    private handleVisibilityChange;
+    private handleWindowBlur;
+    private handleWindowFocus;
+    private syncAcrossTabs;
+    updateTimeInPersistence(): void;
+    private loadTimeFromStorage;
+    private startTracking;
+    private stopTracking;
+    private setTotalTime;
+    getTimeInForeground(): number;
+    resetTimer(): void;
+}

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

@@ -0,0 +1,26 @@
+export default function Forwarders(mpInstance: any, kitBlocker: any): void;
+export default class Forwarders {
+    constructor(mpInstance: any, kitBlocker: any);
+    forwarderStatsUploader: any;
+    initForwarders: (userIdentities: any, forwardingStatsCallback: any) => void;
+    isEnabledForUserAttributes: (filterObject: any, user: any) => boolean;
+    isEnabledForUnknownUser: (excludeAnonymousUserBoolean: any, user: any) => boolean;
+    applyToForwarders: (functionName: any, functionArgs: any) => void;
+    sendEventToForwarders: (event: any) => void;
+    handleForwarderUserAttributes: (functionNameKey: any, key: any, value: any) => void;
+    setForwarderUserIdentities: (userIdentities: any) => void;
+    setForwarderOnUserIdentified: (user: any) => void;
+    setForwarderOnIdentityComplete: (user: any, identityMethod: any) => void;
+    getForwarderStatsQueue: () => any;
+    setForwarderStatsQueue: (queue: any) => void;
+    processForwarders: (config: any, forwardingStatsCallback: any) => void;
+    processUIEnabledKits: (config: any) => void;
+    returnKitConstructors: () => {};
+    configureUIEnabledKit: (configuration: any, kits: any) => void;
+    processSideloadedKits: (mpConfig: any) => void;
+    configureSideloadedKit: (kitConstructor: any) => void;
+    returnConfiguredKit: (forwarder: any, config?: {}) => any;
+    configurePixel: (settings: any) => void;
+    processPixelConfigs: (config: any) => void;
+    sendSingleForwardingStatsToServer: (forwardingStatsData: any) => Promise<void>;
+}

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

@@ -0,0 +1,59 @@
+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, UserAttributes } from './identity-user-interfaces';
+export type MPForwarder = Dictionary;
+export interface UnregisteredKit {
+    constructor: () => void;
+    register(config: KitRegistrationConfig): void;
+    name: string;
+    moduleId?: number;
+    suffix?: string;
+}
+export interface RegisteredKit {
+    constructor: () => void;
+    filters?: IKitFilterSettings;
+}
+export interface KitRegistrationConfig {
+    kits: Dictionary<RegisteredKit>;
+}
+export interface ConfiguredKit extends Omit<IKitConfigs, 'isDebugString' | 'hasDebugString'> {
+    common: Dictionary<unknown>;
+    id: number;
+    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;
+    setOptOut(isOptingOut: boolean): string;
+    removeUserAttribute(key: string): string;
+    setUserAttribute(key: string, value: string): string;
+    setUserIdentity(id: UserIdentityId, type: UserIdentityType): void;
+    isSandbox: boolean;
+    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[];
+export type UserIdentityFilters = typeof IdentityType[];
+export type forwardingStatsCallback = (forwarder: ConfiguredKit, event: SDKEvent) => void;

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

@@ -0,0 +1,5 @@
+export default function forwardingStatsUploader(mpInstance: any): void;
+export default class forwardingStatsUploader {
+    constructor(mpInstance: any);
+    startForwardingStatsTimer: () => void;
+}

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

@@ -0,0 +1,54 @@
+export default function Helpers(mpInstance: any): void;
+export default class Helpers {
+    constructor(mpInstance: any);
+    canLog: () => boolean;
+    getFeatureFlag: (feature: any) => any;
+    invokeCallback: (callback: any, code: any, body: any, mParticleUser: any, previousMpid: any) => void;
+    invokeAliasCallback: (callback: any, code: any, message: any) => void;
+    extend: (...args: any[]) => any;
+    createServiceUrl: (secureServiceUrl: any, devToken: any) => string;
+    createXHR: (cb: any) => any;
+    filterUserIdentities: (userIdentitiesObject: any, filterList: any) => {
+        Type: any;
+        Identity: any;
+    }[];
+    filterUserIdentitiesForForwarders: (userIdentities: utils.Dictionary<string>, filterList: number[]) => utils.Dictionary<string>;
+    filterUserAttributes: (userAttributes: utils.Dictionary<string>, filterList: number[]) => utils.Dictionary<string>;
+    isEventType: (type: any) => boolean;
+    sanitizeAttributes: (attrs: any, name: any) => {};
+    isDelayedByIntegration: (delayedIntegrations: any, timeoutStart: any, now: any) => boolean;
+    createMainStorageName: (workspaceToken: any) => string;
+    converted: (s: string) => string;
+    findKeyInObject: (obj: any, key: string) => string;
+    parseNumber: (value: string | number) => number;
+    inArray: (items: any[], name: any) => boolean;
+    isObject: (value: any) => boolean;
+    decoded: (s: string) => string;
+    parseStringOrNumber: (value: string | number) => string | number;
+    generateHash: typeof utils.generateHash;
+    generateUniqueId: (a?: string) => string;
+    Validators: {
+        isNumber: (value: any) => boolean;
+        isFunction: (fn: any) => boolean;
+        isStringOrNumber: (value: any) => boolean;
+        isValidAttributeValue: (value: any) => boolean;
+        isValidKeyValue: (key: any) => boolean;
+        removeFalsyIdentityValues: (identityApiData: import("@mparticle/web-sdk").IdentityApiData, logger: any) => import("@mparticle/web-sdk").IdentityApiData;
+        validateIdentities: (identityApiData: import("@mparticle/web-sdk").IdentityApiData, method?: import("./identity.interfaces").IdentityAPIMethod) => {
+            valid: boolean;
+            error?: utils.valueof<{
+                readonly ModifyIdentityRequestUserIdentitiesPresent: "identityRequests to modify require userIdentities to be present. Request not sent to server. Please fix and try again";
+                readonly IdentityRequesetInvalidKey: "There is an invalid key on your identityRequest object. It can only contain a `userIdentities` object and a `onUserAlias` function. Request not sent to server. Please fix and try again.";
+                readonly OnUserAliasType: "The onUserAlias value must be a function.";
+                readonly UserIdentities: "The userIdentities key must be an object with keys of identityTypes and values of strings. Request not sent to server. Please fix and try again.";
+                readonly UserIdentitiesInvalidKey: "There is an invalid identity key on your `userIdentities` object within the identityRequest. Request not sent to server. Please fix and try again.";
+                readonly UserIdentitiesInvalidValues: "All user identity values must be strings or null. Request not sent to server. Please fix and try again.";
+                readonly AliasMissingMpid: "Alias Request must contain both a destinationMpid and a sourceMpid";
+                readonly AliasNonUniqueMpid: "Alias Request's destinationMpid and sourceMpid must be unique";
+                readonly AliasMissingTime: "Alias Request must have both a startTime and an endTime";
+                readonly AliasStartBeforeEndTime: "Alias Request's endTime must be later than its startTime";
+            }>;
+        };
+    };
+}
+import * as utils from './utils';

package/dist/types/src/identity-user-interfaces.d.ts

@@ -0,0 +1,106 @@
+import { AllUserAttributes, MPID, User } from '@mparticle/web-sdk';
+import { SDKIdentityTypeEnum } from './identity.interfaces';
+import { MessageType } from './types';
+import { BaseEvent, SDKProduct } from './sdkRuntimeModels';
+declare const HTTPCodes: {
+    readonly noHttpCoverage: -1;
+    readonly activeIdentityRequest: -2;
+    readonly activeSession: -3;
+    readonly validationIssue: -4;
+    readonly nativeIdentityRequest: -5;
+    readonly loggingDisabledOrMissingAPIKey: -6;
+    readonly tooManyRequests: 429;
+};
+interface ICart {
+    /**
+     * @deprecated Cart persistence in mParticle has been deprecated. Please use mParticle.eCommerce.logProductAction(mParticle.ProductActionType.AddToCart, [products])
+     */
+    add: (product: SDKProduct, logEventBoolean?: boolean) => void;
+    /**
+     * @deprecated Cart persistence in mParticle has been deprecated. Please use mParticle.eCommerce.logProductAction(mParticle.ProductActionType.RemoveFromCart, [products])
+     */
+    remove: (product: SDKProduct, logEventBoolean?: boolean) => void;
+    /**
+     * @deprecated Cart persistence in mParticle has been deprecated.
+     */
+    clear: () => void;
+    /**
+     * @deprecated Cart Products have been deprecated
+     */
+    getCartProducts: () => SDKProduct[];
+}
+export interface IMParticleUser extends User {
+    getAllUserAttributes(): any;
+    setUserTag(tagName: string, value?: any): void;
+    setUserAttribute(key: string, value: any): void;
+    getUserAudiences?(callback?: IdentityCallback): void;
+    getCart(): ICart;
+}
+export interface ISDKUserIdentity {
+    Identity: string;
+    Type: number;
+}
+export interface ISDKUserIdentityChanges {
+    New: ISDKUserIdentityChangeData;
+    Old: ISDKUserIdentityChangeData;
+}
+export interface ISDKUserIdentityChangeData {
+    IdentityType: SDKIdentityTypeEnum;
+    Identity: string;
+    CreatedThisBatch: boolean;
+    Timestamp?: number;
+}
+export interface IUserIdentityChangeEvent extends BaseEvent {
+    messageType: typeof MessageType.UserIdentityChange;
+    userIdentityChanges: ISDKUserIdentityChanges;
+}
+export interface ISDKUserAttributes {
+    [key: string]: string | string[] | null;
+}
+export interface ISDKUserAttributeChangeData {
+    UserAttributeName: string;
+    New: string;
+    Old: string;
+    Deleted: boolean;
+    IsNewAttribute: boolean;
+}
+export interface IUserAttributeChangeEvent extends BaseEvent {
+    messageType: typeof MessageType.UserAttributeChange;
+    userAttributeChanges: ISDKUserAttributeChangeData;
+}
+export interface IdentityCallback {
+    (result: IdentityResult): void;
+}
+export interface IIdentityResponse {
+    responseText: IdentityResultBody;
+    status: number;
+    cacheMaxAge?: number;
+    expireTimestamp?: number;
+}
+export interface IdentityResult {
+    httpCode: typeof HTTPCodes;
+    getPreviousUser(): User;
+    getUser(): User;
+    body: IdentityResultBody | IdentityModifyResultBody;
+}
+export interface IdentityResultBody {
+    context: string | null;
+    is_ephemeral: boolean;
+    is_logged_in: boolean;
+    matched_identities: Record<string, unknown>;
+    mpid?: MPID;
+}
+export interface IdentityModifyResultBody {
+    change_results?: {
+        identity_type: SDKIdentityTypeEnum;
+        modified_mpid: MPID;
+    };
+}
+export interface mParticleUserCart {
+    add(): void;
+    remove(): void;
+    clear(): void;
+    getCartProducts(): SDKProduct[];
+}
+export type UserAttributes = AllUserAttributes;
+export {};

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

@@ -0,0 +1,36 @@
+import { Dictionary } from './utils';
+import { BaseVault } from './vault';
+import { IdentityApiData, UserIdentities, IdentityCallback } from '@mparticle/web-sdk';
+import { IdentityAPIMethod } from './identity.interfaces';
+import { IIdentityResponse, IMParticleUser } from './identity-user-interfaces';
+import { IStore } from './store';
+export declare const CACHE_HEADER: "x-mp-max-age";
+export type IdentityCache = BaseVault<Dictionary<ICachedIdentityCall>>;
+export type IParseCachedIdentityResponse = (cachedIdentity: IIdentityResponse, mpid: string, callback: IdentityCallback, identityApiData: IdentityApiData, identityMethod: string, knownIdentities: IKnownIdentities, fromCachedIdentity: boolean) => void;
+export interface IKnownIdentities extends UserIdentities {
+    device_application_stamp?: string;
+}
+export interface ICachedIdentityCall {
+    responseText: string;
+    status: number;
+    expireTimestamp: number;
+}
+export declare const cacheOrClearIdCache: (method: string, knownIdentities: IKnownIdentities, idCache: BaseVault<Dictionary<ICachedIdentityCall>>, identityResponse: IIdentityResponse, parsingCachedResponse: boolean) => void;
+export declare const cacheIdentityRequest: (method: IdentityAPIMethod, identities: IKnownIdentities, expireTimestamp: number, idCache: IdentityCache, identityResponse: IIdentityResponse) => void;
+export declare const concatenateIdentities: (method: IdentityAPIMethod, userIdentities: IKnownIdentities) => string;
+export declare const hasValidCachedIdentity: (method: IdentityAPIMethod, proposedUserIdentities: IKnownIdentities, idCache?: IdentityCache) => boolean;
+export declare const getCachedIdentity: (method: IdentityAPIMethod, proposedUserIdentities: IKnownIdentities, idCache: IdentityCache) => IIdentityResponse | null;
+export declare const createKnownIdentities: (identityApiData: IdentityApiData, deviceId: string) => IKnownIdentities;
+export declare const removeExpiredIdentityCacheDates: (idCache: BaseVault<Dictionary<ICachedIdentityCall>>) => void;
+export declare const tryCacheIdentity: (knownIdentities: IKnownIdentities, idCache: IdentityCache, parseIdentityResponse: IParseCachedIdentityResponse, mpid: string, callback: IdentityCallback, identityApiData: IdentityApiData, identityMethod: IdentityAPIMethod) => boolean;
+export declare const hasIdentityRequestChanged: (currentUser: IMParticleUser, newIdentityRequest: IdentityApiData) => boolean;
+/**
+ * Checks if deviceId or other user identifiers (like email) were explicitly provided
+ * by the partner via config.deviceId or config.identifyRequest.userIdentities.
+ * When noFunctional is true, then cookies are blocked, so the partner must explicitly
+ * pass deviceId or other identifiers to prevent new users from being created on each page load.
+ *
+ * @param store - The SDK store (provides SDKConfig.deviceId and SDKConfig.identifyRequest.userIdentities)
+ * @returns true if deviceId or other identifiers were explicitly provided in config, false otherwise
+ */
+export declare const hasExplicitIdentifier: (store: IStore | undefined | null) => boolean;

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

@@ -0,0 +1,117 @@
+import { IdentityApiData, MPID, UserIdentities } from '@mparticle/web-sdk';
+import AudienceManager from './audienceManager';
+import { ICachedIdentityCall, IKnownIdentities } from './identity-utils';
+import { BaseVault } from './vault';
+import { Dictionary, Environment, valueof } from './utils';
+import Constants from './constants';
+import { IdentityCallback, IUserAttributeChangeEvent, IUserIdentityChangeEvent, IMParticleUser, mParticleUserCart, IIdentityResponse } from './identity-user-interfaces';
+declare const platform: "web", sdkVendor: "mparticle", sdkVersion: string, HTTPCodes: {
+    readonly noHttpCoverage: -1;
+    readonly activeIdentityRequest: -2;
+    readonly activeSession: -3;
+    readonly validationIssue: -4;
+    readonly nativeIdentityRequest: -5;
+    readonly loggingDisabledOrMissingAPIKey: -6;
+    readonly tooManyRequests: 429;
+};
+export type IdentityPreProcessResult = {
+    valid: boolean;
+    error?: string;
+};
+export type IdentityAPIMethod = valueof<typeof Constants.IdentityMethods>;
+export declare enum SDKIdentityTypeEnum {
+    other = "other",
+    customerId = "customerid",
+    facebook = "facebook",
+    twitter = "twitter",
+    google = "google",
+    microsoft = "microsoft",
+    yahoo = "yahoo",
+    email = "email",
+    alias = "alias",
+    facebookCustomAudienceId = "facebookcustomaudienceid",
+    otherId2 = "other2",
+    otherId3 = "other3",
+    otherId4 = "other4",
+    otherId5 = "other5",
+    otherId6 = "other6",
+    otherId7 = "other7",
+    otherId8 = "other8",
+    otherId9 = "other9",
+    otherId10 = "other10",
+    mobileNumber = "mobile_number",
+    phoneNumber2 = "phone_number_2",
+    phoneNumber3 = "phone_number_3"
+}
+export interface IIdentityAPIRequestData {
+    client_sdk: {
+        platform: typeof platform;
+        sdk_vendor: typeof sdkVendor;
+        sdk_version: typeof sdkVersion;
+    };
+    context: string | null;
+    environment: Environment;
+    request_id: string;
+    request_timestamp_unixtime_ms: number;
+    previous_mpid: MPID | null;
+    known_identities: IKnownIdentities;
+}
+export interface IIdentityAPIModifyRequestData extends Omit<IIdentityAPIRequestData, 'known_identities' | 'previous_mpid'> {
+    identity_changes: IIdentityAPIIdentityChangeData[];
+}
+export interface IIdentityAPIIdentityChangeData {
+    identity_type: SDKIdentityTypeEnum;
+    old_value: string;
+    new_value: string;
+}
+export interface IIdentityRequest {
+    combineUserIdentities(previousUIByName: UserIdentities, newUIByName: UserIdentities): UserIdentities;
+    createIdentityRequest(identityApiData: IdentityApiData, platform: string, sdkVendor: string, sdkVersion: string, deviceId: string, context: string | null, mpid: MPID): IIdentityAPIRequestData;
+    createModifyIdentityRequest(currentUserIdentities: UserIdentities, newUserIdentities: UserIdentities, platform: string, sdkVendor: string, sdkVersion: string, context: string | null): IIdentityAPIModifyRequestData;
+    createIdentityChanges(previousIdentities: UserIdentities, newIdentitie: UserIdentities): IIdentityAPIIdentityChangeData;
+    preProcessIdentityRequest(identityApiData: IdentityApiData, callback: IdentityCallback, method: IdentityAPIMethod): IdentityPreProcessResult;
+}
+export type AliasRequestScope = 'device' | 'mpid';
+export interface IAliasRequest {
+    destinationMpid: MPID;
+    sourceMpid: MPID;
+    startTime: number;
+    endTime: number;
+    scope?: AliasRequestScope;
+}
+export interface IAliasCallback {
+    (result: IAliasResult): void;
+}
+export interface IAliasResult {
+    httpCode: number;
+    message: string;
+}
+export interface SDKIdentityApi {
+    HTTPCodes: typeof HTTPCodes;
+    identify?(identityApiData?: IdentityApiData, callback?: IdentityCallback): void;
+    login?(identityApiData?: IdentityApiData, callback?: IdentityCallback): void;
+    logout?(identityApiData?: IdentityApiData, callback?: IdentityCallback): void;
+    modify?(identityApiData?: IdentityApiData, callback?: IdentityCallback): void;
+    getCurrentUser?(): IMParticleUser;
+    getUser?(mpid: string): IMParticleUser;
+    getUsers?(): IMParticleUser[];
+    aliasUsers?(aliasRequest?: IAliasRequest, callback?: IdentityCallback): void;
+    createAliasRequest?(sourceUser: IMParticleUser, destinationUser: IMParticleUser, scope?: AliasRequestScope): IAliasRequest;
+}
+export interface IIdentity {
+    audienceManager: AudienceManager;
+    idCache: BaseVault<Dictionary<ICachedIdentityCall>>;
+    IdentityAPI: SDKIdentityApi;
+    IdentityRequest: IIdentityRequest;
+    mParticleUser(mpid: MPID, IsLoggedIn: boolean): IMParticleUser;
+    createUserAttributeChange(key: string, newValue: string, previousUserAttributeValue: string, isNewAttribute: boolean, deleted: boolean, user: IMParticleUser): IUserAttributeChangeEvent;
+    createUserIdentityChange(identityType: SDKIdentityTypeEnum, newIdentity: string, oldIdentity: string, newCreatedThisBatch: boolean, userInMemory: IMParticleUser): IUserIdentityChangeEvent;
+    parseIdentityResponse(identityResponse: IIdentityResponse, previousMPID: MPID, callback: IdentityCallback, identityApiData: IdentityApiData, method: IdentityAPIMethod, knownIdentities: UserIdentities, parsingCachedResponse: boolean): void;
+    sendUserAttributeChangeEvent(attributeKey: string, newUserAttributeValue: string, previousUserAttributeValue: string, isNewAttribute: boolean, deleted: boolean, user: IMParticleUser): void;
+    sendUserIdentityChangeEvent(newUserIdentities: UserIdentities, method: IdentityAPIMethod, mpid: MPID, prevUserIdentities: UserIdentities): void;
+    /**
+     * @deprecated
+     */
+    mParticleUserCart(): mParticleUserCart;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { IAliasCallback, IAliasRequest, IdentityAPIMethod, IIdentity, IIdentityAPIRequestData } from './identity.interfaces';
+import { IdentityApiData, MPID, UserIdentities } from '@mparticle/web-sdk';
+import { IdentityCallback, IdentityResultBody, IIdentityResponse } from './identity-user-interfaces';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export interface IIdentityApiClient {
+    sendAliasRequest: (aliasRequest: IAliasRequest, aliasCallback: IAliasCallback) => Promise<void>;
+    sendIdentityRequest: (identityApiRequest: IIdentityAPIRequestData, method: IdentityAPIMethod, callback: IdentityCallback, originalIdentityApiData: IdentityApiData, parseIdentityResponse: IIdentity['parseIdentityResponse'], mpid: MPID, knownIdentities: UserIdentities) => Promise<void>;
+    getUploadUrl: (method: IdentityAPIMethod, mpid: MPID) => string;
+    getIdentityResponseFromFetch: (response: Response, responseBody: IdentityResultBody) => IIdentityResponse;
+    getIdentityResponseFromXHR: (response: XMLHttpRequest) => IIdentityResponse;
+}
+export interface IAliasResponseBody {
+}
+export default function IdentityAPIClient(this: IIdentityApiClient, mpInstance: IMParticleWebSDKInstance): void;