react-native-usesense 2.0.0 → 2.1.0

package/android/build.gradle

@@ -36,12 +36,12 @@ dependencies {
     implementation "com.facebook.react:react-native:+"
 
     // UseSense Android SDK — published to Maven Central at
-    // central.sonatype.com/artifact/ai.usesense/sdk. Pinned to 4.2.1
-    // because that's the first release with the vanniktech-based
-    // Maven Central artifact shape and the terminal-screen centering
-    // fix. mavenCentral() is already in the `repositories` block above,
-    // so no custom repository declaration is needed.
-    implementation "ai.usesense:sdk:4.2.1"
+    // central.sonatype.com/artifact/ai.usesense/sdk. Pinned to 4.3.0,
+    // the release that adds the V4 capture API + Flows runner (matches
+    // the iOS SDK 4.3.0 the plugin's podspec depends on). mavenCentral()
+    // is already in the `repositories` block above, so no custom
+    // repository declaration is needed.
+    implementation "ai.usesense:sdk:4.3.0"
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '2.0.0')}"
 }

package/android/src/main/java/com/usesense/reactnative/UseSenseFlowsModule.kt

@@ -0,0 +1,72 @@
+package com.usesense.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.usesense.sdk.flows.FlowError
+import com.usesense.sdk.flows.FlowOutcome
+import com.usesense.sdk.flows.FlowRunResult
+import com.usesense.sdk.flows.FlowRunState
+import com.usesense.sdk.flows.FlowsCallback
+import com.usesense.sdk.flows.UseSenseFlows
+
+/**
+ * React Native bridge for the UseSense Android Flows runner.
+ *
+ * Exposes a single JS-callable method, `runFlow`, that forwards into the
+ * native `UseSenseFlows.run(activity, flowRunId, sdkToken, callback)` entry
+ * point and resolves the Promise with a `FlowRunResult` map. On failure the
+ * Promise rejects with `FlowError.Code.wire` as the JS error code, mirroring
+ * the taxonomy host apps catch on every other surface.
+ *
+ * Sits alongside `UseSenseModule` (Sessions); the existing module is
+ * untouched. Sessions and Flows coexist — host apps pick one per call.
+ */
+class UseSenseFlowsModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "UseSenseFlowsModule"
+
+    @ReactMethod
+    fun runFlow(flowRunId: String?, sdkToken: String?, apiBaseUrl: String?, promise: Promise) {
+        if (flowRunId.isNullOrEmpty() || sdkToken.isNullOrEmpty()) {
+            promise.reject("unknown", "flowRunId and sdkToken are required")
+            return
+        }
+        val activity = reactContext.currentActivity ?: run {
+            promise.reject("unknown", "No current activity to launch from")
+            return
+        }
+        val baseUrl = apiBaseUrl ?: "https://api.usesense.ai"
+
+        val callback = object : FlowsCallback {
+            override fun onResult(result: FlowRunResult) {
+                val map = Arguments.createMap().apply {
+                    putString("flowRunId", result.flowRunId)
+                    putString("state", stateWire(result.state))
+                    val outcomeStr = result.outcome?.let { outcomeWire(it) }
+                    if (outcomeStr != null) putString("outcome", outcomeStr)
+                    else putNull("outcome")
+                }
+                promise.resolve(map)
+            }
+
+            override fun onError(error: FlowError) {
+                promise.reject(error.code.wire, error.message)
+            }
+        }
+
+        UseSenseFlows.run(
+            activity = activity,
+            flowRunId = flowRunId,
+            sdkToken = sdkToken,
+            callback = callback,
+            apiBaseUrl = baseUrl,
+        )
+    }
+
+    private fun stateWire(state: FlowRunState): String = state.wire
+    private fun outcomeWire(outcome: FlowOutcome): String = outcome.wire
+}

package/android/src/main/java/com/usesense/reactnative/UseSenseModule.kt

