@mparticle/web-sdk 2.60.1 → 2.62.0

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

@@ -0,0 +1,319 @@
+import * as EventsApi from '@mparticle/event-models';
+import { DataPlanVersion } from '@mparticle/data-planning-models';
+import { MPConfiguration, MPID, SDKEventOptions, SDKEventAttrs, Callback } from '@mparticle/web-sdk';
+import { IntegrationAttribute, IntegrationAttributes, IStore, WrapperSDKTypes } from './store';
+import Validators from './validators';
+import { Dictionary, valueof } from './utils';
+import { IKitConfigs } from './configAPIClient';
+import { SDKConsentApi, SDKConsentState } from './consent';
+import MPSideloadedKit from './sideloadedKit';
+import { ISessionManager } from './sessionManager';
+import { ConfiguredKit, MPForwarder, UnregisteredKit } from './forwarders.interfaces';
+import { SDKIdentityApi, IAliasCallback } from './identity.interfaces';
+import { ISDKUserAttributeChangeData, ISDKUserIdentityChanges, IMParticleUser, ISDKUserIdentity, IdentityCallback, ISDKUserAttributes } from './identity-user-interfaces';
+import { CommerceEventType, EventType, IdentityType, ProductActionType, PromotionActionType } from './types';
+import { IPixelConfiguration } from './cookieSyncManager';
+import _BatchValidator from './mockBatchCreator';
+import { SDKECommerceAPI } from './ecommerce.interfaces';
+import { IErrorLogMessage, IMParticleWebSDKInstance, IntegrationDelays } from './mp-instance';
+import Constants from './constants';
+import RoktManager, { IRoktLauncherOptions } from './roktManager';
+import { IConsoleLogger } from './logger';
+import { ErrorCodes, IErrorReportingService, ILoggingService } from './reporting/types';
+export type SDKEventCustomFlags = Dictionary<any>;
+export interface SDKEvent {
+    DeviceId: string;
+    IsFirstRun: boolean;
+    EventName: string;
+    EventCategory: number;
+    UserAttributes?: ISDKUserAttributes;
+    UserIdentities?: 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?: SDKGeoLocation;
+    OptOut?: boolean;
+    CustomFlags?: SDKEventCustomFlags;
+    AppVersion?: string;
+    AppName?: string;
+    Package?: string;
+    ConsentState?: SDKConsentState;
+    IntegrationAttributes?: IntegrationAttributes;
+    ProductAction?: SDKProductAction;
+    PromotionAction?: SDKPromotionAction;
+    ProductImpressions?: SDKProductImpression[];
+    ShoppingCart?: SDKShoppingCart;
+    UserIdentityChanges?: ISDKUserIdentityChanges;
+    UserAttributeChanges?: ISDKUserAttributeChangeData;
+    CurrencyCode: string;
+    DataPlan?: SDKDataPlan;
+    LaunchReferral?: string;
+    ExpandedEventCount: number;
+    ActiveTimeOnSite: number;
+    IsBackgroundAST?: boolean;
+    AlreadySentToForwarders?: boolean;
+}
+export interface SDKGeoLocation {
+    lat: number | string;
+    lng: number | string;
+}
+export interface SDKDataPlan {
+    PlanVersion?: number | null;
+    PlanId?: string | null;
+}
+export interface SDKShoppingCart {
+    ProductList?: SDKProduct[];
+}
+export interface SDKPromotionAction {
+    PromotionActionType: string;
+    PromotionList?: SDKPromotion[];
+}
+export interface SDKPromotion {
+    Id?: string;
+    Name?: string;
+    Creative?: string;
+    Position?: string;
+}
+export interface SDKImpression {
+    Name: string;
+    Product: SDKProduct;
+}
+export interface SDKProductImpression {
+    ProductImpressionList?: string;
+    ProductList?: SDKProduct[];
+}
+export declare enum SDKProductActionType {
+    Unknown = 0,
+    AddToCart = 1,
+    RemoveFromCart = 2,
+    Checkout = 3,
+    CheckoutOption = 4,
+    Click = 5,
+    ViewDetail = 6,
+    Purchase = 7,
+    Refund = 8,
+    AddToWishlist = 9,
+    RemoveFromWishlist = 10
+}
+export interface SDKProductAction {
+    ProductActionType: SDKProductActionType;
+    CheckoutStep?: number;
+    CheckoutOptions?: string;
+    ProductList?: SDKProduct[];
+    TransactionId?: string;
+    Affiliation?: string;
+    CouponCode?: string;
+    TotalAmount?: number;
+    ShippingAmount?: number;
+    TaxAmount?: number;
+}
+export interface SDKProduct {
+    Sku?: string;
+    Name?: string;
+    Price?: number;
+    Quantity?: number;
+    Brand?: string;
+    Variant?: string;
+    Category?: string;
+    Position?: number;
+    CouponCode?: string;
+    TotalAmount?: number;
+    Attributes?: Record<string, unknown> | null;
+}
+export interface MParticleWebSDK {
+    addForwarder(forwarder: UnregisteredKit): void;
+    IdentityType: typeof IdentityType;
+    CommerceEventType: typeof CommerceEventType;
+    EventType: typeof EventType;
+    PromotionType: typeof PromotionActionType;
+    ProductActionType: typeof ProductActionType;
+    Identity: SDKIdentityApi;
+    Logger: SDKLoggerApi;
+    Consent: SDKConsentApi;
+    _resetForTests(MPConfig?: SDKInitConfig, keepPersistence?: boolean, instance?: IMParticleWebSDKInstance): void;
+    configurePixel(config: IPixelConfiguration): void;
+    endSession(): void;
+    init(apiKey: string, config: SDKInitConfig, instanceName?: string): void;
+    _getActiveForwarders(): ConfiguredKit[];
+    _getIntegrationDelays(): IntegrationDelays;
+    _setIntegrationDelay(module: number, shouldDelayIntegration: boolean): void;
+    _setWrapperSDKInfo(name: WrapperSDKTypes, version: string): void;
+    getAppName(): string;
+    getAppVersion(): string;
+    getDeviceId(): string;
+    setDeviceId(deviceId: string): void;
+    getEnvironment(): valueof<typeof Constants.Environment>;
+    setSessionAttribute(key: string, value: string): void;
+    getVersion(): string;
+    upload(): void;
+    setLogLevel(logLevel: LogLevelType): void;
+    setPosition(lat: number | string, lng: number | string): void;
+    startNewSession(): void;
+    logEvent(eventName: string, eventType?: valueof<typeof EventType>, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): void;
+    logBaseEvent(event: BaseEvent, eventOptions?: SDKEventOptions): void;
+    logError(error: IErrorLogMessage, attrs?: SDKEventAttrs): void;
+    logLink(selector: string, eventName: string, eventType: valueof<typeof EventType>, eventInfo: SDKEventAttrs): void;
+    logForm(selector: string, eventName: string, eventType: valueof<typeof EventType>, eventInfo: SDKEventAttrs): void;
+    logPageView(eventName?: string, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): void;
+    setOptOut(isOptingOut: boolean): void;
+    eCommerce: SDKECommerceAPI;
+    isInitialized(): boolean;
+    ready(f: Function): void;
+    reset(instance?: IMParticleWebSDKInstance): void;
+    setAppName(name: string): void;
+    setAppVersion(version: string): void;
+    setOptOut(isOptingOut: boolean): void;
+    startTrackingLocation(callback?: Callback): void;
+    stopTrackingLocation(): void;
+    generateHash(value: string): string;
+    setIntegrationAttribute(integrationModuleId: number, attrs: IntegrationAttribute): void;
+    getIntegrationAttributes(integrationModuleId: number): IntegrationAttribute;
+    captureTiming(metricName: string): void;
+    _registerErrorReportingService(service: IErrorReportingService): void;
+    _registerLoggingService(service: ILoggingService): void;
+}
+export interface IMParticleInstanceManager extends MParticleWebSDK {
+    _BatchValidator: _BatchValidator;
+    _instances: Dictionary<IMParticleWebSDKInstance>;
+    _isTestEnv?: boolean;
+    config: SDKInitConfig;
+    isIOS?: boolean;
+    MPSideloadedKit: typeof MPSideloadedKit;
+    Rokt: RoktManager;
+    sessionManager: Pick<ISessionManager, 'getSession'>;
+    Store: IStore;
+    getInstance(instanceName?: string): IMParticleWebSDKInstance;
+}
+export type BooleanStringLowerCase = 'false' | 'true';
+export type BooleanStringTitleCase = 'False' | 'True';
+export type LogLevelType = (typeof LogLevelType)[keyof typeof LogLevelType];
+export declare const LogLevelType: {
+    readonly None: "none";
+    readonly Verbose: "verbose";
+    readonly Warning: "warning";
+    readonly Error: "error";
+};
+export interface SDKInitConfig extends Omit<MPConfiguration, 'dataPlan' | 'logLevel'> {
+    dataPlan?: DataPlanConfig | KitBlockerDataPlan;
+    logLevel?: LogLevelType;
+    kitConfigs?: IKitConfigs[];
+    kits?: Dictionary<UnregisteredKit>;
+    sideloadedKits?: MPForwarder[];
+    dataPlanOptions?: KitBlockerOptions;
+    flags?: Dictionary;
+    pixelConfigs?: IPixelConfiguration[];
+    aliasMaxWindow?: number;
+    deviceId?: string;
+    forceHttps?: boolean;
+    aliasUrl?: string;
+    configUrl?: string;
+    identityUrl?: string;
+    integrationDelayTimeout?: number;
+    isIOS?: boolean;
+    maxProducts?: number;
+    requestConfig?: boolean;
+    sessionTimeout?: number;
+    useNativeSdk?: boolean;
+    useCookieStorage?: boolean;
+    v1SecureServiceUrl?: string;
+    v2SecureServiceUrl?: string;
+    v3SecureServiceUrl?: string;
+    domain?: string;
+    workspaceToken?: string;
+    isDevelopmentMode?: boolean;
+    identityCallback?: IdentityCallback;
+    launcherOptions?: IRoktLauncherOptions;
+    isLoggingEnabled?: boolean;
+    rq?: Function[] | any[];
+    logger?: IConsoleLogger;
+}
+export interface DataPlanConfig {
+    planId?: string;
+    planVersion?: number;
+    document?: DataPlanResult;
+}
+export interface SDKHelpersApi {
+    canLog?(): boolean;
+    createMainStorageName?(workspaceToken: string): string;
+    createServiceUrl(url: string, devToken?: string): string;
+    createXHR?(cb: () => void): XMLHttpRequest;
+    extend?(...args: any[]): any;
+    findKeyInObject?(obj: any, key: string): string;
+    parseNumber?(value: string | number): number;
+    generateUniqueId(): any;
+    generateHash?(value: string): string;
+    getFeatureFlag?(feature: string): boolean | string;
+    invokeAliasCallback(aliasCallback: IAliasCallback, number: number, errorMessage: string): void;
+    isDelayedByIntegration?(delayedIntegrations: Dictionary<boolean>, timeoutStart: number, now: number): boolean;
+    isEventType?(type: valueof<typeof EventType>): boolean;
+    isObject?(item: any): any;
+    invokeCallback?(callback: IdentityCallback, code: number, body: string, mParticleUser?: IMParticleUser, previousMpid?: MPID): void;
+    sanitizeAttributes?(attrs: SDKEventAttrs, name: string): Dictionary<string> | null;
+    Validators: typeof Validators;
+}
+export interface SDKLoggerApi {
+    error(msg: string, code?: ErrorCodes): void;
+    verbose(msg: string): void;
+    warning(msg: string): void;
+    isVerbose(): boolean;
+    setLogLevel(logLevel: LogLevelType): void;
+}
+export interface SDKStoreApi {
+    isEnabled: boolean;
+    isFirstRun: boolean;
+    devToken: string;
+    SDKConfig: SDKConfigApi;
+    sessionId?: string;
+    deviceId?: string;
+}
+export interface SDKConfigApi {
+    v3SecureServiceUrl?: string;
+    isDevelopmentMode: boolean;
+    appVersion?: string;
+    onCreateBatch(batch: EventsApi.Batch): EventsApi.Batch;
+}
+export interface BaseEvent {
+    messageType: number;
+    name?: string;
+    eventType?: number;
+    data?: SDKEventAttrs;
+    customFlags?: {
+        [key: string]: string;
+    };
+    toEventAPIObject?(): SDKEvent;
+    sourceMessageId?: string;
+    userAttributeChanges?: ISDKUserAttributeChangeData;
+    userIdentityChanges?: ISDKUserIdentityChanges;
+}
+export interface KitBlockerOptions {
+    dataPlanVersion: DataPlanVersion;
+    blockUserAttributes: boolean;
+    blockEventAttributes: boolean;
+    blockEvents: boolean;
+    blockUserIdentities: boolean;
+}
+export interface KitBlockerDataPlan {
+    document: DataPlanResult;
+}
+export interface DataPlanResult {
+    dtpn?: {
+        vers: DataPlanVersion;
+        blok: {
+            ev: boolean;
+            ea: boolean;
+            ua: boolean;
+            id: boolean;
+        };
+    };
+    error_message?: string;
+}

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

