react-native-pointr 10.7.1 → 10.9.0

package/API_REFERENCE.md

@@ -354,6 +354,138 @@ const clientName = await pointrSdk.getClientName();
 
 ---
 
+The Site Manager and Data Manager methods that follow resolve sites and buildings by either identifier, defaulting to the **internal** one — whereas the older `getPois`, `getBuildings`, and `getSiteByExternalId` above always take an **external** identifier.
+
+#### `getSite(siteId, isExternalIdentifier?)`
+
+Returns a `Promise<PTRSite | null>`, or `null` if the site is not found.
+
+**Parameters:**
+- `siteId` (`string`): Site identifier.
+- `isExternalIdentifier` (`boolean`, default `false`): When `false`, `siteId` is the internal identifier; when `true`, the external identifier.
+
+```typescript
+const site = await pointrSdk.getSite('<SITE_ID>');
+const byExternal = await pointrSdk.getSite('<SITE_EXTERNAL_ID>', true);
+```
+
+---
+
+#### `getSiteBuildings(siteId, isExternalIdentifier?)`
+
+Returns a `Promise<PTRBuilding[]>` with all buildings for the given site. Rejects with `SITE_NOT_FOUND` if the site does not exist.
+
+**Parameters:**
+- `siteId` (`string`): Site identifier.
+- `isExternalIdentifier` (`boolean`, default `false`): Resolve `siteId` as internal (`false`) or external (`true`).
+
+```typescript
+const buildings = await pointrSdk.getSiteBuildings('<SITE_ID>');
+```
+
+---
+
+#### `getBuilding(siteId, buildingId, isExternalIdentifier?)`
+
+Returns a `Promise<PTRBuilding | null>`, or `null` if the building is not found in that site. Building identifiers are only unique within a site, so the lookup is always scoped by `siteId`.
+
+Rejects with `NOT_READY` if the SDK is not running, or `ERROR` if the lookup fails.
+
+**Parameters:**
+- `siteId` (`string`): Site identifier.
+- `buildingId` (`string`): Building identifier.
+- `isExternalIdentifier` (`boolean`, default `false`): When `false`, **both** ids are internal; when `true`, **both** are external.
+
+```typescript
+const building = await pointrSdk.getBuilding('<SITE_ID>', '<BUILDING_ID>');
+```
+
+---
+
+#### `getLevelByExternalIdentifier(buildingExternalIdentifier, levelExternalIdentifier)`
+
+Returns a `Promise<PTRLevel | null>`, or `null` if the level is not found in that building.
+
+Level external identifiers are only unique **within a building**, so the building's external identifier is required to scope the lookup. Both native SDKs expose this lookup by external identifier only, so there is no `isExternalIdentifier` flag — pass external identifiers for both arguments.
+
+**Parameters:**
+- `buildingExternalIdentifier` (`string`): External identifier of the building containing the level.
+- `levelExternalIdentifier` (`string`): External identifier of the level.
+
+```typescript
+const level = await pointrSdk.getLevelByExternalIdentifier(
+  '<BUILDING_EXTERNAL_ID>',
+  '<LEVEL_EXTERNAL_ID>'
+);
+// level?.index — 0 is ground level
+```
+
+---
+
+#### `getMapUrl(siteId, isExternalIdentifier?)`
+
+Returns a `Promise<string | null>` with the site's map data URL, or `null` if unavailable. Rejects with `SITE_NOT_FOUND` if the site does not exist, or `ERROR` if the URL cannot be retrieved.
+
+**Parameters:**
+- `siteId` (`string`): Site identifier.
+- `isExternalIdentifier` (`boolean`, default `false`): Resolve `siteId` as internal (`false`) or external (`true`).
+
+---
+
+#### `getStyleJsonUrl()`
+
+Returns a `Promise<string | null>` with the map style JSON URL, or `null` if unavailable.
+
+---
+
+#### `loadDataForSite(siteId, shouldRespectCachePolicy?, isExternalIdentifier?)`
+
+Starts data management for a site if the data is not already present. Returns a `Promise<void>`.
+
+This resolves as soon as data management has been **triggered**, not when it completes — subscribe to `onDataManagerCompleteAll` (which reports failures) or `onDataManagerReady` to observe the outcome.
+
+**Parameters:**
+- `siteId` (`string`): Site identifier.
+- `shouldRespectCachePolicy` (`boolean`, default `true`): When `true`, waits until the cache expires if data is already present. When `false`, ignores the cache and triggers an update immediately.
+- `isExternalIdentifier` (`boolean`, default `false`): Resolve `siteId` as internal (`false`) or external (`true`).
+
+Note that if the data is already present no event may fire at all, so check `isSiteContentReady` first and guard with a timeout:
+
+```typescript
+if (await pointrSdk.isSiteContentReady(siteId)) return; // nothing to download
+
+let subscription: { remove: () => void } | null = null;
+let timeout: ReturnType<typeof setTimeout> | null = null;
+const cleanup = () => {
+  subscription?.remove();
+  if (timeout != null) clearTimeout(timeout);
+};
+
+subscription = pointrSdk.onDataManagerCompleteAll((event) => {
+  if (event.site.identifier !== siteId) return;
+  cleanup();
+  console.log(event.isSuccessful ? 'loaded' : event.errors.join(', '));
+});
+timeout = setTimeout(() => {
+  cleanup();
+  console.log('timed out');
+}, 60000);
+
+await pointrSdk.loadDataForSite(siteId);
+```
+
+---
+
+#### `isSiteContentReady(siteId, isExternalIdentifier?)`
+
+Returns a `Promise<boolean>` — whether all data needed to display the site is available. This does not mean the data is the latest, only that there is valid data to show.
+
+**Parameters:**
+- `siteId` (`string`): Site identifier.
+- `isExternalIdentifier` (`boolean`, default `false`): Resolve `siteId` as internal (`false`) or external (`true`).
+
+---
+
 #### `isWayfindingReady(siteId)`
 
 Returns a `Promise<boolean>` indicating whether wayfinding data is ready for the given site.

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [10.9.0] - 2026-09-01
+
+### Changed
+- Mobile SDK 10.9.0 integration.
+
+
+## [10.8.0] - 2026-08-18
+
+### Changed
+- Mobile SDK 10.8.0 integration.
+
+
 ## [10.7.1] - 2026-08-05
 
 ### Changed
