@mparticle/web-sdk 2.60.1 → 2.62.0

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

@@ -0,0 +1,68 @@
+import { BooleanStringLowerCase, DataPlanResult, SDKEventCustomFlags, SDKInitConfig } from './sdkRuntimeModels';
+import { Dictionary } from './utils';
+import { IPixelConfiguration } from './cookieSyncManager';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export interface IKitConfigs extends IKitFilterSettings {
+    name: string;
+    suffix?: string;
+    moduleId: number;
+    isDebug: boolean;
+    isVisible: boolean;
+    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[];
+    attributeFilters: number[];
+    filteringEventAttributeValue?: IFilteringEventAttributeValue;
+    filteringUserAttributeValue?: IFilteringUserAttributeValue;
+    filteringConsentRuleValues?: IFilteringConsentRuleValues;
+    consentRegulationFilters: number[];
+    consentRegulationPurposeFilters: number[];
+    messageTypeFilters: number[];
+    messageTypeStateFilters: number[];
+}
+export interface IFilteringEventAttributeValue {
+    eventAttributeName: string;
+    eventAttributeValue: string;
+    includeOnMatch: boolean;
+}
+export interface IFilteringUserAttributeValue {
+    userAttributeName: string;
+    userAttributeValue: string;
+    includeOnMatch: boolean;
+}
+export interface IFilteringConsentRuleValues {
+    includeOnMatch: boolean;
+    values: IConsentRuleValue[];
+}
+export interface IConsentRuleValue {
+    consentPurpose: string;
+    hasConsented: boolean;
+}
+export interface IConfigResponse {
+    appName: string;
+    dataPlanResult: DataPlanResult;
+    kitConfigs: IKitConfigs[];
+    serviceUrl: string;
+    secureServiceUrl: string;
+    minWebviewBridgeVersion: number;
+    workspaceToken: string;
+    pixelConfigs: IPixelConfiguration[];
+    flags: SDKEventCustomFlags;
+}
+export interface IConfigAPIClient {
+    apiKey: string;
+    config: SDKInitConfig;
+    mpInstance: IMParticleWebSDKInstance;
+    getSDKConfiguration: () => Promise<IConfigResponse>;
+}
+export default function ConfigAPIClient(this: IConfigAPIClient, apiKey: string, config: SDKInitConfig, mpInstance: IMParticleWebSDKInstance): void;

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

@@ -0,0 +1,71 @@
+import { ConsentState, PrivacyConsentState } from '@mparticle/web-sdk';
+import { Dictionary } from './utils';
+import { IMParticleUser } from './identity-user-interfaces';
+import { IMParticleWebSDKInstance } from './mp-instance';
+declare const CCPAPurpose: "data_sale_opt_out";
+export interface IMinifiedConsentJSONObject {
+    gdpr?: Dictionary<IPrivacyV2DTO>;
+    ccpa?: {
+        [CCPAPurpose]: IPrivacyV2DTO;
+    };
+}
+export interface ICreatePrivacyConsentFunction {
+    (consented: boolean, timestamp?: number, consentDocument?: string, location?: string, hardwareId?: string): PrivacyConsentState | null;
+}
+export interface SDKConsentApi {
+    createGDPRConsent: ICreatePrivacyConsentFunction;
+    createCCPAConsent: ICreatePrivacyConsentFunction;
+    createConsentState: (consentState?: ConsentState) => ConsentState;
+}
+export interface IConsentSerialization {
+    toMinifiedJsonObject: (state: ConsentState) => IMinifiedConsentJSONObject;
+    fromMinifiedJsonObject: (json: IMinifiedConsentJSONObject) => ConsentState;
+}
+export interface SDKConsentState extends Omit<ConsentState, 'getGDPRConsentState' | 'getCCPAConsentState'> {
+    getGDPRConsentState(): SDKGDPRConsentState;
+    getCCPAConsentState(): SDKCCPAConsentState;
+}
+export interface SDKConsentStateData {
+    Consented: boolean;
+    Timestamp?: number;
+    ConsentDocument?: string;
+    Location?: string;
+    HardwareId?: string;
+}
+export type SDKGDPRConsentState = Dictionary<SDKConsentStateData>;
+export interface SDKCCPAConsentState extends SDKConsentStateData {
+}
+export interface IPrivacyV2DTO {
+    c: boolean;
+    ts: number;
+    d: string;
+    l: string;
+    h: string;
+}
+export type IGDPRConsentStateV2DTO = Dictionary<IPrivacyV2DTO>;
+export interface ICCPAConsentStateV2DTO {
+    [CCPAPurpose]: IPrivacyV2DTO;
+}
+export interface IConsentStateV2DTO {
+    gdpr?: IGDPRConsentStateV2DTO;
+    ccpa?: ICCPAConsentStateV2DTO;
+}
+export interface IConsentRulesValues {
+    consentPurpose: string;
+    hasConsented: boolean;
+}
+export interface IConsentRules {
+    includeOnMatch: boolean;
+    values: IConsentRulesValues[];
+}
+export interface IConsentState extends ConsentState {
+    removeCCPAState: () => ConsentState;
+}
+export interface IConsent {
+    isEnabledForUserConsent: (consentRules: IConsentRules, user: IMParticleUser) => boolean;
+    createPrivacyConsent: ICreatePrivacyConsentFunction;
+    createConsentState: (consentState?: ConsentState) => ConsentState;
+    ConsentSerialization: IConsentSerialization;
+}
+export default function Consent(this: IConsent, mpInstance: IMParticleWebSDKInstance): void;
+export {};

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

