@mparticle/web-sdk 2.61.0 → 2.63.0

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

@@ -0,0 +1,83 @@
+import { SDKEventCustomFlags } from './sdkRuntimeModels';
+import Constants from './constants';
+import { IntegrationAttributes } from './store';
+import { Dictionary, valueof } from './utils';
+export interface IntegrationCaptureProcessorFunction {
+    (clickId: string, url: string, timestamp?: number): string;
+}
+export declare const facebookClickIdProcessor: IntegrationCaptureProcessorFunction;
+declare const IntegrationOutputs: {
+    readonly CUSTOM_FLAGS: "custom_flags";
+    readonly PARTNER_IDENTITIES: "partner_identities";
+    readonly INTEGRATION_ATTRIBUTES: "integration_attributes";
+};
+interface IntegrationMappingItem {
+    mappedKey: string;
+    output: valueof<typeof IntegrationOutputs>;
+    processor?: IntegrationCaptureProcessorFunction;
+    moduleId?: number;
+}
+interface IntegrationIdMapping {
+    [key: string]: IntegrationMappingItem;
+}
+export default class IntegrationCapture {
+    clickIds: Dictionary<string>;
+    readonly initialTimestamp: number;
+    readonly filteredPartnerIdentityMappings: IntegrationIdMapping;
+    readonly filteredCustomFlagMappings: IntegrationIdMapping;
+    readonly filteredIntegrationAttributeMappings: IntegrationIdMapping;
+    captureMode?: valueof<typeof Constants.CaptureIntegrationSpecificIdsV2Modes>;
+    constructor(captureMode: valueof<typeof Constants.CaptureIntegrationSpecificIdsV2Modes>);
+    /**
+     * Captures Integration Ids from cookies and query params and stores them in clickIds object
+     */
+    capture(): void;
+    /**
+     * Captures cookies based on the integration ID mapping.
+     */
+    captureCookies(): Dictionary<string>;
+    /**
+     * Captures query parameters based on the integration ID mapping.
+     */
+    captureQueryParams(): Dictionary<string>;
+    /**
+     * Captures local storage based on the integration ID mapping.
+     */
+    captureLocalStorage(): Dictionary<string>;
+    /**
+     * Gets the query parameters based on the integration ID mapping.
+     * @returns {Dictionary<string>} The query parameters.
+     */
+    getQueryParams(): Dictionary<string>;
+    /**
+     * Converts captured click IDs to custom flags for SDK events.
+     * @returns {SDKEventCustomFlags} The custom flags.
+     */
+    getClickIdsAsCustomFlags(): SDKEventCustomFlags;
+    /**
+     * Returns only the `partner_identities` mapped integration output.
+     * @returns {Dictionary<string>} The partner identities.
+     */
+    getClickIdsAsPartnerIdentities(): Dictionary<string>;
+    /**
+     * Returns only the `integration_attributes` mapped integration output.
+     * @returns {IntegrationAttributes} The integration attributes.
+     */
+    getClickIdsAsIntegrationAttributes(): IntegrationAttributes;
+    private getClickIds;
+    private applyProcessors;
+    private filterMappings;
+    /**
+     * Returns the allowed keys to capture based on the current mode.
+     * For RoktOnly, limit capture to Rokt keys; for All, capture all mapped keys.
+     */
+    private getAllowedKeysForMode;
+    /**
+    * Selects the active integration mapping for the current captureMode.
+    * - 'roktonly': only Rokt IDs are considered
+    * - 'all': both External and Rokt IDs are considered
+    * - else: returns an empty mapping and nothing will be captured
+    */
+    private getActiveIntegrationMapping;
+}
+export {};

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