@@ -39,6 +51,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - **`PointrSdk` methods** exposing previously native-only capabilities: `shouldRequestPermissionsAtStartup`, `requestPermissions`, `getPois`, `searchPois`, `getSites`, `getBuildings`, `getSiteByExternalId`, `getClientName`, `isWayfindingReady`, `calculateDistance`, `isMyCarMarked`.
 - **Shared bridge key constants** — every string crossing the JS ↔ native boundary for a map widget action (action types, `action` and `sdkConfig` payload keys, view manager command names) is now declared in one constants file per platform: `src/constants/bridgeKeys.ts`, `android/src/main/java/com/pointr/PTRBridgeKeys.kt` and `ios/PTRBridgeKeys.swift`. No literals remain in the action serializer or in either native reader, so a key can no longer be renamed on one side only. `PTRActionParamKeys`, `PTRSdkConfigKeys` and `PTRCommandNames` are exported from the package.
+- **SiteManager** exposed through `PointrSdk`: `getSite`, `getSiteBuildings`, `getBuilding`, `getLevelByExternalIdentifier`, `getMapUrl`, `getStyleJsonUrl`. Site and building lookups accept an `isExternalIdentifier` flag to resolve by internal (default) or external identifier.
+- **Level external identifiers** — `getLevelByExternalIdentifier(buildingExternalIdentifier, levelExternalIdentifier)` wraps the level lookup added in native SDK 10.6.0. Levels are only unique within a building, so the building's external identifier scopes the lookup. Exposed by external identifier only, matching the native SDKs.
+- **DataManager** exposed through `PointrSdk`: `loadDataForSite`, `isSiteContentReady`, plus the five data-management events (`onDataManagerStart`, `onDataManagerCompleteAll`, `onDataManagerBeginProcessing`, `onDataManagerEndProcessing`, `onDataManagerReady`).
+- **Hooks**: `usePointrSite`, `usePointrData`, and one hook per data-manager event.
+- **Bridge key constants for the native → JS path** — the event payload fields (`PTREventPayloadKeys`) and the site / building / level object fields (`PTRModelKeys`) join the existing groups in the three `PTRBridgeKeys` files, so the data-manager events and the level lookup no longer write raw literals on either native side. iOS event names moved to `PTRNativeLibrary.EventNames`, matching Android's companion object and `PTREvents` in TypeScript.
+
 
 ### Changed
 - **Actions serialize through `toPayload()`** — `PTRAction` subclasses now build their JSON payload from `PTRActionParamKeys` instead of the component spreading their class fields, so a field rename can no longer silently change the wire format.