@@ -38,6 +38,13 @@ class UseSenseModule(private val reactContext: ReactApplicationContext) :
         // responsibilities server-side. The JS API no longer exposes
         // the field; any stale JS callers that still pass it will
         // have the key silently ignored.
+        // v4.2: Optional on-device antispoof classifier flag.
+        val antispoofOnDeviceEnabled = configMap.hasKey("antispoofOnDeviceEnabled") &&
+            configMap.getBoolean("antispoofOnDeviceEnabled")
+        // LiveSense v4 capture flow opt-in.
+        val liveSenseV4Enabled = configMap.hasKey("liveSenseV4Enabled") &&
+            configMap.getBoolean("liveSenseV4Enabled")
+
         val config = UseSenseConfig(
             apiKey = apiKey,
             environment = environment,
@@ -46,6 +53,8 @@ class UseSenseModule(private val reactContext: ReactApplicationContext) :
             googleCloudProjectNumber = if (configMap.hasKey("googleCloudProjectNumber"))
                 configMap.getDouble("googleCloudProjectNumber").toLong()
             else UseSenseConfig.DEFAULT_GOOGLE_CLOUD_PROJECT_NUMBER,
+            antispoofOnDeviceEnabled = antispoofOnDeviceEnabled,
+            liveSenseV4Enabled = liveSenseV4Enabled,
         )
 
         val context = reactContext.applicationContext
@@ -112,6 +121,73 @@ class UseSenseModule(private val reactContext: ReactApplicationContext) :
         })
     }
 