@@ -0,0 +1,20 @@
+/**
+ * Internal types for @mparticle/web-sdk
+ *
+ * These types are shared between mParticle and Rokt SDKs but are NOT part of
+ * the public API. They may change without notice between minor versions.
+ *
+ * Usage:
+ *   import type { IKitFilterSettings, IRoktKit, SDKProduct } from '@mparticle/web-sdk/internal';
+ *
+ * This entry point re-exports all public types so that internal consumers
+ * only need a single import path.
+ *
+ * Customers should NOT import from this path.
+ */
+export * from './public-types';
+export type { KitInterface, } from './forwarders.interfaces';
+export type { RoktAttributeValue, RoktAttributeValueType, RoktAttributeValueArray, RoktAttributes, IRoktPartnerExtensionData, IRoktSelectPlacementsOptions, IRoktSelection, IRoktLauncher, IRoktMessage, RoktKitFilterSettings, IRoktKitSettings, IRoktKit, IRoktOptions, IRoktLauncherOptions, } from './roktManager';
+export type { ErrorCodes, WSDKErrorSeverity, } from './reporting/types';
+export type { ISDKError, ISDKLogEntry, IErrorReportingService, ILoggingService, } from './reporting/types';
+export type { SDKEvent, SDKProductAction, SDKProductActionType, SDKPromotionAction, SDKShoppingCart, SDKGeoLocation, SDKDataPlan, SDKLoggerApi, SDKConfigApi, IMParticleInstanceManager, } from './sdkRuntimeModels';

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

@@ -0,0 +1,116 @@
+import { SDKEvent, KitBlockerDataPlan } from './sdkRuntimeModels';
+import { BaseEvent } from '@mparticle/event-models';
+import { DataPlanPoint } from '@mparticle/data-planning-models';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export default class KitBlocker {
+    dataPlanMatchLookups: {
+        [key: string]: {};
+    };
+    blockEvents: boolean;
+    blockEventAttributes: boolean;
+    blockUserAttributes: boolean;
+    blockUserIdentities: boolean;
+    kitBlockingEnabled: boolean;
+    mpInstance: IMParticleWebSDKInstance;
+    constructor(dataPlan: KitBlockerDataPlan, mpInstance: IMParticleWebSDKInstance);
+    addToMatchLookups(point: DataPlanPoint): void;
+    generateMatchKey(match: any): string | null;
+    generateProductAttributeMatchKey(match: any): string | null;
+    getPlannedProperties(type: any, validator: any): boolean | {
+        [key: string]: true;
+    } | null;
+    getProductProperties(type: any, validator: any): boolean | {
+        [key: string]: true;
+    } | null;
+    getMatchKey(eventToMatch: BaseEvent): string | null;
+    getProductAttributeMatchKey(eventToMatch: BaseEvent): string | null;
+    createBlockedEvent(event: SDKEvent): SDKEvent;
+    transformEventAndEventAttributes(event: SDKEvent): SDKEvent;
+    transformProductAttributes(event: SDKEvent): SDKEvent;
+    transformUserAttributes(event: SDKEvent): {
+        DeviceId: string;
+        IsFirstRun: boolean;
+        EventName: string;
+        EventCategory: number;
+        UserAttributes?: import("./identity-user-interfaces").ISDKUserAttributes;
+        UserIdentities?: import("./identity-user-interfaces").ISDKUserIdentity[];
+        SourceMessageId: string;
+        MPID: string;
+        EventAttributes?: {
+            [key: string]: string;
+        };
+        SDKVersion: string;
+        SessionId: string;
+        SessionStartDate: number;
+        SessionLength?: number;
+        currentSessionMPIDs?: string[];
+        Timestamp: number;
+        EventDataType: number;
+        Debug: boolean;
+        Location?: import("./sdkRuntimeModels").SDKGeoLocation;
+        OptOut?: boolean;
+        CustomFlags?: import("./sdkRuntimeModels").SDKEventCustomFlags;
+        AppVersion?: string;
+        AppName?: string;
+        Package?: string;
+        ConsentState?: import("./consent").SDKConsentState;
+        IntegrationAttributes?: import("./store").IntegrationAttributes;
+        ProductAction?: import("./sdkRuntimeModels").SDKProductAction;
+        PromotionAction?: import("./sdkRuntimeModels").SDKPromotionAction;
+        ProductImpressions?: import("./sdkRuntimeModels").SDKProductImpression[];
+        ShoppingCart?: import("./sdkRuntimeModels").SDKShoppingCart;
+        UserIdentityChanges?: import("./identity-user-interfaces").ISDKUserIdentityChanges;
+        UserAttributeChanges?: import("./identity-user-interfaces").ISDKUserAttributeChangeData;
+        CurrencyCode: string;
+        DataPlan?: import("./sdkRuntimeModels").SDKDataPlan;
+        LaunchReferral?: string;
+        ExpandedEventCount: number;
+        ActiveTimeOnSite: number;
+        IsBackgroundAST?: boolean;
+        AlreadySentToForwarders?: boolean;
+    };
+    isAttributeKeyBlocked(key: string): boolean;
+    isIdentityBlocked(key: string): boolean;
+    transformUserIdentities(event: SDKEvent): {
+        DeviceId: string;
+        IsFirstRun: boolean;
+        EventName: string;
+        EventCategory: number;
+        UserAttributes?: import("./identity-user-interfaces").ISDKUserAttributes;
+        UserIdentities?: import("./identity-user-interfaces").ISDKUserIdentity[];
+        SourceMessageId: string;
+        MPID: string;
+        EventAttributes?: {
+            [key: string]: string;
+        };
+        SDKVersion: string;
+        SessionId: string;
+        SessionStartDate: number;
+        SessionLength?: number;
+        currentSessionMPIDs?: string[];
+        Timestamp: number;
+        EventDataType: number;
+        Debug: boolean;
+        Location?: import("./sdkRuntimeModels").SDKGeoLocation;
+        OptOut?: boolean;
+        CustomFlags?: import("./sdkRuntimeModels").SDKEventCustomFlags;
+        AppVersion?: string;
+        AppName?: string;
+        Package?: string;
+        ConsentState?: import("./consent").SDKConsentState;
+        IntegrationAttributes?: import("./store").IntegrationAttributes;
+        ProductAction?: import("./sdkRuntimeModels").SDKProductAction;
+        PromotionAction?: import("./sdkRuntimeModels").SDKPromotionAction;
+        ProductImpressions?: import("./sdkRuntimeModels").SDKProductImpression[];
+        ShoppingCart?: import("./sdkRuntimeModels").SDKShoppingCart;
+        UserIdentityChanges?: import("./identity-user-interfaces").ISDKUserIdentityChanges;
+        UserAttributeChanges?: import("./identity-user-interfaces").ISDKUserAttributeChangeData;
+        CurrencyCode: string;
+        DataPlan?: import("./sdkRuntimeModels").SDKDataPlan;
+        LaunchReferral?: string;
+        ExpandedEventCount: number;
+        ActiveTimeOnSite: number;
+        IsBackgroundAST?: boolean;
+        AlreadySentToForwarders?: boolean;
+    };
+}

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