@@ -48,7 +66,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`markMyCar` / `showMyCar` via the declarative `action` prop on Android** — the completion event read an argument slot the declarative path never pushed, throwing inside the callback. Argument reads are now type-checked with defaults.
 - **`personaId` in the `sdkConfig` prop on iOS** — the key was written by JS but never read, so the persona was ignored when the widget initialised the SDK.
 
-
 ## [10.3.0] - 2026-06-30
 
 ### Changed

package/EXTENDING.md

@@ -360,7 +360,7 @@ Ensure both iOS and Android implementations return the same data structure:
 
 ### 7. Never Hard-code Bridge Strings
 
-Map widget actions cross the bridge as JSON, so a key that JS writes and native
+Data crosses the bridge as JSON, so a key that one side writes and the other
 reads is matched by string only — rename it on one side and the other side
 silently reads an empty value, with no compile error anywhere. Every such string
 lives in a constants file, one per language, and the three are kept identical:
@@ -371,12 +371,22 @@ lives in a constants file, one per language, and the three are kept identical:
 | Android    | `android/src/main/java/com/pointr/PTRBridgeKeys.kt` |
 | iOS        | `ios/PTRBridgeKeys.swift`                           |
 
-They cover four groups:
+They cover six groups — the first four on the JS -> native path, the last two on
+the native -> JS path:
 
 - **Action types** — the `type` discriminator of the `action` prop
 - **Action param keys** — every other field of the `action` prop payload
 - **SDK config keys** — the fields of the `sdkConfig` prop
 - **Command names** — the view manager commands `executeMapAction` dispatches
+- **Event payload keys** — the fields of the payloads native emits to JS; the
+  interfaces in `src/types/events.ts` are the TypeScript side of this contract
+- **Model keys** — the fields of the site / building / level objects native
+  serializes, matching `src/types/PTRSite.ts`
+
+Event *names* are the one exception: each side declares them where it emits or
+subscribes — `PTREvents` in `src/constants/index.ts`, `PTRNativeLibrary`'s
+companion object on Android and `PTRNativeLibrary.EventNames` on iOS. They must
+still match across all three.
 
 When adding an action or a parameter:
 

package/android/build.gradle

@@ -93,7 +93,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-android:0.82.1"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation("com.pointrlabs:pointr:10.7.0")
+  implementation("com.pointrlabs:pointr:10.9.0")
   implementation ("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version")
   implementation 'com.google.android.material:material:1.12.0'
   implementation 'androidx.constraintlayout:constraintlayout:2.2.1'

package/android/src/main/java/com/pointr/PTRBridgeKeys.kt

@@ -3,9 +3,10 @@ package com.pointr
 import androidx.annotation.StringDef
 
 /**
- * Every string that crosses the JS <-> native boundary when an action is sent
- * to the map widget: action type discriminators, `action` / `sdkConfig` payload
- * keys and view manager command names.
+ * Every string that crosses the JS <-> native boundary: action type
+ * discriminators, `action` / `sdkConfig` payload keys and view manager command
+ * names on the JS -> native path, plus the payload keys of the events native
+ * emits back to JS.
  *
  * Nothing here may be hard-coded anywhere else — a key renamed on one side only
  * fails silently (`optString` returns an empty string), so all three sides read
@@ -115,6 +116,47 @@ object PTRBridgeKeys {
         /** Highlight a category */
         const val HIGHLIGHT_CATEGORY = "highlightCategory"
     }
