@dashx/react-native 1.1.5 → 1.3.0

package/android/src/main/java/com/dashx/rn/sdk/DashXReactNativeModuleImpl.kt

@@ -0,0 +1,384 @@
+package com.dashx.rn.sdk
+
+import android.Manifest
+import android.app.Activity
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.dashx.rn.sdk.util.*
+import com.dashx.android.DashX
+import com.dashx.android.DashXLog
+import com.dashx.android.DashXLog.LogLevel
+import com.dashx.android.data.Asset
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+
+class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationContext) {
+    private val tag = DashXReactNativeModuleImpl::class.java.simpleName
+
+    fun initialize() {
+        MessageReceivedEventHolder.reactContext = reactContext
+    }
+
+    fun invalidate() {
+        MessageReceivedEventHolder.reactContext = null
+    }
+
+    fun setLogLevel(level: Double) {
+        // JS contract: 0 = off, 1 = errors, 2 = debug
+        // Native SDK:  OFF = -1, ERROR = 0, INFO = 1, DEBUG = 2
+        val logLevel = when (level.toInt()) {
+            0 -> LogLevel.OFF
+            1 -> LogLevel.ERROR
+            2 -> LogLevel.DEBUG
+            else -> LogLevel.OFF
+        }
+        DashXLog.setLogLevel(logLevel)
+    }
+
+    fun configure(options: ReadableMap) {
+        createDefaultNotificationChannel()
+        DashX.configure(
+            reactContext,
+            options.getString("publicKey")!!,
+            options.getStringIfPresent("baseURI"),
+            options.getStringIfPresent("targetEnvironment")
+        )
+    }
+
+    private fun createDefaultNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val notificationManager = reactContext.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager ?: return
+
+        val existing = notificationManager.getNotificationChannel(DEFAULT_CHANNEL_ID)
+        if (existing != null) return
+
+        val channel = NotificationChannel(
+            DEFAULT_CHANNEL_ID,
+            DEFAULT_CHANNEL_NAME,
+            NotificationManager.IMPORTANCE_HIGH
+        ).apply {
+            enableVibration(true)
+            setShowBadge(true)
+            lockscreenVisibility = android.app.Notification.VISIBILITY_PUBLIC
+        }
+        notificationManager.createNotificationChannel(channel)
+    }
+
+    fun identify(options: ReadableMap?) {
+        val optionsHashMap = options?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+        DashX.identify(optionsHashMap?.let { HashMap(it) })
+    }
+
+    fun setIdentity(uid: String?, token: String?) {
+        DashX.setIdentity(uid, token)
+    }
+
+    fun reset() {
+        DashX.reset()
+    }
+
+    fun track(event: String, data: ReadableMap?) {
+        val jsonData = try {
+            data?.toHashMap()
+                ?.filterValues { it != null }
+                ?.mapValues { it.value.toString() }
+                ?.let { HashMap(it) }
+        } catch (e: Exception) {
+            DashXLog.d(tag, "Failed to convert track data, sending event without data: ${e.message}")
+            null
+        }
+
+        DashX.track(event, jsonData)
+    }
+
+    fun screen(screenName: String, data: ReadableMap?) {
+        val screenData = data?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+            ?.let { HashMap(it) }
+            ?: HashMap()
+        DashX.screen(screenName, screenData)
+    }
+
+    fun fetchRecord(urn: String, options: ReadableMap?, promise: Promise) {
+        val preview = options?.getBooleanIfPresent("preview")
+        val language = options?.getStringIfPresent("language")
+        val fields = try {
+            convertReadableArrayToKJsonList(options?.getArray("fields"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing exclude: ${e.message}")
+            return
+        }
+
+        DashX.fetchRecord(
+            urn = urn,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = {
+                promise.resolve(convertJsonToMap(convertKJsonToJson(it)))
+            }
+        )
+    }
+
+    fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) {
+        val jsonFilter = try {
+            convertMapToJson(options?.getMap("filter"))?.let { convertJsonToKJson(it) }
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing filter: ${e.message}")
+            return
+        }
+        val order = try {
+            convertReadableArrayToKJsonList(options?.getArray("order"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing order: ${e.message}")
+            return
+        }
+        val limit = options?.getIntIfPresent("limit")
+        val preview = options?.getBooleanIfPresent("preview")
+        val language = options?.getStringIfPresent("language")
+        val fields = try {
+            convertReadableArrayToKJsonList(options?.getArray("fields"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing exclude: ${e.message}")
+            return
+        }
+
+        DashX.searchRecords(
+            resource = resource,
+            filter = jsonFilter,
+            order = order,
+            limit = limit,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { records ->
+                val readableArray = Arguments.createArray()
+                records.forEach {
+                    readableArray.pushMap(convertJsonToMap(convertKJsonToJson(it)))
+                }
+                promise.resolve(readableArray)
+            }
+        )
+    }
+
+    fun fetchStoredPreferences(promise: Promise) {
+        DashX.fetchStoredPreferences(
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+            }
+        )
+    }
+
+    fun saveStoredPreferences(preferenceData: ReadableMap?, promise: Promise) {
+        val preferencesString = MapUtil.toJSONElement(preferenceData).toString()
+
+        DashX.saveStoredPreferences(
+            Json.decodeFromString<JsonObject>(preferencesString),
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+            }
+        )
+    }
+
+    fun subscribe() {
+        DashX.subscribe()
+    }
+
+    fun unsubscribe() {
+        DashX.unsubscribe()
+    }
+
+    // --- iOS-only methods: no-op stubs on Android (JS guards prevent these from being called) ---
+
+    fun enableLifecycleTracking() {
+        // iOS-only; no-op on Android
+    }
+
+    fun enableAdTracking() {
+        // iOS-only; no-op on Android
+    }
+
+    fun processURL(url: String, source: String?, forwardToLinkHandler: Boolean) {
+        // iOS-only; no-op on Android
+    }
+
+    fun trackNotificationNavigation(action: ReadableMap?, notificationId: String?) {
+        // iOS-only; no-op on Android
+    }
+
+    fun uploadAsset(filePath: String, resource: String, attribute: String, promise: Promise) {
+        val file = java.io.File(filePath)
+        DashX.uploadAsset(
+            file = file,
+            resource = resource,
+            attribute = attribute,
+            onSuccess = { asset ->
+                try {
+                    val jsonString = Json.encodeToString(asset)
+                    val jsonObject = org.json.JSONObject(jsonString)
+                    promise.resolve(convertJsonToMap(jsonObject))
+                } catch (e: Exception) {
+                    promise.resolve(null)
+                }
+            },
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            }
+        )
+    }
+
+    fun fetchAsset(assetId: String, promise: Promise) {
+        DashX.fetchAsset(
+            assetId = assetId,
+            onSuccess = { asset ->
+                try {
+                    val jsonString = Json.encodeToString(asset)
+                    val jsonObject = org.json.JSONObject(jsonString)
+                    promise.resolve(convertJsonToMap(jsonObject))
+                } catch (e: Exception) {
+                    promise.resolve(null)
+                }
+            },
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            }
+        )
+    }
+
+    fun requestNotificationPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+
+        val alreadyGranted = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+        if (alreadyGranted) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+
+        val activity = reactContext.currentActivity as? PermissionAwareActivity
+        if (activity == null) {
+            promise.reject(E_UNSPECIFIED, "No current activity to request permission from")
+            return
+        }
+
+        reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putBoolean(KEY_PERMISSION_REQUESTED, true)
+            .apply()
+
+        val listener = PermissionListener { requestCode, _, grantResults ->
+            if (requestCode != NOTIFICATION_PERMISSION_REQUEST_CODE) return@PermissionListener false
+            val granted = grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED
+            promise.resolve(if (granted) PERMISSION_AUTHORIZED else PERMISSION_DENIED)
+            true
+        }
+
+        activity.requestPermissions(
+            arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+            NOTIFICATION_PERMISSION_REQUEST_CODE,
+            listener
+        )
+    }
+
+    fun getNotificationPermissionStatus(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+        val granted = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+        if (granted) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+        } else {
+            val wasRequested = reactContext
+                .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+                .getBoolean(KEY_PERMISSION_REQUESTED, false)
+            promise.resolve(if (wasRequested) PERMISSION_DENIED else PERMISSION_NOT_DETERMINED)
+        }
+    }
+
+    companion object {
+        const val NAME = "DashXReactNative"
+        private const val E_UNSPECIFIED = "EUNSPECIFIED"
+        private const val DEFAULT_CHANNEL_ID = "default_dashx_notification_channel"
+        private const val DEFAULT_CHANNEL_NAME = "Notifications"
+
+        private const val NOTIFICATION_PERMISSION_REQUEST_CODE = 3571
+
+        private const val PREFS_NAME = "dashx_rn_prefs"
+        private const val KEY_PERMISSION_REQUESTED = "notification_permission_requested"
+
+        // Mirrors iOS UNAuthorizationStatus values used by the JS layer.
+        private const val PERMISSION_NOT_DETERMINED = 0
+        private const val PERMISSION_DENIED = 1
+        private const val PERMISSION_AUTHORIZED = 2
+    }
+}