@@ -0,0 +1,15 @@
+import { Dictionary, valueof } from "./utils";
+import { EventType, IdentityType } from "./types";
+export default class KitFilterHelper {
+    static hashEventType(eventType: valueof<typeof EventType>): number;
+    static hashEventName(eventName: string, eventType: valueof<typeof EventType>): number;
+    static hashEventAttributeKey(eventType: valueof<typeof EventType>, eventName: string, customAttributeName: string): number;
+    static hashUserAttribute(userAttributeKey: string): number;
+    static hashUserIdentity(userIdentity: typeof IdentityType): typeof IdentityType;
+    static hashConsentPurpose(prefix: string, purpose: string): number;
+    static hashAttributeConditionalForwarding(attribute: string): string;
+    static hashConsentPurposeConditionalForwarding(prefix: string, purpose: string): string;
+    static readonly filterUserAttributes: (userAttributes: Dictionary<string>, filterList: number[]) => Dictionary<string>;
+    static readonly filterUserIdentities: (userIdentities: Dictionary<string>, filterList: number[]) => Dictionary<string>;
+    static readonly isFilteredUserAttribute: (userAttributeKey: string, filterList: number[]) => boolean;
+}

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

@@ -0,0 +1,18 @@
+import { LogLevelType, SDKInitConfig, SDKLoggerApi } from './sdkRuntimeModels';
+export type ILoggerConfig = Pick<SDKInitConfig, 'logLevel' | 'logger'>;
+export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'verbose'>>;
+export declare class Logger {
+    private logLevel;
+    private logger;
+    constructor(config: ILoggerConfig);
+    verbose(msg: string): void;
+    warning(msg: string): void;
+    error(msg: string): void;
+    isVerbose(): boolean;
+    setLogLevel(newLogLevel: LogLevelType): void;
+}
+export declare class ConsoleLogger implements IConsoleLogger {
+    verbose(msg: string): void;
+    error(msg: string): void;
+    warning(msg: string): void;
+}

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