+
+    /**
+     * Field names of the event payloads emitted to JS through the event
+     * emitter. Native writes them, JS reads them back through the typed
+     * interfaces in `src/types/events.ts`.
+     *
+     * Event names are not listed here: they live in `PTREvents` on the JS side
+     * and in [PTRNativeLibrary]'s companion object on this side.
+     */
+    object EventPayloadKeys {
+        /** Site the event refers to, serialized by [ModelKeys] */
+        const val SITE = "site"
+        /** Whether the data came from the server (online) or a local bundle */
+        const val IS_ONLINE_DATA = "isOnlineData"
+        /** Whether the reported operation succeeded */
+        const val IS_SUCCESSFUL = "isSuccessful"
+        /** Error messages collected during the operation */
+        const val ERRORS = "errors"
+        /** Data type being processed */
+        const val DATA_TYPE = "dataType"
+        /** Numeric value of `dataType` */
+        const val DATA_TYPE_VALUE = "value"
+        /** Human-readable name of `dataType` */
+        const val DATA_TYPE_NAME = "name"
+    }
+
+    /**
+     * Field names shared by the site, building and level objects serialized for
+     * JS — both as promise results and inside event payloads. They match the
+     * interfaces in `src/types/PTRSite.ts`.
+     */
+    object ModelKeys {
+        /** Internal identifier */
+        const val IDENTIFIER = "identifier"
+        /** External (customer-facing) identifier */
+        const val EXTERNAL_IDENTIFIER = "externalIdentifier"
+        /** Human-readable name */
+        const val NAME = "name"
+        /** Zero-based level index */
+        const val INDEX = "index"
+    }
 }
 
 /** Restricts a String parameter to the [PTRBridgeKeys.ActionTypes] values. */

package/android/src/main/java/com/pointr/PTRNativeLibrary.kt

@@ -12,16 +12,22 @@ 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.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.pointr.PTRBridgeKeys.EventPayloadKeys
+import com.pointr.PTRBridgeKeys.ModelKeys
 import com.pointrlabs.core.geofence.GeofenceEvent
 import com.pointrlabs.core.geofence.GeofenceEventType
 import com.pointrlabs.core.geofence.GeofenceType
+import com.pointrlabs.core.management.DataManager
 import com.pointrlabs.core.management.GeofenceManager
 import com.pointrlabs.core.management.Pointr
 import com.pointrlabs.core.management.PositioningManager
 import com.pointrlabs.core.management.interfaces.PointrListener
 import com.pointrlabs.core.management.models.Building
+import com.pointrlabs.core.management.models.DataType
+import com.pointrlabs.core.management.models.ErrorMessage
 import com.pointrlabs.core.management.models.PTRParams
 import com.pointrlabs.core.management.models.Site
 import com.pointrlabs.core.nativecore.wrappers.Plog
@@ -43,6 +49,7 @@ class PTRNativeLibrary(reactContext: ReactApplicationContext) :
 
     private val positionManagerListener: PositioningManager.Listener
     private val geofenceListener : GeofenceManager.Listener
+    private val dataManagerListener: DataManager.Listener
     private var listenerCount = 0
 
     init {
@@ -58,9 +65,75 @@ class PTRNativeLibrary(reactContext: ReactApplicationContext) :
                 sendEventToJs(reactContext, OnGeofenceEvent, params)
             }
         }