@@ -0,0 +1,43 @@
+import { SDKEvent, SDKGeoLocation, SDKProduct, SDKPromotion, SDKProductActionType } from './sdkRuntimeModels';
+import * as EventsApi from '@mparticle/event-models';
+import { SDKConsentState, SDKGDPRConsentState, SDKCCPAConsentState } from './consent';
+import { Dictionary } from './utils';
+import { ISDKUserIdentity } from './identity-user-interfaces';
+import { SDKIdentityTypeEnum } from './identity.interfaces';
+import { IMParticleWebSDKInstance } from './mp-instance';
+type PartnerIdentities = Dictionary<string>;
+interface Batch extends EventsApi.Batch {
+    partner_identities?: PartnerIdentities;
+}
+export declare function convertEvents(mpid: string, sdkEvents: SDKEvent[], mpInstance: IMParticleWebSDKInstance): Batch | null;
+export declare function convertConsentState(sdkConsentState?: SDKConsentState): EventsApi.ConsentState | null;
+export declare function convertGdprConsentState(sdkGdprConsentState: SDKGDPRConsentState): {
+    [key: string]: EventsApi.GDPRConsentState | null;
+};
+export declare function convertCcpaConsentState(sdkCcpaConsentState: SDKCCPAConsentState): {
+    data_sale_opt_out: EventsApi.CCPAConsentState;
+};
+export declare function convertUserIdentities(sdkUserIdentities?: ISDKUserIdentity[]): EventsApi.BatchUserIdentities | null;
+export declare function convertEvent(sdkEvent: SDKEvent): EventsApi.BaseEvent | null;
+export declare function convertProductActionType(actionType: SDKProductActionType): EventsApi.ProductActionActionEnum;
+export declare function convertProductAction(sdkEvent: SDKEvent): EventsApi.ProductAction | null;
+export declare function convertProducts(sdkProducts: SDKProduct[]): EventsApi.Product[] | null;
+export declare function convertPromotionAction(sdkEvent: SDKEvent): EventsApi.PromotionAction | null;
+export declare function convertPromotions(sdkPromotions: SDKPromotion[]): EventsApi.Promotion[] | null;
+export declare function convertImpressions(sdkEvent: SDKEvent): EventsApi.ProductImpression[] | null;
+export declare function convertShoppingCart(sdkEvent: SDKEvent): EventsApi.ShoppingCart | null;
+export declare function convertCommerceEvent(sdkEvent: SDKEvent): EventsApi.CommerceEvent;
+export declare function convertCrashReportEvent(sdkEvent: SDKEvent): EventsApi.CrashReportEvent;
+export declare function convertAST(sdkEvent: SDKEvent): EventsApi.ApplicationStateTransitionEvent;
+export declare function convertSessionEndEvent(sdkEvent: SDKEvent): EventsApi.SessionEndEvent;
+export declare function convertSessionStartEvent(sdkEvent: SDKEvent): EventsApi.SessionStartEvent;
+export declare function convertPageViewEvent(sdkEvent: SDKEvent): EventsApi.ScreenViewEvent;
+export declare function convertOptOutEvent(sdkEvent: SDKEvent): EventsApi.OptOutEvent;
+export declare function convertCustomEvent(sdkEvent: SDKEvent): EventsApi.CustomEvent;
+export declare function convertSdkEventType(sdkEventType: number): EventsApi.CustomEventDataCustomEventTypeEnum | EventsApi.CommerceEventDataCustomEventTypeEnum;
+export declare function convertBaseEventData(sdkEvent: SDKEvent): EventsApi.CommonEventData;
+export declare function convertSDKLocation(sdkEventLocation: SDKGeoLocation): EventsApi.GeoLocation;
+export declare function convertUserAttributeChangeEvent(sdkEvent: SDKEvent): EventsApi.UserAttributeChangeEvent | null;
+export declare function convertUserIdentityChangeEvent(sdkEvent: SDKEvent): EventsApi.UserIdentityChangeEvent | null;
+export declare function convertUserIdentityTypeToServerIdentityType(identityType: SDKIdentityTypeEnum): EventsApi.IdentityType;
+export {};

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