@@ -0,0 +1,7 @@
+import { BaseEvent } from './sdkRuntimeModels';
+import { Batch } from '@mparticle/event-models';
+export default class _BatchValidator {
+    private getMPInstance;
+    private createSDKEventFunction;
+    returnBatch(events: BaseEvent | BaseEvent[]): Batch | null;
+}

package/dist/types/src/mp-instance.d.ts

@@ -0,0 +1,76 @@
+import { IAPIClient } from './apiClient';
+import { ICookieSyncManager } from './cookieSyncManager';
+import { ISessionManager } from './sessionManager';
+import { IStore } from './store';
+import { IServerModel } from './serverModel';
+import ForwardingStatsUploader from './forwardingStatsUploader';
+import { IConsent } from './consent';
+import IdentityAPIClient from './identityApiClient';
+import IntegrationCapture from './integrationCapture';
+import { IPreInit } from './pre-init-utils';
+import { MParticleWebSDK, SDKHelpersApi } from './sdkRuntimeModels';
+import { Dictionary } from '@mparticle/web-sdk';
+import { IIdentity } from './identity.interfaces';
+import { IEvents } from './events.interfaces';
+import { IECommerce } from './ecommerce.interfaces';
+import { INativeSdkHelpers } from './nativeSdkHelpers.interfaces';
+import { IPersistence } from './persistence.interfaces';
+import ForegroundTimer from './foregroundTimeTracker';
+import RoktManager from './roktManager';
+import { ICookieConsentManager } from './cookieConsentManager';
+import { ErrorReportingDispatcher } from './reporting/errorReportingDispatcher';
+import { LoggingDispatcher } from './reporting/loggingDispatcher';
+export interface IErrorLogMessage {
+    message?: string;
+    name?: string;
+    stack?: string;
+}
+export interface IErrorLogMessageMinified {
+    m?: string;
+    s?: string;
+    t?: string;
+}
+export type IntegrationDelays = Dictionary<boolean>;
+export interface IMParticleWebSDKInstance extends MParticleWebSDK {
+    _APIClient: IAPIClient;
+    _Consent: IConsent;
+    _CookieSyncManager: ICookieSyncManager;
+    _Ecommerce: IECommerce;
+    _Events: IEvents;
+    _Forwarders: any;
+    _ForwardingStatsUploader: ForwardingStatsUploader;
+    _Helpers: SDKHelpersApi;
+    _Identity: IIdentity;
+    _IdentityAPIClient: typeof IdentityAPIClient;
+    _IntegrationCapture: IntegrationCapture;
+    _NativeSdkHelpers: INativeSdkHelpers;
+    _Persistence: IPersistence;
+    _CookieConsentManager: ICookieConsentManager;
+    _ErrorReportingDispatcher: ErrorReportingDispatcher;
+    _LoggingDispatcher: LoggingDispatcher;
+    _RoktManager: RoktManager;
+    _SessionManager: ISessionManager;
+    _ServerModel: IServerModel;
+    _Store: IStore;
+    _instanceName: string;
+    _preInit: IPreInit;
+    _timeOnSiteTimer: ForegroundTimer;
+    setLauncherInstanceGuid: () => void;
+    getLauncherInstanceGuid: () => string;
+    captureTiming(metricName: string): any;
+    processQueueOnIdentityFailure?: () => void;
+    processQueueOnNoFunctional?: () => void;
+}
+/**
+ * <p>All of the following methods can be called on the primary mParticle class. In version 2.10.0, we introduced <a href="https://docs.mparticle.com/developers/sdk/web/multiple-instances/">multiple instances</a>. If you are using multiple instances (self hosted environments only), you should call these methods on each instance.</p>
+ * <p>In current versions of mParticle, if your site has one instance, that instance name is 'default_instance'. Any methods called on mParticle on a site with one instance will be mapped to the `default_instance`.</p>
+ * <p>This is for simplicity and backwards compatibility. For example, calling mParticle.logPageView() automatically maps to mParticle.getInstance('default_instance').logPageView().</p>
+ * <p>If you have multiple instances, instances must first be initialized and then a method can be called on that instance. For example:</p>
+ * <code>
+ *  mParticle.init('apiKey', config, 'another_instance');
+ *  mParticle.getInstance('another_instance').logPageView();
+ * </code>
+ *
+ * @class mParticle & mParticleInstance
+ */
+export default function mParticleInstance(this: IMParticleWebSDKInstance, instanceName: string): void;

