flowstudio-rn 0.0.1-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,160 @@
+# flowstudio-rn
+
+React Native SDK for Bureau Flow Studio. It runs Flow Studio identity and verification journeys inside React Native and Expo apps, on top of Bureau's native FlowStudio SDK.
+
+> **Alpha:** Android only for now. iOS support is coming. On iOS, `initialize()` and `start()` throw `FlowStudio: ios is not supported yet`, and `isInitialized()` returns `false`.
+
+## Installation
+
+```sh
+npm install flowstudio-rn@alpha
+```
+
+Expo projects can use `npx expo install flowstudio-rn@alpha`.
+
+### Android setup
+
+The native FlowStudio SDK is downloaded from Bureau's Maven repository (`https://packages.bureau.id/api/packages/Bureau/maven`). The SDK registers this repository for your app automatically:
+
+- **Expo (prebuild / CNG):** add the config plugin to `app.json`, then run `npx expo prebuild` (or `npx expo run:android`):
+
+  ```json
+  {
+    "expo": {
+      "plugins": ["flowstudio-rn"]
+    }
+  }
+  ```
+
+- **Bare React Native:** nothing to add. The library's Gradle file registers the repository for all projects.
+
+If your `settings.gradle` sets `repositoriesMode` to `FAIL_ON_PROJECT_REPOS`, add the repository yourself under `dependencyResolutionManagement { repositories { ... } }`:
+
+```groovy
+maven { url "https://packages.bureau.id/api/packages/Bureau/maven" }
+```
+
+**Requirements:** `minSdkVersion` 24 or higher. The SDK declares the `CAMERA` permission, which it uses for document capture and liveness.
+
+## API Reference
+
+```typescript
+import { FlowStudio } from 'flowstudio-rn';
+```
+
+### `FlowStudio.initialize(config)`
+
+Initializes the SDK. Call it before `start()`, for example once you have created the execution on your backend.
+
+**Parameters (`FlowStudioConfig`):**
+
+- `credentialId` (string): your Bureau credential ID
+- `deviceCredentialId` (string): credential ID used for device intelligence
+- `executionId` (string): ID of the Flow Studio execution to run
+- `environment` (string, optional): `'PROD'`, `'STAGING'` or `'DEV'` (default: `'PROD'`)
+- `enableLogging` (boolean, optional): enables SDK logs (default: `false`)
+
+It throws an `Error` if a required field is missing or `environment` is invalid.
+
+### `FlowStudio.start()`
+
+Opens the Flow Studio journey. The promise resolves when the journey ends.
+
+**Returns:** `Promise<FlowStudioResult>`
+
+```typescript
+type FlowStudioResult =
+  | { type: 'result'; response: ExecutionResponse } // journey finished
+  | { type: 'exit' }; // user left the journey without a result
+
+interface ExecutionResponse {
+  executionId: string;
+  merchantId: string;
+  requestId: string;
+  executionStatus: string; // 'PROCESSING' | 'AWAITING' | 'COMPLETED' | 'TIMEOUT' | 'ERROR'
+  currentState: Record<string, unknown>;
+  createdAt: number; // epoch timestamp
+  updatedAt: number; // epoch timestamp
+}
+```
+
+Only one journey can run at a time. `start()` can be called again once the previous call has resolved.
+
+### `FlowStudio.isInitialized()`
+
+**Returns:** `boolean`, which is `true` once `initialize()` has succeeded.
+
+## Usage Example
+
+```typescript
+import { FlowStudio } from 'flowstudio-rn';
+
+async function runVerification(executionId: string) {
+  FlowStudio.initialize({
+    credentialId: 'your-credential-id',
+    deviceCredentialId: 'your-device-credential-id',
+    executionId,
+    environment: 'STAGING', // 'PROD' for live
+  });
+
+  try {
+    const result = await FlowStudio.start();
+
+    if (result.type === 'result') {
+      console.log('Status:', result.response.executionStatus);
+    } else {
+      console.log('User exited the journey');
+    }
+  } catch (error) {
+    console.error('FlowStudio failed:', error);
+  }
+}
+```
+
+## Errors
+
+`initialize()` and `start()` throw or reject with an `Error`. Errors that come from the native side carry a `code`:
+
+| Code | Meaning |
+|---|---|
+| `ERR_ALREADY_STARTED` | `start()` was called while a journey is already running |
+| `ERR_NO_CONTEXT` | No Activity was available to open the journey |
+| `ERR_START_FAILED` | The native SDK failed to start the journey (see `message`) |
+| `ERR_INVALID_ENVIRONMENT` | Unknown `environment` value |
+| `ERR_MODULE_DESTROYED` | The app reloaded or the React context was torn down during a journey |
+
+## Notes
+
+- **Execution ID:** create a new execution for each journey. Execution IDs are single use.
+- **Environment:** use `'STAGING'` for testing and `'PROD'` for live traffic. Credentials are environment specific.
+- **Exit handling:** a `{ type: 'exit' }` result is not an error. It means the user closed the journey.
+
+## Example App
+
+The `example/` directory contains an Expo app that initializes the SDK and starts a journey. To run it on a connected Android device:
+
+```sh
+npm install
+cd example && npm install && npx expo run:android
+```
+
+## Releasing (maintainers)
+
+Releases are published from GitHub Actions ([`.github/workflows/release.yml`](.github/workflows/release.yml)) when a version tag (`1.2.3`, `1.2.3-alpha`, or the same with a leading `v`) is pushed to a commit on `main`:
+
+```sh
+git tag 0.0.1-alpha
+git push origin 0.0.1-alpha
+```
+
+You can also create the tag from the GitHub UI under **Releases → Draft a new release**.
+
+- The tag sets the published version. Keep `package.json` in sync through a PR before tagging.
+- Prerelease tags (`-alpha`, `-beta`, `-rc`, ...) publish to the matching npm dist-tag. They never become `latest`.
+- The workflow publishes to npm and creates a GitHub Release with generated notes and the package tarball.
+- **Actions → Release → Run workflow** does a dry run: the same checks and build, with nothing published.
+- The workflow needs an `NPM_TOKEN` repository secret: an npm automation token for the publishing account.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,41 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+def bureauMavenUrl = "https://packages.bureau.id/api/packages/Bureau/maven"
+
+// Make the Bureau Maven repository available to the host app and all its subprojects, so
+// clients (Expo or bare React Native) do not need to add it to their android/build.gradle.
+// The Expo config plugin (app.plugin.js) adds it too, for apps that regenerate android/.
+rootProject.allprojects {
+  repositories {
+    maven { url bureauMavenUrl }
+  }
+}
+
+def packageJson = new groovy.json.JsonSlurper().parse(file("../package.json"))
+
+group = 'id.bureau.flowstudio.rn'
+version = packageJson.version
+
+repositories {
+  google()
+  mavenCentral()
+  maven { url bureauMavenUrl }
+}
+
+android {
+  namespace "id.bureau.flowstudio.rn"
+  defaultConfig {
+    versionCode 1
+    versionName packageJson.version
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+dependencies {
+  implementation 'id.bureau:flowstudio:0.0.3-alpha'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/id/bureau/flowstudio/rn/FlowStudioReactNativeModule.kt

@@ -0,0 +1,173 @@
+package id.bureau.flowstudio.rn
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import com.bureau.flowstudio.FlowStudio
+import com.bureau.flowstudio.FlowStudioCallback
+import com.bureau.flowstudio.FlowStudioConfig
+import com.bureau.flowstudio.FlowStudioEnvironment
+import com.bureau.flowstudio.ui.FlowStudioActivity
+import com.bureau.network.data.model.network.ExecutionResponse
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.functions.Queues
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Config received from JS. Mirrors `Required<FlowStudioConfig>` in `src/FlowStudio.ts`;
+ * defaults are already applied on the JS side.
+ */
+class FlowStudioConfigRecord : Record {
+  @Field val credentialId: String = ""
+  @Field val deviceCredentialId: String = ""
+  @Field val executionId: String = ""
+  @Field val environment: String = "PROD"
+  @Field val enableLogging: Boolean = false
+}
+
+/**
+ * Android implementation of the bridge contract defined in `src/FlowStudio.ts`
+ * (`FlowStudioNativeContract`). Function names must match it exactly.
+ */
+class FlowStudioReactNativeModule : Module() {
+  // Promise of the flow currently running, if any. Resolved exactly once.
+  private val pendingStart = AtomicReference<Promise?>(null)
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private var flowActivityWatcher: Application.ActivityLifecycleCallbacks? = null
+
+  private fun settle(block: (Promise) -> Unit) {
+    pendingStart.getAndSet(null)?.let { promise ->
+      stopWatchingFlowActivity()
+      block(promise)
+    }
+  }
+
+  /**
+   * The SDK does not invoke FlowStudioCallback when the user backs out of the flow.
+   * Resolve as `exit` once FlowStudioActivity is finished for good, unless the SDK
+   * reports a result first (the delay gives its callback time to arrive).
+   */
+  private fun watchFlowActivity(application: Application) {
+    stopWatchingFlowActivity()
+    val watcher = object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityDestroyed(activity: Activity) {
+        if (activity is FlowStudioActivity && activity.isFinishing) {
+          mainHandler.postDelayed({ settle { it.resolve(mapOf("type" to "exit")) } }, EXIT_FALLBACK_DELAY_MS)
+        }
+      }
+
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+      override fun onActivityStarted(activity: Activity) = Unit
+      override fun onActivityResumed(activity: Activity) = Unit
+      override fun onActivityPaused(activity: Activity) = Unit
+      override fun onActivityStopped(activity: Activity) = Unit
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+    }
+    application.registerActivityLifecycleCallbacks(watcher)
+    flowActivityWatcher = watcher
+  }
+
+  private fun stopWatchingFlowActivity() {
+    val watcher = flowActivityWatcher ?: return
+    flowActivityWatcher = null
+    (appContext.reactContext?.applicationContext as? Application)
+      ?.unregisterActivityLifecycleCallbacks(watcher)
+  }
+
+  override fun definition() = ModuleDefinition {  
+    Name("FlowStudioReactNative")
+
+    // initialize(config: Required<FlowStudioConfig>): void
+    Function("initialize") { config: FlowStudioConfigRecord ->
+      val application = appContext.reactContext?.applicationContext as? Application
+        ?: throw Exceptions.ReactContextLost()
+
+      val environment = FlowStudioEnvironment.entries.find { it.name == config.environment }
+        ?: throw CodedException("ERR_INVALID_ENVIRONMENT", "Unknown environment: ${config.environment}", null)
+
+      FlowStudio.initialize(
+        application,
+        FlowStudioConfig(
+          config.enableLogging,
+          config.credentialId,
+          environment,
+          config.deviceCredentialId,
+          config.executionId,
+        ),
+      )
+    }
+
+    // start(): Promise<FlowStudioResult>
+    // FlowStudio.start() must be called on the main thread.
+    AsyncFunction("start") { promise: Promise ->
+      if (!FlowStudio.isInitialized()) {
+        promise.reject("ERR_NOT_INITIALIZED", "Call initialize() before start()", null)
+        return@AsyncFunction
+      }
+      if (!pendingStart.compareAndSet(null, promise)) {
+        promise.reject("ERR_ALREADY_STARTED", "A FlowStudio flow is already in progress", null)
+        return@AsyncFunction
+      }
+
+      val context = appContext.currentActivity ?: appContext.reactContext
+      if (context == null) {
+        pendingStart.set(null)
+        promise.reject("ERR_NO_CONTEXT", "No Activity or React context available to start FlowStudio", null)
+        return@AsyncFunction
+      }
+
+      (context.applicationContext as? Application)?.let(::watchFlowActivity)
+
+      try {
+        FlowStudio.start(context, object : FlowStudioCallback {
+          override fun onResult(response: ExecutionResponse) {
+            settle { it.resolve(mapOf("type" to "result", "response" to response.toMap())) }
+          }
+
+          override fun onExit() {
+            settle { it.resolve(mapOf("type" to "exit")) }
+          }
+        })
+      } catch (e: Exception) {
+        settle { it.reject("ERR_START_FAILED", e.message ?: "Failed to start FlowStudio", e) }
+      }
+    }.runOnQueue(Queues.MAIN)
+
+    // isInitialized(): boolean
+    Function("isInitialized") {
+      FlowStudio.isInitialized()
+    }
+
+    OnDestroy {
+      mainHandler.removeCallbacksAndMessages(null)
+      settle { it.reject("ERR_MODULE_DESTROYED", "FlowStudio module was destroyed before the flow finished", null) }
+    }
+  }
+
+  private companion object {
+    const val EXIT_FALLBACK_DELAY_MS = 500L
+  }
+}
+
+private fun ExecutionResponse.toMap(): Map<String, Any> = mapOf(
+  "executionId" to executionId,
+  "merchantId" to merchantId,
+  "requestId" to requestId,
+  "executionStatus" to executionStatus.name,
+  "currentState" to mapOf(
+    "type" to currentState.type.name,
+    "popCurrent" to currentState.popCurrent,
+    "screenType" to currentState.screenType.name,
+    "screenId" to currentState.screenId,
+  ),
+  "createdAt" to createdAt,
+  "updatedAt" to updatedAt,
+)

package/app.plugin.js

@@ -0,0 +1,2 @@
+// Expo config plugin entry point, resolved when an app lists "flowstudio-rn" in `plugins`.
+module.exports = require('./plugin/build');

package/build/FlowStudio.d.ts

@@ -0,0 +1,21 @@
+import { FlowStudioConfig, FlowStudioResult } from './FlowStudioReactNative.types';
+/**
+ * Initializes the Flow Studio SDK. Must be called before `start()`.
+ */
+declare function initialize(config: FlowStudioConfig): void;
+/**
+ * Launches the Flow Studio flow. Resolves when the flow finishes
+ * (`type: 'result'`) or the user exits it (`type: 'exit'`).
+ */
+declare function start(): Promise<FlowStudioResult>;
+/**
+ * Returns whether `initialize()` has completed successfully.
+ */
+declare function isInitialized(): boolean;
+export declare const FlowStudio: {
+    initialize: typeof initialize;
+    start: typeof start;
+    isInitialized: typeof isInitialized;
+};
+export {};
+//# sourceMappingURL=FlowStudio.d.ts.map

package/build/FlowStudio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudio.d.ts","sourceRoot":"","sources":["../src/FlowStudio.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,gBAAgB,EAEhB,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AAsBvC;;GAEG;AACH,iBAAS,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAoBlD;AAED;;;GAGG;AACH,iBAAe,KAAK,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAMhD;AAED;;GAEG;AACH,iBAAS,aAAa,IAAI,OAAO,CAEhC;AAED,eAAO,MAAM,UAAU;;;;CAItB,CAAC"}

package/build/FlowStudio.js

@@ -0,0 +1,58 @@
+import { Platform } from 'react-native';
+import native from './FlowStudioReactNativeModule';
+const ENVIRONMENTS = ['PROD', 'STAGING', 'DEV'];
+// Only the Android native module is implemented so far.
+const isSupportedPlatform = Platform.OS === 'android';
+function requireSupportedPlatform() {
+    if (!isSupportedPlatform) {
+        throw new Error(`FlowStudio: ${Platform.OS} is not supported yet (Android only in this release)`);
+    }
+}
+function requireNonEmpty(value, name) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`FlowStudio: \`${name}\` is required and must be a non-empty string`);
+    }
+}
+/**
+ * Initializes the Flow Studio SDK. Must be called before `start()`.
+ */
+function initialize(config) {
+    requireSupportedPlatform();
+    requireNonEmpty(config?.credentialId, 'credentialId');
+    requireNonEmpty(config.deviceCredentialId, 'deviceCredentialId');
+    requireNonEmpty(config.executionId, 'executionId');
+    const environment = config.environment ?? 'PROD';
+    if (!ENVIRONMENTS.includes(environment)) {
+        throw new Error(`FlowStudio: \`environment\` must be one of ${ENVIRONMENTS.join(', ')}, got "${environment}"`);
+    }
+    native.initialize({
+        credentialId: config.credentialId,
+        deviceCredentialId: config.deviceCredentialId,
+        executionId: config.executionId,
+        environment,
+        enableLogging: config.enableLogging ?? false,
+    });
+}
+/**
+ * Launches the Flow Studio flow. Resolves when the flow finishes
+ * (`type: 'result'`) or the user exits it (`type: 'exit'`).
+ */
+async function start() {
+    requireSupportedPlatform();
+    if (!native.isInitialized()) {
+        throw new Error('FlowStudio: call `initialize()` before `start()`');
+    }
+    return native.start();
+}
+/**
+ * Returns whether `initialize()` has completed successfully.
+ */
+function isInitialized() {
+    return isSupportedPlatform && native.isInitialized();
+}
+export const FlowStudio = {
+    initialize,
+    start,
+    isInitialized,
+};
+//# sourceMappingURL=FlowStudio.js.map