@@ -0,0 +1,201 @@
+declare const Constants: {
+    readonly sdkVersion: string;
+    readonly sdkVendor: "mparticle";
+    readonly platform: "web";
+    readonly Messages: {
+        readonly DeprecationMessages: {
+            readonly MethodHasBeenDeprecated: "has been deprecated.";
+            readonly MethodMarkedForDeprecationPostfix: "is a deprecated method and will be removed in future releases.";
+            readonly AlternativeMethodPrefix: "Please use the alternate method:";
+        };
+        readonly ErrorMessages: {
+            readonly NoToken: "A token must be specified.";
+            readonly EventNameInvalidType: "Event name must be a valid string value.";
+            readonly EventDataInvalidType: "Event data must be a valid object hash.";
+            readonly LoggingDisabled: "Event logging is currently disabled.";
+            readonly CookieParseError: "Could not parse cookie";
+            readonly EventEmpty: "Event object is null or undefined, cancelling send";
+            readonly APIRequestEmpty: "APIRequest is null or undefined, cancelling send";
+            readonly NoEventType: "Event type must be specified.";
+            readonly TransactionIdRequired: "Transaction ID is required";
+            readonly TransactionRequired: "A transaction attributes object is required";
+            readonly PromotionIdRequired: "Promotion ID is required";
+            readonly BadAttribute: "Attribute value cannot be object or array";
+            readonly BadKey: "Key value cannot be object or array";
+            readonly BadLogPurchase: "Transaction attributes and a product are both required to log a purchase, https://docs.mparticle.com/?javascript#measuring-transactions";
+            readonly AudienceAPINotEnabled: "Your workspace is not enabled to retrieve user audiences.";
+        };
+        readonly InformationMessages: {
+            readonly CookieSearch: "Searching for cookie";
+            readonly CookieFound: "Cookie found, parsing values";
+            readonly CookieNotFound: "Cookies not found";
+            readonly CookieSet: "Setting cookie";
+            readonly CookieSync: "Performing cookie sync";
+            readonly SendBegin: "Starting to send event";
+            readonly SendIdentityBegin: "Starting to send event to identity server";
+            readonly SendWindowsPhone: "Sending event to Windows Phone container";
+            readonly SendIOS: "Calling iOS path: ";
+            readonly SendAndroid: "Calling Android JS interface method: ";
+            readonly SendHttp: "Sending event to mParticle HTTP service";
+            readonly SendAliasHttp: "Sending alias request to mParticle HTTP service";
+            readonly SendIdentityHttp: "Sending event to mParticle HTTP service";
+            readonly StartingNewSession: "Starting new Session";
+            readonly StartingLogEvent: "Starting to log event";
+            readonly StartingLogOptOut: "Starting to log user opt in/out";
+            readonly StartingEndSession: "Starting to end session";
+            readonly StartingInitialization: "Starting to initialize";
+            readonly StartingLogCommerceEvent: "Starting to log commerce event";
+            readonly StartingAliasRequest: "Starting to Alias MPIDs";
+            readonly LoadingConfig: "Loading configuration options";
+            readonly AbandonLogEvent: "Cannot log event, logging disabled or developer token not set";
+            readonly AbandonAliasUsers: "Cannot Alias Users, logging disabled or developer token not set";
+            readonly AbandonStartSession: "Cannot start session, logging disabled or developer token not set";
+            readonly AbandonEndSession: "Cannot end session, logging disabled or developer token not set";
+            readonly NoSessionToEnd: "Cannot end session, no active session found";
+        };
+        readonly ValidationMessages: {
+            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";
+        };
+    };
+    readonly NativeSdkPaths: {
+        readonly LogEvent: "logEvent";
+        readonly SetUserTag: "setUserTag";
+        readonly RemoveUserTag: "removeUserTag";
+        readonly SetUserAttribute: "setUserAttribute";
+        readonly RemoveUserAttribute: "removeUserAttribute";
+        readonly SetSessionAttribute: "setSessionAttribute";
+        readonly AddToCart: "addToCart";
+        readonly RemoveFromCart: "removeFromCart";
+        readonly ClearCart: "clearCart";
+        readonly LogOut: "logOut";
+        readonly SetUserAttributeList: "setUserAttributeList";
+        readonly RemoveAllUserAttributes: "removeAllUserAttributes";
+        readonly GetUserAttributesLists: "getUserAttributesLists";
+        readonly GetAllUserAttributes: "getAllUserAttributes";
+        readonly Identify: "identify";
+        readonly Logout: "logout";
+        readonly Login: "login";
+        readonly Modify: "modify";
+        readonly Alias: "aliasUsers";
+        readonly Upload: "upload";
+    };
+    readonly StorageNames: {
+        readonly localStorageName: "mprtcl-api";
+        readonly localStorageNameV3: "mprtcl-v3";
+        readonly cookieName: "mprtcl-api";
+        readonly cookieNameV2: "mprtcl-v2";
+        readonly cookieNameV3: "mprtcl-v3";
+        readonly localStorageNameV4: "mprtcl-v4";
+        readonly localStorageProductsV4: "mprtcl-prodv4";
+        readonly cookieNameV4: "mprtcl-v4";
+        readonly currentStorageName: "mprtcl-v4";
+        readonly currentStorageProductsName: "mprtcl-prodv4";
+    };
+    readonly DefaultConfig: {
+        readonly cookieDomain: any;
+        readonly cookieExpiration: 365;
+        readonly logLevel: any;
+        readonly timeout: 300;
+        readonly sessionTimeout: 30;
+        readonly maxProducts: 20;
+        readonly forwarderStatsTimeout: 5000;
+        readonly integrationDelayTimeout: 5000;
+        readonly maxCookieSize: 3000;
+        readonly aliasMaxWindow: 90;
+        readonly uploadInterval: 0;
+    };
+    readonly DefaultBaseUrls: {
+        readonly v1SecureServiceUrl: "jssdks.mparticle.com/v1/JS/";
+        readonly v2SecureServiceUrl: "jssdks.mparticle.com/v2/JS/";
+        readonly v3SecureServiceUrl: "jssdks.mparticle.com/v3/JS/";
+        readonly configUrl: "jssdkcdns.mparticle.com/JS/v2/";
+        readonly identityUrl: "identity.mparticle.com/v1/";
+        readonly aliasUrl: "jssdks.mparticle.com/v1/identity/";
+        readonly userAudienceUrl: "nativesdks.mparticle.com/v1/";
+    };
+    readonly CNAMEUrlPaths: {
+        readonly v1SecureServiceUrl: "/webevents/v1/JS/";
+        readonly v2SecureServiceUrl: "/webevents/v2/JS/";
+        readonly v3SecureServiceUrl: "/webevents/v3/JS/";
+        readonly configUrl: "/tags/JS/v2/";
+        readonly identityUrl: "/identity/v1/";
+        readonly aliasUrl: "/webevents/v1/identity/";
+    };
+    readonly Base64CookieKeys: {
+        readonly csm: 1;
+        readonly sa: 1;
+        readonly ss: 1;
+        readonly lsa: 1;
+        readonly ua: 1;
+        readonly ui: 1;
+        readonly csd: 1;
+        readonly ia: 1;
+        readonly con: 1;
+    };
+    readonly SDKv2NonMPIDCookieKeys: {
+        readonly gs: 1;
+        readonly cu: 1;
+        readonly l: 1;
+        readonly globalSettings: 1;
+        readonly currentUserMPID: 1;
+    };
+    readonly HTTPCodes: {
+        readonly noHttpCoverage: -1;
+        readonly activeIdentityRequest: -2;
+        readonly activeSession: -3;
+        readonly validationIssue: -4;
+        readonly nativeIdentityRequest: -5;
+        readonly loggingDisabledOrMissingAPIKey: -6;
+        readonly tooManyRequests: 429;
+    };
+    readonly FeatureFlags: {
+        readonly ReportBatching: "reportBatching";
+        readonly EventBatchingIntervalMillis: "eventBatchingIntervalMillis";
+        readonly OfflineStorage: "offlineStorage";
+        readonly DirectUrlRouting: "directURLRouting";
+        readonly CacheIdentity: "cacheIdentity";
+        readonly AudienceAPI: "audienceAPI";
+        readonly CaptureIntegrationSpecificIds: "captureIntegrationSpecificIds";
+        readonly CaptureIntegrationSpecificIdsV2: "captureIntegrationSpecificIdsV2";
+        readonly AstBackgroundEvents: "astBackgroundEvents";
+    };
+    readonly DefaultInstance: "default_instance";
+    readonly CCPAPurpose: "data_sale_opt_out";
+    readonly IdentityMethods: {
+        readonly Modify: "modify";
+        readonly Logout: "logout";
+        readonly Login: "login";
+        readonly Identify: "identify";
+    };
+    readonly Environment: {
+        readonly Development: "development";
+        readonly Production: "production";
+    };
+    readonly CaptureIntegrationSpecificIdsV2Modes: {
+        readonly All: "all";
+        readonly None: "none";
+        readonly RoktOnly: "roktonly";
+    };
+    readonly Rokt: {
+        readonly LauncherInstanceGuidKey: "__rokt_li_guid__";
+    };
+};
+export default Constants;
+export declare const ONE_DAY_IN_SECONDS: number;
+export declare const MILLIS_IN_ONE_SEC = 1000;
+export declare const HTTP_OK: 200;
+export declare const HTTP_ACCEPTED: 202;
+export declare const HTTP_BAD_REQUEST: 400;
+export declare const HTTP_UNAUTHORIZED: 401;
+export declare const HTTP_FORBIDDEN: 403;
+export declare const HTTP_NOT_FOUND: 404;
+export declare const HTTP_SERVER_ERROR: 500;

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

