@loyalytics/swan-react-native-sdk 2.0.1

package/lib/module/index.js

@@ -0,0 +1,3494 @@
+"use strict";
+
+/**
+ * Swan React Native SDK
+ * Copyright (c) 2025 Loyalytics. All Rights Reserved.
+ *
+ * PROPRIETARY AND CONFIDENTIAL
+ * Unauthorized copying, modification, distribution, or use of this software
+ * is strictly prohibited. See LICENSE file for full terms.
+ *
+ * For licensing inquiries: support@loyalytics.ai
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import Base64 from 'react-native-base64';
+import uuid from 'react-native-uuid';
+import { StyleSheet, View, Modal, PermissionsAndroid, Platform, AppState } from 'react-native';
+import { SDK_VERSION as PACKAGE_VERSION } from "./version.js";
+import PopUpView from "./components/PopUpView.js";
+import HeaderView from "./components/HeaderView.js";
+import FooterView from "./components/FooterView.js";
+import FullScreenView from "./components/FullScreenView.js";
+import { useState } from 'react';
+import SQLite from 'react-native-sqlite-2';
+import DeviceInfo from 'react-native-device-info';
+import Geolocation from '@react-native-community/geolocation';
+import Logger from "./utils/Logger.js";
+import { EventQueueManager } from "./core/EventQueueManager.js";
+import { FlushManager } from "./core/FlushManager.js";
+import { NetworkMonitor } from "./core/NetworkMonitor.js";
+import { DEFAULT_BATCH_CONFIG } from "./config/BatchConfig.js";
+import NetInfo from '@react-native-community/netinfo';
+
+// New imports for refactored architecture
+import { DeviceStateMachine } from "./state/DeviceStateMachine.js";
+import { PushStateMachine, PushState } from "./state/PushStateMachine.js";
+import { AuthStateMachine } from "./state/AuthStateMachine.js";
+import { DeviceRegistrationService } from "./services/DeviceRegistrationService.js";
+import { PushTokenService } from "./services/PushTokenService.js";
+import { NullPushProvider } from "./providers/NullPushProvider.js";
+import { SharedCredentialsManager } from "./utils/SharedCredentialsManager.js";
+import URLS from "./constants/ApiUrls.js";
+
+// Predefined Notification Channels
+// These channels are created automatically by FirebaseNotificationManager on SDK initialization
+// Swan Builder should use these channel IDs when creating push campaigns
+import { jsx as _jsx } from "react/jsx-runtime";
+export const SWAN_NOTIFICATION_CHANNELS = Object.freeze({
+  TRANSACTIONAL: 'swan_transactional',
+  // High priority - Orders, OTPs, urgent updates
+  ALERTS: 'swan_alerts',
+  // High priority - Critical alerts, warnings
+  PROMOTIONAL: 'swan_promotional',
+  // Normal priority - Marketing, offers, deals
+  GENERAL: 'swan_general',
+  // Normal priority - General updates, news
+  DEFAULT: 'swan_notifications' // Default channel (high priority)
+});
+const ECOM_EVENTS = Object.freeze({
+  APP_LAUNCHED: 'appLaunched',
+  USER_LOGOUT: 'userLogout',
+  USER_LOGIN: 'userLogin',
+  FORGOT_PASSWORD: 'forgotPassword',
+  SEARCH: 'search',
+  PRODUCT_VIEWED: 'productViewed',
+  PRODUCT_CLICKED: 'productClicked',
+  PRODUCT_LIST_VIEWED: 'productListViewed',
+  PRODUCT_ADDED_TO_ADD_TO_CART: 'productAddedToaddTocart',
+  PRODUCT_REMOVED_FROM_ADD_TO_CART: 'productRemovedFromAddToCart',
+  CLEAR_CART: 'clearCart',
+  SELECT_CATEGORY: 'selectCategory',
+  CATEGORY_VIEWED_PAGE: 'categoryViewedPage',
+  PRODUCT_ADDED_TO_WISHLIST: 'productAddedToWishlist',
+  PRODUCT_REMOVED_FROM_WISHLIST: 'productRemovedFromWishlist',
+  PRODUCT_RATED_OR_REVIEWED: 'productRatedOrReviewed',
+  CART_VIEWED: 'cartViewed',
+  OFFER_AVAILED: 'offerAvailed',
+  CHECKOUT_STARTED: 'checkoutStarted',
+  CHECKOUT_COMPLETED: 'checkoutCompleted',
+  CHECKOUT_CANCELED: 'checkoutCanceled',
+  PAYMENT_INFO_ENTERED: 'paymentInfoEntered',
+  ORDER_COMPLETED: 'orderCompleted',
+  ORDER_REFUNDED: 'orderRefunded',
+  ORDER_CANCELLED: 'orderCancelled',
+  ORDER_EXPERIANCE_RATING: 'orderExperianceRating',
+  PRODUCT_REVIEW: 'productReview',
+  PURCHASED: 'purchased',
+  APP_UPDATED: 'appUpdated',
+  ACCOUNT_DELETION: 'accountDeletion',
+  SHARE: 'share',
+  SCREEN: 'screen',
+  WISHLIST_PRODUCT_ADDED_TO_CART: 'wishlistProductAddedToCart',
+  SHIPPED: 'shipped',
+  PRODUCT_QUANTITY_SELECTED: 'productQuantitySelected'
+});
+
+/**
+ * Notification deep link payload
+ * Emitted when user clicks on a push notification
+ */
+
+// Re-export for external use
+
+export default class SwanSDK {
+  listeners = {};
+  SDK_VERSION = PACKAGE_VERSION;
+  isProduction = 'STAGE';
+  appId = '';
+  deviceId = '';
+  static modalInstances = [];
+  isDatabaseConfigured = false;
+  currentScreenName = '';
+  country = '';
+  currency = '';
+  businessUnit = '';
+  deviceModel = '';
+  deviceBrand = '';
+  firebaseManager = null; // FirebaseNotificationManager loaded dynamically
+  eventQueueManager = null;
+  flushManager = null;
+  networkMonitor = null;
+  batchConfig = DEFAULT_BATCH_CONFIG;
+  // Removed: isLoggingIn, isLoggingOut (now handled by AuthStateMachine)
+  // Removed: isSyncingPushPermission (no longer needed with new architecture)
+
+  resolveInitialization = () => {};
+
+  // New: Refactored architecture components
+
+  pushService = null;
+  pendingPushEventListeners = [];
+  appStateSubscription = null;
+
+  // Track if initial notification was already handled to prevent duplicate ACKs
+  initialNotificationHandled = false;
+  static styles = StyleSheet.create({
+    container: {
+      flex: 1,
+      backgroundColor: '#fff',
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    modalBackground: {
+      flex: 1,
+      backgroundColor: 'rgba(0, 0, 0, 0.5)',
+      // Semi-transparent background
+      justifyContent: 'center',
+      // Vertically center
+      alignItems: 'center' // Horizontally center
+    },
+    popUpModalContent: {
+      flex: 1,
+      width: '85%',
+      marginTop: '15%',
+      alignItems: 'center',
+      justifyContent: 'center' // Center the popup content within the modal
+    },
+    headerModalContent: {
+      flex: 1,
+      width: '100%',
+      marginTop: '5%',
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    footerModalContent: {
+      flex: 1,
+      width: '100%',
+      marginTop: '5%',
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    fullScreenModalContent: {
+      flex: 1,
+      width: '100%',
+      marginTop: '5%',
+      alignItems: 'center',
+      justifyContent: 'center'
+    }
+  });
+  constructor(appId, config = {}) {
+    if (SwanSDK.instance) {
+      return SwanSDK.instance; // Return the existing instance
+    }
+    this.isProduction = config.isProduction || false ? 'PROD' : 'STAGE';
+    this.appId = appId;
+    this.deviceId = '';
+    this.notificationToShow = null;
+    this.currentScreenName = '';
+    this.country = '';
+    this.currency = '';
+    this.businessUnit = '';
+    this.deviceBrand = '';
+    this.deviceModel = '';
+    this.firebaseManager = null;
+
+    // Store config
+    this.config = config;
+
+    // Initialize state machines
+    this.deviceStateMachine = new DeviceStateMachine();
+    this.pushStateMachine = new PushStateMachine();
+    this.authStateMachine = new AuthStateMachine();
+
+    // Initialize services
+    this.deviceService = new DeviceRegistrationService(this.appId, this.isProduction, this.sendToSwan.bind(this),
+    // Use checkOnly mode for location during registration to avoid blocking on permission dialogs
+    () => this.getDeviceLocation(true));
+
+    // Push service will be initialized later if push is enabled
+
+    // Initialize the promise that gates access to SDK features
+    this.initializationPromise = new Promise(resolve => {
+      this.resolveInitialization = resolve;
+    });
+
+    // Enable logging if enabled in config
+    if (config.logging) {
+      this.enableLogs(config.logging);
+    }
+    SwanSDK.instance = this;
+  }
+  static getInstance(appId, config) {
+    if (!SwanSDK.instance) {
+      SwanSDK.instance = new SwanSDK(appId, config);
+      // triggers background init (now uses config from constructor)
+      SwanSDK.instance.initializeSDK();
+    }
+    return SwanSDK.instance;
+  }
+
+  /**
+   * Get current SDK instance (if initialized)
+   * Used internally by module-level handlers
+   */
+  static getCurrentInstance() {
+    return SwanSDK.instance || null;
+  }
+  async initializeSDK() {
+    try {
+      Logger.log('[SwanSDK] Starting SDK initialization...');
+
+      // Phase 1: Core infrastructure (always runs)
+      Logger.log('[SwanSDK] Phase 1: Initializing core infrastructure...');
+      await this.initializeDatabase();
+      await this.initializeEventQueue();
+
+      // Start network monitor
+      if (this.networkMonitor) {
+        // Network monitor already exists from old initialization
+      } else {
+        this.networkMonitor = new NetworkMonitor();
+      }
+
+      // Phase 2: Device registration (BACKGROUND - Non-blocking)
+      Logger.log('[SwanSDK] Phase 2: Starting device registration in background...');
+      this.deviceStateMachine.register(() => this.deviceService.registerDevice()).then(async credentials => {
+        // Update deviceId from credentials
+        if (credentials?.deviceId) {
+          this.deviceId = credentials.deviceId;
+        }
+
+        // Ensure ackUrl is up to date in stored credentials (in case environment changed)
+        if (credentials && credentials.ackUrl !== URLS.WEBHOOK_MOBILE_PUSH_URL[this.isProduction]) {
+          Logger.log('[SwanSDK] Updating stored ackUrl to match current environment');
+          await this.saveCredentials({
+            ...credentials,
+            ackUrl: URLS.WEBHOOK_MOBILE_PUSH_URL[this.isProduction]
+          });
+        }
+
+        // Sync AuthStateMachine state with stored credentials
+        this.authStateMachine.restoreState(!!credentials?.currentCDID);
+        Logger.log('[SwanSDK] Device registered successfully:', this.deviceId);
+        this.emit('deviceRegistered', credentials);
+
+        // Flush any events that were queued before device registration
+        if (this.flushManager) {
+          Logger.log('[SwanSDK] Device registered, flushing queued events...');
+          await this.flushManager.flush().catch(err => {
+            Logger.warn('[SwanSDK] Failed to flush events after device registration:', err);
+          });
+        }
+      }).catch(error => {
+        Logger.warn('[SwanSDK] Device registration failed, will retry on network restore:', error);
+        this.emit('deviceRegistrationFailed', error);
+        // Don't throw - SDK continues to work, events will queue locally
+      });
+
+      // SDK is now ready - emit initialized immediately (don't wait for device registration)
+      this.emit('initialized', {
+        success: true
+      });
+      Logger.log('[SwanSDK] SDK initialization completed successfully (device registration continues in background)');
+
+      // Phase 3: Optional push notifications (non-blocking)
+      if (this.config.pushNotifications?.enabled) {
+        Logger.log('[SwanSDK] Phase 3: Initializing push notifications...');
+        this.initializePushNotifications().catch(error => {
+          Logger.error('[SwanSDK] Push initialization failed, continuing without push:', error);
+          this.emit('pushInitializationFailed', error);
+        });
+      } else {
+        Logger.log('[SwanSDK] Push notifications disabled, skipping...');
+      }
+
+      // Phase 4: Optional location update (non-blocking)
+      Logger.log('[SwanSDK] Phase 4: Updating location...');
+      this.updateLocation().catch(error => {
+        Logger.warn('[SwanSDK] Location update failed:', error);
+      });
+    } catch (error) {
+      Logger.error('[SwanSDK] SDK Initialization failed:', error);
+      throw error;
+    } finally {
+      this.resolveInitialization();
+    }
+  }
+
+  /**
+   * Initialize push notifications (new method)
+   * Called only if push is enabled in config
+   */
+  async initializePushNotifications() {
+    try {
+      this.pushStateMachine.transition(PushState.INITIALIZING);
+
+      // Load push provider (Firebase or custom)
+      const provider = await this.loadPushProvider(this.config.pushNotifications?.provider || 'firebase');
+
+      // Create push token service
+      this.pushService = new PushTokenService(provider, this.deviceService);
+
+      // Setup event listeners BEFORE initialize
+      this.setupPushEventListeners();
+
+      // Setup Notifee event listeners for click tracking
+      this.setupNotifeeEventListeners();
+
+      // Initialize the provider
+      await this.pushService.initialize();
+
+      // Attach any pending event listeners that were registered before initialization
+      this.attachPendingEventListeners();
+      this.pushStateMachine.transition(PushState.READY);
+      Logger.log('[SwanSDK] Push notification service ready');
+
+      // Auto-request permission if configured
+      if (this.config.pushNotifications?.autoRequestPermission) {
+        Logger.log('[SwanSDK] Auto-requesting push permission...');
+        await this.pushService.requestPermission();
+      }
+      this.emit('pushNotificationsReady', {
+        success: true
+      });
+    } catch (error) {
+      this.pushStateMachine.transition(PushState.ERROR);
+      Logger.error('[SwanSDK] Push notification initialization error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Load push notification provider based on config
+   */
+  async loadPushProvider(providerType) {
+    if (providerType === 'firebase') {
+      // Dynamically import Firebase provider
+      const {
+        FirebasePushProvider
+      } = await import('./providers/FirebasePushProvider');
+      return new FirebasePushProvider();
+    } else if (providerType === 'custom' && this.config.pushNotifications?.customProvider) {
+      return this.config.pushNotifications.customProvider;
+    }
+
+    // Fallback to null provider
+    Logger.warn('[SwanSDK] Unknown provider type, using NullPushProvider');
+    return new NullPushProvider();
+  }
+
+  /**
+   * Setup event listeners for push token service
+   */
+  setupPushEventListeners() {
+    if (!this.pushService) return;
+
+    // Listen for token received/refreshed
+    this.pushService.on('tokenReceived', async token => {
+      Logger.log('[SwanSDK] Push token received:', token);
+      try {
+        // Sync push subscription to backend
+        await this.syncPushSubscription(token);
+        this.pushStateMachine.transition(PushState.ACTIVE);
+        this.emit('pushTokenUpdated', token);
+      } catch (error) {
+        Logger.error('[SwanSDK] Failed to sync push token:', error);
+      }
+    });
+
+    // Listen for permission granted
+    this.pushService.on('permissionGranted', () => {
+      Logger.log('[SwanSDK] Push permission granted');
+      this.pushStateMachine.transition(PushState.TOKEN_PENDING);
+    });
+
+    // Listen for permission denied
+    this.pushService.on('permissionDenied', () => {
+      Logger.warn('[SwanSDK] Push permission denied');
+      this.pushStateMachine.transition(PushState.PERMISSION_DENIED);
+    });
+
+    // Listen for notifications (for ACK and auto-display)
+    this.pushService.on('notificationReceived', async notification => {
+      Logger.log('[SwanSDK] ✅ Notification received in SDK:', notification);
+
+      // Send ACK
+      await this.sendNotificationAck(notification?.notification?.messageId, 'delivered');
+
+      // Display notification (always auto-display in foreground)
+      Logger.log('[SwanSDK] 📱 Displaying foreground notification...');
+      await this.displayForegroundNotification(notification);
+    });
+    this.pushService.on('notificationOpened', async notification => {
+      Logger.log('[SwanSDK] Notification opened:', notification);
+      await this.sendNotificationAck(notification?.notification?.messageId, 'clicked');
+    });
+  }
+
+  /**
+   * Sync push token to push-subscription API
+   * Now queues the call instead of making immediate network request
+   */
+  async syncPushSubscription(token) {
+    try {
+      const credentials = await this.getStoredCredentials();
+      if (!credentials?.deviceId) {
+        Logger.warn('[SwanSDK] Cannot sync push subscription - device not registered');
+        return;
+      }
+      Logger.log('[SwanSDK] Queueing push subscription sync...');
+
+      // Queue push subscribe call instead of direct network call
+      const queuedEvent = {
+        id: String(uuid.v4()),
+        eventName: 'PUSH_SUBSCRIBE',
+        // Special eventName for routing
+        eventData: {
+          pushNotificationToken: token,
+          subscribedAt: credentials.subscribedAt || new Date().toISOString()
+        },
+        timestamp: Date.now(),
+        priority: 0,
+        // Non-critical, can be queued
+        retryCount: 0,
+        status: 'pending',
+        createdAt: Date.now()
+      };
+      await this.eventQueueManager?.enqueue(queuedEvent);
+
+      // Enforce queue size limit
+      await this.eventQueueManager?.enforceQueueLimit(this.batchConfig.maxQueueSize);
+      Logger.log('[SwanSDK] Push subscription queued successfully');
+
+      // Update stored credentials immediately (optimistic update)
+      // Don't wait for network - credentials updated now for immediate use
+      await this.saveCredentials({
+        ...credentials,
+        subscribedAt: credentials.subscribedAt || new Date().toISOString(),
+        lastSyncedPushToken: token,
+        pushNotificationToken: token // Store token locally
+      });
+
+      // Check if flush needed (triggers if batchSize reached)
+      await this.flushManager?.checkFlushNeeded();
+    } catch (error) {
+      Logger.error('[SwanSDK] Failed to queue push subscription:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Sync push unsubscription to push-subscription API
+   * Now queues the call instead of making immediate network request
+   */
+  async syncPushUnsubscription() {
+    try {
+      const credentials = await this.getStoredCredentials();
+      if (!credentials?.deviceId) {
+        Logger.warn('[SwanSDK] Cannot sync push unsubscription - device not registered');
+        return;
+      }
+      Logger.log('[SwanSDK] Queueing push unsubscription sync...');
+
+      // Queue push unsubscribe call instead of direct network call
+      const queuedEvent = {
+        id: String(uuid.v4()),
+        eventName: 'PUSH_UNSUBSCRIBE',
+        // Special eventName for routing
+        eventData: {
+          unSubscribedAt: new Date().toISOString()
+        },
+        timestamp: Date.now(),
+        priority: 0,
+        // Non-critical, can be queued
+        retryCount: 0,
+        status: 'pending',
+        createdAt: Date.now()
+      };
+      await this.eventQueueManager?.enqueue(queuedEvent);
+
+      // Enforce queue size limit
+      await this.eventQueueManager?.enforceQueueLimit(this.batchConfig.maxQueueSize);
+      Logger.log('[SwanSDK] Push unsubscription queued successfully');
+
+      // Update stored credentials immediately (optimistic update)
+      await this.saveCredentials({
+        ...credentials,
+        pushNotificationToken: undefined,
+        subscribedAt: null,
+        unSubscribedAt: new Date().toISOString(),
+        lastSyncedPushToken: null
+      });
+
+      // Check if flush needed
+      await this.flushManager?.checkFlushNeeded();
+    } catch (error) {
+      Logger.error('[SwanSDK] Failed to queue push unsubscription:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Re-sync push subscription after profile switch (login/logout)
+   * Updates the CDID associated with the push token on the backend
+   */
+  async resyncPushSubscriptionAfterProfileSwitch() {
+    try {
+      const credentials = await this.getStoredCredentials();
+
+      // Only re-sync if there's an active push token
+      if (!credentials?.pushNotificationToken) {
+        Logger.log('[SwanSDK] No active push token, skipping re-sync after profile switch');
+        return;
+      }
+      Logger.log('[SwanSDK] Re-syncing push subscription with new CDID after profile switch...');
+
+      // Re-sync with the current CDID (logged-in or anonymous)
+      await this.syncPushSubscription(credentials.pushNotificationToken);
+      Logger.log('[SwanSDK] Push subscription re-synced successfully with new profile');
+    } catch (error) {
+      Logger.error('[SwanSDK] Failed to re-sync push subscription after profile switch:', error);
+      // Don't throw - this shouldn't block login/logout
+    }
+  }
+  async ensureInitialized() {
+    await this.initializationPromise;
+  }
+  addListener(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(callback);
+
+    // Return a subscription object for easy cleanup
+    return {
+      remove: () => {
+        if (this.listeners[event]) {
+          // This comparison now has "overlap" because both are EventCallback
+          this.listeners[event] = this.listeners[event].filter(l => l !== callback);
+        }
+      }
+    };
+  }
+
+  // Internal method to trigger the update
+  emit(event, data) {
+    const eventListeners = this.listeners[event];
+    if (eventListeners) {
+      // Use a spread to avoid issues if a listener is removed during the loop
+      [...eventListeners].forEach(callback => callback(data));
+    }
+  }
+
+  /**
+   * Emit notification opened event
+   * @internal - Used by module-level notification handlers
+   */
+  emitNotificationOpened(payload) {
+    this.emit(SwanSDK.EVENTS.NOTIFICATION_OPENED, payload);
+  }
+  static setLoggingEnabled(enabled) {
+    Logger.enableLogs(enabled);
+  }
+  buttonClickHandler = null;
+  setButtonClickHandler(handler) {
+    this.buttonClickHandler = handler;
+  }
+  notifyButtonClick(event) {
+    this.buttonClickHandler?.(event);
+    this.sendNotificationAck(event.commId, event.event);
+  }
+  notificationShowHandler = null;
+  async setNotificationShowHandler(handler) {
+    this.notificationShowHandler = handler;
+    this.getNotificationComponent();
+  }
+  notifyNotificationShow(notification) {
+    this.notificationShowHandler?.(notification);
+  }
+  async initializeDatabase() {
+    try {
+      this.db = SQLite.openDatabase('test.db', '1.0', '', 1);
+      // Create tables after successful database open
+      await this.createTable('Notifications');
+      if (!this.isDatabaseConfigured) {
+        this.isDatabaseConfigured = true;
+
+        //Listen for network state changes
+        NetInfo.addEventListener(state => {
+          if (state.isConnected) {
+            Logger.log('Network connected');
+          }
+        });
+      }
+      return this.db;
+    } catch (error) {
+      Logger.error('Detailed Database Initialization Error:', error);
+    }
+  }
+  async initializeEventQueue() {
+    try {
+      // Initialize EventQueueManager with maxRetries from config
+      this.eventQueueManager = new EventQueueManager(this.db, this.batchConfig.maxRetries);
+      await this.eventQueueManager.createTable();
+
+      // Recover stale events (from app crashes during flush)
+      await this.eventQueueManager.recoverStaleEvents();
+
+      // Initialize NetworkMonitor
+      this.networkMonitor = new NetworkMonitor();
+      this.networkMonitor.start();
+
+      // Add listener for network state changes to retry device registration
+      this.networkMonitor.addListener(isOnline => {
+        if (isOnline && !this.deviceId) {
+          Logger.log('[SwanSDK] Network restored and device not registered, retrying device registration...');
+          this.deviceStateMachine.register(() => this.deviceService.registerDevice()).then(async credentials => {
+            if (credentials?.deviceId) {
+              this.deviceId = credentials.deviceId;
+            }
+            this.authStateMachine.restoreState(!!credentials?.currentCDID);
+            Logger.log('[SwanSDK] Device registered successfully after network restore:', this.deviceId);
+            this.emit('deviceRegistered', credentials);
+
+            // Flush queued events
+            if (this.flushManager) {
+              await this.flushManager.flush().catch(err => {
+                Logger.warn('[SwanSDK] Failed to flush events after retry:', err);
+              });
+            }
+          }).catch(error => {
+            Logger.warn('[SwanSDK] Device registration retry failed:', error);
+          });
+        }
+      });
+
+      // Initialize FlushManager
+      this.flushManager = new FlushManager(this.eventQueueManager, this.networkMonitor, this.batchConfig, this.sendEventBatch.bind(this));
+      this.flushManager.start();
+
+      // Track initial app launch event
+      Logger.log('[SwanSDK] Tracking initial app launch event...');
+      this.appLaunched();
+
+      // AppState listener setup (always runs)
+      Logger.log('[SwanSDK] Setting up AppState listener...');
+      this.setupAppStateListener();
+      Logger.log('Event queue system initialized successfully');
+    } catch (error) {
+      Logger.error('Failed to initialize event queue:', error);
+    }
+  }
+
+  /**
+   * Set up AppState listener to track app lifecycle events
+   */
+  setupAppStateListener() {
+    // Clean up existing listener if any
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove();
+    }
+    this.appStateSubscription = AppState.addEventListener('change', nextAppState => {
+      Logger.log('[SwanSDK] AppState changed to:', nextAppState);
+
+      // Track app launched event when app comes to foreground
+      if (nextAppState === 'active') {
+        Logger.log('[SwanSDK] App came to foreground, tracking appLaunched event');
+        this.appLaunched();
+      }
+    });
+    Logger.log('[SwanSDK] AppState listener set up successfully');
+  }
+  createTable(tableName) {
+    return new Promise((resolve, reject) => {
+      if (!this.db) {
+        return reject(new Error('Database not initialized'));
+      }
+      try {
+        this.db.transaction(function (txn) {
+          txn.executeSql(`CREATE TABLE IF NOT EXISTS ${tableName} (` + 'commId TEXT PRIMARY KEY, ' + 'cdid TEXT, ' + 'content TEXT)', [], function () {
+            resolve(); // Resolve the promise on successful table creation
+          }, function (_, error) {
+            Logger.error('Table creation error:', error);
+            reject(error); // Reject the promise on SQL execution error
+          });
+        });
+      } catch (error) {
+        Logger.error('Table creation error:', error);
+        reject(error); // Reject the promise on general error
+      }
+    });
+  }
+
+  // Ensure database is ready before operations
+  async ensureDatabaseReady() {
+    if (!this.db) {
+      Logger.log('Database not initialized, attempting to initialize...');
+      await this.initializeDatabase();
+    }
+    return this.db;
+  }
+
+  //Insert notification into the table
+  async insertNotification(notification, tableName) {
+    return new Promise(async (resolve, reject) => {
+      const {
+        commId,
+        ...content
+      } = notification; // Extract `commId` and content
+
+      try {
+        await this.ensureDatabaseReady();
+        this.db.transaction(function (txn) {
+          txn.executeSql(`INSERT OR REPLACE INTO ${tableName} (commId, content) VALUES (?, ?);`, [commId, JSON.stringify(content)], function () {
+            resolve(); // Resolve the promise on successful insertion
+          }, function (_, error) {
+            Logger.error('Error executing SQL:', error);
+            reject(error); // Reject the promise on SQL execution error
+          });
+        });
+      } catch (error) {
+        Logger.error('Error inserting notification:', error);
+        reject(error); // Reject the promise on general error
+      }
+    });
+  }
+
+  //Fetch all notifications
+  async selectAllFromTable(tableName) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await this.ensureDatabaseReady();
+        let rows = [];
+        this.db.transaction(function (txn) {
+          txn.executeSql(`SELECT * FROM ${tableName};`, [], function (_, res) {
+            for (let i = 0; i < res.rows.length; ++i) {
+              rows.push(res.rows.item(i));
+            }
+            resolve(rows); // Resolve the promise with the collected rows
+          }, function (_, error) {
+            Logger.error('Error executing SQL:', error);
+            reject(error); // Reject the promise on SQL execution error
+          });
+        });
+      } catch (error) {
+        Logger.error('Error fetching notifications:', error);
+        reject(error); // Reject the promise on general error
+      }
+    });
+  }
+
+  //Delete notification by commId
+  async deleteFromTableByValue(tableName, key, value) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await this.ensureDatabaseReady();
+        this.db.transaction(function (txn) {
+          txn.executeSql(`DELETE FROM ${tableName} WHERE ${key} = ?;`, [value], function () {
+            resolve(); // Resolve the promise on successful deletion
+          }, function (_, error) {
+            Logger.error('Error executing SQL:', error);
+            reject(error); // Reject the promise on SQL execution error
+          });
+        });
+      } catch (error) {
+        Logger.error('Error deleting record:', error);
+        reject(error); // Reject the promise on general error
+      }
+    });
+  }
+  lzw64_encode(s) {
+    if (!s) return s;
+    var b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+    var d = new Map();
+    var s = unescape(encodeURIComponent(s)).split('');
+    var word = s[0];
+    var num = 256;
+    var key;
+    var o = [];
+    function out(word) {
+      key = word.length > 1 ? d.get(word) : word.charCodeAt(0);
+      o.push(b64[key & 0x3f]);
+      o.push(b64[key >> 6 & 0x3f]);
+      o.push(b64[key >> 12 & 0x3f]);
+    }
+    for (var i = 1; i < s.length; i++) {
+      var c = s[i];
+      if (d.has(word + c)) {
+        word += c;
+      } else {
+        d.set(word + c, num++);
+        out(word);
+        word = c;
+        if (num == (1 << 18) - 1) {
+          d.clear();
+          num = 256;
+        }
+      }
+    }
+    out(word);
+    return o.join('');
+  }
+  setCurrentScreenName(screenName) {
+    this.currentScreenName = screenName;
+  }
+  setCountry(country) {
+    this.country = country;
+  }
+  setCurrency(currency) {
+    this.currency = currency;
+  }
+  setBusinessUnit(businessUnit) {
+    this.businessUnit = businessUnit;
+  }
+  static generateId() {
+    return Math.random().toString(36).substr(2, 9);
+  }
+  async sendToSwan(url, data, encode = false) {
+    let timeoutId = null;
+    const isSdkAckUrl = url.toLowerCase().includes('post-in-app-notification-sdk-ack');
+    Logger.log('isSdkAckUrl', isSdkAckUrl);
+    Logger.log('url', url);
+    try {
+      const controller = new AbortController();
+      timeoutId = setTimeout(() => controller.abort(), 40000); // 10s timeout (reduced from 30s for better UX)
+
+      const deviceIdHeader = encode ? this.lzw64_encode(this.deviceId) : this.deviceId;
+      const bodyData = encode ? this.lzw64_encode(JSON.stringify(data)) : JSON.stringify(data);
+      Logger.log('[SwanSDK] Sending request:', {
+        url,
+        encode,
+        deviceId: this.deviceId,
+        deviceIdHeader,
+        bodyLength: bodyData?.length || 0
+      });
+
+      // Log actual payload for debugging
+      Logger.log('[SwanSDK] Request payload:', data);
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Swan-Device-Id': deviceIdHeader
+        },
+        body: bodyData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+
+      // Handle HTTP errors
+      if (!response.ok) {
+        Logger.error(`Swan API failed: ${response.status} ${response.statusText}`);
+        return null;
+      }
+      try {
+        return await response.json();
+      } catch (error) {
+        Logger.error('Swan API response is not JSON', error, response);
+        // Non-JSON response (allowed)
+        return null;
+      }
+    } catch (error) {
+      if (error?.name === 'AbortError') {
+        Logger.error('Swan API request timed out');
+      } else {
+        Logger.error('Error sending data to Swan:', error);
+      }
+      return null;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+
+  /**
+   * Send a single event directly to the server (SYNCHRONOUS - bypasses queue)
+   * Used for critical events like login/logout that require immediate processing
+   * @param eventName Event name
+   * @param eventData Event data
+   * @returns Server response with CDID and profileSwitched info
+   */
+  async sendEventDirectly(eventName, eventData) {
+    try {
+      const decodedCredentials = await this.getStoredCredentials();
+      if (!decodedCredentials) {
+        throw new Error('Credentials not found');
+      }
+      const currentCDID = decodedCredentials.currentCDID || null;
+      const generatedCDID = decodedCredentials.generatedCDID || null;
+      const deviceId = decodedCredentials.deviceId || this.deviceId;
+
+      // Build the single event payload (same structure as batch but with one event)
+      const batchPayload = {
+        common: {
+          appId: this.appId,
+          deviceId: deviceId,
+          sdkVersion: this.SDK_VERSION,
+          platform: Platform.OS
+        },
+        events: [{
+          id: String(uuid.v4()),
+          name: eventName,
+          timestamp: Date.now(),
+          data: eventData,
+          userId: currentCDID || generatedCDID,
+          currentCDID: currentCDID,
+          generatedCDID: generatedCDID
+        }],
+        isBatch: false // Single event, not a batch
+      };
+      Logger.log(`Sending ${eventName} directly (synchronous, bypassing queue)...`);
+
+      // Send directly to server
+      const responseData = await this.sendToSwan(`${URLS.ECOM_TRACK_EVENT_URL[this.isProduction]}?appId=${this.appId}`, batchPayload, this.batchConfig.enableCompression);
+      if (responseData && responseData.results && responseData.results.length > 0) {
+        const result = responseData.results[0];
+        Logger.log(`Direct send successful:`, result);
+        return {
+          success: result.success,
+          CDID: result.CDID,
+          profileSwitched: result.profileSwitched
+        };
+      }
+      throw new Error('Direct send failed - no response from server');
+    } catch (error) {
+      Logger.error(`Error in sendEventDirectly for ${eventName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Send batch of events to backend
+   * Routes different call types to appropriate endpoints
+   * Called by FlushManager when flushing queue
+   * @param events Array of events to send (includes standard events, push calls, enrichment, acks)
+   */
+  async sendEventBatch(events) {
+    try {
+      const decodedCredentials = await this.getStoredCredentials();
+      if (!decodedCredentials) {
+        throw new Error('Credentials not found');
+      }
+      const deviceId = decodedCredentials.deviceId || this.deviceId;
+      const results = [];
+
+      // Separate events by type using eventName
+      const ackEvents = events.filter(e => e.eventName === 'SWAN_NOTIFICATION_ACK');
+      const pushSubscribeEvents = events.filter(e => e.eventName === 'PUSH_SUBSCRIBE');
+      const pushUnsubscribeEvents = events.filter(e => e.eventName === 'PUSH_UNSUBSCRIBE');
+      const enrichProfileEvents = events.filter(e => e.eventName === 'PROFILE_ENRICH');
+      const standardEvents = events.filter(e => !['SWAN_NOTIFICATION_ACK', 'PUSH_SUBSCRIBE', 'PUSH_UNSUBSCRIBE', 'PROFILE_ENRICH'].includes(e.eventName));
+
+      // 1. Process Standard Events (Batch to /api/v2/trackEvent)
+      if (standardEvents.length > 0) {
+        const batchPayload = {
+          common: {
+            appId: this.appId,
+            deviceId: deviceId,
+            sdkVersion: this.SDK_VERSION,
+            platform: Platform.OS
+          },
+          events: standardEvents.map(e => ({
+            id: e.id,
+            name: e.eventName,
+            timestamp: e.timestamp,
+            data: e.eventData.data,
+            userId: e.eventData.userId,
+            currentCDID: e.eventData.currentCDID,
+            generatedCDID: e.eventData.generatedCDID
+          })),
+          isBatch: true
+        };
+        const responseData = await this.sendToSwan(`${URLS.ECOM_TRACK_EVENT_URL[this.isProduction]}?appId=${this.appId}`, batchPayload, this.batchConfig.enableCompression);
+        if (responseData && responseData.results) {
+          results.push(...responseData.results);
+        } else if (!responseData) {
+          throw new Error('Batch request failed');
+        }
+      }
+
+      // 2. Process Push Subscribe Events (Individual to /api/device/push-subscription)
+      if (pushSubscribeEvents.length > 0) {
+        const pushPromises = pushSubscribeEvents.map(async event => {
+          const {
+            pushNotificationToken,
+            subscribedAt
+          } = event.eventData;
+          const requestBody = {
+            subscription: {
+              pushNotificationToken,
+              subscribed: true,
+              lastLoginPlatform: Platform.OS,
+              // SDK capabilities - tells backend what this SDK version supports
+              sdkCapabilities: {
+                dataOnlyPush: true,
+                // This SDK handles data-only FCM messages
+                version: this.SDK_VERSION
+              }
+            },
+            status: 'updated',
+            subscribedAt: subscribedAt || new Date().toISOString(),
+            unSubscribedAt: null,
+            linkedAt: decodedCredentials.deviceActivatedAt || null,
+            CDID: decodedCredentials.currentCDID || decodedCredentials.generatedCDID,
+            device: 'mobile'
+          };
+          const response = await this.sendToSwan(`${URLS.ECOM_PUSH_SUBSCRIPTION_URL[this.isProduction]}?appId=${this.appId}`, requestBody, true // enable compression
+          );
+          return {
+            id: event.id,
+            success: !!response,
+            error: response ? null : 'Failed to sync push subscription'
+          };
+        });
+        const pushResults = await Promise.all(pushPromises);
+        results.push(...pushResults);
+      }
+
+      // 3. Process Push Unsubscribe Events (Individual to /api/device/push-subscription)
+      if (pushUnsubscribeEvents.length > 0) {
+        const unpushPromises = pushUnsubscribeEvents.map(async event => {
+          const {
+            unSubscribedAt
+          } = event.eventData;
+          const requestBody = {
+            subscription: null,
+            status: 'revoked',
+            subscribedAt: null,
+            unSubscribedAt: unSubscribedAt || new Date().toISOString(),
+            linkedAt: decodedCredentials.deviceActivatedAt || null,
+            CDID: decodedCredentials.currentCDID || decodedCredentials.generatedCDID,
+            device: 'mobile'
+          };
+          const response = await this.sendToSwan(`${URLS.ECOM_PUSH_SUBSCRIPTION_URL[this.isProduction]}?appId=${this.appId}`, requestBody, true);
+          return {
+            id: event.id,
+            success: !!response,
+            error: response ? null : 'Failed to sync push unsubscription'
+          };
+        });
+        const unpushResults = await Promise.all(unpushPromises);
+        results.push(...unpushResults);
+      }
+
+      // 4. Process Profile Enrichment Events (Individual to /api/v2/customer/enrich-profile)
+      if (enrichProfileEvents.length > 0) {
+        const enrichPromises = enrichProfileEvents.map(async event => {
+          const {
+            profileData
+          } = event.eventData;
+          const requestBody = {
+            ...profileData,
+            CDID: decodedCredentials.currentCDID || decodedCredentials.generatedCDID
+          };
+          const response = await this.sendToSwan(`${URLS.ECOM_ENRICH_PROFILE_URL[this.isProduction]}?appId=${this.appId}`, requestBody, true);
+          return {
+            id: event.id,
+            success: !!response,
+            error: response ? null : 'Failed to enrich profile'
+          };
+        });
+        const enrichResults = await Promise.all(enrichPromises);
+        results.push(...enrichResults);
+      }
+
+      // 5. Process Ack Events (Individual to /post-in-app-notification-sdk-ack)
+      if (ackEvents.length > 0) {
+        const ackPromises = ackEvents.map(async event => {
+          const {
+            commId,
+            event: ackType
+          } = event.eventData.data;
+          const payload = {
+            commId,
+            appId: this.appId,
+            CDID: event.eventData.currentCDID || event.eventData.generatedCDID,
+            event: ackType,
+            deviceId
+          };
+          const response = await this.sendToSwan(URLS.WEBHOOK_MOBILE_PUSH_URL[this.isProduction], payload);
+          return {
+            id: event.id,
+            success: !!response,
+            error: response ? null : 'Failed to send ACK'
+          };
+        });
+        const ackResults = await Promise.all(ackPromises);
+        results.push(...ackResults);
+      }
+      return {
+        results
+      };
+    } catch (error) {
+      Logger.error('Error sending event batch:', error);
+      throw error;
+    }
+  }
+  async getSwanIdentifier() {
+    await this.ensureInitialized();
+    const decodedCredentials = await this.getStoredCredentials();
+    return decodedCredentials?.currentCDID || decodedCredentials?.generatedCDID;
+  }
+
+  // Low-level Storage Helpers
+  async getStoredCredentials(key = 'swanCredentials') {
+    const encoded = await AsyncStorage.getItem(key);
+    return encoded ? JSON.parse(Base64.decode(encoded)) : null;
+  }
+  async saveCredentials(data, key = 'swanCredentials') {
+    const encoded = Base64.encode(JSON.stringify(data));
+    await AsyncStorage.setItem(key, encoded);
+    this.emit('deviceInfoChanged', data);
+
+    // Save to iOS App Group for Notification Service Extension (iOS only)
+    if (key === 'swanCredentials' && Platform.OS === 'ios') {
+      await SharedCredentialsManager.saveToAppGroup({
+        appId: this.appId,
+        deviceId: data.deviceId,
+        cdid: data.currentCDID || data.generatedCDID,
+        ackUrl: URLS.WEBHOOK_MOBILE_PUSH_URL[this.isProduction],
+        isProduction: this.isProduction
+      });
+    }
+  }
+  async hasLocationPermission(checkOnly = false) {
+    // --- ANDROID CHECK ---
+    if (Platform.OS === 'android') {
+      const status = await PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+      if (status) return true;
+
+      // If checkOnly mode, don't request permission (used during initialization to avoid blocking)
+      if (checkOnly) {
+        return false;
+      }
+      const request = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+      return request === PermissionsAndroid.RESULTS.GRANTED;
+    }
+
+    // --- iOS CHECK ---
+    if (Platform.OS === 'ios') {
+      // If checkOnly mode, don't request (used during initialization)
+      if (checkOnly) {
+        return false; // Just return false, don't trigger permission dialog
+      }
+
+      // This will trigger the Info.plist strings we discussed
+      // It handles the 'Not Determined' -> 'Requested' flow automatically
+      try {
+        Geolocation.requestAuthorization();
+        return true; // iOS handles the dialog; if denied, getCurrentPosition will trigger the error callback
+      } catch (e) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get current device location
+   * Returns location data with latitude, longitude, accuracy, and timestamp
+   * Returns null if location permission is not granted or location fetch fails
+   *
+   * @param checkOnly - If true, only checks for existing permission without requesting (non-blocking)
+   */
+  async getDeviceLocation(checkOnly = false) {
+    const hasPermission = await this.hasLocationPermission(checkOnly);
+    if (!hasPermission) {
+      Logger.log('[SwanSDK] Location permission not granted (checkOnly mode), skipping location');
+      return null;
+    }
+    return new Promise(resolve => {
+      Geolocation.getCurrentPosition(position => {
+        Logger.log(position);
+        const {
+          latitude,
+          longitude,
+          accuracy
+        } = position.coords;
+        const locationData = {
+          latitude,
+          longitude,
+          accuracy,
+          // Useful to know if you can trust this for specific tax/zip math
+          timestamp: position.timestamp
+        };
+        Logger.log('Ecom Location Captured:', locationData);
+        resolve(locationData);
+      }, error => {
+        Logger.warn('Location Access Denied or Failed:', error.message);
+        resolve(null);
+      }, {
+        enableHighAccuracy: false,
+        // Better for battery; uses WiFi/Cell which is enough for E-com
+        timeout: 10000 // 10s is plenty for a retail app
+      });
+    });
+  }
+
+  /**
+   * Register device (simplified)
+   * Now delegates to DeviceStateMachine and DeviceRegistrationService
+   *
+   * @deprecated This method is kept for backward compatibility but is no longer needed
+   * in most cases as device registration happens automatically during SDK initialization.
+   */
+  async registerDevice() {
+    // Use state machine to register device
+    await this.deviceStateMachine.register(() => this.deviceService.registerDevice());
+  }
+
+  /**
+   * Enriches an existing customer profile with additional data.
+   * All fields are validated against metastore custom attributes
+   * Note: Profile creation happens automatically during device registration.
+   * This method only updates existing profiles.
+   *
+   * The CDID is automatically retrieved from AsyncStorage:
+   * - Uses currentCDID (credentials) if user is logged in
+   * - Uses generatedCDID if user is anonymous
+   *
+   * BREAKING CHANGE: Now returns void instead of server response
+   * Enrichment is processed asynchronously via queue
+   *
+   * @param profileData - Customer profile data (CDID not required, automatically retrieved)
+   * @returns Promise<void> - No return value (async processing)
+   */
+  async enrichProfile(profileData) {
+    try {
+      const decodedCredentials = await this.getStoredCredentials();
+      if (!decodedCredentials) {
+        throw new Error('Credential not found! Please wait for Swan to register the device!');
+      }
+      Logger.log('[SwanSDK] Queueing profile enrichment...');
+
+      // Queue enrichment call instead of direct network call
+      const queuedEvent = {
+        id: String(uuid.v4()),
+        eventName: 'PROFILE_ENRICH',
+        // Special eventName for routing
+        eventData: {
+          profileData // Store profileData in eventData for sendEventBatch
+        },
+        timestamp: Date.now(),
+        priority: 0,
+        // Non-critical, can be queued
+        retryCount: 0,
+        status: 'pending',
+        createdAt: Date.now()
+      };
+      await this.eventQueueManager?.enqueue(queuedEvent);
+
+      // Enforce queue size limit
+      await this.eventQueueManager?.enforceQueueLimit(this.batchConfig.maxQueueSize);
+      Logger.log('[SwanSDK] Profile enrichment queued successfully');
+
+      // Check if flush needed
+      await this.flushManager?.checkFlushNeeded();
+
+      // NOTE: Return type changed from Promise<any> to Promise<void>
+      // Callers no longer receive immediate response - async handling only
+    } catch (error) {
+      Logger.error('[SwanSDK] Failed to queue profile enrichment:', error);
+      throw error;
+    }
+  }
+  async switchProfile(cdid, options) {
+    try {
+      let decodedCredentials = await this.getStoredCredentials();
+      if (!decodedCredentials) {
+        throw new Error('Credential not found! Please wait for Swan to register the device!');
+      }
+      if (options?.timeOfLogin) {
+        decodedCredentials.timeOfLogin = options.timeOfLogin;
+      }
+      decodedCredentials = {
+        ...decodedCredentials,
+        currentCDID: cdid,
+        profileSwitchedAt: new Date().toISOString()
+      };
+      await this.saveCredentials(decodedCredentials);
+    } catch (error) {
+      Logger.error('Error in switching profile:', error);
+    }
+  }
+  async getSessionId() {
+    try {
+      // Retrieve the session from AsyncStorage
+      const sessionBase64 = await AsyncStorage.getItem('_swanSessionId');
+      if (sessionBase64) {
+        const sessionDoc = JSON.parse(Base64.decode(sessionBase64));
+        const lastActiveTime = new Date(sessionDoc.lastActiveTime).getTime();
+        const currentDate = new Date();
+        const currentTime = currentDate.getTime();
+        const sessionDuration = 20 * 60 * 1000; // 20 minutes in milliseconds
+
+        // Check if the session is still active
+        if (currentTime - lastActiveTime < sessionDuration) {
+          // Update last active time and save the session back
+          sessionDoc.lastActiveTime = currentDate.toISOString();
+          const updatedSessionDocBase64 = Base64.encode(JSON.stringify(sessionDoc));
+          await AsyncStorage.setItem('_swanSessionId', updatedSessionDocBase64);
+          return sessionDoc.sessionId;
+        }
+      }
+
+      // Create a new session if no valid session exists
+      const newSessionDoc = {
+        sessionId: uuid.v4(),
+        // Use UUID for session ID
+        lastActiveTime: new Date().toISOString()
+      };
+      const newSessionDocBase64 = Base64.encode(JSON.stringify(newSessionDoc));
+      await AsyncStorage.setItem('_swanSessionId', newSessionDocBase64);
+      return newSessionDoc.sessionId;
+    } catch (error) {
+      Logger.error('Error in getSessionId:', error);
+      return null; // Return null in case of error
+    }
+  }
+  async trackEvent(eventName, eventData) {
+    try {
+      await this.ensureInitialized();
+
+      // Wait for device registration if it's in progress
+      // This is non-blocking from the host app's perspective since trackEvent returns immediately
+      // The event will be queued once device registration completes
+      let decodedCredentials = await this.getStoredCredentials();
+      if (!decodedCredentials) {
+        Logger.log('[SwanSDK] Device not registered yet, waiting for registration to complete...');
+
+        // Wait for device registration (either in progress or will retry on network restore)
+        // If registration fails, we'll retry when the network comes back
+        const maxWaitTime = 15000; // Wait max 15 seconds
+        const startTime = Date.now();
+        while (!decodedCredentials && Date.now() - startTime < maxWaitTime) {
+          await new Promise(resolve => setTimeout(resolve, 500)); // Check every 500ms
+          decodedCredentials = await this.getStoredCredentials();
+        }
+        if (!decodedCredentials) {
+          throw new Error('Device registration is taking longer than expected. Please check your network connection. Events will be queued and sent when device is registered.');
+        }
+      }
+
+      // Extract all ID fields from credentials
+      const currentCDID = decodedCredentials.currentCDID || null;
+      const generatedCDID = decodedCredentials.generatedCDID || null;
+      const deviceId = decodedCredentials.deviceId || this.deviceId;
+
+      // Get device info if not already set
+      if (!this.deviceModel || !this.deviceBrand) {
+        this.deviceModel = DeviceInfo.getModel();
+        this.deviceBrand = DeviceInfo.getBrand();
+      }
+
+      // Build event payload with metadata
+      const enrichedEventData = {
+        ...eventData,
+        platform: Platform.OS,
+        osModal: Platform.Version,
+        deviceModal: this.deviceModel,
+        deviceBrand: this.deviceBrand,
+        country: this.country,
+        currency: this.currency,
+        businessUnit: this.businessUnit,
+        deviceId: deviceId,
+        sessionId: await this.getSessionId()
+      };
+
+      // Construct the complete event payload
+      const payload = {
+        userId: currentCDID || generatedCDID,
+        currentCDID: currentCDID,
+        generatedCDID: generatedCDID,
+        deviceId: deviceId,
+        name: eventName,
+        data: enrichedEventData
+      };
+
+      // Create queued event object
+      const queuedEvent = {
+        id: String(uuid.v4()),
+        eventName,
+        eventData: payload,
+        timestamp: Date.now(),
+        priority: 0,
+        // All events queued normally (use sendEventDirectly for synchronous)
+        retryCount: 0,
+        status: 'pending',
+        createdAt: Date.now()
+      };
+
+      // Enqueue the event
+      await this.eventQueueManager?.enqueue(queuedEvent);
+
+      // Enforce queue size limit
+      await this.eventQueueManager?.enforceQueueLimit(this.batchConfig.maxQueueSize);
+      Logger.log(`Event queued: ${eventName}`);
+
+      // Check if we need to flush based on queue size
+      await this.flushManager?.checkFlushNeeded();
+      return {
+        queued: true,
+        eventId: queuedEvent.id
+      };
+    } catch (error) {
+      Logger.error('Error in trackEvent:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Track custom event
+   * To use in segments, journeys it needs to be added to metastore
+   * @param name Event name
+   * @param data Event data
+   */
+  customEvent(name, data) {
+    this.trackEvent(name, data || {});
+  }
+
+  /**
+   * Track app launched event
+   * Automatically triggered when app comes to foreground from background
+   * Can also be called manually if needed
+   * @param {any} data - Optional event data
+   */
+  appLaunched(data) {
+    this.trackEvent(ECOM_EVENTS.APP_LAUNCHED, data || {});
+  }
+
+  /**
+   * @param { { success: boolean } } data
+   */
+  forgotPassword(data) {
+    this.trackEvent(ECOM_EVENTS.FORGOT_PASSWORD, data);
+  }
+  /**
+   * @param { { searchKeyword: string } } data
+   */
+  search(data) {
+    this.trackEvent(ECOM_EVENTS.SEARCH, data);
+  }
+  /**
+   * @param { { productId: string } } data
+   */
+  productViewed(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_VIEWED, data);
+  }
+  /**
+   * @param { { productId: string } } data
+   */
+  productClicked(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_CLICKED, data);
+  }
+  /**
+   * @param { { productListId: string } } data
+   */
+  productListViewed(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_LIST_VIEWED, data);
+  }
+  /**
+   * @param { { productId: string, quantity: string } } data
+   */
+  productAddedToAddTocart(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_ADDED_TO_ADD_TO_CART, data);
+  }
+  /**
+   * @param { { productId: string, quantity: string } } data
+   */
+  productRemovedFromAddToCart(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_REMOVED_FROM_ADD_TO_CART, data);
+  }
+  clearCart() {
+    this.trackEvent(ECOM_EVENTS.CLEAR_CART, {});
+  }
+  /**
+   * @param { { categoryId: string } } data
+   */
+  selectCategory(data) {
+    this.trackEvent(ECOM_EVENTS.SELECT_CATEGORY, data);
+  }
+  /**
+   * @param { { categoryId: string } } data
+   */
+  categoryViewedPage(data) {
+    this.trackEvent(ECOM_EVENTS.CATEGORY_VIEWED_PAGE, data);
+  }
+  /**
+   * @param { { productId: string } } data
+   */
+  productAddedToWishlist(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_ADDED_TO_WISHLIST, data);
+  }
+  /**
+   * @param { { productId: string } } data
+   */
+  productRemovedFromWishlist(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_REMOVED_FROM_WISHLIST, data);
+  }
+  /**
+   * @param { { productId: string, rateValue: string, rateSubjectId: string } } data
+   */
+  productRatedOrReviewed(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_RATED_OR_REVIEWED, data);
+  }
+  /**
+   * @param { { productIds: string[] } } data
+   */
+  cartViewed(data) {
+    this.trackEvent(ECOM_EVENTS.CART_VIEWED, data);
+  }
+  /**
+   * @param { { couponCode: string, orderId: string, expiryDate: Date } } data
+   */
+  offerAvailed(data) {
+    this.trackEvent(ECOM_EVENTS.OFFER_AVAILED, data);
+  }
+  /**
+   * @param { { checkoutId: string, orderId: string, totalAmount: float, productIds: {productId: string, quantity: float, price: float}[] } } data
+   */
+  checkoutStarted(data) {
+    this.trackEvent(ECOM_EVENTS.CHECKOUT_STARTED, data);
+  }
+  /**
+   * @param { { checkoutId: string, orderId: string, totalAmount: float, productIds: {productId: string, quantity: float, price: float}[] } } data
+   */
+  checkoutCompleted(data) {
+    this.trackEvent(ECOM_EVENTS.CHECKOUT_COMPLETED, data);
+  }
+  /**
+   * @param { { checkoutId: string, orderId: string, productIds: {productId: string, quantity: float, price: float}[] } } data
+   */
+  checkoutCanceled(data) {
+    this.trackEvent(ECOM_EVENTS.CHECKOUT_CANCELED, data);
+  }
+  /**
+   * @param { { currency: string, value: string, productIds: string[], paymentType: string } } data
+   */
+  paymentInfoEntered(data) {
+    this.trackEvent(ECOM_EVENTS.PAYMENT_INFO_ENTERED, data);
+  }
+  /**
+   * @param { { orderId: string, totalAmount: float, productIds: {productId: string, quantity: float, price: float}[] } } data
+   */
+  orderCompleted(data) {
+    this.trackEvent(ECOM_EVENTS.ORDER_COMPLETED, data);
+  }
+  /**
+   * @param { { orderId: string, totalAmount: float, productIds: {productId: string, quantity: float, price: float}[] } } data
+   */
+  orderRefunded(data) {
+    this.trackEvent(ECOM_EVENTS.ORDER_REFUNDED, data);
+  }
+  /**
+   * @param { { orderId: string, totalAmount: float, productIds: {productId: string, quantity: float, price: float}[] } } data
+   */
+  orderCancelled(data) {
+    this.trackEvent(ECOM_EVENTS.ORDER_CANCELLED, data);
+  }
+  /**
+   * @param { { orderId: string, rateValue: float, rateSubjectId: string } } data
+   */
+  orderExperianceRating(data) {
+    this.trackEvent(ECOM_EVENTS.ORDER_EXPERIANCE_RATING, data);
+  }
+  /**
+   * @param { { productId: string, deliveryType: string, extraNote: string, rateValue: string, rateSubjectId: string } } data
+   */
+  productReview(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_REVIEW, data);
+  }
+  /**
+   * @param { { orderId: string, brandId: string, sku: string, purchaseDate: string, orderCreatedDate: string } } data
+   */
+  purchased(data) {
+    this.trackEvent(ECOM_EVENTS.PURCHASED, data);
+  }
+  /**
+   * @param { { appVersion: string, updateType: string, previousVersion: string, updateId: string } } data
+   */
+  appUpdated(data) {
+    this.trackEvent(ECOM_EVENTS.APP_UPDATED, data);
+  }
+  /**
+   * @param { { apiCode: string, success: boolean, comment: string } } data
+   */
+  accountDeletion(data) {
+    this.trackEvent(ECOM_EVENTS.ACCOUNT_DELETION, data);
+  }
+  /**
+   * @param { { productId: string } } data
+   */
+  share(data) {
+    this.trackEvent(ECOM_EVENTS.SHARE, data);
+  }
+  /**
+   * @param { { screenName: string } } data
+   */
+  screen(data) {
+    this.trackEvent(ECOM_EVENTS.SCREEN, data);
+  }
+  /**
+   * @param { { wishlistId: string, productId: string } } data
+   */
+  wishlistProductAddedToCart(data) {
+    this.trackEvent(ECOM_EVENTS.WISHLIST_PRODUCT_ADDED_TO_CART, data);
+  }
+  /**
+   * @param { { productId: string, orderId: string, price: float, postalCode: string } } data
+   */
+  shipped(data) {
+    this.trackEvent(ECOM_EVENTS.SHIPPED, data);
+  }
+  /**
+   * @param { { quantity: string, productId: string } } data
+   */
+  productQuantitySelected(data) {
+    this.trackEvent(ECOM_EVENTS.PRODUCT_QUANTITY_SELECTED, data);
+  }
+
+  /**
+   * Track user login event and handle profile switching if mobile is provided
+   * @param identifier - identifier to check for profile switching
+   * @param data - Optional customer profile data
+   * @returns Promise with profile switch information if applicable
+   */
+  /**
+   * Track user login event (SYNCHRONOUS - bypasses queue)
+   * Uses AuthStateMachine to prevent concurrent login calls
+   * Sends directly to server for immediate profile switching
+   */
+  async login(identifier, data) {
+    return await this.authStateMachine.login(async () => {
+      await this.ensureInitialized();
+
+      // Get device info if not already set
+      if (!this.deviceModel || !this.deviceBrand) {
+        this.deviceModel = DeviceInfo.getModel();
+        this.deviceBrand = DeviceInfo.getBrand();
+      }
+
+      // Build event data with all required metadata
+      const eventData = {
+        timeOfLogin: new Date().toISOString(),
+        identifier,
+        profileData: data,
+        platform: Platform.OS,
+        osModal: Platform.Version,
+        deviceModal: this.deviceModel,
+        deviceBrand: this.deviceBrand,
+        country: this.country,
+        currency: this.currency,
+        businessUnit: this.businessUnit,
+        sessionId: await this.getSessionId()
+      };
+
+      // CRITICAL: Flush existing queue BEFORE login to avoid CDID mismatch
+      Logger.log('Login: Flushing existing queue before profile switch...');
+      await this.flushManager?.flush(true);
+
+      // Send login event DIRECTLY (synchronous, bypasses queue)
+      const response = await this.sendEventDirectly(ECOM_EVENTS.USER_LOGIN, eventData);
+
+      // Handle profile switching if backend switched profiles
+      if (response && response.profileSwitched) {
+        Logger.log(`Profile switched on login to ${response.CDID}. Updating stored credentials...`);
+
+        // Update stored credentials to use the new CDID
+        await this.switchProfile(response.CDID, {
+          timeOfLogin: eventData.timeOfLogin
+        });
+
+        // Re-sync push subscription with new logged-in CDID
+        await this.resyncPushSubscriptionAfterProfileSwitch();
+
+        // emit swan identifier change
+        this.emit('swanIdentifierChanged', await this.getSwanIdentifier());
+        Logger.log('Credentials updated with new CDID:', response.CDID);
+      }
+      return response;
+    });
+  }
+
+  /**
+   * Track user logout event and switch back to anonymous profile (generatedCDID)
+   * Uses AuthStateMachine to prevent concurrent logout calls (SYNCHRONOUS - bypasses queue)
+   * Sends directly to server for immediate profile switching
+   * @returns Promise with logout response
+   */
+  async logout() {
+    return await this.authStateMachine.logout(async () => {
+      await this.ensureInitialized();
+      const decodedCredentials = await this.getStoredCredentials();
+      if (!decodedCredentials) {
+        throw new Error('Credential not found! Please wait for Swan to register the device!');
+      }
+
+      // Get device info if not already set
+      if (!this.deviceModel || !this.deviceBrand) {
+        this.deviceModel = DeviceInfo.getModel();
+        this.deviceBrand = DeviceInfo.getBrand();
+      }
+
+      // Build event data with all required metadata
+      const eventData = {
+        timeOfLogin: decodedCredentials.timeOfLogin,
+        platform: Platform.OS,
+        osModal: Platform.Version,
+        deviceModal: this.deviceModel,
+        deviceBrand: this.deviceBrand,
+        country: this.country,
+        currency: this.currency,
+        businessUnit: this.businessUnit,
+        sessionId: await this.getSessionId()
+      };
+
+      // CRITICAL: Flush existing queue BEFORE logout to avoid CDID mismatch
+      Logger.log('Logout: Flushing existing queue before profile switch...');
+      await this.flushManager?.flush(true);
+
+      // Try to send logout event to server (non-blocking)
+      // If this fails, user is already logged out locally
+      let response = null;
+      try {
+        response = await this.sendEventDirectly(ECOM_EVENTS.USER_LOGOUT, eventData);
+        Logger.log('Logout event sent to server successfully');
+      } catch (error) {
+        Logger.warn('Failed to send logout event to server (user is logged out locally):', error);
+      }
+
+      // Even if server call fails, user should be logged out locally
+      decodedCredentials.currentCDID = null;
+      decodedCredentials.timeOfLogin = null;
+
+      // Save updated credentials back to AsyncStorage
+      await this.saveCredentials(decodedCredentials);
+      Logger.log(`User logged out locally. Switched to anonymous profile: ${decodedCredentials.generatedCDID}`);
+
+      // Re-sync push subscription with anonymous CDID
+      await this.resyncPushSubscriptionAfterProfileSwitch();
+
+      // Emit swan identifier change
+      this.emit('swanIdentifierChanged', await this.getSwanIdentifier());
+      return response;
+    });
+  }
+
+  // /**
+  //  * Create table for storing pending notification ACKs
+  //  */
+
+  /**
+   * Send notification ACK (delivered/clicked) to Swan API
+   * ACKs are queued and sent with other events
+   */
+  async sendNotificationAck(messageId, event) {
+    try {
+      if (!messageId || !event) {
+        Logger.warn('[SwanSDK] sendNotificationAck: missing messageId or event');
+        return;
+      }
+
+      // Backend expects commId field - we send Firebase messageId as the value
+      const ackData = {
+        commId: messageId,
+        event,
+        timestamp: Date.now()
+      };
+
+      // Enqueue as a special SWAN_NOTIFICATION_ACK event
+      await this.trackEvent('SWAN_NOTIFICATION_ACK', ackData);
+      Logger.log('[SwanSDK] Notification ACK queued:', messageId, event);
+    } catch (error) {
+      Logger.error('[SwanSDK] Error queueing notification ACK:', error);
+    }
+  }
+
+  /**
+   * Get notification priority from payload
+   * Maps priority string to AndroidPriority constants
+   * Used for Android 7.1 and below (Android 8+ uses channel importance)
+   */
+  getPriorityFromPayload(remoteMessage) {
+    // Check payload for priority
+    const priorityStr = remoteMessage?.data?.priority || remoteMessage?.data?.notification_priority || remoteMessage?.notification?.android?.priority;
+    if (!priorityStr) return undefined;
+
+    // Map string to notifee AndroidPriority constants
+    // https://notifee.app/react-native/reference/notificationandroidpriority
+    const priorityMap = {
+      max: -2,
+      // AndroidPriority.MAX
+      high: -1,
+      // AndroidPriority.HIGH
+      default: 0,
+      // AndroidPriority.DEFAULT
+      low: 1,
+      // AndroidPriority.LOW
+      min: 2 // AndroidPriority.MIN
+    };
+    return priorityMap[priorityStr.toLowerCase()];
+  }
+
+  /**
+   * Auto-display notification in foreground using notifee
+   * This provides automatic notification handling like CleverTap, OneSignal, etc.
+   */
+  async displayForegroundNotification(notification) {
+    try {
+      const remoteMessage = notification?.notification;
+      if (!remoteMessage) {
+        Logger.warn('[SwanSDK] No notification data to display');
+        return;
+      }
+
+      // Extract notification data (supports both notification and data-only messages)
+      const title = remoteMessage?.notification?.title || remoteMessage?.data?.title || 'Notification';
+      const body = remoteMessage?.notification?.body || remoteMessage?.data?.body || '';
+      const imageUrl = remoteMessage?.notification?.imageUrl || remoteMessage?.notification?.image || remoteMessage?.data?.image || remoteMessage?.data?.fcm_options?.image || '';
+      Logger.log('[SwanSDK] Auto-displaying foreground notification:', {
+        title,
+        body,
+        imageUrl,
+        hasPayloadChannel: !!(remoteMessage?.notification?.android?.channelId || remoteMessage?.data?.channelId || remoteMessage?.data?.channel_id),
+        hasPayloadPriority: !!(remoteMessage?.data?.priority || remoteMessage?.data?.notification_priority || remoteMessage?.notification?.android?.priority)
+      });
+
+      // Dynamically import notifee (optional dependency)
+      let notifee;
+      try {
+        notifee = require('@notifee/react-native').default;
+      } catch (error) {
+        Logger.warn('[SwanSDK] @notifee/react-native not installed. Install it to enable auto-display:', 'npm install @notifee/react-native');
+        // Emit event so app can handle display if notifee not available
+        this.emit('notificationDisplayFailed', {
+          reason: 'notifee_not_installed',
+          notification: remoteMessage
+        });
+        return;
+      }
+
+      // Get notification channel ID with priority: payload → default
+      const channelId =
+      // 1. Check FCM notification payload (Firebase standard)
+      remoteMessage?.notification?.android?.channelId ||
+      // 2. Check data payload (Swan Builder custom field - recommended)
+      remoteMessage?.data?.channelId || remoteMessage?.data?.channel_id ||
+      // 3. Final fallback to default channel
+      SWAN_NOTIFICATION_CHANNELS.DEFAULT;
+
+      // Get priority from payload (for Android 7.1 and below)
+      const priority = this.getPriorityFromPayload(remoteMessage);
+
+      // Build notification config
+      const notificationConfig = {
+        id: remoteMessage?.messageId || String(Date.now()),
+        // Use Firebase messageId as notification ID
+        title,
+        body,
+        data: {
+          // Preserve ALL original FCM data for click handler
+          ...(remoteMessage.data || {}),
+          // Store messageId for click ACK (must be string for Notifee)
+          ...(remoteMessage.messageId && {
+            messageId: String(remoteMessage.messageId)
+          })
+        },
+        android: {
+          channelId,
+          smallIcon: 'ic_launcher',
+          // App should provide this
+          ...(priority !== undefined && {
+            priority
+          }),
+          // Add priority if specified (Android 7.1-)
+          pressAction: {
+            id: 'default'
+          }
+        },
+        ios: {
+          foregroundPresentationOptions: {
+            alert: true,
+            badge: true,
+            sound: true
+          }
+        }
+      };
+
+      // Add image if present
+      if (imageUrl) {
+        // Dynamically import AndroidStyle to avoid import errors
+        const {
+          AndroidStyle
+        } = require('@notifee/react-native');
+        notificationConfig.android.style = {
+          type: AndroidStyle.BIGPICTURE,
+          picture: imageUrl
+        };
+        notificationConfig.ios.attachments = [{
+          url: imageUrl
+        }];
+      }
+
+      // Display notification
+      Logger.log('[SwanSDK] Displaying notification on channel:', channelId, priority !== undefined ? `with priority: ${priority}` : '(using channel importance)');
+      Logger.log('[SwanSDK] Notification config:', JSON.stringify(notificationConfig));
+      const notificationId = await notifee.displayNotification(notificationConfig);
+      Logger.log('[SwanSDK] Notification displayed successfully with ID:', notificationId);
+    } catch (error) {
+      Logger.error('[SwanSDK] Error displaying foreground notification:', error);
+      // Emit event so app can handle display on error
+      this.emit('notificationDisplayFailed', {
+        reason: 'display_error',
+        error: error?.message || 'Unknown error',
+        notification: notification?.notification
+      });
+    }
+  }
+
+  // Method to show popup and manage modal instances
+  showPopUp({
+    designConfig
+  }) {
+    designConfig = this.flattenDesignConfig(this.notificationToShow);
+    this.notificationToShow = null;
+
+    // Generate unique ID for this modal
+    const modalId = SwanSDK.generateId();
+
+    // Create modal component with visibility management
+    const ModalWrapper = () => {
+      const [isVisible, setIsVisible] = useState(true);
+      const handleClose = () => {
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      const handleButtonClick = event => {
+        this.notifyButtonClick(event);
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      return /*#__PURE__*/_jsx(Modal, {
+        animationType: "fade",
+        transparent: true,
+        visible: isVisible,
+        onRequestClose: handleClose,
+        hardwareAccelerated: true,
+        statusBarTranslucent: true,
+        children: /*#__PURE__*/_jsx(View, {
+          style: SwanSDK.styles.modalBackground,
+          children: /*#__PURE__*/_jsx(View, {
+            style: SwanSDK.styles.popUpModalContent,
+            children: /*#__PURE__*/_jsx(PopUpView, {
+              designConfig: designConfig,
+              onClose: handleClose,
+              onButtonClick: handleButtonClick
+            })
+          })
+        })
+      });
+    };
+
+    // Create modal instance object
+    const modalInstance = {
+      id: modalId,
+      component: /*#__PURE__*/_jsx(ModalWrapper, {}, modalId),
+      visible: true
+    };
+
+    // Add to modal instances array
+    SwanSDK.modalInstances.push(modalInstance);
+
+    // Return the modal component
+    return modalInstance.component;
+  }
+  async processNotification(notificationList) {
+    if (!notificationList || notificationList.length < 1) return null;
+    this.notificationToShow = notificationList.filter(e => e.displayIn.toLowerCase() === 'all' || e.displayIn.toLowerCase() === this.currentScreenName.toLowerCase())[0];
+    if (!this.notificationToShow) {
+      return null;
+    }
+    notificationList.splice(notificationList.indexOf(this.notificationToShow), 1);
+    const {
+      subType,
+      displayIn,
+      expiresAt,
+      displayLimit,
+      displayUnlimited
+    } = this.notificationToShow;
+    if (displayIn && displayIn.toLowerCase() != 'all' && displayIn.toLowerCase() !== this.currentScreenName.toLowerCase()) {
+      return null;
+    }
+    await this.deleteFromTableByValue('Notifications', 'commId', this.notificationToShow.commId);
+    if (!displayUnlimited && displayLimit < 1) {
+      this.processNotification(notificationList);
+      return null;
+    }
+    if (expiresAt && new Date(new Date(expiresAt).setHours(0, 0, 0, 0)) < new Date(new Date().setHours(0, 0, 0, 0))) {
+      this.processNotification(notificationList);
+      return null;
+    }
+    const newDisplayLimit = displayLimit - 1;
+    if (displayUnlimited || newDisplayLimit > 0) {
+      await this.insertNotification({
+        ...this.notificationToShow,
+        displayLimit: newDisplayLimit
+      }, 'Notifications');
+    }
+    try {
+      await AsyncStorage.setItem('lastNotificationFetchFromDbDate', new Date().toISOString());
+    } catch (e) {
+      Logger.log('error in setting lastNotificationFetchFromDbDate', e);
+    }
+    this.sendNotificationAck(this.notificationToShow.commId, 'showed');
+    switch (subType) {
+      case 'popup':
+        return this.showPopUp({
+          designConfig: this.notificationToShow
+        });
+      case 'header':
+        return this.showHeader({
+          designConfig: this.notificationToShow
+        });
+      case 'footer':
+        return this.showFooter({
+          designConfig: this.notificationToShow
+        });
+      case 'fullscreen':
+        return this.showFullScreen({
+          designConfig: this.notificationToShow
+        });
+    }
+    return null;
+  }
+  showHeader({
+    designConfig
+  }) {
+    designConfig = this.flattenDesignConfig(this.notificationToShow);
+    this.notificationToShow = null;
+
+    // Generate unique ID for this modal
+    const modalId = SwanSDK.generateId();
+
+    // Create modal component with visibility management
+    const ModalWrapper = () => {
+      const [isVisible, setIsVisible] = useState(true);
+      const handleClose = () => {
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      const handleButtonClick = event => {
+        this.notifyButtonClick(event);
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      return /*#__PURE__*/_jsx(Modal, {
+        animationType: "fade",
+        transparent: true,
+        visible: isVisible,
+        onRequestClose: handleClose,
+        hardwareAccelerated: true,
+        statusBarTranslucent: true,
+        children: /*#__PURE__*/_jsx(View, {
+          style: SwanSDK.styles.modalBackground,
+          children: /*#__PURE__*/_jsx(View, {
+            style: SwanSDK.styles.headerModalContent,
+            children: /*#__PURE__*/_jsx(HeaderView, {
+              designConfig: designConfig,
+              onClose: handleClose,
+              onButtonClick: handleButtonClick
+            })
+          })
+        })
+      });
+    };
+
+    // Create modal instance object
+    const modalInstance = {
+      id: modalId,
+      component: /*#__PURE__*/_jsx(ModalWrapper, {}, modalId),
+      visible: true
+    };
+
+    // Add to modal instances array
+    SwanSDK.modalInstances.push(modalInstance);
+
+    // Return the modal component
+    return modalInstance.component;
+  }
+  showFooter({
+    designConfig
+  }) {
+    designConfig = this.flattenDesignConfig(this.notificationToShow);
+    this.notificationToShow = null;
+
+    // Generate unique ID for this modal
+    const modalId = SwanSDK.generateId();
+
+    // Create modal component with visibility management
+    const ModalWrapper = () => {
+      const [isVisible, setIsVisible] = useState(true);
+      const handleClose = () => {
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      const handleButtonClick = event => {
+        this.notifyButtonClick(event);
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      return /*#__PURE__*/_jsx(Modal, {
+        animationType: "fade",
+        transparent: true,
+        visible: isVisible,
+        onRequestClose: handleClose,
+        hardwareAccelerated: true,
+        statusBarTranslucent: true,
+        children: /*#__PURE__*/_jsx(View, {
+          style: SwanSDK.styles.modalBackground,
+          children: /*#__PURE__*/_jsx(View, {
+            style: SwanSDK.styles.footerModalContent,
+            children: /*#__PURE__*/_jsx(FooterView, {
+              designConfig: designConfig,
+              onClose: handleClose,
+              onButtonClick: handleButtonClick
+            })
+          })
+        })
+      });
+    };
+
+    // Create modal instance object
+    const modalInstance = {
+      id: modalId,
+      component: /*#__PURE__*/_jsx(ModalWrapper, {}, modalId),
+      visible: true
+    };
+
+    // Add to modal instances array
+    SwanSDK.modalInstances.push(modalInstance);
+
+    // Return the modal component
+    return modalInstance.component;
+  }
+  showFullScreen({
+    designConfig
+  }) {
+    designConfig = this.flattenDesignConfig(this.notificationToShow);
+    this.notificationToShow = null;
+
+    // Generate unique ID for this modal
+    const modalId = SwanSDK.generateId();
+
+    // Create modal component with visibility management
+    const ModalWrapper = () => {
+      const [isVisible, setIsVisible] = useState(true);
+      const handleClose = () => {
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      const handleButtonClick = event => {
+        this.notifyButtonClick(event);
+        // Find the modal in the instances array and mark as invisible
+        const index = SwanSDK.modalInstances.findIndex(m => m.id === modalId);
+        if (index !== -1 && SwanSDK.modalInstances[index]) {
+          SwanSDK.modalInstances[index].visible = false;
+        }
+
+        // Update local state to hide the modal
+        setIsVisible(false);
+      };
+      return /*#__PURE__*/_jsx(Modal, {
+        animationType: "fade",
+        transparent: true,
+        visible: isVisible,
+        onRequestClose: handleClose,
+        hardwareAccelerated: true,
+        statusBarTranslucent: true,
+        children: /*#__PURE__*/_jsx(View, {
+          style: SwanSDK.styles.modalBackground,
+          children: /*#__PURE__*/_jsx(View, {
+            style: SwanSDK.styles.footerModalContent,
+            children: /*#__PURE__*/_jsx(FullScreenView, {
+              designConfig: designConfig,
+              onClose: handleClose,
+              onButtonClick: handleButtonClick
+            })
+          })
+        })
+      });
+    };
+
+    // Create modal instance object
+    const modalInstance = {
+      id: modalId,
+      component: /*#__PURE__*/_jsx(ModalWrapper, {}, modalId),
+      visible: true
+    };
+
+    // Add to modal instances array
+    SwanSDK.modalInstances.push(modalInstance);
+
+    // Return the modal component
+    return modalInstance.component;
+  }
+  async fetchNotificationFromAPI() {
+    try {
+      const CDID = await this.getSwanIdentifier();
+      Logger.log('URL', `${URLS.NOTIFICATION_GET_URL[this.isProduction]}?appId=${this.appId}&CDID=${CDID}`);
+      const response = await fetch(`${URLS.NOTIFICATION_GET_URL[this.isProduction]}?appId=${this.appId}&CDID=${CDID}`, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Swan-Device-Id': this.deviceId
+        }
+      });
+      let responseData = null;
+      try {
+        responseData = await response.json();
+        Logger.log('IN APP NOTIFICATION', responseData);
+        await AsyncStorage.setItem('lastNotificationFetchFromApiDate', new Date().toISOString());
+      } catch (err) {}
+      if (responseData && responseData.notifications && responseData.notifications.length > 0) {
+        responseData.notifications.forEach(async notification => {
+          await this.insertNotification(notification, 'Notifications');
+          this.sendNotificationAck(notification.commId, 'delivered');
+        });
+      }
+      return responseData;
+    } catch (error) {
+      Logger.error('Error fetching data from Swan:', error);
+    }
+  }
+  async fetchNotificationFromDB() {
+    try {
+      const rows = await this.selectAllFromTable('Notifications');
+      if (!rows || rows.length < 1) return [];
+      const notificationList = [];
+      for (let i = 0; i < rows.length; i++) {
+        const content = JSON.parse(rows[i].content);
+        notificationList.push({
+          ...content.design,
+          ...content,
+          commId: rows[i].commId,
+          design: null
+        });
+      }
+      return notificationList;
+    } catch (error) {
+      Logger.error('Error fetching data from DB:', error);
+      return [];
+    }
+  }
+  flattenDesignConfig(designConfig) {
+    const {
+      colors = {},
+      buttons = [],
+      ...restConfig
+    } = designConfig;
+    const primaryButton = buttons.find(button => button.type === 'primary') || {};
+    const secondaryButton = buttons.find(button => button.type === 'secondary') || {};
+    return {
+      themeBackgroundColor: colors.themeBackground || '#f5f5f5',
+      crossButtonColor: colors.crossButton || '#000',
+      imageURL: restConfig.imageUrl || undefined,
+      iconURL: restConfig.iconURL || undefined,
+      title: restConfig.title || 'Title',
+      titleColor: colors.title || '#333',
+      onClickAction: restConfig.onClickAction || '',
+      onClickActionType: restConfig.onClickActionType || '',
+      description: restConfig.description || 'Description',
+      descriptionColor: colors.description || '#666',
+      primaryButtonSwitch: primaryButton.primaryButtonSwitch !== undefined ? primaryButton.primaryButtonSwitch : false,
+      primaryButtonColor: colors.primaryButtonBackground || '#007BFF',
+      primaryButtonFontColor: colors.primaryButtonFont || '#FFF',
+      primaryButtonText: primaryButton.label || 'Primary Action',
+      primaryButtonAction: primaryButton.action || '',
+      primaryButtonActionType: primaryButton.actionType || '',
+      secondaryButtonSwitch: secondaryButton.secondaryButtonSwitch !== undefined ? secondaryButton.secondaryButtonSwitch : false,
+      secondaryButtonColor: colors.secondaryButtonBackground || '#6C757D',
+      secondaryButtonFontColor: colors.secondaryButtonFont || '#FFF',
+      secondaryButtonText: secondaryButton.label || 'Secondary Action',
+      secondaryButtonAction: secondaryButton.action || '',
+      secondaryButtonActionType: secondaryButton.actionType || '',
+      backgroundImageURL: restConfig.backgroundImageUrl || undefined,
+      commId: restConfig.commId || undefined
+    };
+  }
+  async getNotificationComponent() {
+    const lastNotificationFetchFromApi = await AsyncStorage.getItem('lastNotificationFetchFromApiDate');
+    if (!lastNotificationFetchFromApi || (await this.isGreaterThanTimePeriod(lastNotificationFetchFromApi, 5))) {
+      this.fetchNotificationFromAPI();
+    }
+    const lastNotificationFetchFromDB = await AsyncStorage.getItem('lastNotificationFetchFromDbDate');
+    let notificationList = [];
+    if (!lastNotificationFetchFromDB || (await this.isGreaterThanTimePeriod(lastNotificationFetchFromDB, 30))) {
+      notificationList = await this.fetchNotificationFromDB();
+    }
+    if (notificationList && notificationList.length > 0) {
+      const notificationComponent = await this.processNotification(notificationList);
+      this.notifyNotificationShow(notificationComponent);
+      return notificationComponent;
+    }
+    return null;
+  }
+  async isGreaterThanTimePeriod(lastFetchTimeString, timePeriod) {
+    const lastFetchTime = new Date(lastFetchTimeString);
+    const currentTime = new Date();
+    const timeDifference = currentTime - lastFetchTime;
+    if (timeDifference > timePeriod * 60 * 1000) {
+      Logger.log('More than 30 mins');
+      return true;
+    } else {
+      Logger.log('More than 30 mins');
+      //need to set false
+      return false;
+    }
+  }
+
+  // ==========================================
+  // Firebase Notification Manager Integration
+  // ==========================================
+
+  // Expose Event Constants (inline to avoid module-level import)
+  static EVENTS = {
+    PUSH_NOTIFICATION_RECEIVED: 'swnPushNotificationReceived',
+    NOTIFICATION_OPENED: 'swanTapPushNotifiactioncallback',
+    TOKEN_RECEIVED: 'swnTokenReceived',
+    TOKEN_REFRESH: 'swnTokenRefresh',
+    PERMISSION_CHANGED: 'swnPermissionChanged'
+  };
+
+  /**
+   * Intialize Firebase Notification Manager
+   * This sets up FCM token generation and notification handling
+   */
+  async initializeFirebase() {
+    try {
+      const {
+        default: FirebaseNotificationManager
+      } = require('./utils/FirebaseNotificationManager');
+      this.firebaseManager = FirebaseNotificationManager.getInstance();
+
+      // IMPORTANT: Setup event listeners BEFORE initialize() so we don't miss TOKEN_RECEIVED event
+      this.setupFirebaseEventListeners();
+
+      // Setup notifee event listeners for foreground notification clicks
+      this.setupNotifeeEventListeners();
+
+      // firebaseManager.initialize() already handles permission request and token retrieval
+      // No need to call requestNotificationPermission() again here
+      const initialized = await this.firebaseManager.initialize();
+      Logger.log('SwanSDK: Firebase initialized:', initialized);
+    } catch (error) {
+      Logger.error('Error initializing Firebase:', error);
+    }
+  }
+
+  /**
+   * Setup Notifee event listeners for notification clicks
+   * Handles both foreground clicks and initial notification (app opened from quit state)
+   */
+  async setupNotifeeEventListeners() {
+    try {
+      const notifee = require('@notifee/react-native').default;
+
+      // NOTE: Foreground event listener (onForegroundEvent) is registered at module level
+      // in index.js using createNotifeeForegroundHandler(). This is required by Notifee,
+      // similar to how Firebase requires onMessage() at module level.
+
+      // Check if app was opened by tapping a Notifee-displayed notification (data-only architecture)
+      const initialNotification = await notifee.getInitialNotification();
+      if (initialNotification && !this.initialNotificationHandled) {
+        const messageId = initialNotification?.notification?.id;
+        const notificationData = initialNotification.data || {};
+        if (messageId) {
+          Logger.log('[SwanSDK] App opened from Notifee notification tap:', messageId);
+          this.initialNotificationHandled = true;
+          await this.sendNotificationAck(messageId, 'clicked');
+        }
+        // Extract deep link information
+        const deepLinkPayload = {
+          route: notificationData.route,
+          data: notificationData,
+          title: initialNotification.notification?.title || notificationData.title,
+          body: initialNotification.notification?.body || notificationData.body
+        };
+
+        // Emit notificationOpened event for host app to handle deep linking
+        this.emitNotificationOpened(deepLinkPayload);
+      }
+
+      // Also check Firebase's getInitialNotification for iOS auto-displayed notifications
+      // (notification+data payload with NES architecture)
+      if (!this.initialNotificationHandled) {
+        await this.checkFirebaseInitialNotification();
+      }
+      Logger.log('[SwanSDK] ✓ Notifee event listeners setup complete');
+    } catch (error) {
+      Logger.log('[SwanSDK] Notifee not available, skipping notification setup');
+    }
+  }
+
+  /**
+   * Check if app was opened from killed state via Firebase notification tap
+   * This handles notifications auto-displayed by iOS (notification+data payload with NES)
+   * For data-only notifications displayed via Notifee, use notifee.getInitialNotification() instead
+   */
+  async checkFirebaseInitialNotification() {
+    try {
+      const messaging = require('@react-native-firebase/messaging').default;
+      const initialNotification = await messaging().getInitialNotification();
+      if (initialNotification && !this.initialNotificationHandled) {
+        Logger.log('[SwanSDK] App opened from Firebase notification (killed state):', initialNotification.messageId);
+
+        // Mark as handled to prevent duplicate ACKs
+        this.initialNotificationHandled = true;
+
+        // Get messageId and notification data
+        const messageId = initialNotification.messageId;
+        const notificationData = initialNotification.data || {};
+
+        // Extract deep link information
+        const deepLinkPayload = {
+          route: notificationData.route,
+          data: notificationData,
+          title: initialNotification.notification?.title || notificationData.title,
+          body: initialNotification.notification?.body || notificationData.body
+        };
+
+        // Emit notificationOpened event for host app to handle deep linking
+        this.emitNotificationOpened(deepLinkPayload);
+
+        // Send click ACK
+        if (messageId) {
+          await this.sendNotificationAck(messageId, 'clicked');
+          Logger.log('[SwanSDK] ✅ Firebase initial notification click ACK sent');
+        }
+      }
+    } catch (error) {
+      Logger.log('[SwanSDK] Firebase messaging not available for getInitialNotification:', error);
+    }
+  }
+
+  /**
+   * Setup Firebase event listeners
+   */
+  setupFirebaseEventListeners() {
+    if (!this.firebaseManager) return;
+    this.firebaseManager.addEventListener(SwanSDK.EVENTS.TOKEN_RECEIVED, async token => {
+      Logger.log('FCM Token received:', token);
+      await this.syncPushSubscription(token);
+    });
+    this.firebaseManager.addEventListener(SwanSDK.EVENTS.TOKEN_REFRESH, async token => {
+      Logger.log('FCM Token refreshed:', token);
+      await this.syncPushSubscription(token);
+    });
+
+    // NOTE: With data-only push messages, all notifications are displayed via Notifee.
+    // Click tracking is handled by Notifee event handlers (createNotifeeForegroundHandler/createNotifeeBackgroundHandler).
+    // Firebase's NOTIFICATION_OPENED event is not needed since Firebase doesn't auto-display data-only messages.
+  }
+
+  /**
+   * Get the Firebase Manager instance
+   */
+  getFirebaseManager() {
+    return this.firebaseManager;
+  }
+
+  /**
+   * Check if push notifications are enabled in SDK config
+   * Used internally by handler functions to verify push should be processed
+   */
+  isPushEnabled() {
+    return this.config.pushNotifications?.enabled === true;
+  }
+
+  /**
+   * Check if SDK is fully initialized and ready to send events
+   * Used by background handlers to determine if SDK instance can send ACKs
+   */
+  isReady() {
+    return !!this.deviceId;
+  }
+
+  /**
+   * Get current push token
+   */
+  async getPushToken() {
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      const token = await this.pushService.getToken();
+      Logger.log('[SwanSDK] getPushToken:', token);
+      return token;
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      const token = await this.firebaseManager.getToken();
+      Logger.log('[SwanSDK] getPushToken (fallback):', token);
+      return token;
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return null;
+  }
+
+  /**
+   * Delete Firebase token and sync unsubscription to backend
+   */
+  async unsubscribePush() {
+    if (!this.pushService) {
+      Logger.warn('[SwanSDK] Push notifications not initialized');
+      return false;
+    }
+    try {
+      Logger.log('[SwanSDK] Unsubscribing from push notifications...');
+
+      // Delete token via push service
+      const deleted = await this.pushService.deleteToken();
+      if (deleted) {
+        // Sync unsubscription to backend
+        await this.syncPushUnsubscription();
+
+        // Update push state machine
+        this.pushStateMachine.transition(PushState.DISABLED);
+        Logger.log('[SwanSDK] Push token deleted and unsubscription synced');
+      }
+      return deleted;
+    } catch (error) {
+      Logger.error('[SwanSDK] Failed to unsubscribe from push:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if notification permission is granted
+   */
+  async hasNotificationPermission() {
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      const hasPermission = await this.pushService.hasPermission();
+      Logger.log('[SwanSDK] hasNotificationPermission:', hasPermission);
+      return hasPermission;
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      const hasPermission = await this.firebaseManager.hasPermission();
+      Logger.log('[SwanSDK] hasNotificationPermission (fallback):', hasPermission);
+      return hasPermission;
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return false;
+  }
+
+  /**
+   * Request notification permission
+   */
+  /**
+   * Request notification permission
+   * Uses the new PushTokenService if available, falls back to firebaseManager for backward compatibility
+   */
+  async requestNotificationPermission() {
+    Logger.log('[SwanSDK] requestNotificationPermission called');
+
+    // Android 13+ requires POST_NOTIFICATIONS permission
+    if (Platform.OS === 'android' && Platform.Version >= 33) {
+      const permission = PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS;
+      if (permission) {
+        const granted = await PermissionsAndroid.request(permission);
+        Logger.log('[SwanSDK] Android 13+ Notification Permission:', granted);
+        if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
+          Logger.error('[SwanSDK] Notification permission denied');
+          return false;
+        }
+      }
+    }
+
+    // Use new PushTokenService if available (refactored architecture)
+    if (this.pushService) {
+      Logger.log('[SwanSDK] Using PushTokenService to request permission');
+      const granted = await this.pushService.requestPermission();
+      Logger.log('[SwanSDK] Permission result:', granted);
+      return granted;
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      Logger.log('[SwanSDK] Falling back to firebaseManager');
+      const granted = await this.firebaseManager.requestPermission();
+      Logger.log('[SwanSDK] Permission result:', granted);
+      return granted;
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return false;
+  }
+
+  /**
+   * Create a Notification Channel (Android only)
+   * @param channelName - User visible name
+   * @param importance - Importance level (default: 4 - High)
+   * @param description - User visible description
+   * @param channelId - Custom Channel ID (defaults to App ID)
+   */
+  async createNotificationChannel(channelName = 'General Notifications', importance = 4, description, channelId) {
+    // Use provided channelId or fallback to appId
+    const id = channelId || this.appId;
+
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      return await this.pushService.createNotificationChannel(id, channelName, importance, description);
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      return await this.firebaseManager.createNotificationChannel(id, channelName, importance, description);
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return null;
+  }
+
+  /**
+   * Delete a Notification Channel (Android only)
+   */
+  async deleteNotificationChannel(channelId) {
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      return await this.pushService.deleteNotificationChannel(channelId);
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      return await this.firebaseManager.deleteNotificationChannel(channelId);
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return false;
+  }
+
+  /**
+   * Get the Notification Channel ID
+   * Returns the App ID as the channel ID
+   */
+  getNotificationChannelId() {
+    return this.appId;
+  }
+
+  /**
+   * Get app badge count
+   */
+  async getBadgeCount() {
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      const count = await this.pushService.getBadgeCount();
+      Logger.log('[SwanSDK] getBadgeCount:', count);
+      return count;
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      const count = await this.firebaseManager.getBadgeCount();
+      Logger.log('[SwanSDK] getBadgeCount (fallback):', count);
+      return count;
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return 0;
+  }
+
+  /**
+   * Set app badge count
+   */
+  async setBadgeCount(count) {
+    Logger.log('[SwanSDK] setBadgeCount:', count);
+
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      return await this.pushService.setBadgeCount(count);
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      return await this.firebaseManager.setBadgeCount(count);
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+    return false;
+  }
+
+  /**
+   * Add listener for push notification events
+   * Listeners registered before push initialization are queued and attached when ready
+   */
+  addEventListener(eventName, callback) {
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      this.pushService.addEventListener(eventName, callback);
+      return;
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      this.firebaseManager.addEventListener(eventName, callback);
+      return;
+    }
+
+    // Queue the listener to be attached when push notifications are ready
+    Logger.log('[SwanSDK] Queueing event listener for later (push not initialized yet):', eventName);
+    this.pendingPushEventListeners.push({
+      eventName,
+      callback
+    });
+  }
+
+  /**
+   * Attach pending event listeners after push service initialization
+   * Called automatically when push notifications are ready
+   */
+  attachPendingEventListeners() {
+    if (this.pendingPushEventListeners.length === 0) {
+      return;
+    }
+    Logger.log(`[SwanSDK] Attaching ${this.pendingPushEventListeners.length} pending event listeners...`);
+    for (const {
+      eventName,
+      callback
+    } of this.pendingPushEventListeners) {
+      if (this.pushService) {
+        this.pushService.addEventListener(eventName, callback);
+      } else if (this.firebaseManager) {
+        this.firebaseManager.addEventListener(eventName, callback);
+      }
+    }
+
+    // Clear the queue
+    this.pendingPushEventListeners = [];
+    Logger.log('[SwanSDK] All pending event listeners attached');
+  }
+
+  /**
+   * Remove listener for push notification events
+   */
+  removeEventListener(eventName, callback) {
+    // Use new PushTokenService if available
+    if (this.pushService) {
+      this.pushService.removeEventListener(eventName, callback);
+      return;
+    }
+
+    // Fallback to firebaseManager for backward compatibility
+    if (this.firebaseManager) {
+      this.firebaseManager.removeEventListener(eventName, callback);
+      return;
+    }
+    Logger.warn('[SwanSDK] Push notifications not initialized');
+  }
+
+  // ==========================================
+  // Logger Integration
+  // ==========================================
+
+  /**
+   * Log a message using SwanSDK Logger
+   * @param message - Message to log
+   * @param args - Additional arguments
+   */
+  log(message, ...args) {
+    Logger.log(message, ...args);
+  }
+
+  /**
+   * Log a warning using SwanSDK Logger
+   * @param message - Warning message
+   * @param args - Additional arguments
+   */
+  warn(message, ...args) {
+    Logger.warn(message, ...args);
+  }
+
+  /**
+   * Log an error using SwanSDK Logger
+   * @param message - Error message
+   * @param args - Additional arguments
+   */
+  error(message, ...args) {
+    Logger.error(message, ...args);
+  }
+
+  /**
+   * Enable or disable SDK logs
+   * @param enabled - boolean to enable/disable logs
+   */
+  enableLogs(enabled) {
+    Logger.enableLogs(enabled);
+  }
+
+  // ==========================================
+  // Device Info Helper
+  // ==========================================
+
+  /**
+   * Get device information from AsyncStorage
+   * @returns Device info including deviceId, generatedCDID, and currentCDID (credentials)
+   */
+  async getDeviceInfo() {
+    try {
+      return await this.getStoredCredentials();
+    } catch (error) {
+      Logger.error('Error fetching device info:', error);
+      return null;
+    }
+  }
+
+  // ==========================================
+  // Event Queue Management
+  // ==========================================
+
+  /**
+   * Manually flush pending events
+   * Forces immediate send of queued events regardless of batch size or timer
+   * Useful before critical navigation or app closure
+   * @returns Promise that resolves when flush is complete
+   */
+  async flushEvents() {
+    try {
+      Logger.log('Manual flush triggered');
+      await this.flushManager?.flush(true);
+    } catch (error) {
+      Logger.error('Error flushing events:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get current queue size
+   * Returns number of pending events waiting to be sent
+   * @returns Number of pending events in queue
+   */
+  async getQueueSize() {
+    try {
+      return (await this.eventQueueManager?.getQueueSize()) || 0;
+    } catch (error) {
+      Logger.error('Error getting queue size:', error);
+      return 0;
+    }
+  }
+
+  // ==========================================
+  // Location Management
+  // ==========================================
+
+  /**
+   * Update device location
+   * Call this method when location permission is granted to update device location
+   * This fetches current location and updates device details on the backend
+   * @returns Promise that resolves when location is updated
+   */
+  async updateLocation() {
+    try {
+      await this.deviceService.updateLocation();
+    } catch (error) {
+      Logger.error('[SwanSDK] Error updating location:', error);
+      throw error;
+    }
+  }
+
+  // ==========================================
+  // Push Notification Handler (Internal)
+  // ==========================================
+
+  /**
+   * Handle background notification delivery ACK
+   * Uses Firebase messageId for tracking
+   * @internal
+   */
+  async handleBackgroundNotification(remoteMessage) {
+    const messageId = remoteMessage?.messageId;
+    Logger.log('[SwanSDK] Processing background notification, messageId:', messageId);
+
+    // Send delivery ACK using Firebase messageId
+    if (messageId) {
+      await this.sendNotificationAck(messageId, 'delivered');
+      Logger.log('[SwanSDK] Background notification ACK sent');
+    } else {
+      Logger.warn('[SwanSDK] No messageId in notification, skipping delivery ACK');
+    }
+  }
+
+  /**
+   * Check if a push notification is silent (should not display UI)
+   * @param remoteMessage FCM remote message
+   * @returns true if silent push
+   */
+  isSilentPush(remoteMessage) {
+    const silent = remoteMessage?.data?.silent;
+    return silent === 'true' || silent === true;
+  }
+
+  /**
+   * Handle foreground notification (called from createForegroundMessageHandler)
+   * Expects data-only FCM payload
+   * Supports silent push notifications (no UI display)
+   * @internal
+   */
+  async handleForegroundNotification(remoteMessage) {
+    const messageId = remoteMessage?.messageId;
+    const isSilent = this.isSilentPush(remoteMessage);
+    Logger.log('[SwanSDK] Processing foreground notification, messageId:', messageId, 'silent:', isSilent);
+
+    // Handle silent push (no UI display)
+    if (isSilent) {
+      Logger.log('[SwanSDK] Silent push received, skipping notification display');
+      return;
+    }
+
+    // Check if iOS Notification Service Extension is active
+    // NES handles delivery ACK, but iOS does NOT auto-display notifications in foreground
+    // So we must still display via Notifee (which handles image download), but skip the delivery ACK
+    const isNESActive = await SharedCredentialsManager.isNotificationServiceExtensionActive();
+
+    // Send delivery ACK using Firebase messageId
+    if (messageId && !isNESActive) {
+      await this.sendNotificationAck(messageId, 'delivered');
+    } else {
+      Logger.warn('[SwanSDK] No messageId / NES active in notification, skipping delivery ACK');
+    }
+
+    // Display notification via Notifee (non-silent push)
+    await this.displayForegroundNotification({
+      notification: remoteMessage,
+      state: 'foreground'
+    });
+  }
+}
+
+/**
+ * Foreground Message Handler for index.js
+ *
+ * Handles data-only FCM messages when app is in foreground.
+ * React Native Firebase requires onMessage() to be registered at module level in index.js.
+ *
+ * NOTE: This SDK expects DATA-ONLY FCM payloads (no "notification" field).
+ * Backend should set sdkCapabilities.dataOnlyPush check before sending.
+ *
+ * @example
+ * ```javascript
+ * // index.js
+ * import messaging from '@react-native-firebase/messaging';
+ * import { createForegroundMessageHandler } from 'swan-react-native-sdk';
+ *
+ * messaging().onMessage(createForegroundMessageHandler());
+ * ```
+ */
+export function createForegroundMessageHandler() {
+  return async remoteMessage => {
+    Logger.log('[SwanSDK] Foreground notification received:', remoteMessage?.messageId);
+    try {
+      const sdkInstance = SwanSDK.getCurrentInstance();
+      if (!sdkInstance) {
+        Logger.warn('[SwanSDK] SDK not initialized, cannot process foreground notification');
+        return;
+      }
+      if (!sdkInstance.isPushEnabled()) {
+        Logger.log('[SwanSDK] Push notifications disabled, ignoring');
+        return;
+      }
+      await sdkInstance.handleForegroundNotification(remoteMessage);
+    } catch (error) {
+      Logger.error('[SwanSDK] Error handling foreground message:', error);
+    }
+  };
+}
+
+/**
+ * Background Message Handler for index.js
+ *
+ * Handles data-only FCM messages when app is in background or killed state.
+ * React Native Firebase requires setBackgroundMessageHandler() to be registered at module level.
+ *
+ * NOTE: This SDK expects DATA-ONLY FCM payloads (no "notification" field).
+ * Backend should set sdkCapabilities.dataOnlyPush check before sending.
+ *
+ * @example
+ * ```javascript
+ * // index.js
+ * import messaging from '@react-native-firebase/messaging';
+ * import { createBackgroundMessageHandler } from 'swan-react-native-sdk';
+ *
+ * messaging().setBackgroundMessageHandler(createBackgroundMessageHandler());
+ * ```
+ */
+export function createBackgroundMessageHandler() {
+  return async remoteMessage => {
+    const messageId = remoteMessage?.messageId;
+    const isSilent = remoteMessage?.data?.silent === 'true' || remoteMessage?.data?.silent === true;
+    Logger.log('[SwanSDK] Background notification received:', messageId, 'silent:', isSilent);
+
+    // Check if push notifications are enabled
+    const sdkInstance = SwanSDK.getCurrentInstance();
+    if (sdkInstance && !sdkInstance.isPushEnabled()) {
+      Logger.log('[SwanSDK] Push notifications disabled, ignoring');
+      return;
+    }
+
+    // Check if iOS Notification Service Extension is active then skip delivery handling
+    const isNESActive = await SharedCredentialsManager.isNotificationServiceExtensionActive();
+    if (isNESActive) {
+      console.log('[SwanSDK] ✅ iOS Notification Service Extension is active, skipping delivery ACK (NES handles it)');
+      return;
+    }
+
+    // Handle silent push (no UI display)
+    if (isSilent) {
+      console.log('[SwanSDK] Silent push received in background, skipping notification display');
+      console.log('[SwanSDK] ✅ Silent push handled');
+      return;
+    }
+    if (sdkInstance && sdkInstance.isReady()) {
+      await sdkInstance.sendNotificationAck(messageId, 'delivered');
+    }
+    try {
+      // Import notifee dynamically to avoid issues if not installed
+      let notifee;
+      try {
+        notifee = require('@notifee/react-native').default;
+      } catch (e) {
+        Logger.error('[SwanSDK] Notifee not installed - required for data-only push notifications');
+        return;
+      }
+
+      // IMPORTANT: Display notification FIRST, then send ACK
+      // Android may kill headless JS task during network requests
+      // So we must show notification before any network calls
+      const messageId = remoteMessage?.messageId;
+      console.log('[SwanSDK] Background handler - messageId:', messageId);
+
+      // Extract notification data from data payload (data-only messages)
+      console.log('[SwanSDK] Extracting notification data from payload...');
+      const title = remoteMessage.data?.title || 'Notification';
+      const body = remoteMessage.data?.body || 'New message';
+      const imageUrl = remoteMessage.data?.image || remoteMessage.data?.fcm_options?.image || '';
+      console.log('[SwanSDK] Notification content - title:', title, 'body:', body);
+
+      // Get notification channel ID from data payload
+      const channelId = remoteMessage?.data?.channelId || remoteMessage?.data?.channel_id || SWAN_NOTIFICATION_CHANNELS.DEFAULT;
+
+      // Get notification priority from payload (for Android 7.1 and below)
+      const getPriority = () => {
+        const priorityStr = remoteMessage?.data?.priority;
+        if (!priorityStr) return undefined;
+        const priorityMap = {
+          max: -2,
+          high: -1,
+          default: 0,
+          low: 1,
+          min: 2
+        };
+        return priorityMap[priorityStr.toLowerCase()];
+      };
+      const priority = getPriority();
+
+      // Use messageId as notification ID for click tracking
+      const notificationId = messageId || `swan_bg_${Date.now()}`;
+      const notificationConfig = {
+        id: notificationId,
+        title,
+        body,
+        data: {
+          ...(remoteMessage.data || {}),
+          // Store messageId for click ACK (must be string for Notifee)
+          ...(messageId && {
+            messageId: String(messageId)
+          })
+        },
+        android: {
+          channelId,
+          smallIcon: 'ic_launcher',
+          ...(priority !== undefined && {
+            priority
+          }),
+          pressAction: {
+            id: 'default'
+          }
+        }
+      };
+
+      // Add image if present
+      if (imageUrl) {
+        const {
+          AndroidStyle
+        } = require('@notifee/react-native');
+        notificationConfig.android.style = {
+          type: AndroidStyle.BIGPICTURE,
+          picture: imageUrl
+        };
+        // iOS: Add image as attachment
+        // Note: For best results on iOS, implement a Notification Service Extension
+        notificationConfig.ios = {
+          attachments: [{
+            url: imageUrl
+          }]
+        };
+      }
+
+      // STEP 1: Display notification FIRST (fast local operation)
+      console.log('[SwanSDK] STEP 1: Displaying notification...');
+      await notifee.displayNotification(notificationConfig);
+      console.log('[SwanSDK] ✅ Notification displayed successfully');
+
+      // STEP 2: Send delivery ACK (network operation - may be killed by OS)
+      console.log('[SwanSDK] STEP 2: Sending delivery ACK...');
+      const isSDKReady = sdkInstance && sdkInstance.isReady();
+      if (isSDKReady) {
+        console.log('[SwanSDK] Using SDK instance for delivery ACK');
+        await sdkInstance.sendNotificationAck(messageId, 'delivered');
+      } else if (messageId) {
+        // SDK not fully initialized (app was killed) - send delivery ACK directly via fetch
+        console.log('[SwanSDK] SDK not ready, sending delivery ACK via direct fetch');
+        // Fire and forget - don't await since OS may kill us
+        sendDirectNotificationAck(messageId, 'delivered').catch(err => {
+          console.log('[SwanSDK] Direct delivery ACK failed:', err);
+        });
+      }
+      console.log('[SwanSDK] ✅ Background handler completed');
+    } catch (error) {
+      console.log('[SwanSDK] ❌ Error handling background message:', error?.message || error);
+      console.log('[SwanSDK] Error stack:', error?.stack);
+    }
+  };
+}
+export function createNotificationOpenedHandler() {
+  return async event => {
+    try {
+      Logger.log('[SwanSDK] Notification opened Handler:', event);
+      const sdkInstance = SwanSDK.getCurrentInstance();
+      if (!sdkInstance) {
+        Logger.warn('[SwanSDK] SDK not initialized, cannot process notification click');
+        return;
+      }
+      if (!sdkInstance.isPushEnabled()) {
+        return;
+      }
+
+      // Check if iOS Notification Service Extension is active then skip delivery handling
+      const isNESActive = await SharedCredentialsManager.isNotificationServiceExtensionActive();
+      if (!isNESActive && Platform.OS === 'ios') {
+        Logger.log('[SwanSDK] ✅ iOS Notification Service Extension is inactive, will be handled by notifee handlers for click tracking');
+        return;
+      }
+      Logger.log('[SwanSDK] ✅ iOS Notification Service Extension is active, click tracking will be handled now');
+
+      // Get messageId and notification data
+      const messageId = event?.messageId;
+      const notificationData = event?.data || {};
+
+      // Extract deep link information
+      // Note: route field can contain either a path (/products/123) or full URL (myapp://products/123)
+      const deepLinkPayload = {
+        route: notificationData.route,
+        data: notificationData,
+        title: notificationData.title,
+        body: notificationData.body
+      };
+      Logger.log('[SwanSDK] Foreground notification clicked:', {
+        messageId,
+        route: deepLinkPayload.route
+      });
+
+      // Emit notificationOpened event for host app to handle
+      sdkInstance.emitNotificationOpened(deepLinkPayload);
+
+      // Send click ACK
+      if (messageId) {
+        await sdkInstance.sendNotificationAck(messageId, 'clicked');
+      } else {
+        Logger.warn('[SwanSDK] No messageId in notification data, skipping click ACK');
+      }
+    } catch (error) {
+      Logger.error('[SwanSDK] Error handling Notifee foreground event:', error);
+    }
+  };
+}
+
+/**
+ * Notifee Foreground Event Handler for index.js
+ *
+ * Handles notification clicks when app is in foreground.
+ * Notifee requires onForegroundEvent() to be registered at module level in index.js.
+ *
+ * @example
+ * ```javascript
+ * // index.js
+ * import notifee from '@notifee/react-native';
+ * import { createNotifeeForegroundHandler } from 'swan-react-native-sdk';
+ *
+ * notifee.onForegroundEvent(createNotifeeForegroundHandler());
+ * ```
+ */
+export function createNotifeeForegroundHandler() {
+  return async event => {
+    try {
+      const {
+        EventType
+      } = require('@notifee/react-native');
+
+      // Only handle PRESS events (notification clicks)
+      if (event?.type !== EventType.PRESS) {
+        return;
+      }
+      const sdkInstance = SwanSDK.getCurrentInstance();
+      if (!sdkInstance) {
+        Logger.warn('[SwanSDK] SDK not initialized, cannot process notification click');
+        return;
+      }
+      if (!sdkInstance.isPushEnabled()) {
+        return;
+      }
+
+      // NOTE: Even when NES is active, foreground notifications are displayed via Notifee
+      // (because iOS doesn't auto-display in foreground). So this handler MUST handle clicks
+      // for foreground notifications regardless of NES status.
+      // NES only handles delivery ACK, not click ACK.
+
+      // Get messageId and notification data
+      const messageId = event?.detail?.notification?.data?.messageId;
+      const notificationData = event?.detail?.notification?.data || {};
+
+      // Extract deep link information
+      // Note: route field can contain either a path (/products/123) or full URL (myapp://products/123)
+      const deepLinkPayload = {
+        route: notificationData.route,
+        data: notificationData,
+        title: event?.detail?.notification?.title,
+        body: event?.detail?.notification?.body
+      };
+      Logger.log('[SwanSDK] Foreground notification clicked (Notifee):', {
+        messageId,
+        route: deepLinkPayload.route
+      });
+
+      // Emit notificationOpened event for host app to handle
+      sdkInstance.emitNotificationOpened(deepLinkPayload);
+
+      // Send click ACK
+      if (messageId) {
+        await sdkInstance.sendNotificationAck(messageId, 'clicked');
+      } else {
+        Logger.warn('[SwanSDK] No messageId in notification data, skipping click ACK');
+      }
+    } catch (error) {
+      Logger.error('[SwanSDK] Error handling Notifee foreground event:', error);
+    }
+  };
+}
+
+/**
+ * Notifee Background Event Handler
+ *
+ * Handles notification clicks when app is in background or killed state.
+ * Must be registered at module level in index.js.
+ *
+ * @example
+ * ```javascript
+ * // index.js
+ * import notifee from '@notifee/react-native';
+ * import { createNotifeeBackgroundHandler } from 'swan-react-native-sdk';
+ *
+ * notifee.onBackgroundEvent(createNotifeeBackgroundHandler());
+ * ```
+ */
+export function createNotifeeBackgroundHandler() {
+  return async ({
+    type,
+    detail
+  }) => {
+    try {
+      const {
+        EventType
+      } = require('@notifee/react-native');
+
+      // Only handle PRESS events (notification clicks)
+      if (type !== EventType.PRESS) {
+        return;
+      }
+
+      // Check if iOS Notification Service Extension is active then skip delivery handling
+      const isNESActive = await SharedCredentialsManager.isNotificationServiceExtensionActive();
+      if (isNESActive) {
+        Logger.log('[SwanSDK] ✅ iOS Notification Service Extension is active, skipping delivery ACK (NES handles it)');
+        return;
+      }
+
+      // Get messageId and notification data
+      const messageId = detail?.notification?.data?.messageId;
+      const notificationData = detail?.notification?.data || {};
+
+      // Extract deep link information
+      // Note: route field can contain either a path (/products/123) or full URL (myapp://products/123)
+      const deepLinkPayload = {
+        route: notificationData.route,
+        data: notificationData,
+        title: detail?.notification?.title,
+        body: detail?.notification?.body
+      };
+      Logger.log('[SwanSDK] Background notification clicked:', {
+        messageId,
+        route: deepLinkPayload.route
+      });
+
+      // Try to use SDK instance if available and ready (has deviceId)
+      const sdkInstance = SwanSDK.getCurrentInstance();
+      const isSDKReady = sdkInstance && sdkInstance.isReady();
+      if (isSDKReady) {
+        if (!sdkInstance.isPushEnabled()) {
+          return;
+        }
+
+        // Emit notificationOpened event for host app to handle
+        sdkInstance.emitNotificationOpened(deepLinkPayload);
+
+        // Send click ACK
+        if (messageId) {
+          await sdkInstance.sendNotificationAck(messageId, 'clicked');
+          Logger.log('[SwanSDK] Click ACK sent via SDK');
+        }
+        return;
+      }
+
+      // SDK not ready (app was killed) - send ACK directly via fetch
+      Logger.log('[SwanSDK] SDK not ready, sending click ACK via direct fetch');
+      if (messageId) {
+        await sendDirectNotificationAck(messageId, 'clicked');
+      }
+    } catch (error) {
+      Logger.error('[SwanSDK] Error in background click handler:', error);
+    }
+  };
+}
+
+/**
+ * Send notification ACK directly when SDK is not initialized (app was killed)
+ * Used for both delivery and click ACKs when SDK instance is not available
+ * Uses Firebase messageId for tracking (sent as commId to backend)
+ * @internal
+ */
+async function sendDirectNotificationAck(messageId, event) {
+  // Use console.log directly since Logger may be disabled in headless context
+  console.log(`[SwanSDK] sendDirectNotificationAck called - event: ${event}, messageId: ${messageId}`);
+  try {
+    const AsyncStorageModule = require('@react-native-async-storage/async-storage').default;
+    const Base64Module = require('react-native-base64').default;
+
+    // Read credentials from AsyncStorage
+    console.log('[SwanSDK] Reading credentials from AsyncStorage...');
+    const encoded = await AsyncStorageModule.getItem('swanCredentials');
+    if (!encoded) {
+      console.log(`[SwanSDK] No credentials found, cannot send ${event} ACK`);
+      return;
+    }
+    console.log('[SwanSDK] Credentials found, decoding...');
+    const credentials = JSON.parse(Base64Module.decode(encoded));
+    const {
+      appId,
+      deviceId,
+      currentCDID,
+      generatedCDID,
+      isProduction
+    } = credentials;
+    console.log(`[SwanSDK] Credentials - appId: ${appId}, deviceId: ${deviceId}, CDID: ${currentCDID || generatedCDID}, isProduction: ${isProduction}`);
+    if (!appId || !deviceId) {
+      console.log(`[SwanSDK] Invalid credentials, cannot send ${event} ACK`);
+      return;
+    }
+
+    // Backend expects commId field - we send Firebase messageId as the value
+    const payload = {
+      commId: messageId,
+      appId,
+      CDID: currentCDID || generatedCDID,
+      event,
+      deviceId
+    };
+    const urlType = isProduction === 'PROD' ? 'PROD' : 'STAGE';
+    console.log(`[SwanSDK] Sending ${event} ACK to: ${URLS.WEBHOOK_MOBILE_PUSH_URL[urlType]}`);
+    console.log('[SwanSDK] Payload:', JSON.stringify(payload));
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      console.log('[SwanSDK] ACK request timeout triggered (10s)');
+      controller.abort();
+    }, 10000);
+    console.log('[SwanSDK] Starting fetch...');
+    const response = await fetch(URLS.WEBHOOK_MOBILE_PUSH_URL[urlType], {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Swan-Device-Id': deviceId
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    console.log('[SwanSDK] Fetch completed, status:', response.status);
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      console.log(`[SwanSDK] ✅ ${event} ACK sent successfully via direct fetch`);
+    } else {
+      const responseText = await response.text();
+      console.log(`[SwanSDK] ${event} ACK failed - HTTP ${response.status}: ${responseText}`);
+    }
+  } catch (error) {
+    console.log('[SwanSDK] Caught error in sendDirectNotificationAck');
+    if (error?.name === 'AbortError') {
+      console.log(`[SwanSDK] ${event} ACK timed out (AbortError)`);
+    } else {
+      console.log(`[SwanSDK] Error sending ${event} ACK:`, error?.message || error);
+    }
+  }
+}
+
+// Named exports for convenience
+export { SwanSDK as SwanEcomSDK };
+export { ECOM_EVENTS };
+export { SharedCredentialsManager };
+//# sourceMappingURL=index.js.map