package/build/FlowStudio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudio.js","sourceRoot":"","sources":["../src/FlowStudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAOxC,OAAO,MAAM,MAAM,+BAA+B,CAAC;AAEnD,MAAM,YAAY,GAAqC,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;AAElF,wDAAwD;AACxD,MAAM,mBAAmB,GAAG,QAAQ,CAAC,EAAE,KAAK,SAAS,CAAC;AAEtD,SAAS,wBAAwB;IAC/B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,eAAe,QAAQ,CAAC,EAAE,sDAAsD,CACjF,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,eAAe,CAAC,KAAc,EAAE,IAAY;IACnD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,iBAAiB,IAAI,+CAA+C,CAAC,CAAC;IACxF,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,UAAU,CAAC,MAAwB;IAC1C,wBAAwB,EAAE,CAAC;IAC3B,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;IACtD,eAAe,CAAC,MAAM,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC;IACjE,eAAe,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IAEnD,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC;IACjD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CACb,8CAA8C,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,WAAW,GAAG,CAC9F,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,UAAU,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC,YAAY;QACjC,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;QAC7C,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,WAAW;QACX,aAAa,EAAE,MAAM,CAAC,aAAa,IAAI,KAAK;KAC7C,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,KAAK;IAClB,wBAAwB,EAAE,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC;AACxB,CAAC;AAED;;GAEG;AACH,SAAS,aAAa;IACpB,OAAO,mBAAmB,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;AACvD,CAAC;AAED,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,UAAU;IACV,KAAK;IACL,aAAa;CACd,CAAC","sourcesContent":["import { Platform } from 'react-native';\n\nimport {\n  FlowStudioConfig,\n  FlowStudioEnvironment,\n  FlowStudioResult,\n} from './FlowStudioReactNative.types';\nimport native from './FlowStudioReactNativeModule';\n\nconst ENVIRONMENTS: readonly FlowStudioEnvironment[] = ['PROD', 'STAGING', 'DEV'];\n\n// Only the Android native module is implemented so far.\nconst isSupportedPlatform = Platform.OS === 'android';\n\nfunction requireSupportedPlatform(): void {\n  if (!isSupportedPlatform) {\n    throw new Error(\n      `FlowStudio: ${Platform.OS} is not supported yet (Android only in this release)`\n    );\n  }\n}\n\nfunction requireNonEmpty(value: unknown, name: string): void {\n  if (typeof value !== 'string' || value.trim() === '') {\n    throw new Error(`FlowStudio: \\`${name}\\` is required and must be a non-empty string`);\n  }\n}\n\n/**\n * Initializes the Flow Studio SDK. Must be called before `start()`.\n */\nfunction initialize(config: FlowStudioConfig): void {\n  requireSupportedPlatform();\n  requireNonEmpty(config?.credentialId, 'credentialId');\n  requireNonEmpty(config.deviceCredentialId, 'deviceCredentialId');\n  requireNonEmpty(config.executionId, 'executionId');\n\n  const environment = config.environment ?? 'PROD';\n  if (!ENVIRONMENTS.includes(environment)) {\n    throw new Error(\n      `FlowStudio: \\`environment\\` must be one of ${ENVIRONMENTS.join(', ')}, got \"${environment}\"`\n    );\n  }\n\n  native.initialize({\n    credentialId: config.credentialId,\n    deviceCredentialId: config.deviceCredentialId,\n    executionId: config.executionId,\n    environment,\n    enableLogging: config.enableLogging ?? false,\n  });\n}\n\n/**\n * Launches the Flow Studio flow. Resolves when the flow finishes\n * (`type: 'result'`) or the user exits it (`type: 'exit'`).\n */\nasync function start(): Promise<FlowStudioResult> {\n  requireSupportedPlatform();\n  if (!native.isInitialized()) {\n    throw new Error('FlowStudio: call `initialize()` before `start()`');\n  }\n  return native.start();\n}\n\n/**\n * Returns whether `initialize()` has completed successfully.\n */\nfunction isInitialized(): boolean {\n  return isSupportedPlatform && native.isInitialized();\n}\n\nexport const FlowStudio = {\n  initialize,\n  start,\n  isInitialized,\n};\n"]}