@@ -0,0 +1,105 @@
+import { BaseEvent, SDKEvent, SDKGeoLocation } from './sdkRuntimeModels';
+import { Dictionary } from './utils';
+import { ServerSettings } from './store';
+import { MPID } from '@mparticle/web-sdk';
+import { IConsentStateV2DTO, SDKConsentState } from './consent';
+import { IMParticleUser, ISDKUserIdentity } from './identity-user-interfaces';
+import { IMParticleWebSDKInstance } from './mp-instance';
+export interface IServerV2DTO {
+    id: string | number;
+    nm: string | number;
+    pr: number;
+    qt: number;
+    br: string | number;
+    va: string | number;
+    ca: string | number;
+    ps: number;
+    cc: string | number;
+    attrs: Record<string, string> | null;
+    dp_id?: string;
+    dp_v?: number;
+    n?: string;
+    et?: number;
+    ua?: Dictionary<string | string[]>;
+    ui?: ISDKUserIdentity[];
+    ia?: Dictionary<Dictionary<string>>;
+    str?: ServerSettings;
+    sdk?: string;
+    sid?: string;
+    sl?: number;
+    ssd?: number;
+    dt?: number;
+    dbg?: boolean;
+    ct?: number;
+    lc?: SDKGeoLocation;
+    o?: boolean;
+    eec?: number;
+    av?: string;
+    cgid?: string;
+    das?: string;
+    mpid?: MPID;
+    smpids?: MPID[];
+    con?: IConsentStateV2DTO;
+    fr?: boolean;
+    iu?: boolean;
+    at?: number;
+    lr?: string;
+    flags?: Dictionary<string[]>;
+    cu?: string;
+    sc?: {
+        pl: IProductV2DTO[];
+    };
+    pd?: {
+        an: number;
+        cs: number;
+        co: string;
+        pl: IProductV2DTO[];
+        ta: string;
+        ti: string;
+        tcc: string;
+        tr: number;
+        ts: number;
+        tt: number;
+    };
+    pm?: {
+        an: string;
+        pl: IPromotionV2DTO[];
+    };
+    pi?: IProductImpressionV2DTO[];
+    pet?: number;
+}
+export interface IProductV2DTO {
+    id: string | number;
+    nm: string | number;
+    pr: number;
+    qt: number;
+    br: string | number;
+    va: string | number;
+    ca: string | number;
+    ps: number;
+    cc: string | number;
+    tpa: number;
+    attrs: Dictionary<string> | null;
+}
+export interface IPromotionV2DTO {
+    id: string | number;
+    nm: string | number;
+    ps: string | number;
+    cr: string;
+}
+export interface IProductImpressionV2DTO {
+    pil: string;
+    pl: IProductV2DTO[];
+}
+export interface IUploadObject extends SDKEvent {
+    ClientGeneratedId: string;
+    Store: ServerSettings;
+    ExpandedEventCount: number;
+    ProfileMessageType: number;
+}
+export interface IServerModel {
+    convertEventToV2DTO: (event: IUploadObject) => IServerV2DTO;
+    createEventObject: (event: BaseEvent, user?: IMParticleUser) => SDKEvent;
+    convertToConsentStateV2DTO: (state: SDKConsentState) => IConsentStateV2DTO;
+}
+export default function ServerModel(this: IServerModel, mpInstance: IMParticleWebSDKInstance): void;

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