package/android/src/newarch/java/com/dashx/rn/sdk/DashXReactNativeModule.kt

@@ -0,0 +1,85 @@
+package com.dashx.rn.sdk
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+
+class DashXReactNativeModule(reactContext: ReactApplicationContext) :
+    NativeDashXReactNativeSpec(reactContext) {
+
+    private val impl = DashXReactNativeModuleImpl(reactContext)
+
+    override fun getName(): String = DashXReactNativeModuleImpl.NAME
+
+    override fun initialize() {
+        super.initialize()
+        impl.initialize()
+    }
+
+    override fun invalidate() {
+        impl.invalidate()
+        super.invalidate()
+    }
+
+    override fun configure(options: ReadableMap) = impl.configure(options)
+
+    override fun identify(options: ReadableMap?) = impl.identify(options)
+
+    override fun setIdentity(uid: String?, token: String?) = impl.setIdentity(uid, token)
+
+    override fun reset() = impl.reset()
+
+    override fun track(event: String, data: ReadableMap?) = impl.track(event, data)
+
+    override fun screen(screenName: String, data: ReadableMap?) = impl.screen(screenName, data)
+
+    override fun fetchRecord(urn: String, options: ReadableMap?, promise: Promise) =
+        impl.fetchRecord(urn, options, promise)
+
+    override fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) =
+        impl.searchRecords(resource, options, promise)
+
+    override fun fetchStoredPreferences(promise: Promise) = impl.fetchStoredPreferences(promise)
+
+    override fun saveStoredPreferences(preferenceData: ReadableMap?, promise: Promise) =
+        impl.saveStoredPreferences(preferenceData, promise)
+
+    override fun subscribe() = impl.subscribe()
+
+    override fun unsubscribe() = impl.unsubscribe()
+
+    override fun setLogLevel(level: Double) = impl.setLogLevel(level)
+
+    override fun enableLifecycleTracking() = impl.enableLifecycleTracking()
+
+    override fun enableAdTracking() = impl.enableAdTracking()
+
+    override fun processURL(url: String, source: String?, forwardToLinkHandler: Boolean) =
+        impl.processURL(url, source, forwardToLinkHandler)
+
+    override fun trackNotificationNavigation(action: ReadableMap?, notificationId: String?) =
+        impl.trackNotificationNavigation(action, notificationId)
+
+    override fun uploadAsset(
+        filePath: String,
+        resource: String,
+        attribute: String,
+        promise: Promise
+    ) = impl.uploadAsset(filePath, resource, attribute, promise)
+
+    override fun fetchAsset(assetId: String, promise: Promise) = impl.fetchAsset(assetId, promise)
+
+    override fun requestNotificationPermission(promise: Promise) =
+        impl.requestNotificationPermission(promise)
+
+    override fun getNotificationPermissionStatus(promise: Promise) =
+        impl.getNotificationPermissionStatus(promise)
+
+    override fun addListener(eventName: String) {
+        // Required for RN built-in Event Emitter Calls
+    }
+
+    override fun removeListeners(count: Double) {
+        // Required for RN built-in Event Emitter Calls
+    }
+}