package/build/FlowStudioReactNative.types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Backend environment the Flow Studio SDK connects to.
+ * Mirrors native `FlowStudioEnvironment` (PROD | STAGING | DEV).
+ */
+export type FlowStudioEnvironment = 'PROD' | 'STAGING' | 'DEV';
+/**
+ * Configuration passed to `FlowStudio.initialize()`.
+ * Mirrors native `FlowStudioConfig`.
+ */
+export interface FlowStudioConfig {
+    /** Credential ID issued by Bureau. */
+    credentialId: string;
+    /** Credential ID used for device intelligence. */
+    deviceCredentialId: string;
+    /** ID of the flow execution to run. */
+    executionId: string;
+    /** Defaults to `'PROD'`. */
+    environment?: FlowStudioEnvironment;
+    /** Enables SDK logging. Defaults to `false`. */
+    enableLogging?: boolean;
+}
+/**
+ * Result of a completed flow execution.
+ * Mirrors native `ExecutionResponse`.
+ */
+export interface ExecutionResponse {
+    executionId: string;
+    merchantId: string;
+    requestId: string;
+    executionStatus: string;
+    currentState: Record<string, unknown>;
+    /** Epoch timestamp. */
+    createdAt: number;
+    /** Epoch timestamp. */
+    updatedAt: number;
+}
+/**
+ * Outcome of `FlowStudio.start()`. Mirrors native `FlowStudioCallback`:
+ * - `result` → `onResult(response)`
+ * - `exit`   → `onExit()` (user left the flow without a result)
+ */
+export type FlowStudioResult = {
+    type: 'result';
+    response: ExecutionResponse;
+} | {
+    type: 'exit';
+};
+//# sourceMappingURL=FlowStudioReactNative.types.d.ts.map

