react-native-sdk-pianoio 0.3.1 → 0.3.4

package/ios/SdkPianoio.swift

@@ -1,150 +1,76 @@
 import Foundation
 import React
-import PianoComposer
-import PianoOAuth
 
+/**
+ * SdkPianoio - The main React Native bridge module for the Piano SDK.
+ *
+ * This class exposes the functionality of the ComposerPianoImpl to JavaScript.
+ */
 @objc(SdkPianoio)
 class SdkPianoio: NSObject {
-  private var moduleImpl: ComposerPianoImpl?
-  
-  override init() {
-    super.init()
-    self.moduleImpl = ComposerPianoImpl()
-  }
-  
-  @objc
-  static func requiresMainQueueSetup() -> Bool {
-    return false
-  }
-  
-  @objc(initializeComposer:resolver:rejecter:)
-  func initializeComposer(aid: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.initializeComposer(aid)
-    resolver(true)
-  }
-  
-  @objc(getComposer:rejecter:)
-  func getComposer(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    guard let moduleImpl = moduleImpl else {
-      rejecter("composer_error", "Composer not initialized", nil)
-      return
+
+    // The single, persistent instance of our implementation class.
+    private var moduleImpl: ComposerPianoImpl?
+
+    override init() {
+        self.moduleImpl = ComposerPianoImpl()
+        super.init()
+    }
+
+    @objc(initialize:resolver:rejecter:)
+    func initialize(aid: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.initialize(aid: aid)
+        resolver(true)
+    }
+
+    // MARK: - Configuration Methods
+
+    @objc(addTag:resolver:rejecter:)
+    func addTag(tag: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.addTag(tag)
+        resolver(true)
+    }
+
+    @objc(addTags:resolver:rejecter:)
+    func addTags(tags: [String], resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.addTags(tags)
+        resolver(true)
+    }
+
+    @objc(setZoneId:resolver:rejecter:)
+    func setZoneId(zoneId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.setZoneId(zoneId)
+        resolver(true)
     }
-    
-    let composer = moduleImpl.getComposer()
-    if composer != nil {
-      let response: [String: Any] = [
-        "aid": moduleImpl.getAid(),
-        "tags": moduleImpl.getTags(),
-        "zoneId": moduleImpl.getZoneId(),
-        "referrer": moduleImpl.getReferrer(),
-        "url": moduleImpl.getUrl(),
-        "userToken": moduleImpl.getUserToken()
-      ]
-      resolver(response)
-    } else {
-      rejecter("composer_error", "Cannot get composer", nil)
+
+    @objc(setReferrer:resolver:rejecter:)
+    func setReferrer(referrer: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.setReferrer(referrer)
+        resolver(true)
+    }
+
+    @objc(setUrl:resolver:rejecter:)
+    func setUrl(url: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.setUrl(url)
+        resolver(true)
+    }
+
+    @objc(setUserToken:resolver:rejecter:)
+    func setUserToken(token: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.setUserToken(token)
+        resolver(true)
+    }
+
+    @objc(setCustomVariable:value:resolver:rejecter:)
+    func setCustomVariable(name: String, value: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.setCustomVariable(name, value: value)
+        resolver(true)
+    }
+
+    // MARK: - Execution Method
+
+    @objc(executeExperience:rejecter:)
+    func executeExperience(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        moduleImpl?.executeExperience(resolver: resolver, rejecter: rejecter)
     }
-  }
-  
-  @objc(addComposerTag:resolver:rejecter:)
-  func addComposerTag(tag: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.addTag(tag)
-    resolver(nil)
-  }
-  
-  @objc(addComposerTags:resolver:rejecter:)
-  func addComposerTags(tags: [String], resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.addTags(tags)
-    resolver(nil)
-  }
-  
-  @objc(setComposerCustomVariable:value:resolver:rejecter:)
-  func setComposerCustomVariable(name: String, value: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.setCustomVariable(name, value: value)
-    resolver(nil)
-  }
-  
-  @objc(setComposerReferrer:resolver:rejecter:)
-  func setComposerReferrer(referrer: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.setReferrer(referrer)
-    resolver(nil)
-  }
-  
-  @objc(setComposerUrl:resolver:rejecter:)
-  func setComposerUrl(url: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.setUrl(url)
-    resolver(nil)
-  }
-  
-  @objc(setComposerUserToken:resolver:rejecter:)
-  func setComposerUserToken(token: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.setUserToken(token)
-    resolver(nil)
-  }
-  
-  @objc(setComposerZoneId:resolver:rejecter:)
-  func setComposerZoneId(zoneId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.setZoneId(zoneId)
-    resolver(nil)
-  }
-  
-  @objc(executeExperience:rejecter:)
-  func executeExperience(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.executeExperience(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(executeComposer:rejecter:)
-  func executeComposer(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.executeComposerWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(showLogin:rejecter:)
-  func showLogin(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.showLoginWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(showTemplate:rejecter:)
-  func showTemplate(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.showTemplateWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(showForm:rejecter:)
-  func showForm(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.showFormWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(showRecommendations:rejecter:)
-  func showRecommendations(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.showRecommendationsWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(nonSite:rejecter:)
-  func nonSite(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.nonSiteWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(userSegmentTrue:rejecter:)
-  func userSegmentTrue(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.userSegmentTrueWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(userSegmentFalse:rejecter:)
-  func userSegmentFalse(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.userSegmentFalseWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(meterActive:rejecter:)
-  func meterActive(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.meterActiveWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(meterExpired:rejecter:)
-  func meterExpired(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.meterExpiredWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-  
-  @objc(composerExecutionCompleted:rejecter:)
-  func composerExecutionCompleted(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-    moduleImpl?.composerExecutionCompletedWithResolver(resolver: resolver, rejecter: rejecter)
-  }
-} 
+}

package/ios/SdkPianoioBridge.m

@@ -1,81 +1,53 @@
 #import <React/RCTBridgeModule.h>
 
-// Questa macro registra la sua classe Swift 'SdkPianoio' con il bridge di React Native.
+// This macro registers the Swift class 'SdkPianoio' with the React Native bridge.
 @interface RCT_EXTERN_MODULE(SdkPianoio, NSObject)
 
-// Ora, esponiamo ogni metodo dalla sua classe Swift che vogliamo chiamare da JavaScript.
-// Le annotazioni @objc(...) nel suo file Swift definiscono queste esatte firme.
+// MARK: - Initialization
 
-RCT_EXTERN_METHOD(initializeComposer:(NSString *)aid
+RCT_EXTERN_METHOD(initialize:(NSString *)aid
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(getComposer:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
+// MARK: - Configuration Methods
 
-RCT_EXTERN_METHOD(addComposerTag:(NSString *)tag
+RCT_EXTERN_METHOD(addTag:(NSString *)tag
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(addComposerTags:(NSArray<NSString *> *)tags
+RCT_EXTERN_METHOD(addTags:(NSArray<NSString *> *)tags
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setComposerCustomVariable:(NSString *)name
-                  value:(NSString *)value
+RCT_EXTERN_METHOD(setZoneId:(NSString *)zoneId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setComposerReferrer:(NSString *)referrer
+RCT_EXTERN_METHOD(setReferrer:(NSString *)referrer
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setComposerUrl:(NSString *)url
+RCT_EXTERN_METHOD(setUrl:(NSString *)url
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setComposerUserToken:(NSString *)token
+RCT_EXTERN_METHOD(setUserToken:(NSString *)token
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setComposerZoneId:(NSString *)zoneId
+RCT_EXTERN_METHOD(setCustomVariable:(NSString *)name
+                  value:(NSString *)value
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(executeExperience:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(executeComposer:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(showLogin:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(showTemplate:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(showForm:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
+// MARK: - Execution Method
 
-RCT_EXTERN_METHOD(showRecommendations:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(nonSite:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(userSegmentTrue:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(userSegmentFalse:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(meterActive:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(meterExpired:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(executeExperience:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(composerExecutionCompleted:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
+// Note: Authentication methods (signIn, signOut, etc.) would be added here
+// if they were exposed from SdkPianoio.swift. Since they are handled internally
+// by the Composer/TokenService interaction, they don't need to be exposed directly
+// unless you add them to the SdkPianoio.swift class.
 
 @end

package/ios/TokenService.swift

@@ -0,0 +1,219 @@
+import PianoOAuth
+import Foundation
+
+/**
+ * Represents a user from the Piano ID SDK.
+ * This custom class simplifies passing user data back to React Native.
+ */
+public class User {
+    let id: String
+    let email: String
+    let accessToken: String
+
+    init(id: String, email: String, accessToken: String) {
+        self.id = id
+        self.email = email
+        self.accessToken = accessToken
+    }
+}
+
+/**
+ * TokenService - Manages OAuth tokens and authentication with the Piano ID SDK.
+ *
+ * This class is responsible for:
+ * - Integrating with the real PianoID SDK.
+ * - Managing user authentication (sign-in, sign-out).
+ * - Storing and providing the current user's token and information.
+ */
+public class TokenService: NSObject, PianoIDDelegate {
+
+    // MARK: - Properties
+
+    private var cachedToken: PianoIDToken?
+    private var isInitialized: Bool = false
+
+    // Promises to communicate results of async operations back to React Native
+    private var signInResolver: ((Any?) -> Void)?
+    private var signInRejecter: ((String?, String?, Error?) -> Void)?
+    private var signOutResolver: ((Any?) -> Void)?
+    private var signOutRejecter: ((String?, String?, Error?) -> Void)?
+
+    // MARK: - Initialization
+
+    /**
+     * Initializes the TokenService and configures the PianoID singleton.
+     *
+     * @param aid The Piano Application ID.
+     */
+    public func initialize(aid: String) {
+        if isInitialized {
+            return
+        }
+        print("TokenService: Initializing with AID: \(aid)")
+
+        PianoID.shared.aid = aid
+        PianoID.shared.endpoint = PianoEndpoint.production
+        PianoID.shared.delegate = self
+
+        isInitialized = true
+        print("TokenService: Initialization completed successfully")
+    }
+
+    // MARK: - Authentication Methods
+
+    /**
+     * Starts the sign-in process.
+     *
+     * @param resolver The promise resolver from React Native.
+     * @param rejecter The promise rejecter from React Native.
+     */
+    public func signIn(resolver: @escaping (Any?) -> Void, rejecter: @escaping (String?, String?, Error?) -> Void) {
+        if !isInitialized {
+            print("TokenService: Not initialized. Call initialize() first.")
+            rejecter("INIT_ERROR", "TokenService not initialized", nil)
+            return
+        }
+        print("TokenService: Starting sign in")
+        self.signInResolver = resolver
+        self.signInRejecter = rejecter
+        PianoID.shared.signIn()
+    }
+
+    /**
+     * Starts the sign-out process.
+     *
+     * @param resolver The promise resolver from React Native.
+     * @param rejecter The promise rejecter from React Native.
+     */
+    public func signOut(resolver: @escaping (Any?) -> Void, rejecter: @escaping (String?, String?, Error?) -> Void) {
+        if !isInitialized {
+            print("TokenService: Not initialized.")
+            rejecter("INIT_ERROR", "TokenService not initialized", nil)
+            return
+        }
+        guard let token = self.cachedToken else {
+            print("TokenService: No user is signed in.")
+            resolver(["success": true]) // Already signed out
+            return
+        }
+
+        print("TokenService: Starting sign out")
+        self.signOutResolver = resolver
+        self.signOutRejecter = rejecter
+        PianoID.shared.signOut(token: token.accessToken)
+    }
+
+    // MARK: - User Information Methods
+
+    /**
+     * Gets the current user's information.
+     *
+     * @return A User object if authenticated, otherwise null.
+     */
+    public func getCurrentUser() -> User? {
+        guard let token = self.cachedToken else {
+            return nil
+        }
+        
+        // Decode the JWT to get the claims
+        let claims = decode(jwtToken: token.accessToken)
+        
+        // Extract user_id and email from the claims
+        let userId = claims?["uid"] as? String ?? "unknown" // Piano ID often uses 'uid' in the JWT
+        let email = claims?["email"] as? String ?? "unknown"
+        
+        return User(
+            id: userId,
+            email: email,
+            accessToken: token.accessToken
+        )
+    }
+
+    /**
+     * Checks if a user is currently authenticated.
+     *
+     * @return true if a valid token exists, false otherwise.
+     */
+    public func isAuthenticated() -> Bool {
+        return self.cachedToken != nil
+    }
+
+    // MARK: - PianoIDDelegate Implementation
+
+    public func signIn(result: PianoIDSignInResult!, withError error: Error!) {
+        if let r = result {
+            print("TokenService: Sign in successful")
+            self.cachedToken = r.token
+            let user = self.getCurrentUser()
+            
+            let resultMap: [String: Any] = [
+                "success": true,
+                "userId": user?.id ?? "",
+                "userEmail": user?.email ?? "",
+                "accessToken": user?.accessToken ?? ""
+            ]
+            self.signInResolver?(resultMap)
+        } else if let e = error {
+            print("TokenService: Sign in failed: \(e.localizedDescription)")
+            self.signInRejecter?("SIGNIN_ERROR", e.localizedDescription, e)
+        }
+        // Clean up promises
+        self.signInResolver = nil
+        self.signInRejecter = nil
+    }
+
+    public func signOut(withError error: Error!) {
+        if let e = error {
+            print("TokenService: Sign out failed: \(e.localizedDescription)")
+            self.signOutRejecter?("SIGNOUT_ERROR", e.localizedDescription, e)
+        } else {
+            print("TokenService: Sign out successful")
+            self.cachedToken = nil
+            self.signOutResolver?(["success": true])
+        }
+        // Clean up promises
+        self.signOutResolver = nil
+        self.signOutRejecter = nil
+    }
+
+    public func cancel() {
+        print("TokenService: User cancelled the flow")
+        // If there's an active sign-in promise, reject it.
+        if let rejecter = self.signInRejecter {
+            rejecter("CANCELLED", "User cancelled the sign-in process.", nil)
+            self.signInResolver = nil
+            self.signInRejecter = nil
+        }
+    }
+    
+    // MARK: - Helper Methods
+    
+    /**
+     * Decodes the payload of a JWT.
+     *
+     * @param jwt The JSON Web Token string.
+     * @return A dictionary of claims, or nil if decoding fails.
+     */
+    private func decode(jwtToken jwt: String) -> [String: Any]? {
+        let segments = jwt.components(separatedBy: ".")
+        guard segments.count > 1 else {
+            print("JWT Error: Invalid token format")
+            return nil
+        }
+        
+        var base64String = segments[1]
+        let requiredLength = Int(4 * ceil(Float(base64String.count) / 4.0))
+        let nbrPaddings = requiredLength - base64String.count
+        if nbrPaddings > 0 {
+            let padding = String(repeating: "=", count: nbrPaddings)
+            base64String = base64String.appending(padding)
+        }
+        
+        guard let data = Data(base64Encoded: base64String, options: .ignoreUnknownCharacters) else {
+            print("JWT Error: Could not decode base64 payload")
+            return nil
+        }
+        
+        return try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
+    }
+}

package/lib/commonjs/NativeSdkPianoio.ts

@@ -1,28 +1,41 @@
 import { NativeModules, Platform } from 'react-native';
 
+/**
+ * This interface defines the full API surface of the native module.
+ * It is a complete and accurate representation of the methods exposed
+ * in SdkPianoioModule.kt.
+ */
 interface SdkPianoioType {
-  initializeComposer(aid: string): Promise<any>;
-  getComposer(): Promise<any>;
-  addComposerTag(tag: string): Promise<any>;
-  addComposerTags(tags: string[]): Promise<any>;
-  setComposerZoneId(zoneId: string): Promise<any>;
-  setComposerReferrer(referrer: string): Promise<any>;
-  setComposerUrl(url: string): Promise<any>;
-  setComposerCustomVariable(name: string, value: string): Promise<any>;
-  setComposerUserToken(token: string): Promise<any>;
-  executeComposer(): Promise<void>;
-
-  executeExperience(): Promise<boolean>;
-  showLogin(): Promise<boolean>;
-  showTemplate(): Promise<boolean>;
-  showForm(): Promise<boolean>;
-  showRecommendations(): Promise<boolean>;
-  nonSite(): Promise<boolean>;
-  userSegmentTrue(): Promise<boolean>;
-  userSegmentFalse(): Promise<boolean>;
-  meterActive(): Promise<boolean>;
-  meterExpired(): Promise<boolean>;
-  composerExecutionCompleted(): Promise<boolean>;
+  // Initialization
+  initialize(aid: string): Promise<boolean>;
+
+  // Configuration
+  addTag(tag: string): Promise<boolean>;
+  addTags(tags: string[]): Promise<boolean>;
+  setZoneId(zoneId: string): Promise<boolean>;
+  setReferrer(referrer: string): Promise<boolean>;
+  setUrl(url: string): Promise<boolean>;
+  setUserToken(token: string): Promise<boolean>;
+  addCustomVariable(key: string, value: string): Promise<boolean>;
+  setCustomVariables(variables: { [key: string]: string }): Promise<boolean>;
+
+  // Execution
+  executeExperience(): Promise<any>;
+
+  // Authentication
+  signIn(): Promise<any>;
+  signOut(): Promise<any>;
+  getCurrentUser(): Promise<any>;
+  isAuthenticated(): Promise<any>;
+
+  // Status & Cleanup
+  getStatus(): Promise<any>;
+  isInitialized(): Promise<boolean>;
+  clearConfiguration(): Promise<boolean>;
+  removeTag(tag: string): Promise<boolean>;
+  removeCustomVariable(key: string): Promise<boolean>;
+  clearTags(): Promise<boolean>;
+  clearCustomVariables(): Promise<boolean>;
 }
 
 const SdkPianoio = NativeModules.SdkPianoio;