@@ -0,0 +1,50 @@
+/**
+ * Cookie consent flags control SDK behavior based on user consent preferences for Rokt integration.
+ * @see https://docs.rokt.com/developers/integration-guides/web/cookie-consent-flags/
+ */
+export interface ICookieConsentFlags {
+    /**
+     * When true, indicates the user has opted out of functional cookies/tracking.
+     * Default: false (functional tracking is allowed)
+     */
+    noFunctional: boolean;
+    /**
+     * When true, indicates the user has opted out of targeting cookies/tracking.
+     * This flag is used to block cookie syncs and other targeting-related features.
+     * Default: false (targeting is allowed)
+     */
+    noTargeting: boolean;
+}
+export interface ICookieConsentManager {
+    /**
+     * Targeting is allowed when noTargeting is false (default)
+     */
+    getNoTargeting: () => boolean;
+    /**
+     * Functional tracking is allowed when noFunctional is false (default)
+     */
+    getNoFunctional: () => boolean;
+}
+/**
+ * CookieConsentManager handles storage and access of consent flags (noFunctional, noTargeting)
+ * that are passed via launcherOptions during SDK initialization.
+ *
+ * These flags allow Rokt integration to respect user privacy choices.
+ *
+ * Default behavior: Both flags default to false, meaning all features are allowed
+ * unless explicitly opted out by the user.
+ */
+export default class CookieConsentManager implements ICookieConsentManager {
+    private flags;
+    constructor(flags: ICookieConsentFlags);
+    /**
+     * Returns true if third-party targeting is disabled.
+     * Targeting is allowed when noTargeting is false (default).
+     */
+    getNoTargeting(): boolean;
+    /**
+     * Returns true if functional tracking is disabled.
+     * Functional tracking is allowed when noFunctional is false (default).
+     */
+    getNoFunctional(): boolean;
+}

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