package/dist/types/src/mparticle-instance-manager.d.ts

@@ -0,0 +1,2 @@
+declare const mParticleManager: any;
+export default mParticleManager;

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

@@ -0,0 +1,12 @@
+export default function NativeSdkHelpers(mpInstance: any): void;
+export default class NativeSdkHelpers {
+    constructor(mpInstance: any);
+    initializeSessionAttributes: (apiKey: any) => void;
+    isBridgeV2Available: (bridgeName: any) => boolean;
+    isWebviewEnabled: (requiredWebviewBridgeName: any, minWebviewBridgeVersion: any) => any;
+    isBridgeV1Available: () => boolean;
+    sendToNative: (path: any, value: any) => void;
+    sendViaBridgeV1: (path: any, value: any) => void;
+    sendViaIframeToIOS: (path: any, value: any) => void;
+    sendViaBridgeV2: (path: any, value: any, requiredWebviewBridgeName: any) => void;
+}

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

@@ -0,0 +1,10 @@
+export interface INativeSdkHelpers {
+    initializeSessionAttributes: (apiKey: string) => void;
+    isBridgeV2Available: (bridgeName: string) => boolean;
+    isWebviewEnabled: (requiredWebviewBridgeName: string, minWebviewBridgeVersion: number) => boolean;
+    isBridgeV1Available: () => boolean;
+    sendToNative: (path: string, value?: string) => void;
+    sendViaBridgeV1: (path: string, value: string) => void;
+    sendViaIframeToIOS: (path: string, value: string) => void;
+    sendViaBridgeV2: (path: string, value: string, requiredWebviewBridgeName: boolean) => void;
+}

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

@@ -0,0 +1,44 @@
+export default function _Persistence(mpInstance: any): void;
+export default class _Persistence {
+    constructor(mpInstance: any);
+    useLocalStorage: () => any;
+    initializeStorage: () => void;
+    update: () => void;
+    storeDataInMemory: (obj: any, currentMPID: any) => void;
+    determineLocalStorageAvailability: (storage: any) => any;
+    setLocalStorage: () => void;
+    getLocalStorage: () => {};
+    expireCookies: (cookieName: any) => void;
+    getCookie: () => any;
+    setCookie: () => void;
+    reduceAndEncodePersistence: (persistence: any, expires: any, domain: any, maxCookieSize: any) => string;
+    findPrevCookiesBasedOnUI: (identityApiData: any) => void;
+    encodePersistence: (persistence: any) => string;
+    decodePersistence: (persistence: any) => string;
+    getCookieDomain: () => any;
+    getDomain: (doc: any, locationHostname: any) => any;
+    saveUserCookieSyncDatesToPersistence: (mpid: any, csd: any) => void;
+    swapCurrentUser: (previousMPID: any, currentMPID: any, currentSessionMPIDs: any) => void;
+    savePersistence: (persistence: any) => void;
+    getPersistence: () => any;
+    getFirstSeenTime: (mpid: any) => any;
+    /**
+     * set the "first seen" time for a user. the time will only be set once for a given
+     * mpid after which subsequent calls will be ignored
+     */
+    setFirstSeenTime: (mpid: any, time: any) => void;
+    /**
+     * returns the "last seen" time for a user. If the mpid represents the current user, the
+     * return value will always be the current time, otherwise it will be to stored "last seen"
+     * time
+     */
+    getLastSeenTime: (mpid: any) => any;
+    setLastSeenTime: (mpid: any, time: any) => void;
+    getDeviceId: () => any;
+    setDeviceId: (guid: any) => void;
+    resetPersistence: () => void;
+    forwardingStatsBatches: {
+        uploadsTable: {};
+        forwardingStatsEventQueue: any[];
+    };
+}

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

