@datalyr/react-native 1.2.1 → 1.3.1

package/ios/PrivacyInfo.xcprivacy

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>NSPrivacyTracking</key>
+    <false/>
+    <key>NSPrivacyTrackingDomains</key>
+    <array/>
+    <key>NSPrivacyCollectedDataTypes</key>
+    <array>
+        <dict>
+            <key>NSPrivacyCollectedDataType</key>
+            <string>NSPrivacyCollectedDataTypeDeviceID</string>
+            <key>NSPrivacyCollectedDataTypeLinked</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypeTracking</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypePurposes</key>
+            <array>
+                <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+            </array>
+        </dict>
+        <dict>
+            <key>NSPrivacyCollectedDataType</key>
+            <string>NSPrivacyCollectedDataTypeProductInteraction</string>
+            <key>NSPrivacyCollectedDataTypeLinked</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypeTracking</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypePurposes</key>
+            <array>
+                <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+            </array>
+        </dict>
+    </array>
+    <key>NSPrivacyAccessedAPITypes</key>
+    <array>
+        <dict>
+            <key>NSPrivacyAccessedAPIType</key>
+            <string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+            <key>NSPrivacyAccessedAPITypeReasons</key>
+            <array>
+                <string>CA92.1</string>
+            </array>
+        </dict>
+    </array>
+</dict>
+</plist>

package/lib/ConversionValueEncoder.d.ts

@@ -1,7 +1,10 @@
+import { SKANCoarseValue, SKANConversionResult } from './native/SKAdNetworkBridge';
 interface EventMapping {
     bits: number[];
     revenueBits?: number[];
     priority: number;
+    coarseValue?: SKANCoarseValue;
+    lockWindow?: boolean;
 }
 interface ConversionTemplate {
     name: string;
@@ -11,13 +14,22 @@ export declare class ConversionValueEncoder {
     private template;
     constructor(template: ConversionTemplate);
     /**
-     * Encode an event into Apple's 0-63 conversion value format
+     * Encode an event into Apple's 0-63 conversion value format (SKAN 3.0 compatible)
+     * @deprecated Use encodeWithSKAN4 for iOS 16.1+
      */
     encode(event: string, properties?: Record<string, any>): number;
+    /**
+     * Encode an event with full SKAN 4.0 support (fine value, coarse value, lock window)
+     */
+    encodeWithSKAN4(event: string, properties?: Record<string, any>): SKANConversionResult;
     /**
      * Map revenue amount to 3-bit tier (0-7)
      */
     private getRevenueTier;
+    /**
+     * Map revenue to SKAN 4.0 coarse value
+     */
+    private getCoarseValueForRevenue;
 }
 export declare const ConversionTemplates: {
     ecommerce: ConversionTemplate;

package/lib/ConversionValueEncoder.js

@@ -3,18 +3,27 @@ export class ConversionValueEncoder {
         this.template = template;
     }
     /**
-     * Encode an event into Apple's 0-63 conversion value format
+     * Encode an event into Apple's 0-63 conversion value format (SKAN 3.0 compatible)
+     * @deprecated Use encodeWithSKAN4 for iOS 16.1+
      */
     encode(event, properties) {
+        return this.encodeWithSKAN4(event, properties).fineValue;
+    }
+    /**
+     * Encode an event with full SKAN 4.0 support (fine value, coarse value, lock window)
+     */
+    encodeWithSKAN4(event, properties) {
         const mapping = this.template.events[event];
-        if (!mapping)
-            return 0;
+        if (!mapping) {
+            return { fineValue: 0, coarseValue: 'low', lockWindow: false, priority: 0 };
+        }
         let conversionValue = 0;
         // Set event bits
         for (const bit of mapping.bits) {
             conversionValue |= (1 << bit);
         }
         // Set revenue bits if revenue is provided
+        let coarseValue = mapping.coarseValue || 'medium';
         if (mapping.revenueBits && properties) {
             const revenue = properties.revenue || properties.value || 0;
             const revenueTier = this.getRevenueTier(revenue);
@@ -23,8 +32,17 @@ export class ConversionValueEncoder {
                     conversionValue |= (1 << mapping.revenueBits[i]);
                 }
             }
+            // Upgrade coarse value based on revenue
+            coarseValue = this.getCoarseValueForRevenue(revenue);
         }
-        return Math.min(conversionValue, 63);
+        // Ensure value is within 0-63 range
+        const fineValue = Math.min(conversionValue, 63);
+        return {
+            fineValue,
+            coarseValue,
+            lockWindow: mapping.lockWindow || false,
+            priority: mapping.priority
+        };
     }
     /**
      * Map revenue amount to 3-bit tier (0-7)
@@ -46,40 +64,56 @@ export class ConversionValueEncoder {
             return 6; // $100-250
         return 7; // $250+
     }
+    /**
+     * Map revenue to SKAN 4.0 coarse value
+     */
+    getCoarseValueForRevenue(revenue) {
+        if (revenue < 10)
+            return 'low'; // $0-10 = low value
+        if (revenue < 50)
+            return 'medium'; // $10-50 = medium value
+        return 'high'; // $50+ = high value
+    }
 }