package/build/FlowStudioReactNative.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudioReactNative.types.d.ts","sourceRoot":"","sources":["../src/FlowStudioReactNative.types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,gDAAgD;IAChD,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,uBAAuB;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/build/FlowStudioReactNative.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FlowStudioReactNative.types.js.map

package/build/FlowStudioReactNative.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudioReactNative.types.js","sourceRoot":"","sources":["../src/FlowStudioReactNative.types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Backend environment the Flow Studio SDK connects to.\n * Mirrors native `FlowStudioEnvironment` (PROD | STAGING | DEV).\n */\nexport type FlowStudioEnvironment = 'PROD' | 'STAGING' | 'DEV';\n\n/**\n * Configuration passed to `FlowStudio.initialize()`.\n * Mirrors native `FlowStudioConfig`.\n */\nexport interface FlowStudioConfig {\n  /** Credential ID issued by Bureau. */\n  credentialId: string;\n  /** Credential ID used for device intelligence. */\n  deviceCredentialId: string;\n  /** ID of the flow execution to run. */\n  executionId: string;\n  /** Defaults to `'PROD'`. */\n  environment?: FlowStudioEnvironment;\n  /** Enables SDK logging. Defaults to `false`. */\n  enableLogging?: boolean;\n}\n\n/**\n * Result of a completed flow execution.\n * Mirrors native `ExecutionResponse`.\n */\nexport interface ExecutionResponse {\n  executionId: string;\n  merchantId: string;\n  requestId: string;\n  executionStatus: string;\n  currentState: Record<string, unknown>;\n  /** Epoch timestamp. */\n  createdAt: number;\n  /** Epoch timestamp. */\n  updatedAt: number;\n}\n\n/**\n * Outcome of `FlowStudio.start()`. Mirrors native `FlowStudioCallback`:\n * - `result` → `onResult(response)`\n * - `exit`   → `onExit()` (user left the flow without a result)\n */\nexport type FlowStudioResult = { type: 'result'; response: ExecutionResponse } | { type: 'exit' };\n"]}