@@ -0,0 +1,73 @@
+import { Context } from '@mparticle/event-models';
+import { IdentityApiData, MPID, Product, UserIdentities } from '@mparticle/web-sdk';
+import { IForwardingStatsData } from './apiClient';
+import { IntegrationAttributes, ServerSettings, SessionAttributes, LocalSessionAttributes } from './store';
+import { Dictionary } from './utils';
+import { IMinifiedConsentJSONObject } from './consent';
+import { UserAttributes } from './identity-user-interfaces';
+import { CookieSyncDates } from './cookieSyncManager';
+export type UploadsTable = Dictionary<any>;
+export interface iForwardingStatsBatches {
+    uploadsTable: UploadsTable;
+    forwardingStatsEventQueue: IForwardingStatsData[];
+}
+export interface IGlobalStoreV2MinifiedKeys {
+    sid: string;
+    ie: boolean;
+    sa: SessionAttributes;
+    lsa?: LocalSessionAttributes;
+    ss: ServerSettings;
+    dt: string;
+    av: string;
+    cgid: string;
+    das: string;
+    ia: IntegrationAttributes;
+    c: Context;
+    csm: MPID[];
+    les: number;
+    ssd: number;
+}
+export interface IPersistenceMinified extends Dictionary {
+    cu: MPID;
+    gs: IGlobalStoreV2MinifiedKeys;
+    l: boolean;
+}
+export interface IUserPersistenceMinified extends Dictionary {
+    csd: CookieSyncDates;
+    con: IMinifiedConsentJSONObject;
+    ui: UserIdentities;
+    ua: UserAttributes;
+    cp: Product[];
+    fst: number;
+    lst: number;
+}
+export interface IPersistence {
+    useLocalStorage(): boolean;
+    initializeStorage(): void;
+    update(): void;
+    storeDataInMemory(obj: IPersistenceMinified, currentMPID: MPID): void;
+    determineLocalStorageAvailability(storage: Storage): boolean;
+    setLocalStorage(): void;
+    getLocalStorage(): IPersistenceMinified | null;
+    expireCookies(cookieName: string): void;
+    getCookie(): IPersistenceMinified | null;
+    setCookie(): void;
+    reduceAndEncodePersistence(persistence: IPersistenceMinified, expires: string, domain: string, maxCookieSize: number): string;
+    findPrevCookiesBasedOnUI(identityApiData: IdentityApiData): void;
+    encodePersistence(persistence: IPersistenceMinified): string;
+    decodePersistence(persistenceString: string): string;
+    getCookieDomain(): string;
+    getDomain(doc: string, locationHostname: string): string;
+    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDates): void;
+    savePersistence(persistance: IPersistenceMinified): void;
+    getPersistence(): IPersistenceMinified;
+    getFirstSeenTime(mpid: MPID): string | null;
+    setFirstSeenTime(mpid: MPID, time: number): void;
+    getLastSeenTime(mpid: MPID): number | null;
+    setLastSeenTime(mpid: MPID, time: number): void;
+    getDeviceId(): string;
+    setDeviceId(guid: string): void;
+    resetPersistence(): void;
+    swapCurrentUser(previousMPID: MPID, currentMPID: MPID, currentSessionMPIDs?: MPID[]): void;
+    forwardingStatsBatches: iForwardingStatsBatches;
+}

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

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export function forEach(callback: any, thisArg: any, ...args: any[]): void;
+    export function map(callback: any, thisArg: any, ...args: any[]): any[];
+    export function filter(fun: any, ...args: any[]): any[];
+    export function isArray(arg: any): boolean;
+    export { Base64 };
+}
+export default _default;
+declare namespace Base64 {
+    let _keyStr: string;
+    function encode(input: any): string;
+    function _encode(input: any): string;
+    function decode(input: any): string;
+    function _decode(input: any): string;
+}

package/dist/types/src/pre-init-utils.d.ts