-// Industry templates
+// Industry templates with SKAN 4.0 support
 export const ConversionTemplates = {
+    // E-commerce template - optimized for online stores
+    // SKAN 4.0: purchase locks window, high-value events get "high" coarse value
     ecommerce: {
         name: 'ecommerce',
         events: {
-            purchase: { bits: [0], revenueBits: [1, 2, 3], priority: 100 },
-            add_to_cart: { bits: [4], priority: 30 },
-            begin_checkout: { bits: [5], priority: 50 },
-            signup: { bits: [6], priority: 20 },
-            subscribe: { bits: [0, 1], revenueBits: [2, 3, 4], priority: 90 },
-            view_item: { bits: [7], priority: 10 }
+            purchase: { bits: [0], revenueBits: [1, 2, 3], priority: 100, coarseValue: 'high', lockWindow: true },
+            add_to_cart: { bits: [4], priority: 30, coarseValue: 'low' },
+            begin_checkout: { bits: [5], priority: 50, coarseValue: 'medium' },
+            signup: { bits: [6], priority: 20, coarseValue: 'low' },
+            subscribe: { bits: [0, 1], revenueBits: [2, 3, 4], priority: 90, coarseValue: 'high', lockWindow: true },
+            view_item: { bits: [7], priority: 10, coarseValue: 'low' }
         }
     },
+    // Gaming template - optimized for mobile games
+    // SKAN 4.0: purchase locks window, tutorial completion is medium value
     gaming: {
         name: 'gaming',
         events: {
-            level_complete: { bits: [0], priority: 40 },
-            tutorial_complete: { bits: [1], priority: 60 },
-            purchase: { bits: [2], revenueBits: [3, 4, 5], priority: 100 },
-            achievement_unlocked: { bits: [6], priority: 30 },
-            session_start: { bits: [7], priority: 10 },
-            ad_watched: { bits: [0, 6], priority: 20 }
+            level_complete: { bits: [0], priority: 40, coarseValue: 'medium' },
+            tutorial_complete: { bits: [1], priority: 60, coarseValue: 'medium' },
+            purchase: { bits: [2], revenueBits: [3, 4, 5], priority: 100, coarseValue: 'high', lockWindow: true },
+            achievement_unlocked: { bits: [6], priority: 30, coarseValue: 'low' },
+            session_start: { bits: [7], priority: 10, coarseValue: 'low' },
+            ad_watched: { bits: [0, 6], priority: 20, coarseValue: 'low' }
         }
     },
+    // Subscription template - optimized for subscription apps
+    // SKAN 4.0: subscribe/upgrade lock window, trial is medium value
     subscription: {
         name: 'subscription',
         events: {
-            trial_start: { bits: [0], priority: 70 },
-            subscribe: { bits: [1], revenueBits: [2, 3, 4], priority: 100 },
-            upgrade: { bits: [1, 5], revenueBits: [2, 3, 4], priority: 90 },
-            cancel: { bits: [6], priority: 20 },
-            signup: { bits: [7], priority: 30 },
-            payment_method_added: { bits: [0, 7], priority: 50 }
+            trial_start: { bits: [0], priority: 70, coarseValue: 'medium' },
+            subscribe: { bits: [1], revenueBits: [2, 3, 4], priority: 100, coarseValue: 'high', lockWindow: true },
+            upgrade: { bits: [1, 5], revenueBits: [2, 3, 4], priority: 90, coarseValue: 'high', lockWindow: true },
+            cancel: { bits: [6], priority: 20, coarseValue: 'low' },
+            signup: { bits: [7], priority: 30, coarseValue: 'low' },
+            payment_method_added: { bits: [0, 7], priority: 50, coarseValue: 'medium' }
         }
     }
 };