package/android/src/newarch/java/com/dashx/rn/sdk/DashXReactNativePackage.kt

@@ -0,0 +1,33 @@
+package com.dashx.rn.sdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class DashXReactNativePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == DashXReactNativeModuleImpl.NAME) {
+            DashXReactNativeModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            mapOf(
+                DashXReactNativeModuleImpl.NAME to ReactModuleInfo(
+                    DashXReactNativeModuleImpl.NAME,
+                    DashXReactNativeModuleImpl.NAME,
+                    false, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    false, // hasConstants
+                    false, // isCxxModule
+                    true   // isTurboModule
+                )
+            )
+        }
+    }
+}

package/android/src/oldarch/java/com/dashx/rn/sdk/DashXReactNativeModule.kt

@@ -0,0 +1,106 @@
+package com.dashx.rn.sdk
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+
+class DashXReactNativeModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val impl = DashXReactNativeModuleImpl(reactContext)
+
+    override fun getName(): String = DashXReactNativeModuleImpl.NAME
+
+    override fun initialize() {
+        super.initialize()
+        impl.initialize()
+    }
+
+    override fun invalidate() {
+        impl.invalidate()
+        super.invalidate()
+    }
+
+    @ReactMethod
+    fun configure(options: ReadableMap) = impl.configure(options)
+
+    @ReactMethod
+    fun identify(options: ReadableMap?) = impl.identify(options)
+
+    @ReactMethod
+    fun setIdentity(uid: String?, token: String?) = impl.setIdentity(uid, token)
+
+    @ReactMethod
+    fun reset() = impl.reset()
+
+    @ReactMethod
+    fun track(event: String, data: ReadableMap?) = impl.track(event, data)
+
+    @ReactMethod
+    fun screen(screenName: String, data: ReadableMap?) = impl.screen(screenName, data)
+
+    @ReactMethod
+    fun fetchRecord(urn: String, options: ReadableMap?, promise: Promise) =
+        impl.fetchRecord(urn, options, promise)
+
+    @ReactMethod
+    fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) =
+        impl.searchRecords(resource, options, promise)
+
+    @ReactMethod
+    fun fetchStoredPreferences(promise: Promise) = impl.fetchStoredPreferences(promise)
+
+    @ReactMethod
+    fun saveStoredPreferences(preferenceData: ReadableMap?, promise: Promise) =
+        impl.saveStoredPreferences(preferenceData, promise)
+
+    @ReactMethod
+    fun subscribe() = impl.subscribe()
+
+    @ReactMethod
+    fun unsubscribe() = impl.unsubscribe()
+
+    @ReactMethod
+    fun setLogLevel(level: Double) = impl.setLogLevel(level)
+
+    @ReactMethod
+    fun enableLifecycleTracking() = impl.enableLifecycleTracking()
+
+    @ReactMethod
+    fun enableAdTracking() = impl.enableAdTracking()
+
+    @ReactMethod
+    fun processURL(url: String, source: String?, forwardToLinkHandler: Boolean) =
+        impl.processURL(url, source, forwardToLinkHandler)
+
+    @ReactMethod
+    fun trackNotificationNavigation(action: ReadableMap?, notificationId: String?) =
+        impl.trackNotificationNavigation(action, notificationId)
+
+    @ReactMethod
+    fun uploadAsset(filePath: String, resource: String, attribute: String, promise: Promise) =
+        impl.uploadAsset(filePath, resource, attribute, promise)
+
+    @ReactMethod
+    fun fetchAsset(assetId: String, promise: Promise) = impl.fetchAsset(assetId, promise)
+
+    @ReactMethod
+    fun requestNotificationPermission(promise: Promise) =
+        impl.requestNotificationPermission(promise)
+
+    @ReactMethod
+    fun getNotificationPermissionStatus(promise: Promise) =
+        impl.getNotificationPermissionStatus(promise)
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for RN built-in Event Emitter Calls
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Double) {
+        // Required for RN built-in Event Emitter Calls
+    }
+}

