@joryio/web-sdk 0.0.0-stage → 1.3.0-beta.1

package/dist/index.d.mts

@@ -0,0 +1,711 @@
+type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+declare class Logger {
+    private enabled;
+    private level;
+    constructor(enabled: boolean, level?: LogLevel);
+    private shouldLog;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    setEnabled(enabled: boolean): void;
+    setLevel(level: LogLevel): void;
+}
+
+declare class StorageManager {
+    private prefix;
+    private memoryStore;
+    private isLocalStorageAvailable;
+    private logger;
+    private static hashKey;
+    constructor(sdkKey: string, logger: Logger);
+    private checkLocalStorageAvailable;
+    private getKey;
+    storageKeyFor(key: string): string;
+    set<T>(key: string, value: T, expiresInDays?: number): void;
+    get<T>(key: string): T | null;
+    remove(key: string): void;
+    clear(): void;
+}
+
+interface UTMParameters {
+    utm_source?: string;
+    utm_medium?: string;
+    utm_campaign?: string;
+    utm_content?: string;
+    utm_term?: string;
+    referrer?: string;
+    landing_page?: string;
+    captured_at?: number;
+}
+interface UTMData {
+    current: UTMParameters | null;
+    firstTouch: UTMParameters | null;
+    lastTouch: UTMParameters | null;
+}
+
+interface SessionInfo {
+    sessionId: string;
+    sessionStart: number;
+    lastActivity: number;
+    isNewSession: boolean;
+}
+
+interface WriteOwner {
+    anonymousId: string;
+    userId?: string;
+}
+type WriteRecord = {
+    kind: 'alias';
+    payload: {
+        anonymousId: string;
+        userId?: string;
+        aliasLabel: string;
+        aliasName: string;
+    };
+} | {
+    kind: 'subscription';
+    payload: {
+        channel: any;
+        status: any;
+        userId?: string;
+        anonymousId: string;
+    };
+} | {
+    kind: 'group';
+    payload: {
+        groupId: string;
+        channel: any;
+        action: 'subscribe' | 'unsubscribe';
+        userId?: string;
+        anonymousId: string;
+    };
+} | {
+    kind: 'marker';
+    payload: {
+        value: boolean;
+        userId?: string;
+        anonymousId: string;
+    };
+};
+type WriteRunner = (label: string, record: WriteRecord) => void;
+
+declare enum SubscriptionStatus {
+    OPTED_IN = "optedIn",
+    SUBSCRIBED = "subscribed",
+    UNSUBSCRIBED = "unsubscribed"
+}
+type SubscriptionChannel = 'email' | 'sms' | 'whatsapp' | 'push' | 'viber';
+type SubscriptionPreferences = Partial<Record<SubscriptionChannel, SubscriptionStatus>>;
+declare class User {
+    private logger;
+    private network;
+    private identity;
+    private apiEndpoint;
+    private runWrite;
+    constructor(logger: Logger, network: NetworkClient, identity: IdentityManager, apiEndpoint: string, runWrite?: WriteRunner);
+    private sendOnce;
+    private ids;
+    setSubscription(channel: SubscriptionChannel, status: SubscriptionStatus): void;
+    setSubscriptions(preferences: SubscriptionPreferences): void;
+    addToSubscriptionGroup(groupId: string, channel?: SubscriptionChannel): void;
+    removeFromSubscriptionGroup(groupId: string, channel?: SubscriptionChannel): void;
+    private updateGroup;
+}
+
+interface NetworkRequest {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: any;
+    subjectUserId?: string | null;
+}
+interface NetworkResponse {
+    ok: boolean;
+    status: number;
+    data?: any;
+    error?: string;
+    retryAfterMs?: number;
+    softFailure?: boolean;
+}
+interface AttributeOps {
+    attributes?: Record<string, any>;
+    increment?: Record<string, number>;
+    append?: Record<string, any>;
+    remove?: Record<string, any>;
+    unset?: string[];
+}
+interface RetryConfig {
+    maxRetries: number;
+    backoffMs: number;
+    maxBackoffMs?: number;
+    timeoutMs?: number;
+}
+interface RetiredTokenStore {
+    load(): Record<string, unknown> | null;
+    update(mutate: (stored: Record<string, unknown>) => Record<string, unknown>): void;
+}
+type SdkAuthFailureReason = 'missing' | 'invalid' | 'expired' | 'sub_mismatch';
+interface SdkAuthFailureInfo {
+    reason: SdkAuthFailureReason;
+    endpoint: string;
+    userId?: string | null;
+}
+type SdkAuthFailureCallback = (info: SdkAuthFailureInfo) => void | string | Promise<void | string>;
+interface CircuitBreakerConfig {
+    failureThreshold: number;
+    cooldownMs: number;
+}
+type CircuitState = 'closed' | 'open' | 'half-open';
+declare class NetworkClient {
+    private logger;
+    private sdkKey;
+    private retryConfig;
+    private circuitBreakerConfig;
+    private circuitState;
+    private consecutiveFailures;
+    private circuitOpenedAt;
+    private sdkAuthEnabled;
+    private sdkAuthToken;
+    private sdkAuthFailureCallback;
+    private retiredSdkAuthTokens;
+    private retiredTokenStore;
+    private sdkAuthTokenUser;
+    private keepaliveBytesInFlight;
+    private currentUserId;
+    private suspended;
+    constructor(sdkKey: string, logger: Logger, retryConfig: RetryConfig, circuitBreakerConfig?: Partial<CircuitBreakerConfig>);
+    setSdkAuthenticationEnabled(enabled: boolean): void;
+    setSdkAuthenticationToken(token: string | undefined): void;
+    retireSdkAuthToken(): void;
+    private retireToken;
+    switchUser(userId: string | null): void;
+    private adoptStandbyToken;
+    dropStandbySdkAuthTokens(keep?: Set<string>): void;
+    setRetiredTokenStore(store: RetiredTokenStore | null): void;
+    retiredSdkAuthUsers(): string[];
+    forgetRetiredSdkAuthTokensExcept(stillQueued: Set<string>, now?: number): number | null;
+    private saveRetiredTokens;
+    private sdkAuthTokenFor;
+    getCurrentUserId(): string | null;
+    setSdkAuthenticationFailureCallback(cb: SdkAuthFailureCallback | null): void;
+    setCurrentUserId(userId: string | null): void;
+    isSuspended(): boolean;
+    noteSuspended(status: number, data: any): boolean;
+    getSdkAuthHeaders(subjectUserId?: string | null): Record<string, string>;
+    keepaliveBudget(): number;
+    isSdkAuthError(status: number, data: any): boolean;
+    refreshSdkAuthToken(info: SdkAuthFailureInfo): Promise<string | undefined>;
+    request(request: NetworkRequest): Promise<NetworkResponse>;
+    private onRequestSuccess;
+    private onRequestFailure;
+    getCircuitBreakerState(): {
+        state: CircuitState;
+        consecutiveFailures: number;
+        openedAt: number;
+    };
+    private performFetch;
+    private parseResponse;
+    private shouldRetry;
+    private calculateBackoff;
+    private sleep;
+    sendEvents(apiEndpoint: string, events: any[], identify?: {
+        userId: string;
+        anonymousId: string;
+        attributes?: Record<string, any>;
+    }): Promise<NetworkResponse>;
+    supportsKeepalive(): boolean;
+    sendEventsKeepalive(apiEndpoint: string, events: any[], identify?: {
+        userId: string;
+        anonymousId: string;
+        attributes?: Record<string, any>;
+    }): Promise<NetworkResponse> | null;
+    postKeepalive(url: string, body: any): Promise<NetworkResponse> | null;
+    sendIdentify(apiEndpoint: string, userId: string, attributes: any, anonymousId?: string): Promise<NetworkResponse>;
+    sendAddAlias(apiEndpoint: string, payload: {
+        anonymousId: string;
+        userId?: string;
+        aliasLabel: string;
+        aliasName: string;
+    }): Promise<NetworkResponse>;
+    sendDeviceSession(apiEndpoint: string, payload: {
+        userId?: string;
+        anonymousId?: string;
+        deviceId: string;
+        platform: 'ios' | 'android' | 'web';
+        deviceInfo?: Record<string, any>;
+    }): Promise<NetworkResponse>;
+    sendSetAttributes(apiEndpoint: string, ops: AttributeOps, userId?: string | null, anonymousId?: string): Promise<NetworkResponse>;
+    sendSubscriptionUpdate(apiEndpoint: string, payload: {
+        channel: SubscriptionChannel;
+        status: 'optedIn' | 'subscribed' | 'unsubscribed';
+        userId?: string;
+        anonymousId?: string;
+    }): Promise<NetworkResponse>;
+    sendSubscriptionGroupUpdate(apiEndpoint: string, payload: {
+        groupId: string;
+        channel: SubscriptionChannel;
+        action: 'subscribe' | 'unsubscribe';
+        userId?: string;
+        anonymousId?: string;
+    }): Promise<NetworkResponse>;
+}
+
+type AttributeOpKind = 'set' | 'unset' | 'increment' | 'append' | 'remove';
+interface AttributeEntry {
+    key: string;
+    kind: AttributeOpKind;
+    value?: any;
+    values?: any[];
+    inFlight?: boolean;
+    owner?: WriteOwner;
+    attempts?: number;
+}
+interface AttributeRequest {
+    ops: AttributeOps;
+    entries: AttributeEntry[];
+    owner?: WriteOwner;
+}
+type OwnerResolver = (owner: WriteOwner | undefined) => WriteOwner | undefined;
+declare class PendingAttributes {
+    private readonly maxEntries;
+    private entries;
+    constructor(maxEntries?: number);
+    add(kind: AttributeOpKind, key: string, value?: any, owner?: WriteOwner): void;
+    mark(ops: AttributeOps, owner?: WriteOwner): void;
+    isEmpty(): boolean;
+    hasUnsent(): boolean;
+    nextRequest(resolve?: OwnerResolver): AttributeRequest | null;
+    peekRequest(resolve?: OwnerResolver): AttributeRequest | null;
+    toOps(): AttributeOps | null;
+    acknowledge(sent: AttributeEntry[]): void;
+    release(sent: AttributeEntry[], dropIncrements: boolean): number;
+    drop(sent: AttributeEntry[]): void;
+    dropIncrements(sent: AttributeEntry[]): void;
+    pending(anonymousId?: string): Record<string, any>;
+    serialize(): AttributeEntry[];
+    restore(stored: unknown): void;
+    pinOwner(anonymousId: string, userId: string): void;
+    clear(): void;
+    private build;
+    private lastFor;
+    private trim;
+}
+
+interface UserAttributes {
+    [key: string]: any;
+}
+interface UserIdentity {
+    userId: string | null;
+    anonymousId: string;
+    attributes: UserAttributes;
+}
+declare class IdentityManager {
+    readonly pending: PendingAttributes;
+    private storage;
+    private logger;
+    private userId;
+    private anonymousId;
+    private attributes;
+    constructor(storage: StorageManager, logger: Logger, userId?: string, anonymousId?: string);
+    identify(userId: string, attributes?: UserAttributes): void;
+    reset(): void;
+    adopt(anonymousId: string, userId: string | null): void;
+    setAttributes(attributes: UserAttributes): void;
+    setAttribute(key: string, value: any): void;
+    incrementAttribute(key: string, value?: number): void;
+    unsetAttribute(key: string): void;
+    addToArray(key: string, value: any): void;
+    removeFromArray(key: string, value: any): void;
+    getIdentity(): UserIdentity;
+    getUserId(): string | null;
+    getAnonymousId(): string;
+    getAttributes(): UserAttributes;
+    getAttribute(key: string): any;
+    isIdentified(): boolean;
+}
+
+declare const SDK_VERSION = "1.3.0";
+interface InAppDisplayOptions {
+    defaultPosition?: 'top' | 'center' | 'bottom';
+    defaultAnimation?: 'fade' | 'slide' | 'none';
+    backdropColor?: string;
+    closeButtonColor?: string;
+    zIndex?: number;
+}
+interface InAppOptions {
+    enabled?: boolean;
+    evaluationMode?: 'differential-sync' | 'session-start-only';
+    syncInterval?: number;
+    displayOptions?: InAppDisplayOptions;
+    allowHtmlJsInAppMessages?: boolean;
+    onMessageDisplay?: (message: any) => void;
+    onMessageClick?: (message: any, action: string) => void;
+    onMessageDismiss?: (message: any, action: string) => void;
+}
+interface InitConfig {
+    sdkKey: string;
+    apiEndpoint?: string;
+    userId?: string;
+    anonymousId?: string;
+    batchSize?: number;
+    batchFlushInterval?: number;
+    sendImmediately?: boolean;
+    maxQueueSize?: number;
+    sessionTimeout?: number;
+    trackSessionStart?: boolean;
+    trackPageViews?: boolean;
+    captureUTM?: boolean;
+    resetSessionOnNewCampaign?: boolean;
+    trackPageProperties?: boolean;
+    trackDeviceProperties?: boolean;
+    inApp?: InAppOptions;
+    persistQueue?: boolean;
+    maxRetries?: number;
+    retryBackoffMs?: number;
+    requestTimeout?: number;
+    respectDoNotTrack?: boolean;
+    optOut?: boolean;
+    trackingConsent?: 'granted' | 'denied' | 'pending';
+    enableSdkAuthentication?: boolean;
+    sdkAuthenticationToken?: string;
+    enableDebug?: boolean;
+    logLevel?: 'error' | 'warn' | 'info' | 'debug';
+    plugins?: Array<Plugin>;
+}
+interface Plugin {
+    name: string;
+    version: string;
+    load(sdk: any): void | Promise<void>;
+    unload(): void | Promise<void>;
+    beforeTrack?(event: any): any | null;
+    afterTrack?(event: any): void;
+}
+
+interface InAppCampaign {
+    id: string;
+    name: string;
+    type: 'modal' | 'banner' | 'slideup' | 'fullscreen' | 'custom';
+    priority: number;
+    evaluationMode: 'differential-sync' | 'session-start-only';
+    frequencyCap?: {
+        maxImpressions?: number | null;
+        timeWindow: string;
+        minDelayBetweenImpressions?: number;
+    };
+    variantId?: string;
+    variantName?: string;
+    pendingId?: string;
+    deliveryToken?: string;
+    source?: string;
+    content?: {
+        kind: 'html';
+        html: string;
+        css: string;
+        assets?: unknown[];
+    } | {
+        kind: 'native';
+        title?: string;
+        body: string;
+        imageUrl?: string;
+        buttons?: Array<{
+            id: string;
+            text: string;
+            action: string;
+            url?: string;
+        }>;
+        closeButton?: boolean;
+        backdropDismissible?: boolean;
+    };
+    targeting?: {
+        filterGroups: any[];
+    };
+    triggers: InAppTrigger[];
+    reevaluateBeforeDisplay?: boolean;
+    watchedAttributes?: string[];
+}
+interface InAppTrigger {
+    type: 'immediate' | 'event' | 'attribute_change' | 'attribute_threshold' | 'push_notification_tap';
+    event?: string;
+    attribute?: string;
+    operator?: string;
+    value?: any;
+    delay?: number;
+}
+interface InAppMessage {
+    campaign: InAppCampaign;
+    renderedHtml: string;
+    displayedAt?: Date;
+}
+
+interface EcommerceProduct {
+    productId: string;
+    name: string;
+    price: number;
+    quantity?: number;
+    category?: string;
+    brand?: string;
+    variant?: string;
+    variantId?: string;
+    sku?: string;
+    imageUrl?: string;
+    url?: string;
+}
+interface EcommerceCartItem extends EcommerceProduct {
+    quantity: number;
+}
+interface EcommerceOrder {
+    orderId: string;
+    items: EcommerceCartItem[];
+    value: number;
+    currency?: string;
+    shipping?: number;
+    tax?: number;
+    discount?: number;
+    coupon?: string;
+}
+interface EcommerceConfig {
+    currency?: string;
+}
+declare class EcommerceTracker {
+    private sdk;
+    private config;
+    private logger;
+    constructor(sdk: JoryioSDK, config?: EcommerceConfig | null, logger?: Logger);
+    private guard;
+    private productProblem;
+    private itemsProblem;
+    private cartProblem;
+    private textProblem;
+    private amountsProblem;
+    private validItems;
+    private itemCount;
+    viewProduct(product: EcommerceProduct): void;
+    viewCategory(categoryId: string, categoryName: string, properties?: Record<string, any>): void;
+    search(query: string, resultCount?: number, properties?: Record<string, any>): void;
+    addToCart(item: EcommerceCartItem, cartValue?: number): void;
+    removeFromCart(item: EcommerceProduct, quantity?: number): void;
+    cartViewed(items: EcommerceCartItem[], cartValue: number): void;
+    updateCart(items: EcommerceCartItem[], cartValue: number): void;
+    startCheckout(items: EcommerceCartItem[], cartValue: number, properties?: Record<string, any>): void;
+    addPaymentInfo(paymentMethod: string, properties?: Record<string, any>): void;
+    purchase(order: EcommerceOrder): void;
+    orderFulfilled(orderId: string, trackingNumber?: string, carrier?: string): void;
+    orderDelivered(orderId: string): void;
+    orderCancelled(orderId: string, reason?: string): void;
+    orderRefunded(orderId: string, refundAmount?: number, reason?: string): void;
+    addToWishlist(product: EcommerceProduct): void;
+    removeFromWishlist(product: EcommerceProduct): void;
+    shareProduct(product: EcommerceProduct, shareMethod: string): void;
+    applyCoupon(couponCode: string, discountAmount?: number, discountType?: 'fixed' | 'percentage'): void;
+    removeCoupon(couponCode: string): void;
+    submitReview(productId: string, rating: number, reviewText?: string): void;
+}
+declare function createEcommerceTracker(sdk: JoryioSDK, config?: EcommerceConfig | null, logger?: Logger): EcommerceTracker;
+
+interface PushManagerOptions {
+    canSend?: () => boolean;
+    canWithdraw?: () => boolean;
+    withdrawalUserId?: () => string | null;
+    storage?: StorageManager;
+    getDeviceId?: () => string | undefined;
+    onSubscribeSettled?: () => void;
+}
+interface PushSubscribeOptions {
+    swPath?: string;
+    scope?: string;
+}
+type PushPermissionState = 'granted' | 'denied' | 'notDetermined' | 'unavailable';
+declare class PushManager {
+    private readonly logger;
+    private readonly network;
+    private readonly identity;
+    private readonly apiEndpoint;
+    private vapidKeyCache;
+    private prepared;
+    private lastPrepareError;
+    private readonly canSend;
+    private readonly canWithdraw;
+    private readonly withdrawalUserId;
+    private readonly storage;
+    private unregisterInFlight;
+    private unregisterTimer;
+    private readonly getDeviceId;
+    private readonly onSubscribeSettled;
+    constructor(logger: Logger, network: NetworkClient, identity: IdentityManager, apiEndpoint: string, options?: PushManagerOptions);
+    isSupported(): boolean;
+    getPermissionState(): PushPermissionState;
+    getExistingSubscription(options?: PushSubscribeOptions | null): Promise<PushSubscription | null>;
+    syncExistingSubscription(force?: boolean, options?: PushSubscribeOptions | null): Promise<void>;
+    setTrackingOptedOut(optedOut: boolean): Promise<void>;
+    prepare(options?: PushSubscribeOptions | null): Promise<boolean>;
+    subscribe(options?: PushSubscribeOptions | null): Promise<PushSubscription | null>;
+    private subscribeOnce;
+    unsubscribe(options?: PushSubscribeOptions | null): Promise<boolean>;
+    forget(): Promise<void>;
+    pendingUnregisterUsers(): string[];
+    private pendingUnregisters;
+    private storePendingUnregisters;
+    retryPendingUnregister(): void;
+    private sendPendingUnregister;
+    destroy(): void;
+    private logRegisterFailure;
+    private subscriptionKeyMatches;
+    private fetchVapidPublicKey;
+    private registerWithBackend;
+}
+
+type TrackingConsent = 'granted' | 'denied' | 'pending';
+type PreInitDecision = {
+    method: 'optOut';
+} | {
+    method: 'optIn';
+} | {
+    method: 'updateConsent';
+    consent: TrackingConsent;
+} | {
+    method: 'wipeData';
+};
+declare class JoryioSDK {
+    private static instance;
+    private config;
+    private logger;
+    private storage;
+    private session;
+    private static readonly ATTRIBUTE_FLUSH_DEBOUNCE_MS;
+    private attributeFlushTimer;
+    private attributeFlushInFlight;
+    private attributeFlushAgain;
+    private attributeGeneration;
+    private attributeFailures;
+    private identity;
+    private queue;
+    private network;
+    private utm;
+    private inapp;
+    private _user;
+    private _push;
+    private _ecommerce;
+    private isInitialized;
+    private isOptedOut;
+    private disabled;
+    private consentPending;
+    private userOptedOut;
+    private dntEnabled;
+    private trackingConsent;
+    private outbox;
+    private lastTrackedUrl;
+    private deviceId;
+    private boundHandlePageUnload;
+    private boundHandleOnline;
+    private boundHandleStorage;
+    private withdrawalUserId;
+    private optedOutAt;
+    private consentDeniedAt;
+    private lastDecisionStamp;
+    private awaitingSessionOf;
+    private pruneTimer;
+    constructor(config: InitConfig, preInit?: PreInitDecision[]);
+    private createOutbox;
+    private currentOwner;
+    private effectiveUserId;
+    private deferIdentify;
+    private releaseDeferredIdentify;
+    private forgetDeferredIdentify;
+    private scheduleRetiredTokenPrune;
+    private pruneRetiredTokens;
+    private handleStorageEvent;
+    private repersistPrivacyDecisions;
+    private storedStamp;
+    private noteDecisionStamps;
+    private nextDecisionStamp;
+    private storedOptOut;
+    private storedDenial;
+    private writeOptOut;
+    private writeOptIn;
+    private writeDenial;
+    private writeGrant;
+    private resolveOwner;
+    private pinAnonymousWrites;
+    private writeRequest;
+    private markerOps;
+    private sendWrite;
+    private onWriteSettled;
+    private syncWorkerReporting;
+    private initialConsent;
+    private storeConsent;
+    private applyPreInitDecision;
+    getTrackingConsent(): TrackingConsent;
+    isUserOptedOut(): boolean;
+    private syncOptOutMarker;
+    private recomputePrivacy;
+    private canSend;
+    private applyPrivacyState;
+    private releaseHeldWrites;
+    private runWrite;
+    private restoreAttributeWrites;
+    private persistAttributeWrites;
+    private flushQueueForWrite;
+    private trackSessionStart;
+    private trackSessionStartIfMissing;
+    private getOrCreateDeviceId;
+    private trackPageView;
+    track(eventName: string, properties?: Record<string, any>): void;
+    identify(userId: string): void;
+    addAlias(aliasLabel: string, aliasName: string): void;
+    setAttributes(attributes: Record<string, any>): void;
+    private sendAttributesAfterPendingIdentify;
+    private scheduleAttributeFlush;
+    private clearPendingAttributeWrites;
+    private flushAttributeOps;
+    private attributeRetryDelay;
+    private reportPushPermissionIfChanged;
+    setAttribute(key: string, value: any): void;
+    incrementAttribute(key: string, value?: number): void;
+    unsetAttribute(key: string): void;
+    addToArray(key: string, value: any): void;
+    removeFromArray(key: string, value: any): void;
+    reset(): Promise<void>;
+    wipeData(): Promise<void>;
+    private wipeLocalState;
+    private resyncInApp;
+    flush(): Promise<void>;
+    private flushEvents;
+    private classifyFailure;
+    private handlePageUnload;
+    private sendAttributesAtUnload;
+    optOut(): void;
+    optIn(): void;
+    updateConsent(consent: TrackingConsent): void;
+    private isDoNotTrackEnabled;
+    private loadPlugins;
+    private unloadPlugins;
+    get user(): User;
+    get push(): PushManager;
+    ecommerce(config?: EcommerceConfig): EcommerceTracker;
+    setSdkAuthenticationToken(token: string): void;
+    setSdkAuthenticationErrorCallback(cb: SdkAuthFailureCallback): void;
+    getAnonymousId(): string;
+    getUserId(): string | null;
+    private dataGate;
+    private liftDataGate;
+    private inflightSessionStartAtClear;
+    private isDroppingDataCalls;
+    ready(callback: (sdk: JoryioSDK) => void): void;
+    getIdentity(): UserIdentity;
+    getSessionInfo(): SessionInfo;
+    getUTMData(): UTMData;
+    updateUTM(): void;
+    syncInAppCampaigns(attributeChanges?: Record<string, any>): Promise<void>;
+    getInAppCampaigns(): InAppCampaign[];
+    displayInAppCampaign(campaignId: string): Promise<void>;
+    dismissInAppMessage(campaignId: string): void;
+    trackInAppConversion(campaignId: string, eventName: string): Promise<void>;
+    destroy(): Promise<void>;
+    static getInstance(): JoryioSDK | null;
+}
+
+declare function installSnippetQueue(win: any): void;
+
+export { EcommerceTracker, JoryioSDK, PushManager, SDK_VERSION, SubscriptionStatus, User, createEcommerceTracker, JoryioSDK as default, installSnippetQueue };
+export type { EcommerceCartItem, EcommerceConfig, EcommerceOrder, EcommerceProduct, InAppCampaign, InAppDisplayOptions, InAppMessage, InAppOptions, InAppTrigger, InitConfig, Plugin, PushPermissionState, PushSubscribeOptions, SdkAuthFailureCallback, SdkAuthFailureInfo, SdkAuthFailureReason, SubscriptionChannel, SubscriptionPreferences, TrackingConsent, UTMData, UTMParameters };