package/lib/datalyr-sdk.d.ts

@@ -8,6 +8,7 @@ export declare class DatalyrSDK {
     private eventQueue;
     private autoEventsManager;
     private appStateSubscription;
+    private networkStatusUnsubscribe;
     private static conversionEncoder?;
     private static debugEnabled;
     constructor();
@@ -56,15 +57,30 @@ export declare class DatalyrSDK {
         currentUserId?: string;
         queueStats: any;
         attribution: any;
+        journey: any;
     };
     /**
      * Get the persistent anonymous ID
      */
     getAnonymousId(): string;
     /**
-     * Get detailed attribution data
+     * Get detailed attribution data (includes journey tracking data)
      */
-    getAttributionData(): AttributionData;
+    getAttributionData(): AttributionData & Record<string, any>;
+    /**
+     * Get journey tracking summary
+     */
+    getJourneySummary(): {
+        hasFirstTouch: boolean;
+        hasLastTouch: boolean;
+        touchpointCount: number;
+        daysSinceFirstTouch: number;
+        sources: string[];
+    };
+    /**
+     * Get full customer journey (all touchpoints)
+     */
+    getJourney(): import("./journey").TouchPoint[];
     /**
      * Set custom attribution data (for testing or manual attribution)
      */
@@ -91,6 +107,7 @@ export declare class DatalyrSDK {
     updateAutoEventsConfig(config: Partial<AutoEventConfig>): void;
     /**
      * Track event with automatic SKAdNetwork conversion value encoding
+     * Uses SKAN 4.0 on iOS 16.1+ with coarse values and lock window support
      */
     trackWithSKAdNetwork(event: string, properties?: EventData): Promise<void>;
     /**
@@ -140,12 +157,18 @@ export declare class DatalyrSDK {
         meta: boolean;
         tiktok: boolean;
         appleSearchAds: boolean;
+        playInstallReferrer: boolean;
     };
     /**
      * Get Apple Search Ads attribution data
      * Returns attribution if user installed via Apple Search Ads, null otherwise
      */
     getAppleSearchAdsAttribution(): AppleSearchAdsAttribution | null;
+    /**
+     * Get Google Play Install Referrer attribution data (Android only)
+     * Returns referrer data if available, null otherwise
+     */
+    getPlayInstallReferrer(): Record<string, any> | null;
     /**
      * Update tracking authorization status on all platform SDKs
      * Call this AFTER the user responds to the ATT permission dialog
@@ -171,6 +194,11 @@ export declare class DatalyrSDK {
      * Persist user data to storage
      */
     private persistUserData;
+    /**
+     * Initialize network status monitoring
+     * Automatically updates event queue when network status changes
+     */
+    private initializeNetworkMonitoring;
     /**
      * Set up app state monitoring for lifecycle events (optimized)
      */
@@ -221,6 +249,7 @@ export declare class Datalyr {
         currentUserId?: string;
         queueStats: any;
         attribution: any;
+        journey: any;
     };
     static getAnonymousId(): string;
     static getAttributionData(): AttributionData;

package/lib/datalyr-sdk.js

@@ -3,14 +3,17 @@ import { getOrCreateVisitorId, getOrCreateAnonymousId, getOrCreateSessionId, cre
 import { createHttpClient, HttpClient } from './http-client';
 import { createEventQueue, EventQueue } from './event-queue';
 import { attributionManager } from './attribution';
+import { journeyManager } from './journey';
 import { AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+import { networkStatusManager } from './network-status';
 export class DatalyrSDK {
     constructor() {
         this.autoEventsManager = null;
         this.appStateSubscription = null;
+        this.networkStatusUnsubscribe = null;
         // Initialize state with defaults
         this.state = {
             initialized: false,
@@ -72,15 +75,33 @@ export class DatalyrSDK {
                 flushInterval: this.state.config.flushInterval || 30000,
                 maxRetryCount: this.state.config.maxRetries || 3,
             });
-            // Initialize visitor ID, anonymous ID and session
-            this.state.visitorId = await getOrCreateVisitorId();
-            this.state.anonymousId = await getOrCreateAnonymousId();
-            this.state.sessionId = await getOrCreateSessionId();
-            // Load persisted user data
-            await this.loadPersistedUserData();
-            // Initialize attribution manager
-            if (this.state.config.enableAttribution) {
-                await attributionManager.initialize();
+            // PARALLEL INITIALIZATION: IDs and core managers
+            // Run ID creation and core manager initialization in parallel for faster startup
+            const [visitorId, anonymousId, sessionId] = await Promise.all([
+                getOrCreateVisitorId(),
+                getOrCreateAnonymousId(),
+                getOrCreateSessionId(),
+                // These run concurrently but don't return values we need to capture
+                this.loadPersistedUserData(),
+                this.state.config.enableAttribution ? attributionManager.initialize() : Promise.resolve(),
+                journeyManager.initialize(),
+            ]);
+            this.state.visitorId = visitorId;
+            this.state.anonymousId = anonymousId;
+            this.state.sessionId = sessionId;
+            // Record initial attribution to journey if this is a new session with attribution
+            const initialAttribution = attributionManager.getAttributionData();
+            if (initialAttribution.utm_source || initialAttribution.fbclid || initialAttribution.gclid || initialAttribution.lyr) {
+                await journeyManager.recordAttribution(this.state.sessionId, {
+                    source: initialAttribution.utm_source || initialAttribution.campaign_source,
+                    medium: initialAttribution.utm_medium || initialAttribution.campaign_medium,
+                    campaign: initialAttribution.utm_campaign || initialAttribution.campaign_name,
+                    fbclid: initialAttribution.fbclid,
+                    gclid: initialAttribution.gclid,
+                    ttclid: initialAttribution.ttclid,
+                    clickIdType: initialAttribution.fbclid ? 'fbclid' : initialAttribution.gclid ? 'gclid' : initialAttribution.ttclid ? 'ttclid' : undefined,
+                    lyr: initialAttribution.lyr,
+                });
             }
             // Initialize auto-events manager (asynchronously to avoid blocking)
             if (this.state.config.enableAutoEvents) {
@@ -105,7 +126,7 @@ export class DatalyrSDK {
                     errorLog('Error setting up app state monitoring (non-blocking):', error);
                 }
             }, 50);
-            // Initialize SKAdNetwork conversion encoder
+            // Initialize SKAdNetwork conversion encoder (synchronous, no await needed)
             if (config.skadTemplate) {
                 const template = ConversionTemplates[config.skadTemplate];
                 if (template) {
@@ -117,27 +138,39 @@ export class DatalyrSDK {
                     }
                 }
             }
-            // Initialize Meta SDK if configured
+            // PARALLEL INITIALIZATION: Network monitoring and platform integrations
+            // These are independent and can run concurrently for faster startup
+            const platformInitPromises = [
+                // Network monitoring
+                this.initializeNetworkMonitoring(),
+                // Apple Search Ads (iOS only)
+                appleSearchAdsIntegration.initialize(config.debug),
+                // Google Play Install Referrer (Android only)
+                playInstallReferrerIntegration.initialize(),
+            ];
+            // Add Meta initialization if configured
             if ((_b = config.meta) === null || _b === void 0 ? void 0 : _b.appId) {
-                await metaIntegration.initialize(config.meta, config.debug);
-                // Fetch deferred deep link and merge with attribution
-                if (config.enableAttribution !== false) {
-                    const deferredLink = await metaIntegration.fetchDeferredDeepLink();
-                    if (deferredLink) {
-                        await this.handleDeferredDeepLink(deferredLink);
+                platformInitPromises.push(metaIntegration.initialize(config.meta, config.debug).then(async () => {
+                    // After Meta initializes, fetch deferred deep link
+                    if (config.enableAttribution !== false) {
+                        const deferredLink = await metaIntegration.fetchDeferredDeepLink();
+                        if (deferredLink) {
+                            await this.handleDeferredDeepLink(deferredLink);
+                        }
                     }
-                }
+                }));
             }
-            // Initialize TikTok SDK if configured
+            // Add TikTok initialization if configured
             if (((_c = config.tiktok) === null || _c === void 0 ? void 0 : _c.appId) && ((_d = config.tiktok) === null || _d === void 0 ? void 0 : _d.tiktokAppId)) {
-                await tiktokIntegration.initialize(config.tiktok, config.debug);
+                platformInitPromises.push(tiktokIntegration.initialize(config.tiktok, config.debug));
             }
-            // Initialize Apple Search Ads attribution (iOS only, auto-fetches on init)
-            await appleSearchAdsIntegration.initialize(config.debug);
+            // Wait for all platform integrations to complete
+            await Promise.all(platformInitPromises);
             debugLog('Platform integrations initialized', {
                 meta: metaIntegration.isAvailable(),
                 tiktok: tiktokIntegration.isAvailable(),
                 appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+                playInstallReferrer: playInstallReferrerIntegration.isAvailable(),
             });
             // SDK initialized successfully - set state before tracking install event
             this.state.initialized = true;
@@ -398,6 +431,7 @@ export class DatalyrSDK {
             currentUserId: this.state.currentUserId,
             queueStats: this.eventQueue.getStats(),
             attribution: attributionManager.getAttributionSummary(),
+            journey: journeyManager.getJourneySummary(),
         };
     }
     /**
@@ -407,10 +441,28 @@ export class DatalyrSDK {
         return this.state.anonymousId;
     }
     /**
-     * Get detailed attribution data
+     * Get detailed attribution data (includes journey tracking data)
      */
     getAttributionData() {
-        return attributionManager.getAttributionData();
+        const attribution = attributionManager.getAttributionData();
+        const journeyData = journeyManager.getAttributionData();
+        // Merge attribution with journey data
+        return {
+            ...attribution,
+            ...journeyData,
+        };
+    }
+    /**
+     * Get journey tracking summary
+     */
+    getJourneySummary() {
+        return journeyManager.getJourneySummary();
+    }
+    /**
+     * Get full customer journey (all touchpoints)
+     */
+    getJourney() {
+        return journeyManager.getJourney();
     }
     /**
      * Set custom attribution data (for testing or manual attribution)
@@ -460,22 +512,25 @@ export class DatalyrSDK {
     // MARK: - SKAdNetwork Enhanced Methods
     /**
      * Track event with automatic SKAdNetwork conversion value encoding
+     * Uses SKAN 4.0 on iOS 16.1+ with coarse values and lock window support
      */
     async trackWithSKAdNetwork(event, properties) {
         // Existing tracking (keep exactly as-is)
         await this.track(event, properties);
-        // NEW: Automatic SKAdNetwork encoding
+        // Automatic SKAdNetwork encoding with SKAN 4.0 support
         if (!DatalyrSDK.conversionEncoder) {
             if (DatalyrSDK.debugEnabled) {
                 errorLog('SKAdNetwork encoder not initialized. Pass skadTemplate in initialize()');
             }
             return;
         }
-        const conversionValue = DatalyrSDK.conversionEncoder.encode(event, properties);
-        if (conversionValue > 0) {
-            const success = await SKAdNetworkBridge.updateConversionValue(conversionValue);
+        // Use SKAN 4.0 encoding (includes coarse value and lock window)
+        const result = DatalyrSDK.conversionEncoder.encodeWithSKAN4(event, properties);
+        if (result.fineValue > 0 || result.priority > 0) {
+            // Use SKAN 4.0 method (automatically falls back to SKAN 3.0 on older iOS)
+            const success = await SKAdNetworkBridge.updatePostbackConversionValue(result);
             if (DatalyrSDK.debugEnabled) {
-                debugLog(`Event: ${event}, Conversion Value: ${conversionValue}, Success: ${success}`, properties);
+                debugLog(`SKAN: event=${event}, fine=${result.fineValue}, coarse=${result.coarseValue}, lock=${result.lockWindow}, success=${success}`, properties);
             }
         }
         else if (DatalyrSDK.debugEnabled) {
@@ -676,6 +731,7 @@ export class DatalyrSDK {
             meta: metaIntegration.isAvailable(),
             tiktok: tiktokIntegration.isAvailable(),
             appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+            playInstallReferrer: playInstallReferrerIntegration.isAvailable(),
         };
     }
     /**
@@ -685,6 +741,14 @@ export class DatalyrSDK {
     getAppleSearchAdsAttribution() {
         return appleSearchAdsIntegration.getAttributionData();
     }
+    /**
+     * Get Google Play Install Referrer attribution data (Android only)
+     * Returns referrer data if available, null otherwise
+     */
+    getPlayInstallReferrer() {
+        const data = playInstallReferrerIntegration.getReferrerData();
+        return data ? playInstallReferrerIntegration.getAttributionData() : null;
+    }
     /**
      * Update tracking authorization status on all platform SDKs
      * Call this AFTER the user responds to the ATT permission dialog
@@ -849,6 +913,41 @@ export class DatalyrSDK {
             errorLog('Error persisting user data:', error);
         }
     }
+    /**
+     * Initialize network status monitoring
+     * Automatically updates event queue when network status changes
+     */
+    async initializeNetworkMonitoring() {
+        try {
+            await networkStatusManager.initialize();
+            // Update event queue with current network status
+            this.state.isOnline = networkStatusManager.isOnline();
+            this.eventQueue.setOnlineStatus(this.state.isOnline);
+            // Subscribe to network changes
+            this.networkStatusUnsubscribe = networkStatusManager.subscribe((state) => {
+                const isOnline = state.isConnected && (state.isInternetReachable !== false);
+                this.state.isOnline = isOnline;
+                this.eventQueue.setOnlineStatus(isOnline);
+                // Track network status change event (only if SDK is fully initialized)
+                if (this.state.initialized) {
+                    this.track('$network_status_change', {
+                        is_online: isOnline,
+                        network_type: state.type,
+                        is_internet_reachable: state.isInternetReachable,
+                    }).catch(() => {
+                        // Ignore errors for network status events
+                    });
+                }
+            });
+            debugLog(`Network monitoring initialized, online: ${this.state.isOnline}`);
+        }
+        catch (error) {
+            errorLog('Error initializing network monitoring (non-blocking):', error);
+            // Default to online if monitoring fails
+            this.state.isOnline = true;
+            this.eventQueue.setOnlineStatus(true);
+        }
+    }
     /**
      * Set up app state monitoring for lifecycle events (optimized)
      */
@@ -869,6 +968,8 @@ export class DatalyrSDK {
                 else if (nextAppState === 'active') {
                     // App became active, ensure we have fresh session if needed
                     this.refreshSession();
+                    // Refresh network status when coming back from background
+                    networkStatusManager.refresh();
                     // Notify auto-events manager for session handling
                     if (this.autoEventsManager) {
                         this.autoEventsManager.handleAppForeground();
@@ -906,6 +1007,13 @@ export class DatalyrSDK {
                 this.appStateSubscription.remove();
                 this.appStateSubscription = null;
             }
+            // Remove network status listener
+            if (this.networkStatusUnsubscribe) {
+                this.networkStatusUnsubscribe();
+                this.networkStatusUnsubscribe = null;
+            }
+            // Destroy network status manager
+            networkStatusManager.destroy();
             // Destroy event queue
             this.eventQueue.destroy();
             // Reset state

package/lib/index.d.ts

@@ -3,6 +3,8 @@ export declare const datalyr: DatalyrSDK;
 export { Datalyr };
 export * from './types';
 export { attributionManager } from './attribution';
+export { journeyManager } from './journey';
+export type { TouchAttribution, TouchPoint } from './journey';
 export { createAutoEventsManager, AutoEventsManager } from './auto-events';
 export * from './utils';
 export * from './http-client';
@@ -10,6 +12,8 @@ export * from './event-queue';
 export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+export { networkStatusManager } from './network-status';
+export type { NetworkState, NetworkStateListener } from './network-status';
 export type { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
 export default DatalyrSDK;

package/lib/index.js

@@ -8,6 +8,7 @@ export { Datalyr };
 // Export types and utilities
 export * from './types';
 export { attributionManager } from './attribution';
+export { journeyManager } from './journey';
 export { createAutoEventsManager, AutoEventsManager } from './auto-events';
 // Re-export utilities for advanced usage
 export * from './utils';
@@ -19,6 +20,8 @@ export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 // Export platform integrations
-export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+// Export network status manager
+export { networkStatusManager } from './network-status';
 // Default export for compatibility
 export default DatalyrSDK;

package/lib/integrations/index.d.ts

@@ -1,7 +1,9 @@
 /**
  * Platform SDK Integrations
- * Meta (Facebook), TikTok, and Apple Search Ads SDK wrappers
+ * Meta (Facebook), TikTok, Apple Search Ads, and Google Play Install Referrer SDK wrappers
  */
 export { MetaIntegration, metaIntegration } from './meta-integration';
 export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';
 export { AppleSearchAdsIntegration, appleSearchAdsIntegration } from './apple-search-ads-integration';
+export { playInstallReferrerIntegration } from './play-install-referrer';
+export type { PlayInstallReferrer } from './play-install-referrer';

package/lib/integrations/index.js

@@ -1,7 +1,8 @@
 /**
  * Platform SDK Integrations
- * Meta (Facebook), TikTok, and Apple Search Ads SDK wrappers
+ * Meta (Facebook), TikTok, Apple Search Ads, and Google Play Install Referrer SDK wrappers
  */
 export { MetaIntegration, metaIntegration } from './meta-integration';
 export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';
 export { AppleSearchAdsIntegration, appleSearchAdsIntegration } from './apple-search-ads-integration';
+export { playInstallReferrerIntegration } from './play-install-referrer';

package/lib/integrations/meta-integration.d.ts

@@ -15,6 +15,7 @@ export declare class MetaIntegration {
     private deferredDeepLinkData;
     /**
      * Initialize Meta SDK with configuration
+     * Supported on both iOS and Android via native modules
      */
     initialize(config: MetaConfig, debug?: boolean): Promise<void>;
     /**