+    /**
+     * Phase 1 ticket R-1: passthrough to UseSense.startV4Verification.
+     *
+     * The native SDK validates the request, launches the v4 capture
+     * activity, and resolves the promise with the opaque verdict.
+     */
+    @ReactMethod
+    fun startV4Verification(requestMap: ReadableMap, promise: Promise) {
+        val activity = currentActivity ?: run {
+            promise.reject("NO_ACTIVITY", "No current activity available")
+            return
+        }
+        val sessionId = requestMap.getString("sessionId")
+            ?: return promise.reject("INVALID_REQUEST", "sessionId is required")
+        val sessionToken = requestMap.getString("sessionToken")
+            ?: return promise.reject("INVALID_REQUEST", "sessionToken is required")
+        val nonce = requestMap.getString("nonce")
+            ?: return promise.reject("INVALID_REQUEST", "nonce is required")
+        val apiBaseUrl = requestMap.getString("apiBaseUrl")
+            ?: return promise.reject("INVALID_REQUEST", "apiBaseUrl is required")
+        val environment = requestMap.getString("environment") ?: "production"
+        val displayName = if (requestMap.hasKey("displayName")) requestMap.getString("displayName") else null
+        val brandColor = if (requestMap.hasKey("brandPrimaryColor"))
+            runCatching { android.graphics.Color.parseColor(requestMap.getString("brandPrimaryColor")) }.getOrNull()
+        else null
+
+        val request = com.usesense.sdk.api.V4VerificationRequest(
+            sessionId = sessionId,
+            sessionToken = sessionToken,
+            nonce = nonce,
+            apiBaseUrl = apiBaseUrl,
+            environment = environment,
+            brandPrimaryColor = brandColor,
+            displayName = displayName
+        )
+
+        UseSense.startV4Verification(activity, request, object : com.usesense.sdk.api.V4VerificationCallback {
+            override fun onComplete(verdict: com.usesense.sdk.api.V4Verdict) {
+                val map = Arguments.createMap().apply {
+                    putString("session_id", verdict.sessionId)
+                    putString("verdict", verdict.verdict.name.lowercase())
+                    putString("confidence", verdict.confidence.name.lowercase())
+                    putString("assurance_level_achieved", verdict.assuranceLevelAchieved)
+                    putString("capture_channel", "rn")
+                    if (verdict.matchSenseEmbeddingId != null) {
+                        putString("match_sense_embedding_id", verdict.matchSenseEmbeddingId)
+                    } else {
+                        putNull("match_sense_embedding_id")
+                    }
+                    putString("timestamp", verdict.timestamp)
+                }
+                promise.resolve(map)
+            }
+            override fun onFailure(error: Throwable) {
+                promise.reject("V4_FAILED", error.message ?: "v4 verification failed", error)
+            }
+            override fun onPhaseChange(phase: com.usesense.sdk.api.V4Phase) {
+                val map = Arguments.createMap().apply {
+                    putString("type", "V4_PHASE_CHANGE")
+                    putString("phase", phase.name.lowercase())
+                    putDouble("timestamp", System.currentTimeMillis().toDouble())
+                }
+                sendEvent("UseSenseEvent", map)
+            }
+        })
+    }
+
     @ReactMethod
     fun subscribeToEvents() {
         eventUnsubscribe?.invoke()

package/android/src/main/java/com/usesense/reactnative/UseSensePackage.kt

@@ -8,7 +8,12 @@ import com.facebook.react.uimanager.ViewManager
 class UseSensePackage : ReactPackage {
 
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(UseSenseModule(reactContext))
+        return listOf(
+            UseSenseModule(reactContext),
+            // Slice 5d: Flows runner module (parallel surface to Sessions, not
+            // a replacement). Host apps pick one per call.
+            UseSenseFlowsModule(reactContext),
+        )
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

package/ios/UseSenseFlowsModule.m

@@ -0,0 +1,20 @@
+#import <React/RCTBridgeModule.h>
+
+// Bridging header for the Flows runner module. Single JS-callable method:
+// runFlow(flowRunId, sdkToken, apiBaseUrl?). The apiBaseUrl parameter is
+// nullable from JS — pass `null` (or omit, since the JS wrapper supplies a
+// default) and the native side falls back to https://api.usesense.ai.
+@interface RCT_EXTERN_MODULE(UseSenseFlowsModule, NSObject)
+
+RCT_EXTERN_METHOD(runFlow:(NSString *)flowRunId
+                  sdkToken:(NSString *)sdkToken
+                  apiBaseUrl:(NSString * _Nullable)apiBaseUrl
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/UseSenseFlowsModule.swift

@@ -0,0 +1,111 @@
+import Foundation
+import React
+import UseSenseSDK
+
+/// React Native bridge for the UseSense iOS Flows runner.
+///
+/// Exposes a single JS-callable method, `runFlow`, that forwards into the
+/// native `UseSenseFlows.run(flowRunId:sdkToken:from:completion:)` entry
+/// point and resolves the Promise with a `FlowRunResult` map. On failure the
+/// Promise rejects with the SDK's `FlowError.Code.rawValue` as the JS error
+/// code, mirroring the taxonomy host apps catch on every other surface.
+///
+/// Sits alongside `UseSenseModule` (Sessions); the existing module is
+/// untouched. Sessions and Flows coexist — host apps pick one per call.
+@objc(UseSenseFlowsModule)
+class UseSenseFlowsModule: NSObject {
+
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        // Presentation work happens in `runFlow` after the JS call dispatches
+        // back to main via `DispatchQueue.main`. The module itself has no
+        // initialisation that must run on the main queue.
+        return false
+    }
+
+    /// `runFlow(flowRunId, sdkToken, apiBaseUrl?, resolve, reject)` — Promise.
+    /// The SDK takes care of presentation; we just resolve when the run
+    /// reaches a terminal state.
+    @objc
+    func runFlow(_ flowRunId: String,
+                 sdkToken: String,
+                 apiBaseUrl: String?,
+                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let baseString = apiBaseUrl ?? "https://api.usesense.ai"
+        guard let baseURL = URL(string: baseString) else {
+            reject("unknown", "Invalid apiBaseUrl: \(baseString)", nil)
+            return
+        }
+        DispatchQueue.main.async {
+            guard let presenter = Self.topViewController() else {
+                reject("unknown", "No view controller to present from", nil)
+                return
+            }
+            UseSenseFlows.run(
+                flowRunId: flowRunId,
+                sdkToken: sdkToken,
+                apiBaseURL: baseURL,
+                from: presenter
+            ) { runResult in
+                switch runResult {
+                case .success(let r):
+                    resolve([
+                        "flowRunId": r.flowRunId,
+                        "state": Self.stateWire(r.state),
+                        "outcome": r.outcome.map(Self.outcomeWire) as Any,
+                    ])
+                case .failure(let e):
+                    reject(e.code.rawValue, e.message, nil)
+                }
+            }
+        }
+    }
+
+    // MARK: - Helpers (mirror UseSenseFlowsBridge in the Flutter plugin)
+
+    private static func stateWire(_ state: FlowRunState) -> String {
+        switch state {
+        case .pending: return "pending"
+        case .inProgress: return "in_progress"
+        case .stalled: return "stalled"
+        case .awaitingReview: return "awaiting_review"
+        case .completed: return "completed"
+        case .errored: return "errored"
+        case .abandoned: return "abandoned"
+        case .cancelled: return "cancelled"
+        }
+    }
+
+    private static func outcomeWire(_ outcome: FlowOutcome) -> String {
+        switch outcome {
+        case .approve: return "APPROVE"
+        case .reject: return "REJECT"
+        case .manualReview: return "MANUAL_REVIEW"
+        }
+    }
+
+    /// Find the top-most view controller to present from. Mirrors the
+    /// pattern used elsewhere in the bridge layer; works across UIKit +
+    /// SceneDelegate apps and falls back to `keyWindow.rootViewController`.
+    private static func topViewController() -> UIViewController? {
+        var root: UIViewController?
+        if #available(iOS 13.0, *) {
+            for scene in UIApplication.shared.connectedScenes {
+                guard let windowScene = scene as? UIWindowScene else { continue }
+                if let keyWindow = windowScene.windows.first(where: { $0.isKeyWindow }) ?? windowScene.windows.first {
+                    root = keyWindow.rootViewController
+                    break
+                }
+            }
+        }
+        if root == nil {
+            root = UIApplication.shared.keyWindow?.rootViewController
+        }
+        var current = root
+        while let presented = current?.presentedViewController {
+            current = presented
+        }
+        return current
+    }
+}

package/ios/UseSenseModule.m

@@ -20,6 +20,11 @@ RCT_EXTERN_METHOD(subscribeToEvents)
 
 RCT_EXTERN_METHOD(unsubscribeFromEvents)
 
+// LiveSense v4 passthrough (R-1)
+RCT_EXTERN_METHOD(startV4Verification:(NSDictionary *)request
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getSdkVersion)
 
 @end

package/ios/UseSenseModule.swift

@@ -86,11 +86,22 @@ class UseSenseModule: RCTEventEmitter {
         let apiEndpoint = (config["apiEndpoint"] as? String)
             ?? UseSenseConfig.defaultEndpoint
 
+        // v4.2: Optional on-device antispoof classifier flag (defaults to false;
+        // watchtower runs the classifier server-side when off).
+        let antispoofOnDeviceEnabled = (config["antispoofOnDeviceEnabled"] as? Bool) ?? false
+        // LiveSense v4 capture flow opt-in (zoom phase + frame phase tags).
+        let liveSenseV4Enabled = (config["liveSenseV4Enabled"] as? Bool) ?? false
+        let sdkOptions = SDKOptions(
+            antispoofOnDeviceEnabled: antispoofOnDeviceEnabled,
+            liveSenseV4Enabled: liveSenseV4Enabled
+        )
+
         let sdkConfig = UseSenseConfig(
             apiEndpoint: apiEndpoint,
             apiKey: apiKey,
             environment: environment,
-            branding: brandingConfig
+            branding: brandingConfig,
+            options: sdkOptions
         )
 
         // Create (or replace) the client. If a previous client was
@@ -178,6 +189,49 @@ class UseSenseModule: RCTEventEmitter {
         }
     }
 
+    // MARK: - LiveSense v4 (R-1)
+
+    /// Passthrough for the v4 zoom-motion capture. Resolves with the
+    /// opaque verdict; sub-scores never cross the bridge.
+    @objc
+    func startV4Verification(_ request: NSDictionary,
+                             resolver resolve: @escaping RCTPromiseResolveBlock,
+                             rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let sessionIdStr = request["sessionId"] as? String,
+              let sessionId = UUID(uuidString: sessionIdStr),
+              let sessionToken = request["sessionToken"] as? String,
+              let nonce = request["nonce"] as? String,
+              let apiBaseStr = request["apiBaseUrl"] as? String,
+              let apiBaseURL = URL(string: apiBaseStr) else {
+            reject("INVALID_REQUEST", "sessionId, sessionToken, nonce, apiBaseUrl required", nil)
+            return
+        }
+        let environment = request["environment"] as? String ?? "production"
+        let displayName = request["displayName"] as? String
+        let client = UseSense(config: UseSenseConfig(apiKey: "v4-bridge"))
+        let config = LiveSenseV4Config(
+            sessionId: sessionId,
+            sessionToken: sessionToken,
+            nonce: nonce,
+            apiBaseURL: apiBaseURL,
+            environment: environment,
+            brandPrimaryColor: nil,
+            displayName: displayName
+        )
+
+        let delegate = V4BridgeDelegate(resolve: resolve, reject: reject, emit: { [weak self] body in
+            guard let self = self, self.hasListeners else { return }
+            DispatchQueue.main.async { self.sendEvent(withName: "UseSenseEvent", body: body) }
+        })
+        let session = client.startV4Session(config: config, delegate: delegate)
+        delegate.retain(session)
+        do {
+            try session.start()
+        } catch {
+            reject("V4_FAILED", error.localizedDescription, error)
+        }
+    }
+
     @objc
     func reset(_ resolve: @escaping RCTPromiseResolveBlock,
                rejecter reject: @escaping RCTPromiseRejectBlock) {

package/ios/V4BridgeDelegate.swift

@@ -0,0 +1,62 @@
+//
+//  V4BridgeDelegate.swift
+//  react-native-usesense
+//
+//  Phase 1 ticket R-1. Adapter that translates LiveSenseV4Delegate
+//  callbacks into React Native promise resolve/reject + bridge events.
+//
+
+import Foundation
+import UseSenseSDK
+
+final class V4BridgeDelegate: NSObject, LiveSenseV4Delegate {
+    private let resolve: (Any?) -> Void
+    private let reject: (String, String?, Error?) -> Void
+    private let emit: ([String: Any]) -> Void
+    private var strongSession: LiveSenseV4Session?
+    private var didFinish = false
+
+    init(resolve: @escaping (Any?) -> Void,
+         reject: @escaping (String, String?, Error?) -> Void,
+         emit: @escaping ([String: Any]) -> Void) {
+        self.resolve = resolve
+        self.reject = reject
+        self.emit = emit
+    }
+
+    func retain(_ session: LiveSenseV4Session) {
+        strongSession = session
+    }
+
+    func sessionDidComplete(verdict: V4Verdict) {
+        if didFinish { return }
+        didFinish = true
+        let body: [String: Any?] = [
+            "session_id": verdict.sessionId,
+            "verdict": verdict.verdict.rawValue,
+            "confidence": verdict.confidence.rawValue,
+            "assurance_level_achieved": verdict.assuranceLevelAchieved,
+            "capture_channel": "rn",
+            "match_sense_embedding_id": verdict.matchSenseEmbeddingId,
+            "timestamp": verdict.timestamp
+        ]
+        resolve(body.compactMapValues { $0 })
+        strongSession = nil
+    }
+
+    func sessionDidFail(error: Error) {
+        if didFinish { return }
+        didFinish = true
+        reject("V4_FAILED", error.localizedDescription, error)
+        strongSession = nil
+    }
+
+    func sessionPhaseDidChange(phase: LiveSenseV4Phase) {
+        let body: [String: Any] = [
+            "type": "V4_PHASE_CHANGE",
+            "phase": phase.rawValue,
+            "timestamp": Int64(Date().timeIntervalSince1970 * 1000)
+        ]
+        emit(body)
+    }
+}

package/lib/commonjs/flows.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseSenseFlows = exports.FlowError = void 0;
+var _reactNative = require("react-native");
+/**
+ * React Native wrapper for the UseSense Flows runner.
+ *
+ * Coexists with the existing Sessions API (`UseSense.startSession`, etc.);
+ * this is a parallel surface, not a replacement. See `guides/flows/sessions-vs-flows`
+ * in the API docs for when to use which.
+ *
+ * Usage:
+ *
+ *   import { UseSenseFlows, FlowError } from 'react-native-usesense';
+ *
+ *   try {
+ *     const result = await UseSenseFlows.runFlow({ flowRunId, sdkToken });
+ *     console.log(result.outcome); // 'APPROVE' | 'REJECT' | 'MANUAL_REVIEW' | null
+ *   } catch (e) {
+ *     if (e instanceof FlowError) {
+ *       // e.code: 'token_expired' | 'token_invalid' | ...
+ *     }
+ *   }
+ */
+
+const LINKING_ERROR = `react-native-usesense (flows): the native module could not be found.\n\n` + _reactNative.Platform.select({
+  ios: `iOS: run \`cd ios && pod install\` and rebuild the app.`,
+  android: `Android: rebuild the app after installing the package.`,
+  default: ''
+});
+
+// Lazy lookup so this module doesn't throw at import time on platforms that
+// haven't been re-linked yet. The Sessions module mirrors this pattern.
+function nativeModule() {
+  const m = _reactNative.NativeModules.UseSenseFlowsModule;
+  if (!m) throw new Error(LINKING_ERROR);
+  return m;
+}
+
+/**
+ * Server-driven flow run state. Host apps see only the terminal ones via
+ * `FlowRunResult`; intermediate states drive the runner internally.
+ */
+
+/** Terminal outcome of a flow run. */
+
+/**
+ * Uniform error taxonomy across every SDK. See `guides/flows/errors` in the
+ * API docs for per-code recovery patterns.
+ */
+
+const FLOW_ERROR_CODES = ['token_expired', 'token_invalid', 'network_unavailable', 'permission_denied', 'provider_unavailable', 'cancelled', 'unsupported_action', 'invalid_input', 'unknown'];
+function normaliseCode(code) {
+  return typeof code === 'string' && FLOW_ERROR_CODES.includes(code) ? code : 'unknown';
+}
+
+/** Result returned to the host app's `runFlow` promise on terminal state. */
+
+/**
+ * Typed error thrown by `runFlow` when the native runner reports a failure.
+ * Mirrors the web / iOS / Android / Flutter SDKs so host apps catch one
+ * taxonomy regardless of platform.
+ */
+class FlowError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'FlowError';
+    this.code = code;
+  }
+}
+
+/** Options for `UseSenseFlows.runFlow`. */
+exports.FlowError = FlowError;
+/**
+ * Public entry point for the Flows runner. Sessions APIs are untouched;
+ * this is a parallel namespace.
+ */
+const UseSenseFlows = exports.UseSenseFlows = {
+  /**
+   * Run an operator-authored Flow inside the host app. Resolves with a
+   * [FlowRunResult] when the run reaches a terminal state (completed,
+   * cancelled, errored, abandoned). Rejects with a [FlowError] on transport
+   * / token / unsupported-action faults.
+   */
+  async runFlow(options) {
+    try {
+      const native = await nativeModule().runFlow(options.flowRunId, options.sdkToken, options.apiBaseUrl ?? null);
+      return {
+        flowRunId: native.flowRunId,
+        state: native.state,
+        outcome: native.outcome
+      };
+    } catch (e) {
+      // RN bridge errors are surfaced as `Error` with `.code` and `.message`
+      // properties when the native side calls `reject(code, message, null)`.
+      const code = normaliseCode(e.code);
+      const message = e.message ?? 'Flow failed';
+      throw new FlowError(code, message);
+    }
+  }
+};
+//# sourceMappingURL=flows.js.map

