@infilectorg/infiviz-shots-react-sdk 1.0.47 → 1.0.49

package/ios/InfivizShotsReactSdk.swift

@@ -12,313 +12,339 @@ import React
 
 @objc(InfivizShotsReactSdk)
 class InfivizShotsReactSdk:  RCTEventEmitter {
- @objc
-     override static func moduleName() -> String! {
-         return "InfivizShotsReactSdk"
-     }
-
-     @objc
-     override static func requiresMainQueueSetup() -> Bool {
-         return false
-       }
-
-       // MARK: – RCTEventEmitter Boilerplate
-
-       private var hasListeners = false
-
-       // 3. List of events that JS can subscribe to:
-       override func supportedEvents() -> [String]! {
-         return [
-           "SyncEvent",
-           "ActionsGeneratedEvent",
-           "SessionRealTimeResultEvent"]
-       }
-
-        // 4. Only send events if JS has at least one listener:
-       override func startObserving() {
-         hasListeners = true
-
+    @objc
+    override static func moduleName() -> String! {
+        return "InfivizShotsReactSdk"
+    }
+    
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    // MARK: – RCTEventEmitter Boilerplate
+    
+    private var hasListeners = false
+    
+    // 3. List of events that JS can subscribe to:
+    override func supportedEvents() -> [String]! {
+        return [
+            "SyncEvent",
+            "ActionsGeneratedEvent",
+            "SessionRealTimeResultEvent"]
+    }
+    
+    // 4. Only send events if JS has at least one listener:
+    override func startObserving() {
+        hasListeners = true
+        
         NotificationCenter.default.addObserver(self,
-                     selector: #selector(handleActionsGeneratedEvent(_:)),
-                     name: NSNotification.Name("ActionsGeneratedEvent"),
-                     object: nil)
-         NotificationCenter.default.addObserver(self,
-                     selector: #selector(handleSessionRealTimeResultEvent(_:)),
-                     name: NSNotification.Name("SessionRealTimeResultEvent"),
-                     object: nil)
-
-       }
-
-       override func stopObserving() {
-         hasListeners = false
-         NotificationCenter.default.removeObserver(self, name: NSNotification.Name("ActionsGeneratedEvent"), object: nil)
-         NotificationCenter.default.removeObserver(self, name: NSNotification.Name("SessionRealTimeResultEvent"), object: nil)
-       }
-
-       // 5. If you have no constants to export, just return empty:
-       override func constantsToExport() -> [AnyHashable: Any]! {
-         return [:]
-       }
-
-
-     var activity: InfivizShotsActivity?
-
-      // MARK: –––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-       // MARK: – Helper Methods (not directly exposed to JS)
-
-
-       // MARK: - Universal Session ID
-       @objc
-       func fetchUniversalSessionId(_ tempID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-         InfivizShotsSDK.shared.fetchUniversalSessionId(temporarySessionID: tempID as String, completion: { sessionID, error in
-           if let id = sessionID {
-             resolve(id)
-           } else {
-             reject("FETCH_SESSION_ID_ERROR", "Session not found", nil)
-           }
-         })
-       }
-
-     @objc
-       func syncSession(_ sessionId: NSString) {
-         // Kick off the upload. No resolver/rejecter—just emit events once it’s done.
-         InfivizShotsSDK.shared.uploadSession(temporarySessionID: sessionId as String) { result in
-           switch result {
-           case .success(let response):
-             if self.hasListeners {
-               let payload: [String: Any] = [
-                 "status": "200",
-                 "universalSessionID": response,
-                 "temporarySessionID": sessionId as String
-               ]
-               self.sendEvent(withName: "SyncEvent", body: payload)
-             }
-           case .failure(let error):
-             if self.hasListeners {
-               let payload: [String: Any] = [
-                 "status": "400",
-                 "message": error.localizedDescription,
-                 "temporarySessionID": sessionId as String
-               ]
-               self.sendEvent(withName: "SyncEvent", body: payload)
-             }
-           }
-         }
-       }
-
-      // MARK: - Sync Multiple Sessions
-      /// Bridge to InfivizShotsSDK.shared.syncSessions(temporarySessionIDs:completionHandler:)
-
-      @objc
-      func uploadSession(temporarySessionIDs: NSArray) {
+                                               selector: #selector(handleActionsGeneratedEvent(_:)),
+                                               name: NSNotification.Name("ActionsGeneratedEvent"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleSessionRealTimeResultEvent(_:)),
+                                               name: NSNotification.Name("SessionRealTimeResultEvent"),
+                                               object: nil)
+        
+    }
+    
+    override func stopObserving() {
+        hasListeners = false
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("ActionsGeneratedEvent"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("SessionRealTimeResultEvent"), object: nil)
+    }
+    
+    // 5. If you have no constants to export, just return empty:
+    override func constantsToExport() -> [AnyHashable: Any]! {
+        return [:]
+    }
+    
+    
+    var activity: InfivizShotsActivity?
+    
+    // MARK: –––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
+    // MARK: – Helper Methods (not directly exposed to JS)
+    
+    
+    // MARK: - Universal Session ID
+    @objc
+    func fetchUniversalSessionId(_ tempID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.fetchUniversalSessionId(temporarySessionID: tempID as String, completion: { sessionID, error in
+            if let id = sessionID {
+                resolve(id)
+            } else {
+                reject("FETCH_SESSION_ID_ERROR", "Session not found", nil)
+            }
+        })
+    }
+    
+    @objc
+    func syncSession(_ sessionId: NSString) {
+        // Kick off the upload. No resolver/rejecter—just emit events once it’s done.
+        InfivizShotsSDK.shared.uploadSession(temporarySessionID: sessionId as String) { result in
+            switch result {
+            case .success(let response):
+                if self.hasListeners {
+                    let payload: [String: Any] = [
+                        "status": "200",
+                        "universalSessionID": response,
+                        "temporarySessionID": sessionId as String
+                    ]
+                    self.sendEvent(withName: "SyncEvent", body: payload)
+                }
+            case .failure(let error):
+                if self.hasListeners {
+                    let payload: [String: Any] = [
+                        "status": "400",
+                        "message": error.localizedDescription,
+                        "temporarySessionID": sessionId as String
+                    ]
+                    self.sendEvent(withName: "SyncEvent", body: payload)
+                }
+            }
+        }
+    }
+    
+    // MARK: - Sync Multiple Sessions
+    /// Bridge to InfivizShotsSDK.shared.syncSessions(temporarySessionIDs:completionHandler:)
+    
+    @objc
+    func uploadSession(temporarySessionIDs: NSArray) {
         var ids: [String] = []
         if let arr = temporarySessionIDs as? [String] {
-          ids = arr
+            ids = arr
         } else if let arr = temporarySessionIDs as? [NSString] {
-          ids = arr.map { $0 as String }
+            ids = arr.map { $0 as String }
         }
-
+        
         guard !ids.isEmpty else { return }
-
+        
         InfivizShotsSDK.shared.syncSessions(temporarySessionIDs: ids) { sessionId, result in
-          switch result {
-          case .success(let message):
-            if self.hasListeners {
-              let payload: [String: Any] = [
-                "status": "200",
-                "universalSessionID": message,
-                "temporarySessionID": sessionId
-              ]
-              self.sendEvent(withName: "SyncEvent", body: payload)
-            }
-          case .failure(let error):
-            if self.hasListeners {
-              let payload: [String: Any] = [
-                "status": "400",
-                "universalSessionID": error,
-                "temporarySessionID": sessionId
-              ]
-              self.sendEvent(withName: "SyncEvent", body: payload)
+            switch result {
+            case .success(let message):
+                if self.hasListeners {
+                    let payload: [String: Any] = [
+                        "status": "200",
+                        "universalSessionID": message,
+                        "temporarySessionID": sessionId
+                    ]
+                    self.sendEvent(withName: "SyncEvent", body: payload)
+                }
+            case .failure(let error):
+                if self.hasListeners {
+                    let payload: [String: Any] = [
+                        "status": "400",
+                        "universalSessionID": error,
+                        "temporarySessionID": sessionId
+                    ]
+                    self.sendEvent(withName: "SyncEvent", body: payload)
+                }
             }
-          }
         }
-      }
-       
-       // MARK: - Get Session Result
-
+    }
+    
+    // MARK: - Get Session Result
+    
     @objc
     func getSessionStatus(
-      _ temporarySessionID: NSString,
-      resolver resolve: @escaping RCTPromiseResolveBlock,
-      rejecter reject: @escaping RCTPromiseRejectBlock
+        _ temporarySessionID: NSString,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
     ) {
-      InfivizShotsSDK.shared.checkState(sessionID: temporarySessionID as String) { result in
-        switch result {
-        case .success(let response):
-            let json = ["sessionId": temporarySessionID,
-                        "status": response]
-
-            if let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []) {
-                let jsonString = String(data: jsonData, encoding: .utf8)
-                resolve(jsonString)
+        InfivizShotsSDK.shared.checkState(sessionID: temporarySessionID as String) { result in
+            switch result {
+            case .success(let response):
+                let json = ["sessionId": temporarySessionID,
+                            "status": response]
+                
+                if let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []) {
+                    let jsonString = String(data: jsonData, encoding: .utf8)
+                    resolve(jsonString)
+                }
+                
+            case .failure(let error):
+                reject(
+                    "RESULT_FAILED",
+                    "Failed to get result for \(temporarySessionID): \(error.localizedDescription)",
+                    nil
+                )
             }
+        }
+    }
+    
+    // MARK: - Sync All Data
+    @objc
+    func syncAllData(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.syncAllData { result in
+            switch result {
+            case .success(let message):
+                resolve(message)
+            case .failure(let error):
+                reject("SYNC_FAILED", "Sync failed: \(error)", nil)
+            }
+        }
+    }
+    
+    // MARK: - Fetch Session Details
+    @objc
+    func fetchSessionDetails(_ temporarySessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.fetchSessionDetails(temporarySessionID: temporarySessionID as String) {  result in
+            switch result {
+            case .success(let value):
+                // Convert any value to a clean dictionary that handles Optionals properly
+                let cleanDict = self.convertToCleanDictionary(value)
+                print(value)
+                // Return the dictionary directly instead of JSON string
+                resolve(cleanDict)
+            case .failure(let error):
+                reject("RESULT_FAILED", "Failed to get result: \(error)", nil)
+            }
+        }
+    }
+    
+    // MARK: - Convert Any to Clean Dictionary
+    private func convertToCleanDictionary(_ value: Any) -> [String: Any] {
+        if let dict = value as? [String: Any] {
+            return cleanDictionary(dict)
+        } else {
+            let mirror = Mirror(reflecting: value)
+            var result: [String: Any] = [:]
+            
+            for child in mirror.children {
+                if let label = child.label {
+                    result[label] = unwrapOptional(child.value)
+                }
+            }
+            return result
+        }
+    }
 
-        case .failure(let error):
-          reject(
-            "RESULT_FAILED",
-            "Failed to get result for \(temporarySessionID): \(error.localizedDescription)",
-            nil
-          )
+    // MARK: - Recursively Clean Dictionary
+    private func cleanDictionary(_ dict: [String: Any]) -> [String: Any] {
+        var cleaned: [String: Any] = [:]
+        for (key, value) in dict {
+            cleaned[key] = unwrapOptional(value)
         }
-      }
+        return cleaned
     }
 
-       // MARK: - Sync All Data
-       @objc
-       func syncAllData(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-         InfivizShotsSDK.shared.syncAllData { result in
-           switch result {
-           case .success(let message):
-             resolve(message)
-           case .failure(let error):
-             reject("SYNC_FAILED", "Sync failed: \(error)", nil)
-           }
-         }
-       }
+    // MARK: - Unwrap Optionals and Flatten SDK Values
+    private func unwrapOptional(_ value: Any) -> Any {
+        // 1. Handle Optional
+        let mirror = Mirror(reflecting: value)
+        if mirror.displayStyle == .optional {
+            if let unwrapped = mirror.children.first?.value {
+                return unwrapOptional(unwrapped)
+            } else {
+                return NSNull()
+            }
+        }
+
+        // 2. Handle JSONValue directly
+        if let jsonValue = value as? InfivizShotSDK.JSONValue {
+            switch jsonValue {
+            case .string(let str): return str
+            case .bool(let b): return b
+            case .int(let i): return i
+            case .double(let d): return d
+            case .dictionary(let dict):
+                var cleaned: [String: Any] = [:]
+                for (k, v) in dict {
+                    cleaned[k] = unwrapOptional(v)
+                }
+                return cleaned
+            case .array(let arr):
+                return arr.map { unwrapOptional($0) }
+            case .null:
+                return NSNull()
+            @unknown default:
+                return NSNull()
+            }
+        }
+
+        // 3. Arrays
+        if let array = value as? [Any] {
+            return array.map { unwrapOptional($0) }
+        }
+
+        // 4. Dictionaries
+        if let dict = value as? [String: Any] {
+            var cleaned: [String: Any] = [:]
+            for (k, v) in dict {
+                cleaned[k] = unwrapOptional(v)
+            }
+            return cleaned
+        }
 
-              // MARK: - Fetch Session Details
-       @objc
-         func fetchSessionDetails(_ temporarySessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-             InfivizShotsSDK.shared.fetchSessionDetails(temporarySessionID: temporarySessionID as String) {  result in
-                 switch result {
-                 case .success(let value):
-                     // Convert any value to a clean dictionary that handles Optionals properly
-                     let cleanDict = self.convertToCleanDictionary(value)
-                     // Return the dictionary directly instead of JSON string
-                     resolve(cleanDict)
-                 case .failure(let error):
-                     reject("RESULT_FAILED", "Failed to get result: \(error)", nil)
-                 }
-             }
-         }
-         
-         // Helper method to convert any value to a clean dictionary that handles Optionals
-         private func convertToCleanDictionary(_ value: Any) -> [String: Any] {
-             if let dict = value as? [String: Any] {
-                 return cleanDictionary(dict)
-             } else {
-                 // Try to convert to dictionary using Mirror reflection
-                 let mirror = Mirror(reflecting: value)
-                 var result: [String: Any] = [:]
-                 
-                 for child in mirror.children {
-                     if let label = child.label {
-                         result[label] = unwrapOptional(child.value)
-                     }
-                 }
-                 return result
-             }
-         }
-         
-         // Recursively clean a dictionary to handle Optionals
-         private func cleanDictionary(_ dict: [String: Any]) -> [String: Any] {
-             var cleaned: [String: Any] = [:]
-             
-             for (key, value) in dict {
-                 cleaned[key] = unwrapOptional(value)
-             }
-             
-             return cleaned
-         }
-         
-         // Unwrap Optional values and clean nested structures
-         private func unwrapOptional(_ value: Any) -> Any {
-             let mirror = Mirror(reflecting: value)
-             
-             // Check if it's an Optional by checking the type name
-             let typeName = String(describing: type(of: value))
-             if typeName.hasPrefix("Optional<") {
-                 if let unwrapped = mirror.children.first?.value {
-                     return unwrapOptional(unwrapped)
-                 } else {
-                     return NSNull() // nil value
-                 }
-             }
-             
-             // Handle arrays
-             if let array = value as? [Any] {
-                 return array.map { unwrapOptional($0) }
-             }
-             
-             // Handle dictionaries
-             if let dict = value as? [String: Any] {
-                 return cleanDictionary(dict)
-             }
-             
-             // Handle Date objects
-             if let date = value as? Date {
-                 let formatter = DateFormatter()
-                 formatter.dateFormat = "yyyy-MM-dd HH:mm:ss Z"
-                 return formatter.string(from: date)
-             }
-             
-             // Handle custom objects (like ImageMetaData) using Mirror reflection
-             // This ensures that objects with optional properties are properly serialized
-             let objectMirror = Mirror(reflecting: value)
-             if !objectMirror.children.isEmpty {
-                 var result: [String: Any] = [:]
-                 for child in objectMirror.children {
-                     if let label = child.label {
-                         result[label] = unwrapOptional(child.value)
-                     }
-                 }
-                 return result
-             }
-             
-             // Return the value as-is if it's a basic type
-             return value
-         }
+        // 5. Enum like SessionSyncStateEnum
+        let typeName = String(describing: type(of: value))
+        if typeName.contains("InfivizShotSDK.SessionSyncStateEnum") {
+            return String(describing: value)
+        }
 
-       // MARK: - Logout
-       @objc
-       func logout(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-         InfivizShotsSDK.shared.callLogoutAPI { result in
-           switch result {
-           case .success(let success):
-             resolve(success)
-           case .failure(let error):
-             reject("LOGOUT_FAILED", "Logout error: \(error)", nil)
-           }
-         }
-       }
+        // 6. Date
+        if let date = value as? Date {
+            let formatter = DateFormatter()
+            formatter.dateFormat = "yyyy-MM-dd HH:mm:ss Z"
+            return formatter.string(from: date)
+        }
 
-       // MARK: - Reprocessing Enable Time
-       @objc
-       func getReprocessingButtonEnableTime(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-         InfivizShotsSDK.shared.getReprocessingButtonEnableTime(sessionID: sessionID as String) { result in
-           switch result {
-           case .success(let time):
-             resolve(time)
-           case .failure(let error):
-             reject("REPROCESS_TIME_ERROR", "Error fetching reprocessing time: \(error)", nil)
-           }
-         }
-       }
+        // 7. Custom objects
+        if !mirror.children.isEmpty {
+            var result: [String: Any] = [:]
+            for child in mirror.children {
+                if let label = child.label {
+                    result[label] = unwrapOptional(child.value)
+                }
+            }
+            return result
+        }
 
-       // MARK: - Start Reprocessing Workflow
-       @objc
-       func startReprocessingWorkflow(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-         InfivizShotsSDK.shared.startReprocessingWorkflow(sessionID: sessionID as String) { result in
-           switch result {
-           case .success(let time):
-             resolve(time)
-           case .failure(let error):
-             reject("REPROCESS_WORKFLOW_ERROR", "Reprocessing workflow error: \(error)", nil)
-           }
-         }
-       }
+        // 8. Primitive
+        return value
+    }
 
-       // MARK: - Start Camera
+    // MARK: - Logout
+    @objc
+    func logout(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.callLogoutAPI { result in
+            switch result {
+            case .success(let success):
+                resolve(success)
+            case .failure(let error):
+                reject("LOGOUT_FAILED", "Logout error: \(error)", nil)
+            }
+        }
+    }
+    
+    // MARK: - Reprocessing Enable Time
+    @objc
+    func getReprocessingButtonEnableTime(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.getReprocessingButtonEnableTime(sessionID: sessionID as String) { result in
+            switch result {
+            case .success(let time):
+                resolve(time)
+            case .failure(let error):
+                reject("REPROCESS_TIME_ERROR", "Error fetching reprocessing time: \(error)", nil)
+            }
+        }
+    }
+    
+    // MARK: - Start Reprocessing Workflow
+    @objc
+    func startReprocessingWorkflow(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.startReprocessingWorkflow(sessionID: sessionID as String) { result in
+            switch result {
+            case .success(let time):
+                resolve(time)
+            case .failure(let error):
+                reject("REPROCESS_WORKFLOW_ERROR", "Reprocessing workflow error: \(error)", nil)
+            }
+        }
+    }
+    
+    // MARK: - Start Camera
     @objc(startCamera:storeTitle:storeId:photoType:category:maxPhoto:maxPhotoOneGo:metaData:resolver:rejecter:)
     func startCamera(_ taskName: NSString,
                      storeTitle: NSString,
@@ -330,229 +356,229 @@ class InfivizShotsReactSdk:  RCTEventEmitter {
                      metaData: NSDictionary,
                      resolver resolve: @escaping RCTPromiseResolveBlock,
                      rejecter reject: @escaping RCTPromiseRejectBlock) {
-
-      DispatchQueue.main.async {
-        // 1️⃣ Build the CameraContext just like before
-        let metadataDict: [String: Any]? = metaData as? [String: Any]
-        let context = CameraContext(
-          taskName:     taskName as String,
-          storeTitle:   storeTitle as String,
-          storeId:      storeId as String,
-          photoType:    photoType as String,
-          category:     category as String,
-          maxPhoto:     maxPhoto.intValue,
-          maxPhotoOneGo: maxPhotoOneGo.intValue,
-          tempSessionId: nil,
-          imageURI:      nil,
-          navigationController: nil,
-          retake: false,
-          metaData: metadataDict
+        
+        DispatchQueue.main.async {
+            // 1️⃣ Build the CameraContext just like before
+            let metadataDict: [String: Any]? = metaData as? [String: Any]
+            let context = CameraContext(
+                taskName:     taskName as String,
+                storeTitle:   storeTitle as String,
+                storeId:      storeId as String,
+                photoType:    photoType as String,
+                category:     category as String,
+                maxPhoto:     maxPhoto.intValue,
+                maxPhotoOneGo: maxPhotoOneGo.intValue,
+                tempSessionId: nil,
+                imageURI:      nil,
+                navigationController: nil,
+                retake: false,
+                metaData: metadataDict
+            )
+            
+            // 2️⃣ Instantiate the SDK activity
+            let activity = InfilectSDKCameraActivityForResult(cameraContext: context)
+            
+            // 3️⃣ Call its existing `start(completion:)` which will handle validation,
+            activity.start { result in
+                switch result {
+                case .success(let sessionID):
+                    resolve(sessionID)
+                case .failure(let apiError):
+                    reject("CAMERA_ERROR", apiError.localizedDescription, nil)
+                }
+            }
+        }
+    }
+    
+    @objc
+    func initialize(_ appID: NSString,
+                    authSecret: NSString,
+                    accountKey: NSString,
+                    userID: NSString,
+                    clientID: NSString,
+                    apiToken: NSString,
+                    env: NSString,
+                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        let model = InfivizUserLoginContext(
+            appID: appID as String,
+            authSecret: authSecret as String,
+            accountKey: accountKey as String,
+            userID: userID as String,
+            clientID: clientID as String,
+            apiToken: apiToken as String
         )
-
-        // 2️⃣ Instantiate the SDK activity
-        let activity = InfilectSDKCameraActivityForResult(cameraContext: context)
-
-        // 3️⃣ Call its existing `start(completion:)` which will handle validation,
-        activity.start { result in
-          switch result {
-          case .success(let sessionID):
-            resolve(sessionID)
-          case .failure(let apiError):
-            reject("CAMERA_ERROR", apiError.localizedDescription, nil)
-          }
+        
+        let environment =  APIEnvironment(rawValue: env as String) ?? .production
+        InfivizShotsSDK.shared.initializeEnvironent(environment)
+        activity = InfivizShotsActivity(model: model)
+        activity?.initialize { result in
+            switch result {
+            case .success(let success):
+                resolve(success)
+            case .failure(let error):
+                reject("LOGIN_FAILED", error.localizedDescription, nil)
+            }
         }
-      }
     }
-
-       @objc
-         func initialize(_ appID: NSString,
-                       authSecret: NSString,
-                       accountKey: NSString,
-                       userID: NSString,
-                       clientID: NSString,
-                       apiToken: NSString,
-                       env: NSString,
+    
+    @objc
+    func fetchSessionID(_ taskCategory: NSString,
+                        storeID: NSString,
+                        taskPhotoType: NSString,
+                        resolver resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        InfivizShotsSDK.shared.fetchSessionID(
+            taskCategory: taskCategory as String,
+            storeID: storeID as String,
+            taskPhotoType: taskPhotoType as String
+        ) { sessionID, error in
+            if let id = sessionID {
+                resolve(id)
+            } else {
+                reject("SESSION_NOT_FOUND", "Session not found", nil)
+            }
+        }
+    }
+    
+    // MARK: - View IR Results via bridge
+    @objc(viewIRResults:resolver:rejecter:)
+    func viewIRResults(_ sessionID: NSString,
                        resolver resolve: @escaping RCTPromiseResolveBlock,
-                         rejecter reject: @escaping RCTPromiseRejectBlock) {
-             
-             let model = InfivizUserLoginContext(
-                appID: appID as String,
-                authSecret: authSecret as String,
-                accountKey: accountKey as String,
-                userID: userID as String,
-                clientID: clientID as String,
-                apiToken: apiToken as String
-             )
-             
-             let environment =  APIEnvironment(rawValue: env as String) ?? .production
-             InfivizShotsSDK.shared.initializeEnvironent(environment)
-             activity = InfivizShotsActivity(model: model)
-             activity?.initialize { result in
-                 switch result {
-                 case .success(let success):
-                     resolve(success)
-                 case .failure(let error):
-                     reject("LOGIN_FAILED", error.localizedDescription, nil)
-                 }
-             }
-         }
-
-     @objc
-     func fetchSessionID(_ taskCategory: NSString,
-                         storeID: NSString,
-                         taskPhotoType: NSString,
-                         resolver resolve: @escaping RCTPromiseResolveBlock,
-                         rejecter reject: @escaping RCTPromiseRejectBlock) {
-
-         InfivizShotsSDK.shared.fetchSessionID(
-             taskCategory: taskCategory as String,
-             storeID: storeID as String,
-             taskPhotoType: taskPhotoType as String
-         ) { sessionID, error in
-             if let id = sessionID {
-                 resolve(id)
-             } else {
-                 reject("SESSION_NOT_FOUND", "Session not found", nil)
-             }
-         }
-     }
-
-     // MARK: - View IR Results via bridge
-       @objc(viewIRResults:resolver:rejecter:)
-       func viewIRResults(_ sessionID: NSString,
-                          resolver resolve: @escaping RCTPromiseResolveBlock,
-                          rejecter reject: @escaping RCTPromiseRejectBlock) {
-         DispatchQueue.main.async {
-           guard let navigationController = UIApplication.shared.connectedScenes
-                   .compactMap({ $0 as? UIWindowScene })
-                   .flatMap({ $0.windows })
-                   .first(where: { $0.isKeyWindow })?
-                   .rootViewController?.navigationController else {
-             reject("NAV_ERROR", "No navigation controller available", nil)
-             return
-           }
-           let realTimeView = InfivizRealTimeView(sessionID: sessionID as String,
-                                                  navigationController: navigationController)
-           realTimeView.viewIRResults(sessionID: sessionID as String) { result in
-             switch result {
-             case .success(let value): resolve(value)
-             case .failure(let error): reject("VIEW_IR_FAILED", error.localizedDescription, nil)
-             }
-           }
-         }
-       }
-
-       // MARK: - Start Actions Workflow via bridge
-       @objc(startActionsWorkFlow:sessionId:latitude:longitude:dateTimeStamp:resolver:rejecter:)
-       func startActionsWorkFlow(_ storeId: NSString,
-                                 sessionId: NSString,
-                                 latitude: NSString,
-                                 longitude: NSString,
-                                 dateTimeStamp: NSString,
-                                 resolver resolve: @escaping RCTPromiseResolveBlock,
-                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
-         DispatchQueue.main.async {
-           guard let navigationController = UIApplication.shared.connectedScenes
-                   .compactMap({ $0 as? UIWindowScene })
-                   .flatMap({ $0.windows })
-                   .first(where: { $0.isKeyWindow })?
-                   .rootViewController?.navigationController else {
-             reject("NAV_ERROR", "No navigation controller available", nil)
-             return
-           }
-           let realTimeView = InfivizRealTimeView(sessionID: sessionId as String,
-                                                  navigationController: navigationController)
-           realTimeView.startActionsWorkFlow(storeId: storeId as String,
-                                             sessionId: sessionId as String,
-                                             latitude: latitude as String,
-                                             longitude: longitude as String,
-                                             dateTimeStamp: dateTimeStamp as String) { result in
-             switch result {
-             case .success(let value): resolve(value)
-             case .failure(let error): reject("ACTIONS_WORKFLOW_FAILED", error.localizedDescription, nil)
-             }
-           }
-         }
-       }
-
-       @objc(resumeCamera:metaData:resolver:rejecter:)
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            guard let navigationController = UIApplication.shared.connectedScenes
+                .compactMap({ $0 as? UIWindowScene })
+                .flatMap({ $0.windows })
+                .first(where: { $0.isKeyWindow })?
+                .rootViewController?.navigationController else {
+                reject("NAV_ERROR", "No navigation controller available", nil)
+                return
+            }
+            let realTimeView = InfivizRealTimeView(sessionID: sessionID as String,
+                                                   navigationController: navigationController)
+            realTimeView.viewIRResults(sessionID: sessionID as String) { result in
+                switch result {
+                case .success(let value): resolve(value)
+                case .failure(let error): reject("VIEW_IR_FAILED", error.localizedDescription, nil)
+                }
+            }
+        }
+    }
+    
+    // MARK: - Start Actions Workflow via bridge
+    @objc(startActionsWorkFlow:sessionId:latitude:longitude:dateTimeStamp:resolver:rejecter:)
+    func startActionsWorkFlow(_ storeId: NSString,
+                              sessionId: NSString,
+                              latitude: NSString,
+                              longitude: NSString,
+                              dateTimeStamp: NSString,
+                              resolver resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            guard let navigationController = UIApplication.shared.connectedScenes
+                .compactMap({ $0 as? UIWindowScene })
+                .flatMap({ $0.windows })
+                .first(where: { $0.isKeyWindow })?
+                .rootViewController?.navigationController else {
+                reject("NAV_ERROR", "No navigation controller available", nil)
+                return
+            }
+            let realTimeView = InfivizRealTimeView(sessionID: sessionId as String,
+                                                   navigationController: navigationController)
+            realTimeView.startActionsWorkFlow(storeId: storeId as String,
+                                              sessionId: sessionId as String,
+                                              latitude: latitude as String,
+                                              longitude: longitude as String,
+                                              dateTimeStamp: dateTimeStamp as String) { result in
+                switch result {
+                case .success(let value): resolve(value)
+                case .failure(let error): reject("ACTIONS_WORKFLOW_FAILED", error.localizedDescription, nil)
+                }
+            }
+        }
+    }
+    
+    @objc(resumeCamera:metaData:resolver:rejecter:)
     func resumeCamera(
-      _ temporarySessionID: NSString,
-      metaData: NSDictionary?,
-      resolver resolve: @escaping RCTPromiseResolveBlock,
-      rejecter reject: @escaping RCTPromiseRejectBlock
+        _ temporarySessionID: NSString,
+        metaData: NSDictionary?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
     ) {
-      // Build whatever CameraContext your SDK needs. In your original UI code,
-      // you were reading from text fields (e.g. shelfTextField.text, traderTextField.text, etc.).
-      // In a module method you typically won't have those outlets available, so you'll
-      // need to pass any required "taskName", "storeTitle" etc. from JS into this call
-      // or hard‐code defaults here. For now, I'll show a minimal example:
-
-      let context = CameraContext(
-        taskName: "",                       // ← pass in from JS if you really need it
-        storeTitle: "",
-        storeId: "",
-        photoType: "",
-        category: "",
-        maxPhoto: 0,
-        maxPhotoOneGo: 0,
-        navigationController: nil           // ← no UIKit nav controller in RN module
-      )
-
-      // Instantiate your SDK's camera controller just like before:
-      let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
-
-      // Convert NSDictionary to [String: Any]
-      let metadataDict: [String: Any]? = metaData as? [String: Any]
-
-      // Call the updated `resumeCamera(sessionID:metaData:completion:)` API with metadata
-      controller.resumeCamera(sessionID: temporarySessionID as String, metaData: metadataDict) { result in
-        switch result {
-        case .success(let successString):
-          // fulfill the JS promise with the returned string
-          resolve(successString)
-
-        case .failure(let sdkError):
-          // reject the JS promise
-          let nsError = sdkError as NSError
-          reject(
-            "ResumeCameraError",
-            "Failed to resume camera: \(nsError.localizedDescription)",
-            nsError
-          )
+        // Build whatever CameraContext your SDK needs. In your original UI code,
+        // you were reading from text fields (e.g. shelfTextField.text, traderTextField.text, etc.).
+        // In a module method you typically won't have those outlets available, so you'll
+        // need to pass any required "taskName", "storeTitle" etc. from JS into this call
+        // or hard‐code defaults here. For now, I'll show a minimal example:
+        
+        let context = CameraContext(
+            taskName: "",                       // ← pass in from JS if you really need it
+            storeTitle: "",
+            storeId: "",
+            photoType: "",
+            category: "",
+            maxPhoto: 0,
+            maxPhotoOneGo: 0,
+            navigationController: nil           // ← no UIKit nav controller in RN module
+        )
+        
+        // Instantiate your SDK's camera controller just like before:
+        let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
+        
+        // Convert NSDictionary to [String: Any]
+        let metadataDict: [String: Any]? = metaData as? [String: Any]
+        
+        // Call the updated `resumeCamera(sessionID:metaData:completion:)` API with metadata
+        controller.resumeCamera(sessionID: temporarySessionID as String, metaData: metadataDict) { result in
+            switch result {
+            case .success(let successString):
+                // fulfill the JS promise with the returned string
+                resolve(successString)
+                
+            case .failure(let sdkError):
+                // reject the JS promise
+                let nsError = sdkError as NSError
+                reject(
+                    "ResumeCameraError",
+                    "Failed to resume camera: \(nsError.localizedDescription)",
+                    nsError
+                )
+            }
         }
-      }
     }
-
-     @objc
-     func deletePhoto(
-       _ imageURI: NSString,
-       temporarySessionId: NSString,
-       resolver resolve: @escaping RCTPromiseResolveBlock,
-       rejecter reject: @escaping RCTPromiseRejectBlock
-     ) {
-       let context = CameraContext(
-         taskName: "",
-         storeTitle: "",
-         storeId: "",
-         photoType: "",
-         
-         category: "",
-         maxPhoto: 0,
-         maxPhotoOneGo: 0,
-         navigationController: nil
-       )
-       let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
-       controller.deleteImage(imageID: imageURI as String, sessionID: temporarySessionId as String) { result in
-         switch result {
-         case .success(let successMessage):
-           resolve(successMessage)
-         case .failure(let error):
-           reject("DELETE_IMAGE_ERROR", "Failed to delete image: \(error.localizedDescription)", error)
-         }
-       }
-     }
-
+    
+    @objc
+    func deletePhoto(
+        _ imageURI: NSString,
+        temporarySessionId: NSString,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let context = CameraContext(
+            taskName: "",
+            storeTitle: "",
+            storeId: "",
+            photoType: "",
+            
+            category: "",
+            maxPhoto: 0,
+            maxPhotoOneGo: 0,
+            navigationController: nil
+        )
+        let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
+        controller.deleteImage(imageID: imageURI as String, sessionID: temporarySessionId as String) { result in
+            switch result {
+            case .success(let successMessage):
+                resolve(successMessage)
+            case .failure(let error):
+                reject("DELETE_IMAGE_ERROR", "Failed to delete image: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
     @objc(retakeImage:imageURL:metaData:resolver:rejecter:)
     func retakeImage(
         _ temporarySessionId: NSString,
@@ -593,70 +619,70 @@ class InfivizShotsReactSdk:  RCTEventEmitter {
             }
         }
     }
-
-      // MARK: – React Native Promise Exposures for OutputAPI
-       /// Expose `getIRResult(sessionID:completion:)` to JavaScript as:
-       ///   InfiBridge.getIRResult("session-123").then(...).catch(...)
-       @objc
-       func getIrResult(
-         _ sessionId: NSString,
-         resolver resolve: @escaping RCTPromiseResolveBlock,
-         rejecter reject: @escaping RCTPromiseRejectBlock
-       ) {
-           print("Inside GetIrResult sessionId -> \(sessionId)")
-         // Call the Swift helper (which calls outputAPI.getIRResult)
-           InfivizShotsSDK.shared.getIrResult(sessionID: sessionId as String) { (dataAny, error) in
-           if let err = error {
-             // If the SDK returned an error, reject the JS promise
-               print("err", err)
-               reject(
-                 "IR_RESULT_ERROR",                // error code (custom identifier)
-                 err as? String,                      // error message
-                 nil                               // optional NSError (can be nil)
-               )
-           } else if let output = dataAny {
-             // If the SDK returned data (Any), pass it back to JS.
-             resolve(output)
-           } else {
-             // Neither data nor error? Just resolve with `nil`.
-             resolve(nil)
-           }
-         }
-       }
-
-       /// Expose `getActionsResult(sessionID:completion:)` to JavaScript as:
-       ///   InfiBridge.getActionsResult("session-123").then(...).catch(...)
-       @objc
-       func getActionsResult(
-         _ sessionId: NSString,
-         resolver resolve: @escaping RCTPromiseResolveBlock,
-         rejecter reject: @escaping RCTPromiseRejectBlock
-       ) {
-         // Call the Swift helper (which calls outputAPI.getActionsResult)
-           InfivizShotsSDK.shared.getActionsResult(sessionID: sessionId as String) { (dataAny, error) in
-           if let err = error {
-             reject("ACTIONS_FAILED", err as? String, nil)
-           } else if let output = dataAny {
-             resolve(output)
-           } else {
-             resolve(nil)
-           }
-         }
-       }
-
-       @objc
-        private func handleActionsGeneratedEvent(_ notification: Notification) {
-          guard hasListeners else { return }
-
-          let payload = notification.userInfo ?? [:]
-          sendEvent(withName: "ActionsGeneratedEvent", body: payload)
+    
+    // MARK: – React Native Promise Exposures for OutputAPI
+    /// Expose `getIRResult(sessionID:completion:)` to JavaScript as:
+    ///   InfiBridge.getIRResult("session-123").then(...).catch(...)
+    @objc
+    func getIrResult(
+        _ sessionId: NSString,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        print("Inside GetIrResult sessionId -> \(sessionId)")
+        // Call the Swift helper (which calls outputAPI.getIRResult)
+        InfivizShotsSDK.shared.getIrResult(sessionID: sessionId as String) { (dataAny, error) in
+            if let err = error {
+                // If the SDK returned an error, reject the JS promise
+                print("err", err)
+                reject(
+                    "IR_RESULT_ERROR",                // error code (custom identifier)
+                    err as? String,                      // error message
+                    nil                               // optional NSError (can be nil)
+                )
+            } else if let output = dataAny {
+                // If the SDK returned data (Any), pass it back to JS.
+                resolve(output)
+            } else {
+                // Neither data nor error? Just resolve with `nil`.
+                resolve(nil)
+            }
         }
-        
-       @objc
-        private func handleSessionRealTimeResultEvent(_ notification: Notification) {
-          guard hasListeners else { return }
-
-          let payload = notification.userInfo ?? [:]
-          sendEvent(withName: "SessionRealTimeResultEvent", body: payload)
+    }
+    
+    /// Expose `getActionsResult(sessionID:completion:)` to JavaScript as:
+    ///   InfiBridge.getActionsResult("session-123").then(...).catch(...)
+    @objc
+    func getActionsResult(
+        _ sessionId: NSString,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        // Call the Swift helper (which calls outputAPI.getActionsResult)
+        InfivizShotsSDK.shared.getActionsResult(sessionID: sessionId as String) { (dataAny, error) in
+            if let err = error {
+                reject("ACTIONS_FAILED", err as? String, nil)
+            } else if let output = dataAny {
+                resolve(output)
+            } else {
+                resolve(nil)
+            }
         }
+    }
+    
+    @objc
+    private func handleActionsGeneratedEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "ActionsGeneratedEvent", body: payload)
+    }
+    
+    @objc
+    private func handleSessionRealTimeResultEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "SessionRealTimeResultEvent", body: payload)
+    }
 }