+        dataManagerListener = object : DataManager.Listener {
+            override fun onDataManagerStartDataManagementForSite(site: Site, isOnlineData: Boolean) {
+                sendEventToJs(reactContext, OnDataManagerStartDataManagementForSite, Arguments.createMap().apply {
+                    putMap(EventPayloadKeys.SITE, site.toWritableMap())
+                    putBoolean(EventPayloadKeys.IS_ONLINE_DATA, isOnlineData)
+                })
+            }
+
+            override fun onDataManagerCompleteAllForSite(
+                site: Site,
+                isSuccessful: Boolean,
+                isOnlineData: Boolean,
+                errors: List<ErrorMessage?>?
+            ) {
+                sendEventToJs(reactContext, OnDataManagerCompleteAllForSite, Arguments.createMap().apply {
+                    putMap(EventPayloadKeys.SITE, site.toWritableMap())
+                    putBoolean(EventPayloadKeys.IS_SUCCESSFUL, isSuccessful)
+                    putBoolean(EventPayloadKeys.IS_ONLINE_DATA, isOnlineData)
+                    putArray(EventPayloadKeys.ERRORS, errorsArray(errors))
+                })
+            }
+
+            override fun onDataManagerBeginProcessingDataForSite(site: Site, dataType: DataType?, isOnlineData: Boolean) {
+                sendEventToJs(reactContext, OnDataManagerBeginProcessingDataForSite, Arguments.createMap().apply {
+                    putMap(EventPayloadKeys.SITE, site.toWritableMap())
+                    putMap(EventPayloadKeys.DATA_TYPE, dataTypeMap(dataType))
+                    putBoolean(EventPayloadKeys.IS_ONLINE_DATA, isOnlineData)
+                })
+            }
+
+            override fun onDataManagerEndProcessingDataForSite(
+                site: Site,
+                dataType: DataType?,
+                isOnlineData: Boolean,
+                isSuccessful: Boolean,
+                errors: List<ErrorMessage?>?
+            ) {
+                sendEventToJs(reactContext, OnDataManagerEndProcessingDataForSite, Arguments.createMap().apply {
+                    putMap(EventPayloadKeys.SITE, site.toWritableMap())
+                    putMap(EventPayloadKeys.DATA_TYPE, dataTypeMap(dataType))
+                    putBoolean(EventPayloadKeys.IS_ONLINE_DATA, isOnlineData)
+                    putBoolean(EventPayloadKeys.IS_SUCCESSFUL, isSuccessful)
+                    putArray(EventPayloadKeys.ERRORS, errorsArray(errors))
+                })
+            }
+
+            override fun onDataManagerReadyForSite(site: Site) {
+                sendEventToJs(reactContext, OnDataManagerReadyForSite, Arguments.createMap().apply {
+                    putMap(EventPayloadKeys.SITE, site.toWritableMap())
+                })
+            }
+        }
         setPointrListeners()
     }
 
+    private fun dataTypeMap(dataType: DataType?): WritableMap? {
+        val type = dataType ?: return null
+        return Arguments.createMap().apply {
+            putInt(EventPayloadKeys.DATA_TYPE_VALUE, type.value)
+            putString(EventPayloadKeys.DATA_TYPE_NAME, type.name)
+        }
+    }
+
+    private fun errorsArray(errors: List<ErrorMessage?>?): WritableArray {
+        val arr = Arguments.createArray()
+        errors?.filterNotNull()?.forEach { arr.pushString(it.message) }
+        return arr
+    }
+
 
     override fun getName(): String {
         return NAME
@@ -198,6 +271,149 @@ class PTRNativeLibrary(reactContext: ReactApplicationContext) :
         }
     }
 
