@usercentrics/react-native-sdk 2.25.1 → 2.26.1

package/android/build-legacy.gradle

@@ -1,4 +1,4 @@
-def usercentrics_version = "2.25.1"
+def usercentrics_version = "2.26.1"
 version usercentrics_version
 
 buildscript {

package/android/build.gradle.kts

@@ -1,4 +1,4 @@
-val usercentricsVersion = "2.25.1"
+val usercentricsVersion = "2.26.1"
 val reactNativeVersion = "+"
 
 fun BooleanProperty(name: String): Boolean {

package/android/src/main/java/com/usercentrics/reactnative/RNUsercentricsModule.kt

@@ -1,10 +1,14 @@
 package com.usercentrics.reactnative
 
 import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.usercentrics.sdk.UsercentricsDisposableEvent
+import com.usercentrics.sdk.UsercentricsEvent
 import com.usercentrics.reactnative.api.UsercentricsProxy
 import com.usercentrics.reactnative.extensions.*
 import com.usercentrics.sdk.UsercentricsAnalyticsEventType
 import com.usercentrics.sdk.models.settings.UsercentricsConsentType
+import com.usercentrics.sdk.services.gpp.GppSectionChangePayload
 import com.usercentrics.sdk.services.tcf.TCFDecisionUILayer
 
 internal class RNUsercentricsModule(
@@ -12,6 +16,8 @@ internal class RNUsercentricsModule(
     private val usercentricsProxy: UsercentricsProxy,
     private val reactContextProvider: ReactContextProvider,
 ) : RNUsercentricsModuleSpec(reactContext) {
+    private var gppSectionChangeSubscription: UsercentricsDisposableEvent<GppSectionChangePayload>? = null
+    private var gppSectionChangeListenersCount = 0
 
     override fun getName() = NAME
 
@@ -79,6 +85,16 @@ internal class RNUsercentricsModule(
         promise.resolve(usercentricsProxy.instance.getABTestingVariant())
     }
 
+    @ReactMethod
+    override fun getDpsMetadata(templateId: String, promise: Promise) {
+        val metadata = usercentricsProxy.instance.getDpsMetadata(templateId)
+        if (metadata == null) {
+            promise.resolve(null)
+        } else {
+            promise.resolve(metadata.toWritableMap())
+        }
+    }
+
     @ReactMethod
     override fun getConsents(promise: Promise) {
         promise.resolve(usercentricsProxy.instance.getConsents().toWritableArray())
@@ -121,6 +137,28 @@ internal class RNUsercentricsModule(
         promise.resolve(usercentricsProxy.instance.getUSPData().serialize())
     }
 
+    @ReactMethod
+    override fun getGPPData(promise: Promise) {
+        promise.resolve(usercentricsProxy.instance.getGPPData().serializeGppData())
+    }
+
+    @ReactMethod
+    override fun getGPPString(promise: Promise) {
+        promise.resolve(usercentricsProxy.instance.getGPPString())
+    }
+
+    @ReactMethod
+    override fun setGPPConsent(sectionName: String, fieldName: String, value: ReadableMap) {
+        if (!value.hasKey("value")) return
+        val parsedValue = if (value.getType("value") == ReadableType.Null) {
+            null
+        } else {
+            readableMapValueToAny(value)
+        }
+        val safeValue = parsedValue ?: org.json.JSONObject.NULL
+        usercentricsProxy.instance.setGPPConsent(sectionName, fieldName, safeValue)
+    }
+
     @ReactMethod
     override fun changeLanguage(language: String, promise: Promise) {
         usercentricsProxy.instance.changeLanguage(language, {
@@ -149,10 +187,10 @@ internal class RNUsercentricsModule(
     }
 
     @ReactMethod
-    override fun denyAllForTCF(fromLayer: Double, consentType: Double, unsavedPurposeLIDecisions: ReadableArray, promise: Promise) {
+    override fun denyAllForTCF(fromLayer: Double, consentType: Double, unsavedPurposeLIDecisions: ReadableArray, unsavedVendorLIDecisions: ReadableArray, promise: Promise) {
         promise.resolve(
             usercentricsProxy.instance.denyAllForTCF(
-                TCFDecisionUILayer.values()[fromLayer.toInt()], UsercentricsConsentType.values()[consentType.toInt()], unsavedPurposeLIDecisions.deserializePurposeLIDecisionsMap()
+                TCFDecisionUILayer.values()[fromLayer.toInt()], UsercentricsConsentType.values()[consentType.toInt()], unsavedPurposeLIDecisions.deserializePurposeLIDecisionsMap(), unsavedVendorLIDecisions.deserializePurposeLIDecisionsMap()
             ).toWritableArray()
         )
     }
@@ -216,11 +254,73 @@ internal class RNUsercentricsModule(
         })
     }
 
+    @ReactMethod
+    override fun addListener(eventName: String) {
+        if (eventName != ON_GPP_SECTION_CHANGE_EVENT) return
+
+        gppSectionChangeListenersCount++
+        if (gppSectionChangeSubscription != null) return
+
+        gppSectionChangeSubscription = UsercentricsEvent.onGppSectionChange { payload ->
+            emitEvent(ON_GPP_SECTION_CHANGE_EVENT, payload.serializeGppPayload())
+        }
+    }
+
+    @ReactMethod
+    override fun removeListeners(count: Double) {
+        gppSectionChangeListenersCount = (gppSectionChangeListenersCount - count.toInt()).coerceAtLeast(0)
+        if (gppSectionChangeListenersCount == 0) {
+            gppSectionChangeSubscription?.dispose()
+            gppSectionChangeSubscription = null
+        }
+    }
+
+    override fun invalidate() {
+        gppSectionChangeSubscription?.dispose()
+        gppSectionChangeSubscription = null
+        gppSectionChangeListenersCount = 0
+        super.invalidate()
+    }
+
+    private fun emitEvent(eventName: String, payload: WritableMap) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, payload)
+    }
+
+    private fun readableMapValueToAny(map: ReadableMap): Any? {
+        if (!map.hasKey("value")) return null
+        return when (map.getType("value")) {
+            ReadableType.Null -> null
+            ReadableType.Boolean -> map.getBoolean("value")
+            ReadableType.Number -> normalizeNumber(map.getDouble("value"))
+            ReadableType.String -> map.getString("value")
+            ReadableType.Map -> normalizeCompositeValue(map.getMap("value")?.toHashMap())
+            ReadableType.Array -> normalizeCompositeValue(map.getArray("value")?.toArrayList())
+        }
+    }
+
+    private fun normalizeCompositeValue(value: Any?): Any? {
+        return when (value) {
+            is Double -> normalizeNumber(value)
+            is ArrayList<*> -> value.map { normalizeCompositeValue(it) }
+            is HashMap<*, *> -> value.entries.associate { (key, nestedValue) ->
+                key.toString() to normalizeCompositeValue(nestedValue)
+            }
+            else -> value
+        }
+    }
+
+    private fun normalizeNumber(value: Double): Any {
+        return if (value % 1.0 == 0.0) value.toInt() else value
+    }
+
     private fun runOnUiThread(block: () -> Unit) {
         UiThreadUtil.runOnUiThread(block)
     }
 
     companion object {
         const val NAME = "RNUsercentricsModule"
+        const val ON_GPP_SECTION_CHANGE_EVENT = "onGppSectionChange"
     }
 }

package/android/src/main/java/com/usercentrics/reactnative/RNUsercentricsModuleSpec.kt

@@ -51,15 +51,27 @@ abstract class RNUsercentricsModuleSpec internal constructor(context: ReactAppli
     @ReactMethod
     abstract fun getUSPData(promise: Promise)
 
+    @ReactMethod
+    abstract fun getGPPData(promise: Promise)
+
+    @ReactMethod
+    abstract fun getGPPString(promise: Promise)
+
     @ReactMethod
     abstract fun getABTestingVariant(promise: Promise)
 
+    @ReactMethod
+    abstract fun getDpsMetadata(templateId: String, promise: Promise)
+
     @ReactMethod
     abstract fun setCMPId(id: Double)
 
     @ReactMethod
     abstract fun setABTestingVariant(variant: String)
 
+    @ReactMethod
+    abstract fun setGPPConsent(sectionName: String, fieldName: String, value: ReadableMap)
+
     @ReactMethod
     abstract fun changeLanguage(language: String, promise: Promise)
 
@@ -73,7 +85,7 @@ abstract class RNUsercentricsModuleSpec internal constructor(context: ReactAppli
     abstract fun denyAll(consentType: Double, promise: Promise)
 
     @ReactMethod
-    abstract fun denyAllForTCF(fromLayer: Double, consentType: Double, unsavedPurposeLIDecisions: ReadableArray, promise: Promise)
+    abstract fun denyAllForTCF(fromLayer: Double, consentType: Double, unsavedPurposeLIDecisions: ReadableArray, unsavedVendorLIDecisions: ReadableArray, promise: Promise)
 
     @ReactMethod
     abstract fun saveDecisions(decisions: ReadableArray, consentType: Double, promise: Promise)
@@ -93,6 +105,12 @@ abstract class RNUsercentricsModuleSpec internal constructor(context: ReactAppli
     @ReactMethod
     abstract fun track(event: Double)
 
+    @ReactMethod
+    abstract fun addListener(eventName: String)
+
+    @ReactMethod
+    abstract fun removeListeners(count: Double)
+
     companion object {
         const val NAME = "RNUsercentricsModule"
     }

package/android/src/main/java/com/usercentrics/reactnative/extensions/BannerSettingsExtensions.kt

@@ -137,9 +137,10 @@ internal fun ReadableMap.buttonLayoutFromMap(context: Context): ButtonLayout? {
 
 internal fun ReadableMap.buttonSettingsFromMap(context: Context): ButtonSettings {
     val assetManager = context.assets
+    val buttonType = getString("buttonType")?.deserializeButtonType() ?: ButtonType.MORE
 
     return ButtonSettings(
-        type = getString("buttonType")!!.deserializeButtonType(),
+        type = buttonType,
         isAllCaps = getBooleanOrNull("isAllCaps"),
         font = assetManager.createFontFromName(getString("fontName")),
         textColor = getString("textColorHex")?.deserializeColor(),

package/android/src/main/java/com/usercentrics/reactnative/extensions/GppDataExtensions.kt

@@ -0,0 +1,83 @@
+package com.usercentrics.reactnative.extensions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.usercentrics.sdk.services.gpp.GppData
+import com.usercentrics.sdk.services.gpp.GppSectionChangePayload
+
+private fun normalizeNumber(value: Double): Any {
+    return if (value % 1.0 == 0.0 && value <= Int.MAX_VALUE && value >= Int.MIN_VALUE) {
+        value.toInt()
+    } else {
+        value
+    }
+}
+
+private fun Any?.toWritableValue(): Any? {
+    return when (this) {
+        null -> null
+        is Boolean -> this
+        is Number -> normalizeNumber(this.toDouble())
+        is String -> this
+        is Map<*, *> -> this.toWritableMap()
+        is Iterable<*> -> this.toWritableArray()
+        is Array<*> -> this.asList().toWritableArray()
+        else -> this.toString()
+    }
+}
+
+private fun Map<*, *>.toWritableMap(): WritableMap {
+    val result = Arguments.createMap()
+    for ((key, value) in this) {
+        val fieldName = key?.toString() ?: continue
+        when (val writableValue = value.toWritableValue()) {
+            null -> result.putNull(fieldName)
+            is Boolean -> result.putBoolean(fieldName, writableValue)
+            is Int -> result.putInt(fieldName, writableValue)
+            is Double -> result.putDouble(fieldName, writableValue)
+            is String -> result.putString(fieldName, writableValue)
+            is WritableMap -> result.putMap(fieldName, writableValue)
+            is WritableArray -> result.putArray(fieldName, writableValue)
+            else -> result.putString(fieldName, writableValue.toString())
+        }
+    }
+    return result
+}
+
+private fun Iterable<*>.toWritableArray(): WritableArray {
+    val result = Arguments.createArray()
+    for (item in this) {
+        when (val writableValue = item.toWritableValue()) {
+            null -> result.pushNull()
+            is Boolean -> result.pushBoolean(writableValue)
+            is Int -> result.pushInt(writableValue)
+            is Double -> result.pushDouble(writableValue)
+            is String -> result.pushString(writableValue)
+            is WritableMap -> result.pushMap(writableValue)
+            is WritableArray -> result.pushArray(writableValue)
+            else -> result.pushString(writableValue.toString())
+        }
+    }
+    return result
+}
+
+internal fun GppData.serializeGppData(): WritableMap {
+    val sectionsMap = Arguments.createMap()
+    sections.forEach { (sectionName, fields) ->
+        val fieldsMap = fields.toWritableMap()
+        sectionsMap.putMap(sectionName, fieldsMap)
+    }
+
+    val result = Arguments.createMap()
+    result.putString("gppString", gppString)
+    result.putArray("applicableSections", applicableSections.serialize())
+    result.putMap("sections", sectionsMap)
+    return result
+}
+
+internal fun GppSectionChangePayload.serializeGppPayload(): WritableMap {
+    val result = Arguments.createMap()
+    result.putString("data", data)
+    return result
+}

package/android/src/main/java/com/usercentrics/reactnative/extensions/UserDecisionExtensions.kt

@@ -14,9 +14,10 @@ internal fun ReadableArray.deserializeUserDecision(): List<UserDecision> {
     for (i in 0 until size()) {
         val map = getMap(i)
         map?.let {
+            val serviceId = it.getString("serviceId") ?: return@let
             decisionList.add(
                 UserDecision(
-                    it.getString("serviceId")!!,
+                    serviceId,
                     it.getBoolean("consent")
                 )
             )

package/android/src/main/java/com/usercentrics/reactnative/extensions/UsercentricsCMPDataExtensions.kt

@@ -63,7 +63,9 @@ private fun UsercentricsSettings.serialize(): WritableMap {
         "framework" to framework?.ordinal,
         "publishedApps" to publishedApps?.map { it.serialize() },
         "renewConsentsTimestamp" to renewConsentsTimestamp,
-        "consentWebhook" to consentWebhook
+        "consentWebhook" to consentWebhook,
+        "gppSignalingEnabled" to getGppSignalingEnabledCompat(),
+        "gpcSignalHonoured" to getGpcSignalHonouredCompat(),
     ).toWritableMap()
 }
 
@@ -178,6 +180,8 @@ private fun CCPASettings.serialize(): WritableMap {
         "secondLayerDescription" to secondLayerDescription,
         "secondLayerHideLanguageSwitch" to secondLayerHideLanguageSwitch,
         "btnMoreInfo" to btnMoreInfo,
+        "mspaCoveredTransaction" to getMspaCoveredTransactionCompat(),
+        "mspaMode" to getMspaModeCompat(),
     ).toWritableMap()
 }
 
@@ -219,7 +223,7 @@ private fun TCF2Settings.serialize(): WritableMap {
         "disabledSpecialFeatures" to disabledSpecialFeatures,
         "firstLayerShowDescriptions" to firstLayerShowDescriptions,
         "hideNonIabOnFirstLayer" to hideNonIabOnFirstLayer,
-        "resurfacePeriodEnded" to resurfacePeriodEnded,
+        "resurfacePeriod" to getResurfacePeriodCompat(),
         "resurfacePurposeChanged" to resurfacePurposeChanged,
         "resurfaceVendorAdded" to resurfaceVendorAdded,
         "firstLayerDescription" to firstLayerDescription,
@@ -245,6 +249,44 @@ private fun TCF2Settings.serialize(): WritableMap {
     ).toWritableMap()
 }
 
+private fun TCF2Settings.getResurfacePeriodCompat(): Int {
+    val intValue = runCatching {
+        javaClass.getMethod("getResurfacePeriod").invoke(this) as? Int
+    }.getOrNull()
+    if (intValue != null) return intValue
+    val boolValue = runCatching {
+        javaClass.getMethod("getResurfacePeriodEnded").invoke(this)
+    }.getOrNull() ?: runCatching {
+        javaClass.getMethod("isResurfacePeriodEnded").invoke(this)
+    }.getOrNull()
+    return if (boolValue as? Boolean == true) 1 else 0
+}
+
+private fun UsercentricsSettings.getGppSignalingEnabledCompat(): Boolean {
+    return runCatching {
+        javaClass.getMethod("getGppSignalingEnabled").invoke(this) as? Boolean
+    }.getOrNull() ?: false
+}
+
+private fun UsercentricsSettings.getGpcSignalHonouredCompat(): Boolean {
+    return runCatching {
+        javaClass.getMethod("getGpcSignalHonoured").invoke(this) as? Boolean
+    }.getOrNull() ?: false
+}
+
+private fun CCPASettings.getMspaCoveredTransactionCompat(): Boolean {
+    return runCatching {
+        javaClass.getMethod("getMspaCoveredTransaction").invoke(this) as? Boolean
+    }.getOrNull() ?: false
+}
+
+private fun CCPASettings.getMspaModeCompat(): Int? {
+    return runCatching {
+        val mode = javaClass.getMethod("getMspaMode").invoke(this) ?: return@runCatching null
+        mode.javaClass.getMethod("ordinal").invoke(mode) as? Int
+    }.getOrNull()
+}
+
 private fun UsercentricsCustomization.serialize(): WritableMap {
     return mapOf(
         "color" to color?.serialize(),

package/android/src/test/java/com/usercentrics/reactnative/extensions/NullabilityTest.kt

@@ -0,0 +1,189 @@
+package com.usercentrics.reactnative.extensions
+
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import org.junit.Test
+import org.junit.Assert.*
+
+/**
+ * Tests for nullability handling in React Native 0.77+
+ * These tests ensure that null values from ReadableArray/ReadableMap are handled safely
+ */
+class NullabilityTest {
+
+    @Test
+    fun `deserializeUserDecision handles null map entries`() {
+        // Given: array with null entries
+        val array = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("serviceId", "service1", "consent", true))
+            pushNull() // Simulate null entry
+            pushMap(JavaOnlyMap.of("serviceId", "service2", "consent", false))
+        }
+
+        // When: deserializing
+        val result = array.deserializeUserDecision()
+
+        // Then: null entries are skipped, valid entries are processed
+        assertEquals(2, result.size)
+        assertEquals("service1", result[0].serviceId)
+        assertEquals(true, result[0].consent)
+        assertEquals("service2", result[1].serviceId)
+        assertEquals(false, result[1].consent)
+    }
+
+    @Test
+    fun `deserializePurposeLIDecisionsMap handles null map entries`() {
+        // Given: array with null entries
+        val array = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("id", 1, "legitimateInterestConsent", true))
+            pushNull() // Simulate null entry
+            pushMap(JavaOnlyMap.of("id", 2, "legitimateInterestConsent", false))
+        }
+
+        // When: deserializing
+        val result = array.deserializePurposeLIDecisionsMap()
+
+        // Then: null entries are skipped
+        assertNotNull(result)
+        assertEquals(2, result?.size)
+        assertEquals(true, result?.get(1))
+        assertEquals(false, result?.get(2))
+    }
+
+    @Test
+    fun `deserializePurposeLIDecisionsMap returns null for empty array`() {
+        // Given: empty array
+        val array = JavaOnlyArray()
+
+        // When: deserializing
+        val result = array.deserializePurposeLIDecisionsMap()
+
+        // Then: returns null
+        assertNull(result)
+    }
+
+    @Test
+    fun `deserializeTCFUserDecisions handles null purpose entries`() {
+        // Given: TCF decisions with null entries in purposes array
+        val purposesArray = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("id", 1, "consent", true))
+            pushNull() // Simulate null entry
+            pushMap(JavaOnlyMap.of("id", 2, "consent", false))
+        }
+
+        val tcfMap = JavaOnlyMap.of("purposes", purposesArray)
+
+        // When: deserializing
+        val result = tcfMap.deserializeTCFUserDecisions()
+
+        // Then: null entries are skipped
+        assertNotNull(result.purposes)
+        assertEquals(2, result.purposes?.size)
+    }
+
+    @Test
+    fun `deserializeTCFUserDecisions handles null special features entries`() {
+        // Given: TCF decisions with null entries in specialFeatures array
+        val specialFeaturesArray = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("id", 1, "consent", true))
+            pushNull()
+            pushMap(JavaOnlyMap.of("id", 2, "consent", false))
+        }
+
+        val tcfMap = JavaOnlyMap.of("specialFeatures", specialFeaturesArray)
+
+        // When: deserializing
+        val result = tcfMap.deserializeTCFUserDecisions()
+
+        // Then: null entries are skipped
+        assertNotNull(result.specialFeatures)
+        assertEquals(2, result.specialFeatures?.size)
+    }
+
+    @Test
+    fun `deserializeTCFUserDecisions handles null vendors entries`() {
+        // Given: TCF decisions with null entries in vendors array
+        val vendorsArray = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("id", 1, "consent", true))
+            pushNull()
+            pushMap(JavaOnlyMap.of("id", 2, "consent", false))
+        }
+
+        val tcfMap = JavaOnlyMap.of("vendors", vendorsArray)
+
+        // When: deserializing
+        val result = tcfMap.deserializeTCFUserDecisions()
+
+        // Then: null entries are skipped
+        assertNotNull(result.vendors)
+        assertEquals(2, result.vendors?.size)
+    }
+
+    @Test
+    fun `deserializeTCFUserDecisions handles null adTechProviders entries`() {
+        // Given: TCF decisions with null entries in adTechProviders array
+        val adTechArray = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("id", 1, "consent", true))
+            pushNull()
+            pushMap(JavaOnlyMap.of("id", 2, "consent", false))
+        }
+
+        val tcfMap = JavaOnlyMap.of("adTechProviders", adTechArray)
+
+        // When: deserializing
+        val result = tcfMap.deserializeTCFUserDecisions()
+
+        // Then: null entries are skipped
+        assertNotNull(result.adTechProviders)
+        assertEquals(2, result.adTechProviders.size)
+    }
+
+    @Test
+    fun `deserializeTCFUserDecisions handles missing arrays gracefully`() {
+        // Given: empty TCF map
+        val tcfMap = JavaOnlyMap()
+
+        // When: deserializing
+        val result = tcfMap.deserializeTCFUserDecisions()
+
+        // Then: all fields are null or empty
+        assertNull(result.purposes)
+        assertNull(result.specialFeatures)
+        assertNull(result.vendors)
+        assertEquals(0, result.adTechProviders.size)
+    }
+
+    @Test
+    fun `deserializeUserDecision handles array with all null entries`() {
+        // Given: array with only null entries
+        val array = JavaOnlyArray().apply {
+            pushNull()
+            pushNull()
+            pushNull()
+        }
+
+        // When: deserializing
+        val result = array.deserializeUserDecision()
+
+        // Then: returns empty list
+        assertEquals(0, result.size)
+    }
+
+    @Test
+    fun `deserializeUserDecision skips entries with null serviceId`() {
+        // Given: array with entry missing serviceId
+        val array = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap.of("serviceId", "service1", "consent", true))
+            pushMap(JavaOnlyMap.of("consent", false)) // Missing serviceId
+            pushMap(JavaOnlyMap.of("serviceId", "service2", "consent", true))
+        }
+
+        // When: deserializing
+        val result = array.deserializeUserDecision()
+
+        // Then: entry without serviceId is skipped
+        assertEquals(2, result.size)
+        assertEquals("service1", result[0].serviceId)
+        assertEquals("service2", result[1].serviceId)
+    }
+}

