securiti-consent-sdk 1.132.0

package/ios/Bridge.h

@@ -0,0 +1,10 @@
+//
+//  Bridge.h
+//  NitroSecuritiConsentSdk
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once
+
+// No imports needed for simple logging test

package/ios/HybridConsentSDK.swift

@@ -0,0 +1,640 @@
+import ConsentUI
+import os
+import NitroModules
+
+/**
+ * Implementation of the HybridConsentSDK iOS for React Native.
+ */
+public class HybridConsentSDK : HybridConsentSDKSpec {
+
+    private var sdkOptions: CmpSDKOptions?
+    
+    public override init() {
+        print("*** HybridConsentSDK - initializer called ***")
+        os_log("*** HybridConsentSDK - initializer called in os_log ***")
+        super.init()
+    }
+    
+    public func initialize(options: CmpSDKOptions) throws {
+        print("*** initialize method called with options: \(options) ***")
+        os_log("*** initialize method called in os_log ***")
+        
+        // Store options for later reference
+        self.sdkOptions = options
+        
+        // Determine log level based on options
+        let logLevel: ConsentUI.LogLevel
+        switch options.loggerLevel.lowercased() {
+        case "debug":
+            logLevel = .debug
+        case "info":
+            logLevel = .info
+        case "warning", "warn":
+            logLevel = .warning
+        case "error":
+            logLevel = .error
+        default:
+            logLevel = .debug
+        }
+        
+        // Set up SDK with options
+        ConsentSDK.shared.setupSDK(options: ConsentUI.ConsentSDKOptions(
+            appUrl: options.appURL,
+            cdnUrl: options.cdnURL,
+            tenantId: options.tenantID,
+            appId: options.appID,
+            testingMode: options.testingMode,
+            logLevel: logLevel,
+            consentsCheckInterval: Int(options.consentsCheckInterval),
+            languageCode: options.languageCode,
+            locationCode: options.locationCode
+        ))
+        
+        // Register for ready status
+        ConsentSDK.shared.isReady { state in
+            print("*** SDK Status is \(state) ***")
+            os_log("*** SDK Status is %@ ***", String(describing: state))
+        }
+    }
+
+    public func isSdkReady() throws -> Bool {
+        print("*** isSdkReady method called ***")
+        os_log("*** isSdkReady method called in os_log ***")
+        return ConsentSDK.shared.getStatus() == .available
+    }
+    
+    public func presentPreferenceCenter() throws {
+        print("*** presentPreferenceCenter method called ***")
+        os_log("*** presentPreferenceCenter method called in os_log ***")
+        
+        // Check if SDK is ready before presenting
+        if ConsentSDK.shared.getStatus() != .available {
+            let error = NSError(domain: "HybridConsentSDK", code: 1, 
+                               userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"])
+            print("*** Error: SDK is not ready ***")
+            os_log("*** Error: SDK is not ready ***")
+            throw error
+        }
+        
+        ConsentSDK.shared.presentPreferenceCenter()
+    }
+
+    public func presentConsentBanner() throws {
+        print("*** presentConsentBanner method called ***")
+        os_log("*** presentConsentBanner method called in os_log ***")
+        
+        // Check if SDK is ready before presenting
+        if ConsentSDK.shared.getStatus() != .available {
+            let error = NSError(domain: "HybridConsentSDK", code: 1, 
+                               userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"])
+            print("*** Error: SDK is not ready ***")
+            os_log("*** Error: SDK is not ready ***")
+            throw error
+        }
+        
+        ConsentSDK.shared.presentConsentBanner()
+    }
+    
+    public func isReady(callback: @escaping (Bool) -> Void) throws {
+        print("*** isReady method called ***")
+        os_log("*** isReady method called in os_log ***")
+        
+        ConsentSDK.shared.isReady { state in
+            callback(state == .available)
+        }
+    }
+    
+    public func resetConsents() throws {
+        print("*** resetConsents method called ***")
+        os_log("*** resetConsents method called in os_log ***")
+        
+        // Check if SDK is ready
+        if ConsentSDK.shared.getStatus() != .available {
+            let error = NSError(domain: "HybridConsentSDK", code: 1, 
+                               userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"])
+            print("*** Error: SDK is not ready ***")
+            os_log("*** Error: SDK is not ready ***")
+            throw error
+        }
+        
+        ConsentSDK.shared.removeConsents()
+    }
+    
+    // MARK: - Consent Management Methods
+    
+    public func getPurposes() throws -> Promise<[Purpose]> {
+        print("*** getPurposes method called ***")
+        os_log("*** getPurposes method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return []
+            }
+            
+            // Retrieve purposes from the SDK
+            let nativePurposes = await ConsentSDK.shared.getPurposeConsents()
+            
+            // Convert native purposes to our Purpose model
+            var purposes: [Purpose] = []
+            
+            for nativePurpose in nativePurposes {
+                var purpose = Purpose()
+                
+                // Map properties from native Purpose to our Purpose model
+                purpose.purposeId = Double(nativePurpose.purposeId ?? -1)
+                purpose.purposeName = self.getString(nativePurpose.purposeName)
+                purpose.purposeDescription = self.getString(nativePurpose.purposeDescription)
+                purpose.disableOptOut = nativePurpose.disableOptOut
+                purpose.optOutText = self.getString(nativePurpose.optOutText)
+                purpose.hideDetails = nativePurpose.hideDetails
+                purpose.isATTMapped = nativePurpose.isATTMapped
+                purpose.attDescription = self.getString(nativePurpose.attDescription)
+                
+                // Convert consent status
+                switch nativePurpose.consentStatus {
+                case .granted:
+                    purpose.consentStatus = "granted"
+                case .declined:
+                    purpose.consentStatus = "declined"
+                case .notDetermined:
+                    purpose.consentStatus = "not_determined"
+                case .withDrawn:
+                    purpose.consentStatus = "withdrawn"
+                @unknown default:
+                    purpose.consentStatus = "not_determined"
+                }
+                
+                // Convert SDK array
+                if let nativeSDKs = nativePurpose.sdks {
+                    var sdks: [SDK] = []
+                    
+                    for nativeSDK in nativeSDKs {
+                        var sdk = SDK()
+                        
+                        // Map SDK properties
+                        sdk.sdkId = Double(nativeSDK.sdkId ?? -1)
+                        sdk.namespaceId = nativeSDK.namespaceId
+                        sdk.sdkName = self.getString(nativeSDK.sdkName)
+                        sdk.sdkDescription = self.getString(nativeSDK.sdkDescription)
+                        sdk.vendor = nativeSDK.vendor
+                        sdk.logoBase64 = nativeSDK.logoBase64
+                        sdk.website = nativeSDK.website
+                        sdk.matchedBy = nativeSDK.matchedBy
+                        sdk.collectingData = nativeSDK.collectingData
+                        
+                        sdks.append(sdk)
+                    }
+                    
+                    purpose.sdks = sdks
+                }
+                
+                purposes.append(purpose)
+            }
+            
+            return purposes
+        }
+    }
+    
+    public func getConsentByPurposeId(purposeId: Double) throws -> NitroModules.Promise<String> {
+        print("*** getConsentByPurposeId method called with purposeId: \(purposeId) ***")
+        os_log("*** getConsentByPurposeId method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return "unknown"
+            }
+            
+            // Convert from SecuritiMobileCmp ConsentStatus to string
+            let consentStatus = ConsentSDK.shared.getConsent(purposeId: Int(purposeId))
+            return switch consentStatus {
+            case .granted:
+                "granted"
+            case .declined:
+                "declined"
+            case .notDetermined:
+                "not_determined"
+            case .withDrawn:
+                "withdrawn"
+            @unknown default:
+                "not_determined"
+            }
+        }
+    }
+    
+    public func getPermissions() throws -> Promise<[AppPermission]> {
+        print("*** getPermissions method called ***")
+        os_log("*** getPermissions method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return []
+            }
+            
+            // Retrieve permissions from the SDK
+            let permissions = await ConsentSDK.shared.getPermissionConsents()
+            
+            // Convert native permissions to our AppPermission model
+            var appPermissions: [AppPermission] = []
+            
+            for permission in permissions {
+                var appPermission = AppPermission()
+                
+                // Map properties from native Permission to our AppPermission
+                appPermission.id = Double(permission.id ?? -1)
+                appPermission.name = permission.name
+                appPermission.permissionId = permission.permissionId?.rawValue
+                appPermission.description = self.getString(permission.description)
+                appPermission.group = permission.group
+                appPermission.groupId = Double(permission.groupId ?? -1)
+                appPermission.nameMap = self.getString(permission.nameMap)
+                appPermission.isSettingsPromptEnabled = permission.isSettingsPromptEnabled
+                
+                // Convert consent status
+                switch permission.consentStatus {
+                case .granted:
+                    appPermission.consentStatus = "granted"
+                case .declined:
+                    appPermission.consentStatus = "declined"
+                case .notDetermined:
+                    appPermission.consentStatus = "not_determined"
+                case .withDrawn:
+                    appPermission.consentStatus = "withdrawn"
+                @unknown default:
+                    appPermission.consentStatus = "not_determined"
+                }
+                
+                appPermissions.append(appPermission)
+            }
+            
+            return appPermissions
+        }
+    }
+    
+    public func getSdksInPurpose(purposeId: Double) throws -> NitroModules.Promise<[SDK]> {
+        print("*** getSdksInPurpose method called with purposeId: \(purposeId) ***")
+        os_log("*** getSdksInPurpose method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return []
+            }
+            
+            // Retrieve SDKs from the purpose
+            let nativeSDKs = await ConsentSDK.shared.getPurposeConsents().first(where: { $0.purposeId == Int(purposeId) })?.sdks ?? []
+            
+            // Convert native SDKs to our SDK model
+            var sdks: [SDK] = []
+            
+            for nativeSDK in nativeSDKs {
+                var sdk = SDK()
+                
+                // Map SDK properties
+                sdk.sdkId = Double(nativeSDK.sdkId ?? -1)
+                sdk.namespaceId = nativeSDK.namespaceId
+                sdk.sdkName = self.getString(nativeSDK.sdkName)
+                sdk.sdkDescription = self.getString(nativeSDK.sdkDescription)
+                sdk.vendor = nativeSDK.vendor
+                sdk.logoBase64 = nativeSDK.logoBase64
+                sdk.website = nativeSDK.website
+                sdk.matchedBy = nativeSDK.matchedBy
+                sdk.collectingData = nativeSDK.collectingData
+                
+                sdks.append(sdk)
+            }
+            
+            return sdks
+        }
+    }
+    
+    public func getBannerConfig() throws -> Promise<BannerConfig?> {
+        print("*** getBannerConfig method called ***")
+        os_log("*** getBannerConfig method called in os_log ***")
+        
+        return Promise.async {
+            
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return BannerConfig()
+            }
+            
+            // Otherwise try to get config from the SDK
+            if let nativeBannerConfig = await ConsentSDK.shared.getBannerConfig() {
+                var bannerConfig = BannerConfig()
+                
+                // Map properties from native BannerConfig to our model
+                bannerConfig.hideCloseButton = nativeBannerConfig.hideCloseButton
+                bannerConfig.hideAcceptButton = nativeBannerConfig.hideAcceptButton
+                bannerConfig.embedDSRPortalLink = nativeBannerConfig.embedDSRPortalLink
+                bannerConfig.recordConsentUponAppStart = nativeBannerConfig.recordConsentUponAppStart
+                bannerConfig.hideToggleForEssentialCategories = nativeBannerConfig.hideToggleForEssentialCategories
+                bannerConfig.name = nativeBannerConfig.name
+                bannerConfig.dsrPortalLink = nativeBannerConfig.dsrPortalLink
+                bannerConfig.complianceType = nativeBannerConfig.complianceType?.rawValue ?? "notice-only"
+                bannerConfig.bannerReappearanceTime = nativeBannerConfig.bannerReappearanceTime
+                bannerConfig.privacyNoticeLink = nativeBannerConfig.privacyNoticeLink
+                bannerConfig.accept = self.getString(nativeBannerConfig.accept)
+                bannerConfig.reject = self.getString(nativeBannerConfig.reject)
+                bannerConfig.bannerText = self.getString(nativeBannerConfig.bannerText)
+                bannerConfig.bannerHeading = self.getString(nativeBannerConfig.bannerHeading)
+                bannerConfig.sdkTabHeading = self.getString(nativeBannerConfig.sdkTabHeading)
+                bannerConfig.privacyNoticeText = self.getString(nativeBannerConfig.privacyNoticeText)
+                bannerConfig.preferenceCenterLink = self.getString(nativeBannerConfig.preferenceCenterLink)
+                bannerConfig.permissionsTabHeading = self.getString(nativeBannerConfig.permissionsTabHeading)
+                bannerConfig.permissionsTabGuidance = self.getString(nativeBannerConfig.permissionsTabGuidance)
+                bannerConfig.preferenceCenterHeading = self.getString(nativeBannerConfig.preferenceCenterHeading)
+                bannerConfig.preferenceCenterGuidance = self.getString(nativeBannerConfig.preferenceCenterGuidance)
+                bannerConfig.permissionsTabDescription = self.getString(nativeBannerConfig.permissionsTabDescription)
+                bannerConfig.preferenceCenterDescription = self.getString(nativeBannerConfig.preferenceCenterDescription)
+                bannerConfig.showPoweredBySecuritiLogo = nativeBannerConfig.showPoweredBySecuritiLogo
+                bannerConfig.showDescriptionTextWithPrefCenterToggle = nativeBannerConfig.showDescriptionTextWithPrefCenterToggle
+                bannerConfig.paletteTheme = Double(nativeBannerConfig.paletteTheme ?? 1)
+                bannerConfig.bannerPosition = nativeBannerConfig.bannerPosition?.rawValue
+                bannerConfig.buttonShape = nativeBannerConfig.buttonShape?.rawValue
+                bannerConfig.companyLogo = nativeBannerConfig.companyLogo
+                // Convert nested dictionary structure to a flattened Map
+                if let nestedTranslations = nativeBannerConfig.translations {
+                    var flattenedTranslations: [String: String] = [:]
+                    
+                    // For each parent key (e.g., "Go back")
+                    for (parentKey, innerDict) in nestedTranslations {
+                        // Get the inner dictionary and extract its values directly
+                        flattenedTranslations[parentKey] = self.getString(innerDict)
+                    }
+                    
+                    bannerConfig.translations = flattenedTranslations
+                }
+                
+                // Map custom colors if available
+                if let nativeColors = nativeBannerConfig.customPaletteTheme {
+                    var customColors = CustomColors()
+                    customColors.buttonBackground = nativeColors.buttonBackground
+                    customColors.buttonText = nativeColors.buttonText
+                    customColors.buttonBorder = nativeColors.buttonBorder
+                    customColors.bannerBackground = nativeColors.bannerBackground
+                    customColors.bannerText = nativeColors.bannerText
+                    customColors.bannerLinks = nativeColors.bannerLinks
+                    customColors.preferenceCenterFooterBackground = nativeColors.preferenceCenterFooterBackground
+                    customColors.preferenceCenterFooterSelector = nativeColors.preferenceCenterFooterSelector
+                    
+                    bannerConfig.customPaletteTheme = customColors
+                }
+                
+                return bannerConfig
+            } else {
+                return nil
+            }
+        }
+    }
+    
+    public func options() throws -> CmpSDKOptions? {
+        print("*** options method called ***")
+        os_log("*** options method called in os_log ***")
+        
+        // Just return the stored options from the initialize call
+        return self.sdkOptions
+    }
+    
+    public func getSettingsPrompt() throws -> Promise<SettingsPrompt?> {
+        print("*** getSettingsPrompt method called ***")
+        os_log("*** getSettingsPrompt method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return SettingsPrompt()
+            }
+            
+            // Get settings prompt configuration
+            if let nativeSettingsPrompt = await ConsentSDK.shared.getSettingsPrompt() {
+                var settingsPrompt = SettingsPrompt()
+                
+                var settingPromptPermissions: [String] = []
+                
+                nativeSettingsPrompt.permissions?.keys.forEach {
+                    if(nativeSettingsPrompt.permissions?[$0] == true) {
+                        settingPromptPermissions.append($0)
+                    }
+                }
+                
+                // Map properties from native SettingsPrompt to our model
+                settingsPrompt.promptHeading = self.getString(nativeSettingsPrompt.promptHeading)
+                settingsPrompt.promptMessage = self.getString(nativeSettingsPrompt.promptMessage)
+                settingsPrompt.settingsButtonText = self.getString(nativeSettingsPrompt.settingsButtonText)
+                settingsPrompt.notNowButtonText = self.getString(nativeSettingsPrompt.notNowButtonText)
+                settingsPrompt.permissions = settingPromptPermissions
+                
+                return settingsPrompt
+            } else {
+                return SettingsPrompt()
+            }
+        }
+    }
+    
+    public func uploadConsents(request: PostConsentsRequest) throws -> Promise<Bool> {
+        print("*** uploadConsents method called ***")
+        os_log("*** uploadConsents method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return false
+            }
+            
+            // Create native purpose consents array
+            var nativePurposeConsents: [ConsentUI.PurposeConsent] = []
+            for purposeConsent in request.purposeConsents {
+                let consentStatus = self.convertStringToConsentStatus(purposeConsent.consentStatus)
+                let nativePurposeConsent = ConsentUI.PurposeConsent(
+                    purposeID: Int(purposeConsent.purposeID),
+                    consentStatus: consentStatus,
+                    timestamp: Int64(purposeConsent.timestamp),
+                    isEssential: purposeConsent.isEssential
+                )
+                nativePurposeConsents.append(nativePurposeConsent)
+            }
+            
+            // Create native permission consents array
+            var nativePermissionConsents: [ConsentUI.PermissionConsent] = []
+            for permissionConsent in request.permissions {
+                let consentStatus = self.convertStringToConsentStatus(permissionConsent.consentStatus)
+                let nativePermissionConsent = ConsentUI.PermissionConsent(
+                    permission: (ConsentUI.PrivaciKey(rawValue: permissionConsent.permission) ?? .none)!,
+                    consentStatus: consentStatus,
+                    timestamp: Int64(permissionConsent.timestamp)
+                )
+                nativePermissionConsents.append(nativePermissionConsent)
+            }
+            
+            // Create the request object for native SDK
+            let nativeRequest = ConsentUI.PostConsentsRequest(
+                uuid: request.uuid,
+                appUUID: request.appUUID,
+                device: request.device,
+                implicitConsent: request.implicitConsent,
+                version: Int(request.version),
+                purposeConsents: nativePurposeConsents,
+                permissions: nativePermissionConsents,
+                testingMode: request.isTestMode,
+                adId: request.adId,
+                bannerInfo: request.bannerInfo
+            )
+            
+            // Upload consents
+            await ConsentSDK.shared.uploadConsents(url: self.sdkOptions?.appURL ?? "", request: nativeRequest)
+            return true
+        }
+    }
+    
+    public func getConsentByPermissionId(permissionId: String) throws -> Promise<String> {
+        print("*** getConsentByPermissionId method called with permissionId: \(permissionId) ***")
+        os_log("*** getConsentByPermissionId method called in os_log ***")
+        
+        return Promise.async {
+            if ConsentSDK.shared.getStatus() != .available {
+                debugPrint(NSError(domain: "HybridConsentSDK", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"]))
+                return "unknown"
+            }
+            
+            let nativeId : PrivaciKey = PrivaciKey(rawValue: permissionId) ?? .custom("unknown")
+            
+            // Convert from SecuritiMobileCmp ConsentStatus to string
+            let consentStatus = ConsentSDK.shared.getConsent(privaciKey: nativeId)
+            return switch consentStatus {
+            case .granted:
+                "granted"
+            case .declined:
+                "declined"
+            case .notDetermined:
+                "not_determined"
+            case .withDrawn:
+                "withdrawn"
+            @unknown default:
+                "not_determined"
+            }
+        }
+    }
+    
+    public func setPurposeConsent(purpose: Purpose, consent: String) throws -> Bool {
+        print("*** setPurposeConsent method called with consent: \(consent) ***")
+        os_log("*** setPurposeConsent method called in os_log ***")
+        
+        if ConsentSDK.shared.getStatus() != .available {
+            let error = NSError(domain: "HybridConsentSDK", code: 1, 
+                               userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"])
+            print("*** Error: SDK is not ready ***")
+            os_log("*** Error: SDK is not ready ***")
+            throw error
+        }
+        
+        // Convert string consent status to native ConsentStatus
+        let consentStatus = self.convertStringToConsentStatus(consent)
+        
+        // Convert to native purpose
+        let nativePurpose = self.convertToPurpose(purpose)
+        
+        // Set purpose consent
+        return ConsentSDK.shared.setConsent(purpose: nativePurpose, consent: consentStatus)
+    }
+    
+    public func setPermissionConsent(permission: AppPermission, consent: String) throws -> Bool {
+        print("*** setPermissionConsent method called with consent: \(consent) ***")
+        os_log("*** setPermissionConsent method called in os_log ***")
+        
+        if ConsentSDK.shared.getStatus() != .available {
+            let error = NSError(domain: "HybridConsentSDK", code: 1, 
+                               userInfo: [NSLocalizedDescriptionKey: "SDK is not ready"])
+            print("*** Error: SDK is not ready ***")
+            os_log("*** Error: SDK is not ready ***")
+            throw error
+        }
+        
+        // Convert string consent status to native ConsentStatus
+        let consentStatus = self.convertStringToConsentStatus(consent)
+        
+        // Convert to native permission
+        let nativePermission = self.convertToAppPermission(permission)
+        
+        // Set permission consent
+        return ConsentSDK.shared.setConsent(permission: nativePermission, consent: consentStatus)
+    }
+    
+    // MARK: - Helper Methods
+    
+    private func convertStringToConsentStatus(_ status: String) -> ConsentUI.ConsentStatus {
+        switch status.lowercased() {
+        case "granted":
+            return .granted
+        case "declined":
+            return .declined
+        case "not_determined":
+            return .notDetermined
+        case "withdrawn":
+            return .withDrawn
+        default:
+            return .notDetermined
+        }
+    }
+    
+    private func convertToPurpose(_ purpose: Purpose) -> ConsentUI.Purpose {
+        // Create JSON representation of purpose
+        let encoder = JSONEncoder()
+        encoder.keyEncodingStrategy = .convertToSnakeCase
+        
+        // Purpose data to encode
+        let purposeData: [String: Any] = [
+            "purpose_id": purpose.purposeId as Any,
+            "purpose_name": purpose.purposeName as Any,
+            "purpose_description": purpose.purposeDescription as Any,
+            "sdks": [], // Empty array as we handle SDKs separately
+            "disable_opt_out": purpose.disableOptOut as Any,
+            "opt_out_text": purpose.optOutText as Any,
+            "hide_details": purpose.hideDetails as Any
+        ]
+        
+        // Convert to JSON data
+        let jsonData = try! JSONSerialization.data(withJSONObject: purposeData)
+        
+        // Decode into ConsentUI.Purpose
+        var nativePurpose = try! JSONDecoder().decode(ConsentUI.Purpose.self, from: jsonData)
+        
+        return nativePurpose
+    }
+    
+    private func convertToAppPermission(_ permission: AppPermission) -> ConsentUI.AppPermission {
+        // Create JSON representation of permission
+        let permissionData: [String: Any] = [
+            "id": permission.id as Any,
+            "name": permission.name as Any,
+            "permission_id": permission.permissionId as Any,
+            "description": permission.description as Any,
+            "group": permission.group as Any,
+            "group_id": permission.groupId as Any,
+            "name_map": permission.nameMap as Any,
+            "is_settings_prompt_enabled": permission.isSettingsPromptEnabled as Any
+        ]
+        
+        // Convert to JSON data
+        let jsonData = try! JSONSerialization.data(withJSONObject: permissionData)
+        
+        // Decode into ConsentUI.AppPermission
+        let nativePermission = try! JSONDecoder().decode(ConsentUI.AppPermission.self, from: jsonData)
+        
+        return nativePermission
+    }
+    
+    private func getString(_ map: [String : String]?) -> String {
+        return map?["_"] ?? ""
+    }
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+* linguist-generated