+    // ─── Data Manager ────────────────────────────────────────────────────────
+
+    @ReactMethod
+    fun loadDataForSite(
+        siteId: String,
+        shouldRespectCachePolicy: Boolean,
+        isExternalIdentifier: Boolean,
+        promise: Promise
+    ) {
+        try {
+            val site = resolveSite(siteId, isExternalIdentifier)
+                ?: return promise.reject("SITE_NOT_FOUND", "Site not found: $siteId")
+            Pointr.getPointr()?.dataManager?.loadDataForSite(site, shouldRespectCachePolicy)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to load data for site: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun isSiteContentReady(siteId: String, isExternalIdentifier: Boolean, promise: Promise) {
+        try {
+            val site = resolveSite(siteId, isExternalIdentifier)
+                ?: return promise.reject("SITE_NOT_FOUND", "Site not found: $siteId")
+            val ready = Pointr.getPointr()?.dataManager?.isSiteContentReady(site) ?: false
+            promise.resolve(ready)
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to check site content: ${e.message}", e)
+        }
+    }
+
+    private fun resolveSite(siteId: String, isExternalIdentifier: Boolean): Site? {
+        val siteManager = Pointr.getPointr()?.siteManager ?: return null
+        return if (isExternalIdentifier) {
+            siteManager.getSiteByExternalIdentifier(siteId)
+        } else {
+            siteManager.getSite(siteId)
+        }
+    }
+
+    // ─── Site Manager ────────────────────────────────────────────────────────
+
+    @ReactMethod
+    fun getSite(siteId: String, isExternalIdentifier: Boolean, promise: Promise) {
+        try {
+            val site = resolveSite(siteId, isExternalIdentifier)
+            promise.resolve(site?.toWritableMap())
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get site: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun getSiteBuildings(siteId: String, isExternalIdentifier: Boolean, promise: Promise) {
+        try {
+            val site = resolveSite(siteId, isExternalIdentifier)
+                ?: return promise.reject("SITE_NOT_FOUND", "Site not found: $siteId")
+            val buildings = Pointr.getPointr()?.siteManager?.getBuildings(site.identifier) ?: emptyList()
+            val arr = Arguments.createArray()
+            buildings.forEach { b -> arr.pushMap(b.toWritableMap()) }
+            promise.resolve(arr)
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get buildings: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun getBuilding(
+        siteId: String,
+        buildingId: String,
+        isExternalIdentifier: Boolean,
+        promise: Promise
+    ) {
+        try {
+            val siteManager = Pointr.getPointr()?.siteManager
+                ?: return promise.reject("NOT_READY", "Site manager is not available")
+            val building = if (isExternalIdentifier) {
+                siteManager.getBuildingByExternalIdentifier(siteId, buildingId)
+            } else {
+                siteManager.getBuilding(siteId, buildingId)
+            }
+            promise.resolve(building?.toWritableMap())
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get building: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun getLevelByExternalIdentifier(
+        buildingExternalIdentifier: String,
+        levelExternalIdentifier: String,
+        promise: Promise
+    ) {
+        try {
+            val siteManager = Pointr.getPointr()?.siteManager
+                ?: return promise.reject("NOT_READY", "Site manager is not available")
+            // Named arguments on purpose: PointrKit takes (level, building) while
+            // this SDK takes (building, level), and both are plain strings.
+            val level = siteManager.getLevelByExternalIdentifier(
+                buildingExternalIdentifier = buildingExternalIdentifier,
+                levelExternalIdentifier = levelExternalIdentifier
+            )
+            promise.resolve(level?.let { lvl ->
+                Arguments.createMap().apply {
+                    putString(ModelKeys.IDENTIFIER, lvl.identifier)
+                    putString(ModelKeys.EXTERNAL_IDENTIFIER, lvl.externalIdentifier)
+                    putString(ModelKeys.NAME, lvl.name ?: "")
+                    putInt(ModelKeys.INDEX, lvl.index)
+                }
+            })
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get level: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun getMapUrl(siteId: String, isExternalIdentifier: Boolean, promise: Promise) {
+        try {
+            val site = resolveSite(siteId, isExternalIdentifier)
+                ?: return promise.reject("SITE_NOT_FOUND", "Site not found: $siteId")
+            val siteManager = Pointr.getPointr()?.siteManager
+                ?: return promise.reject("NOT_READY", "Site manager is not available")
+            siteManager.getMapUrl(site.identifier) { mapUrl, error ->
+                if (error != null) {
+                    promise.reject("ERROR", error)
+                } else {
+                    promise.resolve(mapUrl)
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get map url: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun getStyleJsonUrl(promise: Promise) {
+        try {
+            promise.resolve(Pointr.getPointr()?.siteManager?.styleJsonUrl)
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get style json url: ${e.message}", e)
+        }
+    }
+
     // ─── Sites & Buildings ───────────────────────────────────────────────────
 
     @ReactMethod
@@ -358,6 +574,12 @@ class PTRNativeLibrary(reactContext: ReactApplicationContext) :
 
         const val OnGeofenceEvent = "OnGeofenceEvent"
 
+        const val OnDataManagerStartDataManagementForSite = "OnDataManagerStartDataManagementForSite"
+        const val OnDataManagerCompleteAllForSite = "OnDataManagerCompleteAllForSite"
+        const val OnDataManagerBeginProcessingDataForSite = "OnDataManagerBeginProcessingDataForSite"
+        const val OnDataManagerEndProcessingDataForSite = "OnDataManagerEndProcessingDataForSite"
+        const val OnDataManagerReadyForSite = "OnDataManagerReadyForSite"
+
         var shouldRequestPermissionsAtStartup = true
 
         fun sendEventToJs(
@@ -597,6 +819,7 @@ class PTRNativeLibrary(reactContext: ReactApplicationContext) :
         if (pointr.state != Pointr.State.RUNNING) return
         pointr.positioningManager?.removeListener(positionManagerListener)
         pointr.geofenceManager?.removeListener(geofenceListener)
+        pointr.dataManager?.removeListener(dataManagerListener)
     }
 
     private fun setPointrListeners() {
@@ -604,6 +827,7 @@ class PTRNativeLibrary(reactContext: ReactApplicationContext) :
         if (pointr.state != Pointr.State.RUNNING) return
         pointr.positioningManager?.addListener(positionManagerListener)
         pointr.geofenceManager?.addListener(geofenceListener)
+        pointr.dataManager?.addListener(dataManagerListener)
         if (shouldRequestPermissionsAtStartup) {
             requestPermissions()
         } else {

package/ios/PTRBridgeKeys.swift

@@ -1,8 +1,9 @@
 import Foundation
 
-/// Every string that crosses the JS <-> native boundary when an action is sent
-/// to the map widget: action type discriminators, `action` / `sdkConfig` payload
-/// keys and view manager command names.
+/// Every string that crosses the JS <-> native boundary: action type
+/// discriminators, `action` / `sdkConfig` payload keys and view manager command
+/// names on the JS -> native path, plus the payload keys of the events native
+/// emits back to JS.
 ///
 /// Nothing here may be hard-coded anywhere else — a key renamed on one side only
 /// fails silently (the cast yields `nil` and the parameter defaults to empty), so
@@ -107,4 +108,41 @@ enum PTRBridgeKeys {
         /// Highlight a category
         static let highlightCategory = "highlightCategory"
     }
+
+    /// Field names of the event payloads emitted to JS through the event
+    /// emitter. Native writes them, JS reads them back through the typed
+    /// interfaces in `src/types/events.ts`.
+    ///
+    /// Event names are not listed here: they live in `PTREvents` on the JS side
+    /// and in `PTRNativeLibrary.EventNames` on this side.
+    enum EventPayloadKeys {
+        /// Site the event refers to, serialized by `ModelKeys`
+        static let site = "site"
+        /// Whether the data came from the server (online) or a local bundle
+        static let isOnlineData = "isOnlineData"
+        /// Whether the reported operation succeeded
+        static let isSuccessful = "isSuccessful"
+        /// Error messages collected during the operation
+        static let errors = "errors"
+        /// Data type being processed
+        static let dataType = "dataType"
+        /// Numeric value of `dataType`
+        static let dataTypeValue = "value"
+        /// Human-readable name of `dataType`
+        static let dataTypeName = "name"
+    }
+
+    /// Field names shared by the site, building and level objects serialized for
+    /// JS — both as promise results and inside event payloads. They match the
+    /// interfaces in `src/types/PTRSite.ts`.
+    enum ModelKeys {
+        /// Internal identifier
+        static let identifier = "identifier"
+        /// External (customer-facing) identifier
+        static let externalIdentifier = "externalIdentifier"
+        /// Human-readable name
+        static let name = "name"
+        /// Zero-based level index
+        static let index = "index"
+    }
 }

package/ios/PTRNativeLibrary-Bridging.m

@@ -35,6 +35,48 @@ RCT_EXTERN_METHOD(getPois:(NSString *)siteId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+// Data Manager
+RCT_EXTERN_METHOD(loadDataForSite:(NSString *)siteId
+                  shouldRespectCachePolicy:(BOOL)shouldRespectCachePolicy
+                  isExternalIdentifier:(BOOL)isExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isSiteContentReady:(NSString *)siteId
+                  isExternalIdentifier:(BOOL)isExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Site Manager
+RCT_EXTERN_METHOD(getSite:(NSString *)siteId
+                  isExternalIdentifier:(BOOL)isExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getSiteBuildings:(NSString *)siteId
+                  isExternalIdentifier:(BOOL)isExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getBuilding:(NSString *)siteId
+                  buildingId:(NSString *)buildingId
+                  isExternalIdentifier:(BOOL)isExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getLevelByExternalIdentifier:(NSString *)buildingExternalIdentifier
+                  levelExternalIdentifier:(NSString *)levelExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getMapUrl:(NSString *)siteId
+                  isExternalIdentifier:(BOOL)isExternalIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getStyleJsonUrl:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 // Sites & Buildings
 RCT_EXTERN_METHOD(getSites:(RCTPromiseResolveBlock)resolve
                          rejecter:(RCTPromiseRejectBlock)reject)