package/ios/Extensions/GppData+Dict.swift

@@ -0,0 +1,45 @@
+import Foundation
+import Usercentrics
+
+private func bridgeValue(_ value: Any) -> Any {
+    switch value {
+    case let dictionary as [String: Any]:
+        return bridgeDictionary(dictionary)
+    case let array as [Any]:
+        return array.map { item -> Any in
+            if let nested = item as? [String: Any] {
+                return bridgeDictionary(nested)
+            }
+            if let nestedArray = item as? [Any] {
+                return nestedArray.map { nestedItem -> Any in
+                    if let nestedDict = nestedItem as? [String: Any] {
+                        return bridgeDictionary(nestedDict)
+                    }
+                    return nestedItem
+                } as NSArray
+            }
+            return item
+        } as NSArray
+    default:
+        return value
+    }
+}
+
+private func bridgeDictionary(_ dictionary: [String: Any]) -> NSDictionary {
+    let mapped = dictionary.mapValues { bridgeValue($0) }
+    return mapped as NSDictionary
+}
+
+extension GppData {
+    func toDictionary() -> NSDictionary {
+        let bridgedSections = sections.reduce(into: [String: Any]()) { partialResult, section in
+            partialResult[section.key] = bridgeDictionary(section.value)
+        }
+
+        return [
+            "gppString": self.gppString,
+            "applicableSections": self.applicableSections as NSArray,
+            "sections": bridgedSections as NSDictionary,
+        ]
+    }
+}

package/ios/Extensions/GppSectionChangePayload+Dict.swift

@@ -0,0 +1,10 @@
+import Foundation
+import Usercentrics
+
+extension GppSectionChangePayload {
+    func toDictionary() -> NSDictionary {
+        return [
+            "data": self.data
+        ]
+    }
+}