package/build/FlowStudioReactNativeModule.d.ts

@@ -0,0 +1,15 @@
+import { NativeModule } from 'expo';
+import { FlowStudioConfig, FlowStudioResult } from './FlowStudioReactNative.types';
+/**
+ * Contract the native modules (Kotlin on Android, Swift on iOS) must implement.
+ * Names must match `Function(...)` / `AsyncFunction(...)` in the native modules exactly.
+ * Only plain data crosses the bridge, so config is passed fully resolved.
+ */
+declare class FlowStudioReactNativeModule extends NativeModule<{}> {
+    initialize(config: Required<FlowStudioConfig>): void;
+    start(): Promise<FlowStudioResult>;
+    isInitialized(): boolean;
+}
+declare const _default: FlowStudioReactNativeModule;
+export default _default;
+//# sourceMappingURL=FlowStudioReactNativeModule.d.ts.map

package/build/FlowStudioReactNativeModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudioReactNativeModule.d.ts","sourceRoot":"","sources":["../src/FlowStudioReactNativeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEnF;;;;GAIG;AACH,OAAO,OAAO,2BAA4B,SAAQ,YAAY,CAAC,EAAE,CAAC;IAChE,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,IAAI;IACpD,KAAK,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAClC,aAAa,IAAI,OAAO;CACzB;;AAED,wBAAyF"}

