@mparticle/web-sdk 2.61.0 → 2.62.0

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

@@ -0,0 +1,157 @@
+import { Batch, Context } from '@mparticle/event-models';
+import { MPID, IdentifyRequest, SDKEventCustomFlags, ConsentState, UserIdentities } from '@mparticle/web-sdk';
+import { IKitConfigs } from './configAPIClient';
+import { DataPlanResult, KitBlockerOptions, LogLevelType, SDKDataPlan, SDKEvent, SDKGeoLocation, SDKInitConfig, SDKProduct } from './sdkRuntimeModels';
+import { Dictionary, AttributeValue } from './utils';
+import { SDKConsentState } from './consent';
+import { ConfiguredKit, MPForwarder, UnregisteredKit } from './forwarders.interfaces';
+import { IdentityCallback, UserAttributes } from './identity-user-interfaces';
+import { IPersistenceMinified } from './persistence.interfaces';
+import { CookieSyncDates, IPixelConfiguration } from './cookieSyncManager';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export interface SDKConfig {
+    isDevelopmentMode?: boolean;
+    logger: {
+        error?(msg: any): any;
+        warning?(msg: any): any;
+        verbose?(msg: any): any;
+    };
+    onCreateBatch(batch: Batch): Batch;
+    customFlags?: SDKEventCustomFlags;
+    dataPlan: SDKDataPlan;
+    dataPlanOptions: KitBlockerOptions;
+    dataPlanResult?: DataPlanResult;
+    appName?: string;
+    appVersion?: string;
+    package?: string;
+    flags?: IFeatureFlags;
+    kitConfigs: IKitConfigs[];
+    kits: Dictionary<UnregisteredKit>;
+    logLevel?: LogLevelType;
+    cookieDomain?: string;
+    maxCookieSize?: number | undefined;
+    minWebviewBridgeVersion: 1 | 2 | undefined;
+    identifyRequest: IdentifyRequest;
+    identityCallback: IdentityCallback;
+    integrationDelayTimeout: number;
+    sideloadedKits: MPForwarder[];
+    aliasMaxWindow: number;
+    deviceId?: string;
+    forceHttps?: boolean;
+    aliasUrl?: string;
+    configUrl?: string;
+    identityUrl?: string;
+    userAudienceUrl?: string;
+    isIOS?: boolean;
+    maxAliasWindow: number;
+    maxProducts: number;
+    requestConfig?: boolean;
+    sessionTimeout?: number;
+    useNativeSdk?: boolean;
+    useCookieStorage?: boolean;
+    v1SecureServiceUrl?: string;
+    v2SecureServiceUrl?: string;
+    v3SecureServiceUrl?: string;
+    webviewBridgeName?: string;
+    workspaceToken?: string;
+    requiredWebviewBridgeName?: string;
+    isLoggingEnabled?: boolean;
+}
+export type ServerSettings = Dictionary;
+export type SessionAttributes = Dictionary;
+export type LocalSessionAttributes = Dictionary;
+export type IntegrationAttribute = Dictionary<string>;
+export type IntegrationAttributes = Dictionary<IntegrationAttribute>;
+export type WrapperSDKTypes = 'flutter' | 'none';
+export interface WrapperSDKInfo {
+    name: WrapperSDKTypes;
+    version: string | null;
+    isInfoSet: boolean;
+}
+export interface IFeatureFlags {
+    reportBatching?: boolean;
+    eventBatchingIntervalMillis?: number;
+    offlineStorage?: string;
+    directURLRouting?: boolean;
+    cacheIdentity?: boolean;
+    captureIntegrationSpecificIds?: boolean;
+    captureIntegrationSpecificIdsV2?: string;
+    astBackgroundEvents?: boolean;
+}
+export interface IStore {
+    isEnabled: boolean;
+    isInitialized: boolean;
+    sessionAttributes: SessionAttributes;
+    localSessionAttributes: LocalSessionAttributes;
+    currentSessionMPIDs: MPID[];
+    consentState: SDKConsentState | null;
+    sessionId: string | null;
+    isFirstRun: boolean;
+    clientId: string;
+    deviceId: string;
+    devToken: string | null;
+    serverSettings: ServerSettings;
+    dateLastEventSent: Date;
+    sessionStartDate: Date;
+    currentPosition: SDKGeoLocation | null;
+    isTracking: boolean;
+    watchPositionId: number | null;
+    cartProducts: SDKProduct[];
+    eventQueue: SDKEvent[];
+    currencyCode: string | null;
+    globalTimer: number | null;
+    context: Context | null;
+    configurationLoaded: boolean;
+    identityCallInFlight: boolean;
+    identityCallFailed: boolean;
+    identifyRequestCount: number;
+    SDKConfig: Partial<SDKConfig>;
+    nonCurrentUserMPIDs: Record<MPID, Dictionary>;
+    identifyCalled: boolean;
+    isLoggedIn: boolean;
+    sideloadedKitsCount?: number;
+    cookieSyncDates: CookieSyncDates;
+    integrationAttributes: IntegrationAttributes;
+    requireDelay: boolean;
+    isLocalStorageAvailable: boolean | null;
+    storageName: string | null;
+    activeForwarders: ConfiguredKit[];
+    kits: Dictionary<MPForwarder>;
+    sideloadedKits: MPForwarder[];
+    configuredForwarders: MPForwarder[];
+    pixelConfigurations: IPixelConfiguration[];
+    integrationDelayTimeoutStart: number;
+    webviewBridgeEnabled?: boolean;
+    wrapperSDKInfo: WrapperSDKInfo;
+    roktAccountId: string | null;
+    integrationName: string | null;
+    persistenceData?: IPersistenceMinified;
+    getConsentState?(mpid: MPID): ConsentState | null;
+    setConsentState?(mpid: MPID, consentState: ConsentState): void;
+    _getFromPersistence?<T>(mpid: MPID, key: string): T;
+    _setPersistence?<T>(mpid: MPID, key: string, value: T): void;
+    getDeviceId?(): string;
+    setDeviceId?(deviceId: string): void;
+    getFirstSeenTime?(mpid: MPID): number;
+    setFirstSeenTime?(mpid: MPID, time?: number): void;
+    getLastSeenTime?(mpid: MPID): number;
+    setLastSeenTime?(mpid: MPID, time?: number): void;
+    getLocalSessionAttributes?(): LocalSessionAttributes;
+    setLocalSessionAttribute?(key: string, value: AttributeValue): void;
+    getUserAttributes?(mpid: MPID): UserAttributes;
+    setUserAttributes?(mpid: MPID, attributes: UserAttributes): void;
+    getUserIdentities?(mpid: MPID): UserIdentities;
+    setUserIdentities?(mpid: MPID, userIdentities: UserIdentities): void;
+    getRoktAccountId?(): string;
+    setRoktAccountId?(accountId: string): void;
+    getIntegrationName?(): string;
+    setIntegrationName?(integrationName: string): void;
+    addMpidToSessionHistory?(mpid: MPID, previousMpid?: MPID): void;
+    hasInvalidIdentifyRequest?: () => boolean;
+    nullifySession?: () => void;
+    processConfig(config: SDKInitConfig): void;
+    syncPersistenceData?: () => void;
+}
+export default function Store(this: IStore, config: SDKInitConfig, mpInstance: IMParticleWebSDKInstance, apiKey?: string): void;
+export declare function processFlags(config: SDKInitConfig): IFeatureFlags;
+export declare function processBaseUrls(config: SDKInitConfig, flags: IFeatureFlags, apiKey?: string): Dictionary<string>;

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;
+}