@@ -0,0 +1,34 @@
+import { Dictionary } from './utils';
+import { MPID } from '@mparticle/web-sdk';
+import { IConsentRules } from './consent';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export declare const DAYS_IN_MILLISECONDS: number;
+export declare const PARTNER_MODULE_IDS: {
+    readonly AdobeEventForwarder: 11;
+    readonly DoubleclickDFP: 41;
+    readonly AppNexus: 50;
+    readonly Lotame: 58;
+    readonly TradeDesk: 103;
+    readonly VerizonMedia: 155;
+    readonly Rokt: 1277;
+};
+export type CookieSyncDates = Dictionary<number>;
+export interface IPixelConfiguration {
+    name?: string;
+    moduleId: number;
+    esId?: number;
+    isDebug?: boolean;
+    isProduction?: boolean;
+    settings: Dictionary<string>;
+    frequencyCap: number;
+    pixelUrl: string;
+    redirectUrl: string;
+    filteringConsentRuleValues?: IConsentRules;
+}
+export interface ICookieSyncManager {
+    attemptCookieSync: (mpid: MPID, mpidIsNotInCookies?: boolean) => void;
+    performCookieSync: (url: string, moduleId: string, mpid: MPID, cookieSyncDates: CookieSyncDates) => void;
+    combineUrlWithRedirect: (mpid: MPID, pixelUrl: string, redirectUrl: string) => string;
+}
+export default function CookieSyncManager(this: ICookieSyncManager, mpInstance: IMParticleWebSDKInstance): void;
+export declare const isLastSyncDateExpired: (frequencyCap: number, lastSyncDate?: number) => boolean;

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