package/build/FlowStudioReactNativeModule.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo';
+export default requireNativeModule('FlowStudioReactNative');
+//# sourceMappingURL=FlowStudioReactNativeModule.js.map

package/build/FlowStudioReactNativeModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudioReactNativeModule.js","sourceRoot":"","sources":["../src/FlowStudioReactNativeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAezD,eAAe,mBAAmB,CAA8B,uBAAuB,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\nimport { FlowStudioConfig, FlowStudioResult } from './FlowStudioReactNative.types';\n\n/**\n * Contract the native modules (Kotlin on Android, Swift on iOS) must implement.\n * Names must match `Function(...)` / `AsyncFunction(...)` in the native modules exactly.\n * Only plain data crosses the bridge, so config is passed fully resolved.\n */\ndeclare class FlowStudioReactNativeModule extends NativeModule<{}> {\n  initialize(config: Required<FlowStudioConfig>): void;\n  start(): Promise<FlowStudioResult>;\n  isInitialized(): boolean;\n}\n\nexport default requireNativeModule<FlowStudioReactNativeModule>('FlowStudioReactNative');\n"]}

package/build/FlowStudioReactNativeModule.web.d.ts

@@ -0,0 +1,6 @@
+import { NativeModule } from 'expo';
+declare class FlowStudioReactNativeModule extends NativeModule<{}> {
+}
+declare const _default: typeof FlowStudioReactNativeModule;
+export default _default;
+//# sourceMappingURL=FlowStudioReactNativeModule.web.d.ts.map

package/build/FlowStudioReactNativeModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudioReactNativeModule.web.d.ts","sourceRoot":"","sources":["../src/FlowStudioReactNativeModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,MAAM,MAAM,CAAC;AAGvD,cAAM,2BAA4B,SAAQ,YAAY,CAAC,EAAE,CAAC;CAAG;;AAE7D,wBAA6F"}

package/build/FlowStudioReactNativeModule.web.js

@@ -0,0 +1,6 @@
+import { registerWebModule, NativeModule } from 'expo';
+// FlowStudioReactNativeModule is not available on the web platform.
+class FlowStudioReactNativeModule extends NativeModule {
+}
+export default registerWebModule(FlowStudioReactNativeModule, 'FlowStudioReactNativeModule');
+//# sourceMappingURL=FlowStudioReactNativeModule.web.js.map

package/build/FlowStudioReactNativeModule.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowStudioReactNativeModule.web.js","sourceRoot":"","sources":["../src/FlowStudioReactNativeModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEvD,oEAAoE;AACpE,MAAM,2BAA4B,SAAQ,YAAgB;CAAG;AAE7D,eAAe,iBAAiB,CAAC,2BAA2B,EAAE,6BAA6B,CAAC,CAAC","sourcesContent":["import { registerWebModule, NativeModule } from 'expo';\n\n// FlowStudioReactNativeModule is not available on the web platform.\nclass FlowStudioReactNativeModule extends NativeModule<{}> {}\n\nexport default registerWebModule(FlowStudioReactNativeModule, 'FlowStudioReactNativeModule');\n"]}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export { FlowStudio } from './FlowStudio';
+export { FlowStudio as default } from './FlowStudio';
+export type { ExecutionResponse, FlowStudioConfig, FlowStudioEnvironment, FlowStudioResult, } from './FlowStudioReactNative.types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAErD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,+BAA+B,CAAC"}

package/build/index.js

@@ -0,0 +1,4 @@
+// Public API of flowstudio-rn. Only what is exported here is available to clients.
+export { FlowStudio } from './FlowStudio';
+export { FlowStudio as default } from './FlowStudio';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC","sourcesContent":["// Public API of flowstudio-rn. Only what is exported here is available to clients.\nexport { FlowStudio } from './FlowStudio';\nexport { FlowStudio as default } from './FlowStudio';\n\nexport type {\n  ExecutionResponse,\n  FlowStudioConfig,\n  FlowStudioEnvironment,\n  FlowStudioResult,\n} from './FlowStudioReactNative.types';\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["FlowStudioReactNativeModule"]
+  },
+  "android": {
+    "modules": ["id.bureau.flowstudio.rn.FlowStudioReactNativeModule"]
+  }
+}

package/ios/FlowStudioReactNative.podspec