package/android/src/oldarch/java/com/dashx/rn/sdk/DashXReactNativePackage.kt

@@ -0,0 +1,33 @@
+package com.dashx.rn.sdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class DashXReactNativePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == DashXReactNativeModuleImpl.NAME) {
+            DashXReactNativeModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            mapOf(
+                DashXReactNativeModuleImpl.NAME to ReactModuleInfo(
+                    DashXReactNativeModuleImpl.NAME,
+                    DashXReactNativeModuleImpl.NAME,
+                    false, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    false, // hasConstants
+                    false, // isCxxModule
+                    false  // isTurboModule
+                )
+            )
+        }
+    }
+}

package/index.d.ts

@@ -7,6 +7,8 @@ import { EmitterSubscription } from 'react-native';
 export enum DashXErrorCode {
   /** An unspecified error occurred. */
   EUNSPECIFIED = 'EUNSPECIFIED',
+  /** The operation is not supported on this platform. */
+  EUNSUPPORTED = 'EUNSUPPORTED',
 }
 
 export interface ConfigureOptions {
@@ -72,6 +74,12 @@ export type NavigationAction =
   | { type: 'richLanding'; url: string }
   | { type: 'clickAction'; action: string };
 
+export interface NotificationClickedEvent {
+  notification: NotificationMessage;
+  action: NavigationAction | null;
+  actionIdentifier: string;
+}
+
 export interface ProcessURLOptions {
   source?: string;
   forwardToLinkHandler?: boolean;
@@ -90,9 +98,11 @@ export interface DashXInstance {
   identify(options: IdentifyOptions): void;
 
   /**
-   * Set user identity using a UID and authentication token.
+   * Set user identity using a UID and authentication token. Both are
+   * nullable — passing `null` clears that field on the native SDK. Empty
+   * strings are forwarded as-is (no coercion to `null`).
    */
-  setIdentity(uid: string, token: string): void;
+  setIdentity(uid: string | null, token?: string | null): void;
 
   /**
    * Clear the current user identity and reset SDK state.
@@ -222,6 +232,18 @@ export interface DashXInstance {
    * Returns a subscription that can be removed via `.remove()`.
    */
   onLinkReceived(callback: (url: string) => void): EmitterSubscription;
+
+  /**
+   * Register a listener for notification tap events. Fired when the user taps
+   * a DashX notification or one of its action buttons. The callback receives
+   * the full notification payload, the resolved `NavigationAction` (parsed
+   * from the payload; `null` if no navigation intent could be resolved), and
+   * the raw `actionIdentifier` from `UNNotificationResponse`.
+   * Returns a subscription that can be removed via `.remove()`.
+   */
+  onNotificationClicked(
+    callback: (event: NotificationClickedEvent) => void
+  ): EmitterSubscription;
 }
 
 declare const DashX: DashXInstance;