@@ -0,0 +1,16 @@
+import { IMParticleWebSDKInstance } from './mp-instance';
+export interface ISessionManager {
+    initialize: () => void;
+    getSessionId: () => string;
+    startNewSession: () => void;
+    endSession: (override?: boolean) => void;
+    setSessionTimer: () => void;
+    resetSessionTimer: () => void;
+    clearSessionTimeout: () => void;
+    startNewSessionIfNeeded: () => void;
+    /**
+     * @deprecated
+     */
+    getSession: () => string;
+}
+export default function SessionManager(this: ISessionManager, mpInstance: IMParticleWebSDKInstance): void;

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

@@ -0,0 +1,30 @@
+import { IKitFilterSettings } from './configAPIClient';
+import { UnregisteredKit } from './forwarders.interfaces';
+import { EventType, IdentityType } from './types';
+import { valueof } from './utils';
+export interface IMPSideloadedKit {
+    kitInstance: UnregisteredKit;
+    filterDictionary: IKitFilterSettings;
+    addEventTypeFilter(eventType: valueof<typeof EventType>): void;
+    addEventNameFilter(eventType: valueof<typeof EventType>, eventName: string): void;
+    addEventAttributeFilter(eventType: valueof<typeof EventType>, eventName: string, customAttributeKey: string): void;
+    addScreenNameFilter(screenName: string): void;
+    addScreenAttributeFilter(screenName: string, screenAttribute: string): void;
+    addUserIdentityFilter(userIdentity: typeof IdentityType): void;
+    addUserAttributeFilter(userAttributeKey: string): void;
+}
+export interface IMPSideloadedKitConstructor {
+    new (unregisteredKitInstance: UnregisteredKit): IMPSideloadedKit;
+}
+export default class MPSideloadedKit implements IMPSideloadedKit {
+    kitInstance: UnregisteredKit;
+    filterDictionary: IKitFilterSettings;
+    constructor(unregisteredKitInstance: UnregisteredKit);
+    addEventTypeFilter(eventType: valueof<typeof EventType>): void;
+    addEventNameFilter(eventType: valueof<typeof EventType>, eventName: string): void;
+    addEventAttributeFilter(eventType: valueof<typeof EventType>, eventName: string, customAttributeKey: string): void;
+    addScreenNameFilter(screenName: string): void;
+    addScreenAttributeFilter(screenName: string, screenAttribute: string): void;
+    addUserIdentityFilter(userIdentity: typeof IdentityType): void;
+    addUserAttributeFilter(userAttributeKey: string): void;
+}

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