@@ -0,0 +1,23 @@
+Pod::Spec.new do |s|
+  s.name           = 'FlowStudioReactNative'
+  s.version        = '1.0.0'
+  s.summary        = 'A sample project summary'
+  s.description    = 'A sample project description'
+  s.author         = ''
+  s.homepage       = 'https://docs.expo.dev/modules/'
+  s.platforms      = {
+    :ios => '16.4',
+    :tvos => '16.4'
+  }
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/FlowStudioReactNativeModule.swift

@@ -0,0 +1,7 @@
+import ExpoModulesCore
+
+public class FlowStudioReactNativeModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("FlowStudioReactNative")
+  }
+}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "flowstudio-rn",
+  "version": "0.0.1-alpha",
+  "description": "React Native SDK for Bureau Flow Studio: run Flow Studio identity and verification journeys in React Native / Expo apps.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build",
+    "src",
+    "android",
+    "!android/build",
+    "!android/.gradle",
+    "!android/.gitignore",
+    "!android/src/test",
+    "!android/src/androidTest",
+    "ios",
+    "plugin/build",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "!**/__tests__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "build": "node internal/module_scripts/build.js",
+    "clean": "node internal/module_scripts/clean.js",
+    "lint": "eslint src/ plugin/src/",
+    "test": "node internal/module_scripts/test.js",
+    "prepare": "node internal/module_scripts/prepare.js",
+    "open:ios": "node internal/module_scripts/open-ios.js",
+    "open:android": "node internal/module_scripts/open-android.js",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p plugin"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "bureau",
+    "flowstudio",
+    "identity-verification",
+    "kyc"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepak-bureau/flowstudio-react-native-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/deepak-bureau/flowstudio-react-native-sdk/issues"
+  },
+  "author": "Bureau <techops@bureau.id> (https://bureau.id)",
+  "license": "MIT",
+  "homepage": "https://github.com/deepak-bureau/flowstudio-react-native-sdk#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": "^20.19.4 || ^22.13.0 || >=24.3.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@react-native/jest-preset": "^0.86.3",
+    "@types/jest": "^29.2.1",
+    "@types/react": "~19.2.2",
+    "babel-preset-expo": "~57.0.12",
+    "eslint": "~9.39.4",
+    "eslint-config-universe": "^15.0.3",
+    "expo": "~57.0.24",
+    "expo-modules-core": "~57.0.18",
+    "jest": "^29.7.0",
+    "jest-expo": "~57.0.5",
+    "prettier": "^3.0.0",
+    "react": "19.2.3",
+    "react-native": "0.86.3",
+    "typescript": "^5.9.2"
+  },
+  "jest": {
+    "preset": "jest-expo",
+    "roots": [
+      "<rootDir>/src"
+    ]
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from 'expo/config-plugins';
+declare const withFlowStudio: ConfigPlugin;
+export default withFlowStudio;

package/plugin/build/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+// Maven repository hosting the native FlowStudio SDK (id.bureau:flowstudio).
+const BUREAU_MAVEN_URL = 'https://packages.bureau.id/api/packages/Bureau/maven';
+/**
+ * Adds the Bureau Maven repository to the app's android/build.gradle
+ * (`allprojects { repositories { ... } }`) so the native FlowStudio SDK can be resolved.
+ */
+const withBureauMavenRepo = (config) => (0, config_plugins_1.withProjectBuildGradle)(config, (config) => {
+    const { contents, language } = config.modResults;
+    // Already added (by us on a previous run, or by hand).
+    if (contents.includes(BUREAU_MAVEN_URL)) {
+        return config;
+    }
+    const repoLine = language === 'kt'
+        ? `maven { url = uri("${BUREAU_MAVEN_URL}") }`
+        : `maven { url '${BUREAU_MAVEN_URL}' }`;
+    const anchor = /allprojects\s*\{\s*repositories\s*\{/;
+    if (!anchor.test(contents)) {
+        config_plugins_1.WarningAggregator.addWarningAndroid('flowstudio-rn', `Could not find "allprojects { repositories { ... } }" in android/build.gradle. ` +
+            `Add the FlowStudio Maven repository manually: ${repoLine}`);
+        return config;
+    }
+    config.modResults.contents = contents.replace(anchor, (match) => `${match}\n    ${repoLine}`);
+    return config;
+});
+const withFlowStudio = (config) => withBureauMavenRepo(config);
+exports.default = withFlowStudio;

package/src/FlowStudio.ts

@@ -0,0 +1,77 @@
+import { Platform } from 'react-native';
+
+import {
+  FlowStudioConfig,
+  FlowStudioEnvironment,
+  FlowStudioResult,
+} from './FlowStudioReactNative.types';
+import native from './FlowStudioReactNativeModule';
+
+const ENVIRONMENTS: readonly FlowStudioEnvironment[] = ['PROD', 'STAGING', 'DEV'];
+
+// Only the Android native module is implemented so far.
+const isSupportedPlatform = Platform.OS === 'android';
+
+function requireSupportedPlatform(): void {
+  if (!isSupportedPlatform) {
+    throw new Error(
+      `FlowStudio: ${Platform.OS} is not supported yet (Android only in this release)`
+    );
+  }
+}
+
+function requireNonEmpty(value: unknown, name: string): void {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`FlowStudio: \`${name}\` is required and must be a non-empty string`);
+  }
+}
+
+/**
+ * Initializes the Flow Studio SDK. Must be called before `start()`.
+ */
+function initialize(config: FlowStudioConfig): void {
+  requireSupportedPlatform();
+  requireNonEmpty(config?.credentialId, 'credentialId');
+  requireNonEmpty(config.deviceCredentialId, 'deviceCredentialId');
+  requireNonEmpty(config.executionId, 'executionId');
+
+  const environment = config.environment ?? 'PROD';
+  if (!ENVIRONMENTS.includes(environment)) {
+    throw new Error(
+      `FlowStudio: \`environment\` must be one of ${ENVIRONMENTS.join(', ')}, got "${environment}"`
+    );
+  }
+
+  native.initialize({
+    credentialId: config.credentialId,
+    deviceCredentialId: config.deviceCredentialId,
+    executionId: config.executionId,
+    environment,
+    enableLogging: config.enableLogging ?? false,
+  });
+}
+
+/**
+ * Launches the Flow Studio flow. Resolves when the flow finishes
+ * (`type: 'result'`) or the user exits it (`type: 'exit'`).
+ */
+async function start(): Promise<FlowStudioResult> {
+  requireSupportedPlatform();
+  if (!native.isInitialized()) {
+    throw new Error('FlowStudio: call `initialize()` before `start()`');
+  }
+  return native.start();
+}
+
+/**
+ * Returns whether `initialize()` has completed successfully.
+ */
+function isInitialized(): boolean {
+  return isSupportedPlatform && native.isInitialized();
+}
+
+export const FlowStudio = {
+  initialize,
+  start,
+  isInitialized,
+};

package/src/FlowStudioReactNative.types.ts

@@ -0,0 +1,45 @@
+/**
+ * Backend environment the Flow Studio SDK connects to.
+ * Mirrors native `FlowStudioEnvironment` (PROD | STAGING | DEV).
+ */
+export type FlowStudioEnvironment = 'PROD' | 'STAGING' | 'DEV';
+
+/**
+ * Configuration passed to `FlowStudio.initialize()`.
+ * Mirrors native `FlowStudioConfig`.
+ */
+export interface FlowStudioConfig {
+  /** Credential ID issued by Bureau. */
+  credentialId: string;
+  /** Credential ID used for device intelligence. */
+  deviceCredentialId: string;
+  /** ID of the flow execution to run. */
+  executionId: string;
+  /** Defaults to `'PROD'`. */
+  environment?: FlowStudioEnvironment;
+  /** Enables SDK logging. Defaults to `false`. */
+  enableLogging?: boolean;
+}
+
+/**
+ * Result of a completed flow execution.
+ * Mirrors native `ExecutionResponse`.
+ */
+export interface ExecutionResponse {
+  executionId: string;
+  merchantId: string;
+  requestId: string;
+  executionStatus: string;
+  currentState: Record<string, unknown>;
+  /** Epoch timestamp. */
+  createdAt: number;
+  /** Epoch timestamp. */
+  updatedAt: number;
+}
+
+/**
+ * Outcome of `FlowStudio.start()`. Mirrors native `FlowStudioCallback`:
+ * - `result` → `onResult(response)`
+ * - `exit`   → `onExit()` (user left the flow without a result)
+ */
+export type FlowStudioResult = { type: 'result'; response: ExecutionResponse } | { type: 'exit' };

package/src/FlowStudioReactNativeModule.ts

@@ -0,0 +1,16 @@
+import { NativeModule, requireNativeModule } from 'expo';
+
+import { FlowStudioConfig, FlowStudioResult } from './FlowStudioReactNative.types';
+
+/**
+ * Contract the native modules (Kotlin on Android, Swift on iOS) must implement.
+ * Names must match `Function(...)` / `AsyncFunction(...)` in the native modules exactly.
+ * Only plain data crosses the bridge, so config is passed fully resolved.
+ */
+declare class FlowStudioReactNativeModule extends NativeModule<{}> {
+  initialize(config: Required<FlowStudioConfig>): void;
+  start(): Promise<FlowStudioResult>;
+  isInitialized(): boolean;
+}
+
+export default requireNativeModule<FlowStudioReactNativeModule>('FlowStudioReactNative');

package/src/FlowStudioReactNativeModule.web.ts

@@ -0,0 +1,6 @@
+import { registerWebModule, NativeModule } from 'expo';
+
+// FlowStudioReactNativeModule is not available on the web platform.
+class FlowStudioReactNativeModule extends NativeModule<{}> {}
+
+export default registerWebModule(FlowStudioReactNativeModule, 'FlowStudioReactNativeModule');

package/src/index.ts

@@ -0,0 +1,10 @@
+// Public API of flowstudio-rn. Only what is exported here is available to clients.
+export { FlowStudio } from './FlowStudio';
+export { FlowStudio as default } from './FlowStudio';
+
+export type {
+  ExecutionResponse,
+  FlowStudioConfig,
+  FlowStudioEnvironment,
+  FlowStudioResult,
+} from './FlowStudioReactNative.types';