@@ -0,0 +1,11 @@
+import { IPixelConfiguration } from './cookieSyncManager';
+import { MPForwarder } from './forwarders.interfaces';
+import { IntegrationDelays } from './mp-instance';
+export interface IPreInit {
+    readyQueue: Function[] | any[];
+    integrationDelays: IntegrationDelays;
+    forwarderConstructors: MPForwarder[];
+    pixelConfigurations?: IPixelConfiguration[];
+    isDevelopmentMode?: boolean;
+}
+export declare const processReadyQueue: (readyQueue: any) => Function[];

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

@@ -0,0 +1,23 @@
+/**
+ * Public types for @mparticle/web-sdk
+ *
+ * These types are part of the stable public API and are safe for customers
+ * to import. Only add types here that are intended for external consumption.
+ *
+ * Usage:
+ *   import type { SDKInitConfig, EventType } from '@mparticle/web-sdk';
+ *
+ * Note: Types from @types/mparticle__web-sdk (e.g., MPConfiguration, MPID,
+ * ConsentState) are NOT re-exported here to avoid circular references.
+ * Consumers get those automatically via DefinitelyTyped until they are
+ * natively defined in this SDK and the DT package is deprecated.
+ */
+export type { Batch, } from '@mparticle/event-models';
+export type { EventType, CommerceEventType, IdentityType, ProductActionType, PromotionActionType, MessageType, } from './types';
+export type { SDKInitConfig, DataPlanConfig, BaseEvent, SDKEventCustomFlags, LogLevelType, MParticleWebSDK, } from './sdkRuntimeModels';
+export type { IMParticleUser, IdentityCallback, IdentityResult, IdentityResultBody, IdentityModifyResultBody, ISDKUserIdentity, ISDKUserAttributes, } from './identity-user-interfaces';
+export type { SDKIdentityApi, IAliasRequest, IAliasCallback, IAliasResult, SDKIdentityTypeEnum, } from './identity.interfaces';
+export type { SDKECommerceAPI, SDKCart, } from './ecommerce.interfaces';
+export type { SDKProduct, SDKPromotion, SDKImpression, SDKProductImpression, } from './sdkRuntimeModels';
+export type { SDKConsentApi, SDKConsentState, SDKConsentStateData, SDKGDPRConsentState, SDKCCPAConsentState, } from './consent';
+export type { Dictionary, valueof } from './utils';

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

@@ -0,0 +1,8 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { IErrorReportingService, ISDKError } from './types';
+export declare class ErrorReportingDispatcher implements IErrorReportingService {
+    private readonly services;
+    logger?: SDKLoggerApi;
+    register(service: IErrorReportingService): void;
+    report(error: ISDKError): void;
+}

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

@@ -0,0 +1,8 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { ILoggingService, ISDKLogEntry } from './types';
+export declare class LoggingDispatcher implements ILoggingService {
+    private readonly services;
+    logger?: SDKLoggerApi;
+    register(service: ILoggingService): void;
+    log(entry: ISDKLogEntry): void;
+}

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

@@ -0,0 +1,37 @@
+import { valueof } from '../utils';
+export declare const ErrorCodes: {
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly UNHANDLED_EXCEPTION: "UNHANDLED_EXCEPTION";
+    readonly IDENTITY_REQUEST: "IDENTITY_REQUEST";
+    readonly IDENTITY_MISMATCH: "IDENTITY_MISMATCH";
+    readonly ROKT_KIT_ATTACHED: "ROKT_KIT_ATTACHED";
+};
+export type ErrorCodes = valueof<typeof ErrorCodes>;
+export declare const WSDKErrorSeverity: {
+    readonly ERROR: "ERROR";
+    readonly INFO: "INFO";
+    readonly WARNING: "WARNING";
+};
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+/** Structured error object for reporting. */
+export interface ISDKError {
+    message: string;
+    code?: ErrorCodes;
+    severity: WSDKErrorSeverity;
+    stackTrace?: string;
+    additionalInformation?: Record<string, string>;
+}
+/** Structured log entry for informational logging. */
+export interface ISDKLogEntry {
+    message: string;
+    code?: ErrorCodes;
+    additionalInformation?: Record<string, string>;
+}
+/** Contract for error/warning reporting services. */
+export interface IErrorReportingService {
+    report(error: ISDKError): void;
+}
+/** Contract for informational logging services. */
+export interface ILoggingService {
+    log(entry: ISDKLogEntry): void;
+}