package/lib/commonjs/flows.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","LINKING_ERROR","Platform","select","ios","android","default","nativeModule","m","NativeModules","UseSenseFlowsModule","Error","FLOW_ERROR_CODES","normaliseCode","code","includes","FlowError","constructor","message","name","exports","UseSenseFlows","runFlow","options","native","flowRunId","sdkToken","apiBaseUrl","state","outcome","e"],"sourceRoot":"../../src","sources":["flows.ts"],"mappings":";;;;;;AAqBA,IAAAA,YAAA,GAAAC,OAAA;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,MAAMC,aAAa,GACjB,0EAA0E,GAC1EC,qBAAQ,CAACC,MAAM,CAAC;EACdC,GAAG,EAAE,yDAAyD;EAC9DC,OAAO,EAAE,wDAAwD;EACjEC,OAAO,EAAE;AACX,CAAC,CAAC;;AAEJ;AACA;AACA,SAASC,YAAYA,CAAA,EAAG;EACtB,MAAMC,CAAC,GAAGC,0BAAa,CAACC,mBAAmB;EAC3C,IAAI,CAACF,CAAC,EAAE,MAAM,IAAIG,KAAK,CAACV,aAAa,CAAC;EACtC,OAAOO,CAAC;AACV;;AAEA;AACA;AACA;AACA;;AAWA;;AAGA;AACA;AACA;AACA;;AAeA,MAAMI,gBAA0C,GAAG,CACjD,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,WAAW,EACX,oBAAoB,EACpB,eAAe,EACf,SAAS,CACD;AAEV,SAASC,aAAaA,CAACC,IAAa,EAAiB;EACnD,OAAO,OAAOA,IAAI,KAAK,QAAQ,IAAKF,gBAAgB,CAAuBG,QAAQ,CAACD,IAAI,CAAC,GACpFA,IAAI,GACL,SAAS;AACf;;AAEA;;AAaA;AACA;AACA;AACA;AACA;AACO,MAAME,SAAS,SAASL,KAAK,CAAC;EAEnCM,WAAWA,CAACH,IAAmB,EAAEI,OAAe,EAAE;IAChD,KAAK,CAACA,OAAO,CAAC;IACd,IAAI,CAACC,IAAI,GAAG,WAAW;IACvB,IAAI,CAACL,IAAI,GAAGA,IAAI;EAClB;AACF;;AAEA;AAAAM,OAAA,CAAAJ,SAAA,GAAAA,SAAA;AAQA;AACA;AACA;AACA;AACO,MAAMK,aAAa,GAAAD,OAAA,CAAAC,aAAA,GAAG;EAC3B;AACF;AACA;AACA;AACA;AACA;EACE,MAAMC,OAAOA,CAACC,OAAuB,EAA0B;IAC7D,IAAI;MACF,MAAMC,MAAM,GAAG,MAAMjB,YAAY,CAAC,CAAC,CAACe,OAAO,CACzCC,OAAO,CAACE,SAAS,EACjBF,OAAO,CAACG,QAAQ,EAChBH,OAAO,CAACI,UAAU,IAAI,IACxB,CAAC;MACD,OAAO;QACLF,SAAS,EAAED,MAAM,CAACC,SAAS;QAC3BG,KAAK,EAAEJ,MAAM,CAACI,KAAK;QACnBC,OAAO,EAAEL,MAAM,CAACK;MAClB,CAAC;IACH,CAAC,CAAC,OAAOC,CAAC,EAAE;MACV;MACA;MACA,MAAMhB,IAAI,GAAGD,aAAa,CAAEiB,CAAC,CAAuBhB,IAAI,CAAC;MACzD,MAAMI,OAAO,GAAIY,CAAC,CAA0BZ,OAAO,IAAI,aAAa;MACpE,MAAM,IAAIF,SAAS,CAACF,IAAI,EAAEI,OAAO,CAAC;IACpC;EACF;AACF,CAAC","ignoreList":[]}