@mparticle/web-sdk 2.60.1 → 2.62.0

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

@@ -0,0 +1,59 @@
+import { SDKEvent, SDKEventCustomFlags } from './sdkRuntimeModels';
+import { Dictionary } from './utils';
+import { IKitConfigs, IKitFilterSettings } from './configAPIClient';
+import { IdentityApiData, IdentityType } from '@mparticle/web-sdk';
+import { Batch } from '@mparticle/event-models';
+import { IMParticleUser, ISDKUserIdentity, UserAttributes } from './identity-user-interfaces';
+export type MPForwarder = Dictionary;
+export interface UnregisteredKit {
+    constructor: () => void;
+    register(config: KitRegistrationConfig): void;
+    name: string;
+    moduleId?: number;
+    suffix?: string;
+}
+export interface RegisteredKit {
+    constructor: () => void;
+    filters?: IKitFilterSettings;
+}
+export interface KitRegistrationConfig {
+    kits: Dictionary<RegisteredKit>;
+}
+export interface ConfiguredKit extends Omit<IKitConfigs, 'isDebugString' | 'hasDebugString'> {
+    common: Dictionary<unknown>;
+    id: number;
+    init(settings: Dictionary<unknown>, service: forwardingStatsCallback, testMode: boolean, trackerId: string | null, userAttributes: UserAttributes, userIdentities: ISDKUserIdentity, appVersion: string, appName: string, customFlags: SDKEventCustomFlags, clientId: string): string;
+    onIdentifyComplete(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onLoginComplete(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onLogoutComplete(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onModifyComplete(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onUserIdentified(user: IMParticleUser): string;
+    process(event: SDKEvent): string;
+    setOptOut(isOptingOut: boolean): string;
+    removeUserAttribute(key: string): string;
+    setUserAttribute(key: string, value: string): string;
+    setUserIdentity(id: UserIdentityId, type: UserIdentityType): void;
+    isSandbox: boolean;
+    hasSandbox: boolean;
+}
+export interface KitInterface {
+    id: number;
+    name: string;
+    init(settings: Dictionary<unknown>, service: forwardingStatsCallback, testMode?: boolean, trackerId?: string | null, userAttributes?: UserAttributes, userIdentities?: ISDKUserIdentity, appVersion?: string, appName?: string, customFlags?: SDKEventCustomFlags, clientId?: string): string;
+    onIdentifyComplete?(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onLoginComplete?(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onLogoutComplete?(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onModifyComplete?(user: IMParticleUser, filteredIdentityRequest: IdentityApiData): string;
+    onUserIdentified?(user: IMParticleUser): string;
+    process?(event: SDKEvent): string;
+    processBatch?(batch: Batch): string;
+    setOptOut?(isOptingOut: boolean): string;
+    removeUserAttribute?(key: string): string;
+    setUserAttribute?(key: string, value: string): string;
+    setUserIdentity?(id: UserIdentityId, type: UserIdentityType): void;
+}
+export type UserIdentityId = string;
+export type UserIdentityType = number;
+export type UserAttributeFilters = number[];
+export type UserIdentityFilters = typeof IdentityType[];
+export type forwardingStatsCallback = (forwarder: ConfiguredKit, event: SDKEvent) => void;

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

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

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

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

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

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

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

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

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

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

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

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

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