@mparticle/web-sdk 2.61.0 → 2.62.0

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

@@ -0,0 +1,176 @@
+import { IKitConfigs } from "./configAPIClient";
+import { UserAttributeFilters } from "./forwarders.interfaces";
+import { IMParticleUser } from "./identity-user-interfaces";
+import { Dictionary, AttributeValue } from "./utils";
+import { SDKIdentityApi } from "./identity.interfaces";
+import { SDKLoggerApi } from "./sdkRuntimeModels";
+import { IStore, LocalSessionAttributes } from "./store";
+import { IErrorReportingService, ILoggingService } from "./reporting/types";
+export type RoktAttributeValueArray = Array<string | number | boolean>;
+export type RoktAttributeValueType = string | number | boolean | undefined | null;
+export type RoktAttributeValue = RoktAttributeValueType | RoktAttributeValueArray;
+export type RoktAttributes = Record<string, RoktAttributeValue>;
+export interface IRoktPartnerExtensionData<T> {
+    [extensionName: string]: T;
+}
+export interface IRoktSelectPlacementsOptions {
+    attributes: RoktAttributes;
+    identifier?: string;
+}
+interface IRoktPlacement {
+}
+export interface IRoktSelection {
+    close: () => void;
+    getPlacements: () => Promise<IRoktPlacement[]>;
+}
+export interface IRoktLauncher {
+    selectPlacements: (options: IRoktSelectPlacementsOptions) => Promise<IRoktSelection>;
+    hashAttributes: (attributes: RoktAttributes) => Promise<Record<string, string>>;
+    use: <T>(name: string) => Promise<T>;
+}
+export interface IRoktMessage {
+    messageId: string;
+    methodName: string;
+    payload: any;
+    resolve?: Function;
+    reject?: Function;
+}
+export interface RoktKitFilterSettings {
+    userAttributeFilters?: UserAttributeFilters;
+    filterUserAttributes?: (userAttributes: Dictionary<string>, filterList: number[]) => Dictionary<string>;
+    filteredUser?: IMParticleUser | null;
+}
+export interface IRoktKitSettings {
+    accountId?: string;
+    placementAttributesMapping?: string;
+    hashedEmailUserIdentityType?: string;
+}
+export interface IRoktKit {
+    filters: RoktKitFilterSettings;
+    filteredUser: IMParticleUser | null;
+    launcher: IRoktLauncher | null;
+    userAttributes: Dictionary<string>;
+    hashAttributes: (attributes: RoktAttributes) => Promise<RoktAttributes>;
+    selectPlacements: (options: IRoktSelectPlacementsOptions) => Promise<IRoktSelection>;
+    setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void;
+    use: <T>(name: string) => Promise<T>;
+    launcherOptions?: Dictionary<any>;
+    settings?: IRoktKitSettings;
+    integrationName?: string;
+}
+export interface IRoktOptions {
+    sandbox?: boolean;
+    launcherOptions?: IRoktLauncherOptions;
+    domain?: string;
+}
+export type IRoktLauncherOptions = Dictionary<any>;
+export default class RoktManager {
+    kit: IRoktKit;
+    filters: RoktKitFilterSettings;
+    private currentUser;
+    private messageQueue;
+    private sandbox;
+    private placementAttributesMapping;
+    private identityService;
+    private store;
+    private launcherOptions?;
+    private logger;
+    private errorReporter;
+    private loggingService;
+    private domain?;
+    private mappedEmailShaIdentityType?;
+    private captureTiming?;
+    private onReadyCallback;
+    private initialized;
+    /**
+     * Sets a callback to be invoked when RoktManager becomes ready
+     */
+    setOnReadyCallback(callback: () => void): void;
+    /**
+     * Initializes the RoktManager with configuration settings and user data.
+     *
+     * @param {IKitConfigs} roktConfig - Configuration object containing user attribute filters and settings
+     * @param {IMParticleUser} filteredUser - User object with filtered attributes
+     * @param {SDKIdentityApi} identityService - The mParticle Identity instance
+     * @param {SDKLoggerApi} logger - The mParticle Logger instance
+     * @param {IRoktOptions} options - Options for the RoktManager
+     * @param {Function} captureTiming - Function to capture performance timing marks
+     * @param {IErrorReportingService} errorReporter - Dispatcher for error/warning reporting
+     * @param {ILoggingService} loggingService - Dispatcher for informational logging
+     *
+     * @throws Logs error to console if placementAttributesMapping parsing fails
+     */
+    init(roktConfig: IKitConfigs, filteredUser: IMParticleUser, identityService: SDKIdentityApi, store: IStore, logger?: SDKLoggerApi, options?: IRoktOptions, captureTiming?: (metricsName: string) => void, errorReporter?: IErrorReportingService, loggingService?: ILoggingService): void;
+    get isInitialized(): boolean;
+    attachKit(kit: IRoktKit): void;
+    /**
+     * Renders ads based on the options provided
+     *
+     * @param {IRoktSelectPlacementsOptions} options - The options for selecting placements, including attributes and optional identifier
+     * @returns {Promise<IRoktSelection>} A promise that resolves to the selection
+     *
+     * @example
+     * // Correct usage with await
+     * await window.mParticle.Rokt.selectPlacements({
+     *   attributes: {
+     *     email: 'user@example.com',
+     *     customAttr: 'value'
+     *   }
+     * });
+     */
+    selectPlacements(options: IRoktSelectPlacementsOptions): Promise<IRoktSelection>;
+    /**
+     * Hashes attributes and returns both original and hashed versions
+     * with Rokt-compatible key names (like emailsha256, mobilesha256)
+     *
+     *
+     * @param {RoktAttributes} attributes - Attributes to hash
+     * @returns {Promise<RoktAttributes>} Object with both original and hashed attributes
+     *
+     */
+    hashAttributes(attributes: RoktAttributes): Promise<RoktAttributes>;
+    setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void;
+    use<T>(name: string): Promise<T>;
+    /**
+     * Hashes an attribute using SHA-256
+     *
+     * @param {string | number | boolean | undefined | null} attribute - The value to hash
+     * @returns {Promise<string | undefined | null>} SHA-256 hashed value or undefined/null
+     *
+     */
+    hashSha256(attribute: RoktAttributeValueType): Promise<string | undefined | null>;
+    getLocalSessionAttributes(): LocalSessionAttributes;
+    setLocalSessionAttribute(key: string, value: AttributeValue): void;
+    isReady(): boolean;
+    private setUserAttributes;
+    private mapPlacementAttributes;
+    onIdentityComplete(): void;
+    processMessageQueue(): void;
+    private queueMessage;
+    private deferredCall;
+    /**
+     * Hashes a string input using SHA-256 and returns the hex digest
+     * Uses the Web Crypto API for secure hashing
+     *
+     * @param {string} input - The string to hash
+     * @returns {Promise<string>} The SHA-256 hash as a hexadecimal string
+     */
+    private sha256Hex;
+    /**
+     * Converts an ArrayBuffer to a hexadecimal string representation
+     * Each byte is converted to a 2-character hex string with leading zeros
+     *
+     * @param {ArrayBuffer} buffer - The buffer to convert
+     * @returns {string} The hexadecimal string representation
+     */
+    private arrayBufferToHex;
+    /**
+     * Checks if an identity value has changed by comparing current and new values
+     *
+     * @param {string | undefined} currentValue - The current identity value
+     * @param {string | undefined} newValue - The new identity value to compare against
+     * @returns {boolean} True if the identity has changed (new value exists and differs from current), false otherwise
+     */
+    private hasIdentityChanged;
+}
+export {};

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