diff --git a/CLAUDE.md b/CLAUDE.md
index 9373a961..c26c43bf 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -137,3 +137,4 @@ Conversion utilities in `src/utils/` translate TypeScript types to the NitroModu
 - **TypeScript:** Strict mode with `noUnusedLocals`, `noUnusedParameters`
 - Named imports enforced; no floating promises; optional chaining preferred
 - `src/types/Glyphmap.ts` is excluded from linting (generated file)
+- **Any language:** Always use braces for `if` statements — no single-line braceless ifs
diff --git a/apps/example/ios/Podfile.lock b/apps/example/ios/Podfile.lock
index 1b6eda50..833a39e8 100644
--- a/apps/example/ios/Podfile.lock
+++ b/apps/example/ios/Podfile.lock
@@ -2624,7 +2624,7 @@ PODS:
     - React-perflogger (= 0.83.5)
     - React-utils (= 0.83.5)
     - SocketRocket
-  - ReactNativeAutoPlay (0.4.7):
+  - ReactNativeAutoPlay (0.4.12):
     - boost
     - DoubleConversion
     - fast_float
@@ -2995,7 +2995,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: 105856c6da6fe71c545dec3c2466ae04f25f9a73
   ReactCodegen: 507d02fe6f19c44a3274adbefd38a1a252843d24
   ReactCommon: 506ceb24983c6b80e0075968be21aac74a367739
-  ReactNativeAutoPlay: 8451b7306f94785877308f12ba104d7ada33db25
+  ReactNativeAutoPlay: a1ca22b8f49a95a942835e01e28238a3a5fd5049
   SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748
   Yoga: 897e8c1fb1fd80c3c01231ed4ec8c1ffa652c29f
 
diff --git a/apps/example/src/App.tsx b/apps/example/src/App.tsx
index 66541213..589b54c1 100644
--- a/apps/example/src/App.tsx
+++ b/apps/example/src/App.tsx
@@ -2,6 +2,7 @@ import {
   AutoPlayModules,
   type CleanupCallback,
   HybridAutoPlay,
+  HybridVoice,
 } from '@iternio/react-native-auto-play';
 import { Buffer } from 'buffer';
 import { useEffect, useState } from 'react';
@@ -120,14 +121,22 @@ function AppContent() {
           <Button
             title="record audio"
             onPress={async () => {
-              const granted = await HybridAutoPlay.requestVoiceInputPermission();
+              const granted = await HybridVoice.requestVoiceInputPermission();
               if (!granted) {
                 return;
               }
 
-              const audio = await HybridAutoPlay.startVoiceInput();
-              console.log(`received ${audio.byteLength} bytes`);
-              dispatch(setRecording(Buffer.from(new Uint8Array(audio)).toString('base64')));
+              void HybridVoice.startVoiceInput({ preferSpeechToText: true }).then((result) => {
+                if (result.audio) {
+                  console.log(`received ${result.audio.byteLength} bytes`);
+                  dispatch(
+                    setRecording(Buffer.from(new Uint8Array(result.audio)).toString('base64'))
+                  );
+                } else if (result.transcription) {
+                  console.log(`received ${result.transcription}`);
+                  setSavedVoiceRecording(result.transcription);
+                }
+              });
             }}
           />
           <Button
diff --git a/apps/example/src/templates/AutoTemplate.ts b/apps/example/src/templates/AutoTemplate.ts
index 906727c9..5f89894f 100644
--- a/apps/example/src/templates/AutoTemplate.ts
+++ b/apps/example/src/templates/AutoTemplate.ts
@@ -4,6 +4,7 @@ import {
   CarPlayDashboard,
   type HeaderActions,
   HybridAutoPlay,
+  HybridVoice,
   type ImageButton,
   type MapTemplate,
   type MapTemplateConfig,
@@ -242,14 +243,18 @@ const mapHeaderActions: MapTemplateConfig['headerActions'] = {
       type: 'image',
       image: { name: 'mic', type: 'glyph' },
       onPress: () => {
-        void HybridAutoPlay.requestVoiceInputPermission().then((isGranted) => {
+        void HybridVoice.requestVoiceInputPermission().then((isGranted) => {
           if (!isGranted) {
             return;
           }
 
-          void HybridAutoPlay.startVoiceInput().then((audio) => {
-            console.log(`received ${audio.byteLength} bytes`);
-            dispatch(setRecording(Buffer.from(new Uint8Array(audio)).toString('base64')));
+          void HybridVoice.startVoiceInput({ preferSpeechToText: true }).then((result) => {
+            if (result.audio) {
+              console.log(`received ${result.audio.byteLength} bytes`);
+              dispatch(setRecording(Buffer.from(new Uint8Array(result.audio)).toString('base64')));
+            } else {
+              console.log(`received ${result.transcription}`);
+            }
           });
         });
       },
@@ -288,14 +293,20 @@ const mapHeaderActions: MapTemplateConfig['headerActions'] = {
           type: 'glyph',
         },
         onPress: () => {
-          void HybridAutoPlay.requestVoiceInputPermission().then((isGranted) => {
+          void HybridVoice.requestVoiceInputPermission().then((isGranted) => {
             if (!isGranted) {
               return;
             }
 
-            void HybridAutoPlay.startVoiceInput().then((audio) => {
-              console.log(`received ${audio.byteLength} bytes`);
-              dispatch(setRecording(Buffer.from(new Uint8Array(audio)).toString('base64')));
+            void HybridVoice.startVoiceInput({ preferSpeechToText: true }).then((result) => {
+              if (result.audio) {
+                console.log(`received ${result.audio.byteLength} bytes`);
+                dispatch(
+                  setRecording(Buffer.from(new Uint8Array(result.audio)).toString('base64'))
+                );
+              } else {
+                console.log(`received ${result.transcription}`);
+              }
             });
           });
         },
diff --git a/packages/react-native-autoplay/README.md b/packages/react-native-autoplay/README.md
index f4ed137a..a33a1828 100644
--- a/packages/react-native-autoplay/README.md
+++ b/packages/react-native-autoplay/README.md
@@ -314,6 +314,32 @@ The library does **not** bundle any icon font — the consuming app must provide
 
    For cross-platform compatibility use **lowercase names with underscores only** (e.g. `material_symbols`).
 
+**or**
+
+1. use expo-font
+    ```js
+    [
+      'expo-font',
+      {
+        android: {
+          fonts: [
+            {
+              fontFamily: 'MaterialSymbols',
+              fontDefinitions: [
+                {
+                  path: './assets/fonts/material_symbols.ttf',
+                  weight: 800,
+                },
+              ],
+            },
+          ],
+        },
+        ios: ['./assets/fonts/material_symbols.ttf'],
+      },
+    ],
+    ```
+    For cross-platform compatibility use **lowercase names with underscores only** (e.g. `material_symbols`).
+
 2. Register the font and an optional glyph map at startup:
 
    ```ts
diff --git a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay.kt b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay.kt
index 4e7a8ec7..acf252f4 100644
--- a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay.kt
+++ b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay.kt
@@ -1,19 +1,11 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
-import android.content.pm.PackageManager
 import android.os.Build
-import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.UiThreadUtil
-import com.facebook.react.modules.core.PermissionAwareActivity
-import com.facebook.react.modules.core.PermissionListener
-import com.margelo.nitro.NitroModules
-import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.MessageTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ThreadUtil
-import kotlinx.coroutines.suspendCancellableCoroutine
-import java.nio.ByteBuffer
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.coroutines.resume
@@ -255,84 +247,6 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
         }
     }
 
-    override fun hasVoiceInputPermission(): Boolean {
-        val context = NitroModules.applicationContext ?: return false
-        return ContextCompat.checkSelfPermission(
-            context, android.Manifest.permission.RECORD_AUDIO
-        ) == PackageManager.PERMISSION_GRANTED
-    }
-
-    override fun requestVoiceInputPermission(): Promise<Boolean> {
-        return Promise.async {
-            if (hasVoiceInputPermission()) {
-                return@async true
-            }
-
-            val carContext = AndroidAutoSession.getRootContext()
-
-            if (carContext != null) {
-                suspendCancellableCoroutine {
-                    carContext.requestPermissions(listOf(android.Manifest.permission.RECORD_AUDIO)) { approved, _ ->
-                        it.resume(approved.contains(android.Manifest.permission.RECORD_AUDIO))
-                    }
-                }
-            } else {
-                val context = NitroModules.applicationContext ?: return@async false
-                val activity =
-                    context.currentActivity as? PermissionAwareActivity ?: return@async false
-                val code = (Math.random() * 10000).toInt()
-
-                suspendCancellableCoroutine {
-                    activity.requestPermissions(
-                        arrayOf(android.Manifest.permission.RECORD_AUDIO),
-                        code,
-                        PermissionListener { requestCode, _, grantResults ->
-                            if (requestCode != code) {
-                                return@PermissionListener false
-                            }
-
-                            val granted =
-                                grantResults.isNotEmpty() && grantResults.first() == PackageManager.PERMISSION_GRANTED
-
-                            it.resume(granted)
-
-                            return@PermissionListener true
-                        })
-                }
-            }
-        }
-    }
-
-    override fun startVoiceInput(
-        silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?
-    ): Promise<ArrayBuffer> {
-        return Promise.async {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-                throw UnsupportedOperationException("startVoiceInput requires at least API level ${Build.VERSION_CODES.O}")
-            }
-
-            val manager = VoiceInputManager(AndroidAutoSession.getRootContext())
-            voiceInputManager = manager
-
-            try {
-                val pcmBytes = manager.start(
-                    silenceThresholdMs = silenceThresholdMs?.toLong() ?: 1_500L,
-                    maxDurationMs = maxDurationMs?.toLong() ?: 10_000L,
-                )
-                val directBuffer =
-                    ByteBuffer.allocateDirect(pcmBytes.size).put(pcmBytes).rewind() as ByteBuffer
-                ArrayBuffer.wrap(directBuffer)
-            } finally {
-                voiceInputManager = null
-                manager.dispose()
-            }
-        }
-    }
-
-    override fun stopVoiceInput() {
-        voiceInputManager?.stop()
-    }
-
     companion object {
         const val TAG = "HybridAutoPlay"
 
@@ -343,9 +257,6 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
 
         private val voiceInputListeners = CopyOnWriteArrayList<(Location?, String?) -> Unit>()
 
-        @Volatile
-        private var voiceInputManager: VoiceInputManager? = null
-
         private val safeAreaInsetsListeners =
             ConcurrentHashMap<String, CopyOnWriteArrayList<(SafeAreaInsets) -> Unit>>()
 
diff --git a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoice.kt b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoice.kt
new file mode 100644
index 00000000..ab3d3645
--- /dev/null
+++ b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoice.kt
@@ -0,0 +1,97 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+class HybridVoice : HybridVoiceSpec() {
+    @Volatile
+    private var voiceInputManager: VoiceInputManager? = null
+
+    override fun hasVoiceInputPermission(): Boolean {
+        return VoiceInputManager.hasVoiceInputPermission()
+    }
+
+    override fun requestVoiceInputPermission(): Promise<Boolean> {
+        return Promise.async {
+            if (hasVoiceInputPermission()) {
+                return@async true
+            }
+
+            val carContext = AndroidAutoSession.getRootContext()
+
+            if (carContext != null) {
+                suspendCancellableCoroutine { cont ->
+                    carContext.requestPermissions(
+                        listOf(android.Manifest.permission.RECORD_AUDIO)
+                    ) { approved, _ ->
+                        cont.resume(approved.contains(android.Manifest.permission.RECORD_AUDIO))
+                    }
+                }
+            } else {
+                val context = NitroModules.applicationContext ?: return@async false
+                val activity =
+                    context.currentActivity as? PermissionAwareActivity ?: return@async false
+                val code = (Math.random() * 10000).toInt()
+
+                suspendCancellableCoroutine { cont ->
+                    activity.requestPermissions(
+                        arrayOf(android.Manifest.permission.RECORD_AUDIO),
+                        code,
+                        PermissionListener { requestCode, _, grantResults ->
+                            if (requestCode != code) {
+                                return@PermissionListener false
+                            }
+                            cont.resume(
+                                grantResults.isNotEmpty() &&
+                                    grantResults.first() == PackageManager.PERMISSION_GRANTED
+                            )
+                            true
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    override fun startVoiceInput(
+        silenceThresholdMs: Double?,
+        maxDurationMs: Double?,
+        listeningText: String?,
+        preferSpeechToText: Boolean?,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): Promise<VoiceInputResult> {
+        return Promise.async {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                throw UnsupportedOperationException("startVoiceInput requires at least API level ${Build.VERSION_CODES.O}")
+            }
+
+            val manager = VoiceInputManager(AndroidAutoSession.getRootContext())
+            voiceInputManager = manager
+
+            try {
+                manager.start(
+                    silenceThresholdMs = silenceThresholdMs?.toLong() ?: 1_500L,
+                    maxDurationMs = maxDurationMs?.toLong() ?: 10_000L,
+                    preferSpeechToText = preferSpeechToText ?: false,
+                    onChunk = onChunk,
+                    language = language
+                )
+            } finally {
+                voiceInputManager = null
+                manager.dispose()
+            }
+        }
+    }
+
+    override fun stopVoiceInput() {
+        voiceInputManager?.stop()
+    }
+}
diff --git a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputManager.kt b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputManager.kt
index 830c8475..da85b726 100644
--- a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputManager.kt
+++ b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputManager.kt
@@ -1,5 +1,9 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
 import android.media.AudioAttributes
 import android.media.AudioFocusRequest
@@ -8,18 +12,28 @@ import android.media.AudioManager
 import android.media.AudioRecord
 import android.media.MediaRecorder
 import android.os.Build
+import android.os.Bundle
+import android.os.ParcelFileDescriptor
+import android.speech.RecognitionListener
+import android.speech.RecognizerIntent
+import android.speech.SpeechRecognizer
 import androidx.annotation.RequiresApi
 import androidx.car.app.CarContext
 import androidx.car.app.media.CarAudioRecord
 import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.UiThreadUtil
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ThreadUtil
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
@@ -27,43 +41,280 @@ import kotlin.math.abs
 
 /**
  * Captures 16-bit PCM audio (16 kHz, mono).
- * When [carContext] is provided uses CarAudioRecord (Android Auto/Automotive).
- * When [carContext] is null falls back to standard AudioRecord (phone-only).
+ * When [carContext] is provided uses CarAudioRecord (Android Auto/Automotive),
+ * otherwise falls back to standard AudioRecord.
+ *
+ * When preferSpeechToText is true and SpeechRecognizer is available, it owns
+ * the microphone and streams partial results; the PCM path is not used.
+ * When SpeechRecognizer is unavailable the manager falls back to PCM recording.
  */
 class VoiceInputManager(
     private val carContext: CarContext?,
 ) {
+    // PCM recording state
     private var carAudioRecord: CarAudioRecord? = null
     private var audioRecord: AudioRecord? = null
     private var audioFocusRequest: AudioFocusRequest? = null
     private var recordingJob: Job? = null
-    private var continuation: Continuation<ByteArray>? = null
+    private var pcmContinuation: Continuation<ByteArray>? = null
     private val scope = CoroutineScope(Dispatchers.IO)
 
     @Volatile
     private var isRecording = false
 
-    /**
-     * Acquires audio focus, starts recording, and suspends until stopped.
-     * Stops automatically after [silenceThresholdMs] of silence or [maxDurationMs] total.
-     * Returns the complete raw PCM buffer (Int16 LE, 16 kHz, mono).
-     */
+    // STT state — only set when SpeechRecognizer owns the mic
+    @Volatile
+    private var activeSpeechRecognizer: SpeechRecognizer? = null
+
     @RequiresApi(Build.VERSION_CODES.O)
     suspend fun start(
         silenceThresholdMs: Long = 1_500,
         maxDurationMs: Long = 10_000,
+        preferSpeechToText: Boolean = false,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)? = null,
+        language: String? = null
+    ): VoiceInputResult {
+        if (preferSpeechToText) {
+            val context = NitroModules.applicationContext ?: throw IllegalArgumentException()
+            if (SpeechRecognizer.isRecognitionAvailable(context)) {
+                if (carContext != null) {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        return startSTTFromCarAudio(silenceThresholdMs, maxDurationMs, onChunk, language)
+                    }
+                    // Car connected but API < 33: EXTRA_AUDIO_SOURCE unavailable, fall back to PCM
+                    return startPCM(silenceThresholdMs, maxDurationMs, onChunk)
+                }
+                return ThreadUtil.postOnUiAndAwait { startSTT(context, onChunk, language) }.getOrThrow()
+            }
+        }
+        return startPCM(silenceThresholdMs, maxDurationMs, onChunk)
+    }
+
+    // MARK: - STT path (SpeechRecognizer owns the mic)
+
+    private suspend fun startSTT(
+        context: Context,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): VoiceInputResult = suspendCancellableCoroutine { cont ->
+        val recognizer = SpeechRecognizer.createSpeechRecognizer(context)
+        activeSpeechRecognizer = recognizer
+
+        recognizer.setRecognitionListener(object : RecognitionListener {
+            override fun onResults(results: Bundle?) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                val text =
+                    results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull()
+                cont.resume(VoiceInputResult(transcription = text, audio = null))
+            }
+
+            override fun onError(error: Int) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                cont.resumeWithException(RuntimeException("SpeechRecognizer error $error"))
+            }
+
+            override fun onPartialResults(partialResults: Bundle?) {
+                val text = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
+                    ?.firstOrNull()
+                if (!text.isNullOrEmpty()) {
+                    onChunk?.invoke(VoiceInputChunk(partial = text, audio = null))
+                }
+            }
+
+            override fun onReadyForSpeech(params: Bundle?) {}
+            override fun onBeginningOfSpeech() {}
+            override fun onRmsChanged(rmsdB: Float) {}
+            override fun onBufferReceived(buffer: ByteArray?) {}
+            override fun onEndOfSpeech() {}
+            override fun onEvent(eventType: Int, params: Bundle?) {}
+        })
+
+        val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+            putExtra(
+                RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+            )
+            putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+            putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+            language?.let {
+                putExtra(RecognizerIntent.EXTRA_LANGUAGE, it)
+            }
+        }
+
+        recognizer.startListening(intent)
+
+        cont.invokeOnCancellation {
+            activeSpeechRecognizer = null
+            recognizer.destroy()
+        }
+    }
+
+    // MARK: - STT path fed from CarAudioRecord via a pipe (API 33+)
+    @SuppressLint("MissingPermission")
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
+    private suspend fun startSTTFromCarAudio(
+        silenceThresholdMs: Long,
+        maxDurationMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): VoiceInputResult {
+        if (!hasVoiceInputPermission()) {
+            throw SecurityException("RECORD_AUDIO permission not granted")
+        }
+
+        val appContext = NitroModules.applicationContext ?: throw IllegalArgumentException()
+        val pipes = ParcelFileDescriptor.createPipe()
+        val readFd = pipes[0]
+        val pipeOut = ParcelFileDescriptor.AutoCloseOutputStream(pipes[1])
+
+        val sttDeferred = scope.async {
+            ThreadUtil.postOnUiAndAwait {
+                startSTTWithSource(appContext, readFd, silenceThresholdMs, onChunk, language)
+            }.getOrThrow()
+        }
+
+        var pcmBytes: ByteArray
+        try {
+            pcmBytes = recordPCM(silenceThresholdMs, maxDurationMs) { chunk ->
+                chunk.audio?.let { ab ->
+                    try {
+                        pipeOut.write(ab.toByteArray())
+                    } catch (_: Exception) {
+                        isRecording = false
+                    }
+                }
+            }
+        } finally {
+            try {
+                pipeOut.close()
+            } catch (_: Exception) {
+            }
+            try {
+                readFd.close()
+            } catch (_: Exception) {
+            }
+        }
+
+        return try {
+            sttDeferred.await()
+        } catch (_: Exception) {
+            val directBuffer = ByteBuffer.allocateDirect(pcmBytes.size).put(pcmBytes).rewind() as ByteBuffer
+            VoiceInputResult(transcription = null, audio = ArrayBuffer.wrap(directBuffer))
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
+    private suspend fun startSTTWithSource(
+        context: Context,
+        audioSource: ParcelFileDescriptor,
+        silenceThresholdMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): VoiceInputResult = suspendCancellableCoroutine { cont ->
+        val recognizer = SpeechRecognizer.createSpeechRecognizer(context)
+        activeSpeechRecognizer = recognizer
+        // When EXTRA_AUDIO_SOURCE is used, onResults always returns an empty list — the actual
+        // transcription only arrives via onPartialResults. Track the last partial here.
+        var lastPartial: String? = null
+
+        recognizer.setRecognitionListener(object : RecognitionListener {
+            override fun onResults(results: Bundle?) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                val text =
+                    results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull()
+                        ?: lastPartial
+                cont.resume(VoiceInputResult(transcription = text, audio = null))
+            }
+
+            override fun onError(error: Int) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                cont.resumeWithException(RuntimeException("SpeechRecognizer error $error"))
+            }
+
+            override fun onPartialResults(partialResults: Bundle?) {
+                val text = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
+                    ?.firstOrNull()
+                if (!text.isNullOrEmpty()) {
+                    lastPartial = text
+                    onChunk?.invoke(VoiceInputChunk(partial = text, audio = null))
+                }
+            }
+
+            override fun onReadyForSpeech(params: Bundle?) {}
+            override fun onBeginningOfSpeech() {}
+            override fun onRmsChanged(rmsdB: Float) {}
+            override fun onBufferReceived(buffer: ByteArray?) {}
+            override fun onEndOfSpeech() {}
+            override fun onEvent(eventType: Int, params: Bundle?) {}
+        })
+
+        val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+            putExtra(
+                RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+            )
+            putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+            putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+            language?.let {
+                putExtra(RecognizerIntent.EXTRA_LANGUAGE, it)
+            }
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE, audioSource)
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_CHANNEL_COUNT, 1)
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_ENCODING, AudioFormat.ENCODING_PCM_16BIT)
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_SAMPLING_RATE, SAMPLE_RATE)
+            putExtra(RecognizerIntent.EXTRA_SPEECH_INPUT_MINIMUM_LENGTH_MILLIS, WARMUP_MS)
+            putExtra(
+                RecognizerIntent.EXTRA_SPEECH_INPUT_COMPLETE_SILENCE_LENGTH_MILLIS,
+                silenceThresholdMs
+            )
+            putExtra(
+                RecognizerIntent.EXTRA_SPEECH_INPUT_POSSIBLY_COMPLETE_SILENCE_LENGTH_MILLIS,
+                silenceThresholdMs / 2,
+            )
+        }
+
+        recognizer.startListening(intent)
+
+        cont.invokeOnCancellation {
+            activeSpeechRecognizer = null
+            recognizer.destroy()
+        }
+    }
+
+    // MARK: - PCM path
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private suspend fun startPCM(
+        silenceThresholdMs: Long,
+        maxDurationMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+    ): VoiceInputResult {
+        val pcmBytes = recordPCM(silenceThresholdMs, maxDurationMs, onChunk)
+        val directBuffer =
+            ByteBuffer.allocateDirect(pcmBytes.size).put(pcmBytes).rewind() as ByteBuffer
+        return VoiceInputResult(transcription = null, audio = ArrayBuffer.wrap(directBuffer))
+    }
+
+    @SuppressLint("MissingPermission")
+    @RequiresApi(Build.VERSION_CODES.O)
+    private suspend fun recordPCM(
+        silenceThresholdMs: Long,
+        maxDurationMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
     ): ByteArray = suspendCancellableCoroutine { cont ->
-        val appContext = NitroModules.applicationContext
-        if (appContext == null || ContextCompat.checkSelfPermission(
-                appContext,
-                android.Manifest.permission.RECORD_AUDIO,
-            ) != PackageManager.PERMISSION_GRANTED
-        ) {
+        if (!hasVoiceInputPermission()) {
             cont.resumeWithException(SecurityException("RECORD_AUDIO permission not granted"))
             return@suspendCancellableCoroutine
         }
 
-        continuation = cont
+        val appContext = NitroModules.applicationContext ?: run {
+            cont.resumeWithException(SecurityException("Missing application context"))
+            return@suspendCancellableCoroutine
+        }
+
+        pcmContinuation = cont
 
         val audioManager = appContext.getSystemService(AudioManager::class.java)
 
@@ -80,7 +331,7 @@ class VoiceInputManager(
                 }.build()
 
         if (audioManager.requestAudioFocus(focusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
-            continuation = null
+            pcmContinuation = null
             cont.resumeWithException(IllegalStateException("Audio focus request denied"))
             return@suspendCancellableCoroutine
         }
@@ -136,6 +387,13 @@ class VoiceInputManager(
                     if (read > 0) {
                         outputStream.write(buffer, 0, read)
 
+                        onChunk?.let { cb ->
+                            val chunk = ByteArray(read) { buffer[it] }
+                            val direct =
+                                ByteBuffer.allocateDirect(read).put(chunk).rewind() as ByteBuffer
+                            cb(VoiceInputChunk(partial = null, audio = ArrayBuffer.wrap(direct)))
+                        }
+
                         val now = System.currentTimeMillis()
                         val elapsedMs = now - recordingStart
 
@@ -151,7 +409,9 @@ class VoiceInputManager(
                                 val sample =
                                     (buffer[i].toInt() and 0xFF) or (buffer[i + 1].toInt() shl 8)
                                 val absSample = abs(sample.toShort().toInt())
-                                if (absSample > peak) peak = absSample
+                                if (absSample > peak) {
+                                    peak = absSample
+                                }
                                 i += 2
                             }
 
@@ -170,14 +430,21 @@ class VoiceInputManager(
                 }
             } finally {
                 releaseResources()
-                val capturedContinuation = continuation
-                continuation = null
-                capturedContinuation?.resume(outputStream.toByteArray())
+                val captured = pcmContinuation
+                pcmContinuation = null
+                captured?.resume(outputStream.toByteArray())
             }
         }
     }
 
     fun stop() {
+        // STT path: stopListening() triggers onResults/onError which resolves the continuation
+        activeSpeechRecognizer?.let { recognizer ->
+            UiThreadUtil.runOnUiThread {
+                recognizer.stopListening()
+            }
+        }
+        // PCM path and car-audio STT pump
         isRecording = false
         carAudioRecord?.stopRecording()
         audioRecord?.stop()
@@ -210,5 +477,12 @@ class VoiceInputManager(
         private const val WARMUP_MS = 500L
         private const val SAMPLE_RATE = 16_000
         private const val PHONE_BUFFER_SIZE = 3_200 // ~100ms at 16kHz/16-bit/mono
+
+        fun hasVoiceInputPermission(): Boolean {
+            val context = NitroModules.applicationContext ?: return false
+            return ContextCompat.checkSelfPermission(
+                context, Manifest.permission.RECORD_AUDIO
+            ) == PackageManager.PERMISSION_GRANTED
+        }
     }
 }
diff --git a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ThreadUtil.kt b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ThreadUtil.kt
index d90cefbb..21ada6f0 100644
--- a/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ThreadUtil.kt
+++ b/packages/react-native-autoplay/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ThreadUtil.kt
@@ -1,19 +1,12 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
 
-import com.facebook.react.bridge.UiThreadUtil
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
 object ThreadUtil {
-    suspend fun <T> postOnUiAndAwait(block: () -> T): Result<T> =
-        suspendCancellableCoroutine { cont ->
-            UiThreadUtil.runOnUiThread {
-                try {
-                    val result = block()
-                    cont.resume(Result.success(result))
-                } catch (e: Exception) {
-                    cont.resume(Result.failure(e))
-                }
-            }
+    suspend fun <T> postOnUiAndAwait(block: suspend () -> T): Result<T> = runCatching {
+        withContext(Dispatchers.Main) {
+            block()
         }
+    }
 }
\ No newline at end of file
diff --git a/packages/react-native-autoplay/ios/hybrid/HybridAutoPlay.swift b/packages/react-native-autoplay/ios/hybrid/HybridAutoPlay.swift
index 9f697c83..93221f30 100644
--- a/packages/react-native-autoplay/ios/hybrid/HybridAutoPlay.swift
+++ b/packages/react-native-autoplay/ios/hybrid/HybridAutoPlay.swift
@@ -21,7 +21,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     private static var listeners = [EventName: [StateListener]]()
     private static var renderStateListeners = [String: [RenderStateListener]]()
     private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
-    private static var voiceInputManager: VoiceInputManager?
+
 
     override init() {
         HybridAutoPlay.listeners.removeAll()
@@ -123,55 +123,10 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     func addListenerVoiceInput(
         callback: @escaping (Location?, String?) -> Void
     ) throws -> () -> Void {
-        // iOS does not use the OS-triggered voice input path — use startVoiceInput() instead.
+        // iOS does not use the OS-triggered voice input path — use HybridVoice instead.
         return {}
     }
 
-    func hasVoiceInputPermission() throws -> Bool {
-        return AVAudioSession.sharedInstance().recordPermission == .granted
-    }
-
-    func requestVoiceInputPermission() throws -> Promise<Bool> {
-        return Promise.async {
-            return await withCheckedContinuation { cont in
-                AVAudioSession.sharedInstance().requestRecordPermission { granted in
-                    cont.resume(returning: granted)
-                }
-            }
-        }
-    }
-
-    func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?) throws -> Promise<
-        ArrayBuffer
-    > {
-        return Promise.async {
-            let interfaceController = try? await RootModule.withInterfaceController { $0 }
-
-            let manager = VoiceInputManager()
-            HybridAutoPlay.voiceInputManager = manager
-
-            defer {
-                HybridAutoPlay.voiceInputManager = nil
-            }
-
-            let data = try await manager.start(
-                interfaceController: interfaceController,
-                silenceThresholdMs: silenceThresholdMs ?? 1_500,
-                maxDurationMs: maxDurationMs ?? 10_000,
-                listeningText: listeningText ?? "Listening..."
-            )
-
-            return try ArrayBuffer.copy(data: data)
-        }
-    }
-
-    func stopVoiceInput() throws {
-        Task { @MainActor in
-            let interfaceController = try? await RootModule.withInterfaceController { $0 }
-            HybridAutoPlay.voiceInputManager?.stop(interfaceController: interfaceController)
-        }
-    }
-
     // MARK: set/push/pop templates
     func setRootTemplate(templateId: String) throws -> Promise<Void> {
         return Promise.async {
diff --git a/packages/react-native-autoplay/ios/hybrid/HybridVoice.swift b/packages/react-native-autoplay/ios/hybrid/HybridVoice.swift
new file mode 100644
index 00000000..52ad50b5
--- /dev/null
+++ b/packages/react-native-autoplay/ios/hybrid/HybridVoice.swift
@@ -0,0 +1,65 @@
+import AVFoundation
+import NitroModules
+import Speech
+
+class HybridVoice: HybridVoiceSpec {
+    private var voiceInputManager: VoiceInputManager?
+
+    func hasVoiceInputPermission() throws -> Bool {
+        let micGranted = AVAudioSession.sharedInstance().recordPermission == .granted
+        let speechGranted = SFSpeechRecognizer.authorizationStatus() == .authorized
+        return micGranted && speechGranted
+    }
+
+    func requestVoiceInputPermission() throws -> Promise<Bool> {
+        return Promise.async {
+            let micGranted = await withCheckedContinuation { cont in
+                AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                    cont.resume(returning: granted)
+                }
+            }
+            guard micGranted else { return false }
+
+            return await withCheckedContinuation { cont in
+                SFSpeechRecognizer.requestAuthorization { status in
+                    cont.resume(returning: status == .authorized)
+                }
+            }
+        }
+    }
+
+    func startVoiceInput(
+        silenceThresholdMs: Double?,
+        maxDurationMs: Double?,
+        listeningText: String?,
+        preferSpeechToText: Bool?,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        language: String?
+    ) throws -> Promise<VoiceInputResult> {
+        return Promise.async {
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+
+            let manager = VoiceInputManager()
+            self.voiceInputManager = manager
+
+            defer { self.voiceInputManager = nil }
+
+            return try await manager.start(
+                interfaceController: interfaceController,
+                silenceThresholdMs: silenceThresholdMs ?? 1_500,
+                maxDurationMs: maxDurationMs ?? 10_000,
+                listeningText: listeningText ?? "Listening...",
+                preferSpeechToText: preferSpeechToText ?? false,
+                onChunk: onChunk,
+                language: language
+            )
+        }
+    }
+
+    func stopVoiceInput() throws {
+        Task { @MainActor in
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+            self.voiceInputManager?.stop(interfaceController: interfaceController)
+        }
+    }
+}
diff --git a/packages/react-native-autoplay/ios/utils/VoiceInputManager.swift b/packages/react-native-autoplay/ios/utils/VoiceInputManager.swift
index 27930850..17bb12e5 100644
--- a/packages/react-native-autoplay/ios/utils/VoiceInputManager.swift
+++ b/packages/react-native-autoplay/ios/utils/VoiceInputManager.swift
@@ -1,16 +1,47 @@
 import AVFoundation
 import CarPlay
+import NitroModules
+import Speech
 
-/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM.
-/// Recording stops automatically when silence is detected or the max duration is reached.
+/// Wraps CheckedContinuation so it can only be resumed once even when
+/// shared between a stop() call and an async recognition task callback.
+private final class ResultBox: @unchecked Sendable {
+    private var continuation: CheckedContinuation<VoiceInputResult, Error>?
+    private let lock = NSLock()
+
+    init(_ continuation: CheckedContinuation<VoiceInputResult, Error>) {
+        self.continuation = continuation
+    }
+
+    func resume(returning result: VoiceInputResult) {
+        lock.lock()
+        defer { lock.unlock() }
+        continuation?.resume(returning: result)
+        continuation = nil
+    }
+
+    func resume(throwing error: Error) {
+        lock.lock()
+        defer { lock.unlock() }
+        continuation?.resume(throwing: error)
+        continuation = nil
+    }
+}
+
+/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM,
+/// or transcribes it via SFSpeechRecognizer when preferSpeechToText is true.
 class VoiceInputManager {
     private var audioEngine: AVAudioEngine?
     private var voiceControlTemplate: CPVoiceControlTemplate?
-    private var continuation: CheckedContinuation<[Int16], Error>?
+    private var resultBox: ResultBox?
     private var samples: [Int16] = []
     private var isStopping = false
     private let stopLock = NSLock()
 
+    // STT
+    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
+    private var isSTTMode = false
+
     // Timing
     private var recordingStart: Date?
     private var silenceStart: Date?
@@ -33,30 +64,35 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String
-    ) async throws -> Data {
-        let samples = try await withCheckedThrowingContinuation {
-            (cont: CheckedContinuation<[Int16], Error>) in
-            self.continuation = cont
+        listeningText: String,
+        preferSpeechToText: Bool,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        language: String?
+    ) async throws -> VoiceInputResult {
+        return try await withCheckedThrowingContinuation { cont in
+            let box = ResultBox(cont)
+            self.resultBox = box
             self.samples = []
             self.isStopping = false
+            self.isSTTMode = preferSpeechToText
 
             do {
                 try self.startCapture(
                     interfaceController: interfaceController,
                     silenceThresholdMs: silenceThresholdMs,
                     maxDurationMs: maxDurationMs,
-                    listeningText: listeningText
+                    listeningText: listeningText,
+                    preferSpeechToText: preferSpeechToText,
+                    onChunk: onChunk,
+                    box: box,
+                    language: language
                 )
             }
             catch {
-                self.stopCapture(interfaceController: interfaceController)
-                self.continuation = nil
-                cont.resume(throwing: error)
+                self.cleanup(interfaceController: interfaceController)
+                box.resume(throwing: error)
             }
         }
-
-        return samplesAsData(samples)
     }
 
     func stop(interfaceController: AutoPlayInterfaceController? = nil) {
@@ -66,14 +102,23 @@ class VoiceInputManager {
             return
         }
         isStopping = true
-        let capturedContinuation = continuation
+        let wasSTTMode = isSTTMode
+        let capturedRequest = recognitionRequest
+        let box = resultBox
         let capturedSamples = samples
-        continuation = nil
+        resultBox = nil
         samples = []
         stopLock.unlock()
 
-        stopCapture(interfaceController: interfaceController)
-        capturedContinuation?.resume(returning: capturedSamples)
+        if wasSTTMode {
+            // endAudio() causes the recognition task to fire its final result,
+            // which resumes the box. Engine teardown happens there too.
+            capturedRequest?.endAudio()
+        }
+        else {
+            cleanup(interfaceController: interfaceController)
+            box?.resume(returning: makePCMResult(from: capturedSamples))
+        }
     }
 
     // MARK: - Private
@@ -82,13 +127,16 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String
+        listeningText: String,
+        preferSpeechToText: Bool,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        box: ResultBox,
+        language: String?
     ) throws {
         guard AVAudioSession.sharedInstance().recordPermission == .granted else {
             throw VoiceInputError.microphonePermissionDenied
         }
 
-        // Activate the session first so inputNode reports the correct hardware format
         let session = AVAudioSession.sharedInstance()
         try session.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
@@ -97,12 +145,60 @@ class VoiceInputManager {
             presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
         }
 
+        var activeRecognitionRequest: SFSpeechAudioBufferRecognitionRequest? = nil
+
+        if preferSpeechToText, SFSpeechRecognizer.authorizationStatus() == .authorized,
+            let recognizer = language != nil ? SFSpeechRecognizer(locale: Locale(identifier: language!)) : SFSpeechRecognizer(locale: Locale.current),
+            recognizer.isAvailable
+        {
+            let request = SFSpeechAudioBufferRecognitionRequest()
+            request.shouldReportPartialResults = true
+            recognitionRequest = request
+            activeRecognitionRequest = request
+
+            recognizer.recognitionTask(with: request) { [weak self] result, error in
+                guard let self else { return }
+
+                if error != nil {
+                    // STT failed — fall back to whatever PCM was accumulated
+                    self.stopLock.lock()
+                    self.isStopping = true
+                    let capturedSamples = self.samples
+                    self.samples = []
+                    self.stopLock.unlock()
+
+                    self.cleanup(interfaceController: interfaceController)
+                    box.resume(returning: self.makePCMResult(from: capturedSamples))
+                    return
+                }
+
+                guard let result else { return }
+
+                if result.isFinal {
+                    self.stopLock.lock()
+                    self.isStopping = true
+                    self.samples = []
+                    self.stopLock.unlock()
+
+                    self.cleanup(interfaceController: interfaceController)
+                    box.resume(
+                        returning: VoiceInputResult(
+                            transcription: result.bestTranscription.formattedString,
+                            audio: nil
+                        )
+                    )
+                }
+                else {
+                    onChunk?(VoiceInputChunk(partial: result.bestTranscription.formattedString, audio: nil))
+                }
+            }
+        }
+
         let engine = AVAudioEngine()
         let inputNode = engine.inputNode
         let nativeFormat = inputNode.outputFormat(forBus: 0)
 
-        let targetFormat = VoiceInputManager.targetFormat
-        guard let converter = AVAudioConverter(from: nativeFormat, to: targetFormat) else {
+        guard let converter = AVAudioConverter(from: nativeFormat, to: VoiceInputManager.targetFormat) else {
             throw VoiceInputError.converterUnavailable
         }
 
@@ -116,36 +212,47 @@ class VoiceInputManager {
         ) { [weak self] buffer, _ in
             guard let self, !self.isStopping else { return }
 
+            // Feed STT if active
+            activeRecognitionRequest?.append(buffer)
+
+            // Convert to 16kHz int16 for accumulation and PCM chunks
             let outputFrameCapacity = AVAudioFrameCount(
-                Double(buffer.frameLength)
-                    * VoiceInputManager.sampleRate
-                    / nativeFormat.sampleRate
+                Double(buffer.frameLength) * VoiceInputManager.sampleRate / nativeFormat.sampleRate
             )
-
             guard
                 let outputBuffer = AVAudioPCMBuffer(
-                    pcmFormat: targetFormat,
+                    pcmFormat: VoiceInputManager.targetFormat,
                     frameCapacity: outputFrameCapacity
                 )
             else { return }
 
             var conversionError: NSError?
-            let status = converter.convert(to: outputBuffer, error: &conversionError) {
-                _,
-                outStatus in
+            let status = converter.convert(to: outputBuffer, error: &conversionError) { _, outStatus in
                 outStatus.pointee = .haveData
                 return buffer
             }
-
             guard status != .error, let int16Data = outputBuffer.int16ChannelData else { return }
 
             let frameCount = Int(outputBuffer.frameLength)
             let newSamples = Array(UnsafeBufferPointer(start: int16Data[0], count: frameCount))
-            self.samples.append(contentsOf: newSamples)
+            self.stopLock.lock()
+            if !self.isStopping {
+                self.samples.append(contentsOf: newSamples)
+            }
+            self.stopLock.unlock()
+
+            // PCM chunk callback
+            if activeRecognitionRequest == nil, let onChunk {
+                if let chunkBuffer = try? ArrayBuffer.copy(
+                    data: newSamples.withUnsafeBufferPointer { Data(buffer: $0) }
+                ) {
+                    onChunk(VoiceInputChunk(partial: nil, audio: chunkBuffer))
+                }
+            }
 
             let now = Date()
 
-            // Max duration check
+            // Max duration — applies in both modes
             if let start = self.recordingStart,
                 now.timeIntervalSince(start) * 1000 >= maxDurationMs
             {
@@ -160,7 +267,9 @@ class VoiceInputManager {
             {
                 let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
                 if peak < VoiceInputManager.silenceAmplitudeThreshold {
-                    if self.silenceStart == nil { self.silenceStart = now }
+                    if self.silenceStart == nil {
+                        self.silenceStart = now
+                    }
                     if let silenceBegin = self.silenceStart,
                         now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
                     {
@@ -183,10 +292,11 @@ class VoiceInputManager {
         }
     }
 
-    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
+    private func cleanup(interfaceController: AutoPlayInterfaceController?) {
         audioEngine?.inputNode.removeTap(onBus: 0)
         audioEngine?.stop()
         audioEngine = nil
+        recognitionRequest = nil
         recordingStart = nil
         silenceStart = nil
         try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
@@ -195,6 +305,12 @@ class VoiceInputManager {
         }
     }
 
+    private func makePCMResult(from samples: [Int16]) -> VoiceInputResult {
+        let data = samples.withUnsafeBufferPointer { Data(buffer: $0) }
+        let buffer = try? ArrayBuffer.copy(data: data)
+        return VoiceInputResult(transcription: nil, audio: buffer)
+    }
+
     private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
         let listeningState = CPVoiceControlState(
             identifier: "listening",
@@ -218,12 +334,6 @@ class VoiceInputManager {
         }
         voiceControlTemplate = nil
     }
-
-    private func samplesAsData(_ samples: [Int16]) -> Data {
-        samples.withUnsafeBufferPointer { ptr in
-            Data(buffer: ptr)
-        }
-    }
 }
 
 enum VoiceInputError: Error {
diff --git a/packages/react-native-autoplay/nitro.json b/packages/react-native-autoplay/nitro.json
index 7ce78a7d..5c2add17 100644
--- a/packages/react-native-autoplay/nitro.json
+++ b/packages/react-native-autoplay/nitro.json
@@ -9,6 +9,16 @@
     "androidCxxLibName": "ReactNativeAutoPlay"
   },
   "autolinking": {
+    "Voice": {
+      "android": {
+        "implementationClassName": "HybridVoice",
+        "language": "kotlin"
+      },
+      "ios": {
+        "implementationClassName": "HybridVoice",
+        "language": "swift"
+      }
+    },
     "AutoPlay": {
       "android": {
         "implementationClassName": "HybridAutoPlay",
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake b/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake
index c823d1a1..d3015244 100644
--- a/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake
+++ b/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake
@@ -45,6 +45,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridMessageTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSearchTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSignInTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridVoiceSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
@@ -62,6 +63,7 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridSearchTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JHybridSignInTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JVariant_QrSignIn_PinSignIn_InputSignIn_GoogleSignIn.cpp
+  ../nitrogen/generated/android/c++/JHybridVoiceSpec.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp b/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp
index a673aeb3..49dde806 100644
--- a/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp
+++ b/packages/react-native-autoplay/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp
@@ -46,6 +46,8 @@
 #include "JHybridSearchTemplateSpec.hpp"
 #include "JHybridSignInTemplateSpec.hpp"
 #include "JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_.hpp"
+#include "JHybridVoiceSpec.hpp"
+#include "JFunc_void_VoiceInputChunk.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -56,6 +58,14 @@ int initialize(JavaVM* vm) {
   });
 }
 
+struct JHybridVoiceSpecImpl: public jni::JavaClass<JHybridVoiceSpecImpl, JHybridVoiceSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoice;";
+  static std::shared_ptr<JHybridVoiceSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridVoiceSpecImpl::javaobject()>();
+    jni::local_ref<JHybridVoiceSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridVoiceSpec();
+  }
+};
 struct JHybridAutoPlaySpecImpl: public jni::JavaClass<JHybridAutoPlaySpecImpl, JHybridAutoPlaySpec::JavaPart> {
   static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay;";
   static std::shared_ptr<JHybridAutoPlaySpec> create() {
@@ -181,8 +191,16 @@ void registerAllNatives() {
   margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSearchTemplateSpec::CxxPart::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSignInTemplateSpec::CxxPart::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount__cxx::registerNatives();
+  margelo::nitro::swe::iternio::reactnativeautoplay::JHybridVoiceSpec::CxxPart::registerNatives();
+  margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_VoiceInputChunk_cxx::registerNatives();
 
   // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Voice",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridVoiceSpecImpl::create();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "AutoPlay",
     []() -> std::shared_ptr<HybridObject> {
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JFunc_void_VoiceInputChunk.hpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JFunc_void_VoiceInputChunk.hpp
new file mode 100644
index 00000000..c2f4b338
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JFunc_void_VoiceInputChunk.hpp
@@ -0,0 +1,81 @@
+///
+/// JFunc_void_VoiceInputChunk.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "VoiceInputChunk.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JVoiceInputChunk.hpp"
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(chunk: VoiceInputChunk) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_VoiceInputChunk: public jni::JavaClass<JFunc_void_VoiceInputChunk> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_VoiceInputChunk` instance holds through JNI.
+     */
+    void invoke(const VoiceInputChunk& chunk) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVoiceInputChunk> /* chunk */)>("invoke");
+      method(self(), JVoiceInputChunk::fromCpp(chunk));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_VoiceInputChunk that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_VoiceInputChunk_cxx final: public jni::HybridClass<JFunc_void_VoiceInputChunk_cxx, JFunc_void_VoiceInputChunk> {
+  public:
+    static jni::local_ref<JFunc_void_VoiceInputChunk::javaobject> fromCpp(const std::function<void(const VoiceInputChunk& /* chunk */)>& func) {
+      return JFunc_void_VoiceInputChunk_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_VoiceInputChunk_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JVoiceInputChunk> chunk) {
+      _func(chunk->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const VoiceInputChunk& /* chunk */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_VoiceInputChunk_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_VoiceInputChunk_cxx(const std::function<void(const VoiceInputChunk& /* chunk */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const VoiceInputChunk& /* chunk */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
index 9d5d68d7..d8f0072b 100644
--- a/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
@@ -37,8 +37,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include <NitroModules/JNICallable.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
-#include <NitroModules/ArrayBuffer.hpp>
-#include <NitroModules/JArrayBuffer.hpp>
 #include <NitroModules/JUnit.hpp>
 #include "EventName.hpp"
 #include "JEventName.hpp"
@@ -145,47 +143,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       }
     }();
   }
-  bool JHybridAutoPlaySpec::hasVoiceInputPermission() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("hasVoiceInputPermission");
-    auto __result = method(_javaPart);
-    return static_cast<bool>(__result);
-  }
-  std::shared_ptr<Promise<bool>> JHybridAutoPlaySpec::requestVoiceInputPermission() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestVoiceInputPermission");
-    auto __result = method(_javaPart);
-    return [&]() {
-      auto __promise = Promise<bool>::create();
-      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
-        __promise->resolve(static_cast<bool>(__result->value()));
-      });
-      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
-        jni::JniException __jniError(__throwable);
-        __promise->reject(std::make_exception_ptr(__jniError));
-      });
-      return __promise;
-    }();
-  }
-  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> JHybridAutoPlaySpec::startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JDouble> /* silenceThresholdMs */, jni::alias_ref<jni::JDouble> /* maxDurationMs */, jni::alias_ref<jni::JString> /* listeningText */)>("startVoiceInput");
-    auto __result = method(_javaPart, silenceThresholdMs.has_value() ? jni::JDouble::valueOf(silenceThresholdMs.value()) : nullptr, maxDurationMs.has_value() ? jni::JDouble::valueOf(maxDurationMs.value()) : nullptr, listeningText.has_value() ? jni::make_jstring(listeningText.value()) : nullptr);
-    return [&]() {
-      auto __promise = Promise<std::shared_ptr<ArrayBuffer>>::create();
-      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-        auto __result = jni::static_ref_cast<JArrayBuffer::javaobject>(__boxedResult);
-        __promise->resolve(__result->cthis()->getArrayBuffer());
-      });
-      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
-        jni::JniException __jniError(__throwable);
-        __promise->reject(std::make_exception_ptr(__jniError));
-      });
-      return __promise;
-    }();
-  }
-  void JHybridAutoPlaySpec::stopVoiceInput() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopVoiceInput");
-    method(_javaPart);
-  }
   std::shared_ptr<Promise<void>> JHybridAutoPlaySpec::setRootTemplate(const std::string& templateId) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */)>("setRootTemplate");
     auto __result = method(_javaPart, jni::make_jstring(templateId));
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.hpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.hpp
index 1eb29d7e..7ccbe1aa 100644
--- a/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.hpp
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridAutoPlaySpec.hpp
@@ -57,10 +57,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::function<void()> addListener(EventName eventType, const std::function<void()>& callback) override;
     std::function<void()> addListenerRenderState(const std::string& moduleName, const std::function<void(VisibilityState /* payload */)>& callback) override;
     std::function<void()> addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) override;
-    bool hasVoiceInputPermission() override;
-    std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override;
-    std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) override;
-    void stopVoiceInput() override;
     std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) override;
     std::shared_ptr<Promise<void>> pushTemplate(const std::string& templateId) override;
     std::shared_ptr<Promise<void>> popTemplate(std::optional<bool> animate) override;
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridVoiceSpec.cpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridVoiceSpec.cpp
new file mode 100644
index 00000000..a56d0312
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridVoiceSpec.cpp
@@ -0,0 +1,104 @@
+///
+/// JHybridVoiceSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridVoiceSpec.hpp"
+
+// Forward declaration of `VoiceInputResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
+// Forward declaration of `VoiceInputChunk` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "VoiceInputResult.hpp"
+#include "JVoiceInputResult.hpp"
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include "VoiceInputChunk.hpp"
+#include <functional>
+#include "JFunc_void_VoiceInputChunk.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JVoiceInputChunk.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  std::shared_ptr<JHybridVoiceSpec> JHybridVoiceSpec::JavaPart::getJHybridVoiceSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridVoiceSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridVoiceSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridVoiceSpec::CxxPart::jhybriddata> JHybridVoiceSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridVoiceSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridVoiceSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridVoiceSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridVoiceSpec>(castJavaPart);
+  }
+
+  void JHybridVoiceSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVoiceSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  bool JHybridVoiceSpec::hasVoiceInputPermission() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("hasVoiceInputPermission");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::shared_ptr<Promise<bool>> JHybridVoiceSpec::requestVoiceInputPermission() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestVoiceInputPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<VoiceInputResult>> JHybridVoiceSpec::startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JDouble> /* silenceThresholdMs */, jni::alias_ref<jni::JDouble> /* maxDurationMs */, jni::alias_ref<jni::JString> /* listeningText */, jni::alias_ref<jni::JBoolean> /* preferSpeechToText */, jni::alias_ref<JFunc_void_VoiceInputChunk::javaobject> /* onChunk */, jni::alias_ref<jni::JString> /* language */)>("startVoiceInput_cxx");
+    auto __result = method(_javaPart, silenceThresholdMs.has_value() ? jni::JDouble::valueOf(silenceThresholdMs.value()) : nullptr, maxDurationMs.has_value() ? jni::JDouble::valueOf(maxDurationMs.value()) : nullptr, listeningText.has_value() ? jni::make_jstring(listeningText.value()) : nullptr, preferSpeechToText.has_value() ? jni::JBoolean::valueOf(preferSpeechToText.value()) : nullptr, onChunk.has_value() ? JFunc_void_VoiceInputChunk_cxx::fromCpp(onChunk.value()) : nullptr, language.has_value() ? jni::make_jstring(language.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<VoiceInputResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVoiceInputResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridVoiceSpec::stopVoiceInput() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopVoiceInput");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridVoiceSpec.hpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridVoiceSpec.hpp
new file mode 100644
index 00000000..83168210
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JHybridVoiceSpec.hpp
@@ -0,0 +1,66 @@
+///
+/// HybridVoiceSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridVoiceSpec.hpp"
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  class JHybridVoiceSpec: public virtual HybridVoiceSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoiceSpec;";
+      std::shared_ptr<JHybridVoiceSpec> getJHybridVoiceSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoiceSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridVoiceSpec(const jni::local_ref<JHybridVoiceSpec::JavaPart>& javaPart):
+      HybridObject(HybridVoiceSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridVoiceSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridVoiceSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    bool hasVoiceInputPermission() override;
+    std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override;
+    std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) override;
+    void stopVoiceInput() override;
+
+  private:
+    jni::global_ref<JHybridVoiceSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JVoiceInputChunk.hpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JVoiceInputChunk.hpp
new file mode 100644
index 00000000..c418edca
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JVoiceInputChunk.hpp
@@ -0,0 +1,64 @@
+///
+/// JVoiceInputChunk.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "VoiceInputChunk.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "VoiceInputChunk" and the the Kotlin data class "VoiceInputChunk".
+   */
+  struct JVoiceInputChunk final: public jni::JavaClass<JVoiceInputChunk> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputChunk;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct VoiceInputChunk by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    VoiceInputChunk toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPartial = clazz->getField<jni::JString>("partial");
+      jni::local_ref<jni::JString> partial = this->getFieldValue(fieldPartial);
+      static const auto fieldAudio = clazz->getField<JArrayBuffer::javaobject>("audio");
+      jni::local_ref<JArrayBuffer::javaobject> audio = this->getFieldValue(fieldAudio);
+      return VoiceInputChunk(
+        partial != nullptr ? std::make_optional(partial->toStdString()) : std::nullopt,
+        audio != nullptr ? std::make_optional(audio->cthis()->getArrayBuffer()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JVoiceInputChunk::javaobject> fromCpp(const VoiceInputChunk& value) {
+      using JSignature = JVoiceInputChunk(jni::alias_ref<jni::JString>, jni::alias_ref<JArrayBuffer::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.partial.has_value() ? jni::make_jstring(value.partial.value()) : nullptr,
+        value.audio.has_value() ? JArrayBuffer::wrap(value.audio.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/c++/JVoiceInputResult.hpp b/packages/react-native-autoplay/nitrogen/generated/android/c++/JVoiceInputResult.hpp
new file mode 100644
index 00000000..62b2aa36
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/c++/JVoiceInputResult.hpp
@@ -0,0 +1,64 @@
+///
+/// JVoiceInputResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "VoiceInputResult.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "VoiceInputResult" and the the Kotlin data class "VoiceInputResult".
+   */
+  struct JVoiceInputResult final: public jni::JavaClass<JVoiceInputResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct VoiceInputResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    VoiceInputResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTranscription = clazz->getField<jni::JString>("transcription");
+      jni::local_ref<jni::JString> transcription = this->getFieldValue(fieldTranscription);
+      static const auto fieldAudio = clazz->getField<JArrayBuffer::javaobject>("audio");
+      jni::local_ref<JArrayBuffer::javaobject> audio = this->getFieldValue(fieldAudio);
+      return VoiceInputResult(
+        transcription != nullptr ? std::make_optional(transcription->toStdString()) : std::nullopt,
+        audio != nullptr ? std::make_optional(audio->cthis()->getArrayBuffer()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JVoiceInputResult::javaobject> fromCpp(const VoiceInputResult& value) {
+      using JSignature = JVoiceInputResult(jni::alias_ref<jni::JString>, jni::alias_ref<JArrayBuffer::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.transcription.has_value() ? jni::make_jstring(value.transcription.value()) : nullptr,
+        value.audio.has_value() ? JArrayBuffer::wrap(value.audio.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk.kt b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk.kt
new file mode 100644
index 00000000..a767f72a
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk.kt
@@ -0,0 +1,80 @@
+///
+/// Func_void_VoiceInputChunk.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(chunk: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_VoiceInputChunk: (VoiceInputChunk) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(chunk: VoiceInputChunk): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(chunk: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_VoiceInputChunk_cxx: Func_void_VoiceInputChunk {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(chunk: VoiceInputChunk): Unit
+    = invoke_cxx(chunk)
+
+  @FastNative
+  private external fun invoke_cxx(chunk: VoiceInputChunk): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(chunk: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(VoiceInputChunk) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_VoiceInputChunk_java(private val function: (VoiceInputChunk) -> Unit): Func_void_VoiceInputChunk {
+  @DoNotStrip
+  @Keep
+  override fun invoke(chunk: VoiceInputChunk): Unit {
+    return this.function(chunk)
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlaySpec.kt b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlaySpec.kt
index fe59064c..e3d208e6 100644
--- a/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlaySpec.kt
+++ b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlaySpec.kt
@@ -11,7 +11,6 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.Promise
-import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -57,22 +56,6 @@ abstract class HybridAutoPlaySpec: HybridObject() {
     return Func_void_java(__result)
   }
   
-  @DoNotStrip
-  @Keep
-  abstract fun hasVoiceInputPermission(): Boolean
-  
-  @DoNotStrip
-  @Keep
-  abstract fun requestVoiceInputPermission(): Promise<Boolean>
-  
-  @DoNotStrip
-  @Keep
-  abstract fun startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?): Promise<ArrayBuffer>
-  
-  @DoNotStrip
-  @Keep
-  abstract fun stopVoiceInput(): Unit
-  
   @DoNotStrip
   @Keep
   abstract fun setRootTemplate(templateId: String): Promise<Unit>
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoiceSpec.kt b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoiceSpec.kt
new file mode 100644
index 00000000..1c582f47
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoiceSpec.kt
@@ -0,0 +1,72 @@
+///
+/// HybridVoiceSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the Voice HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of Voice.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridVoiceSpec: HybridObject() {
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun hasVoiceInputPermission(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun requestVoiceInputPermission(): Promise<Boolean>
+  
+  abstract fun startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, preferSpeechToText: Boolean?, onChunk: ((chunk: VoiceInputChunk) -> Unit)?, language: String?): Promise<VoiceInputResult>
+  
+  @DoNotStrip
+  @Keep
+  private fun startVoiceInput_cxx(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, preferSpeechToText: Boolean?, onChunk: Func_void_VoiceInputChunk?, language: String?): Promise<VoiceInputResult> {
+    val __result = startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk?.let { it }, language)
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun stopVoiceInput(): Unit
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject Voice]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridVoiceSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridVoiceSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridVoiceSpec"
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputChunk.kt b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputChunk.kt
new file mode 100644
index 00000000..4fc72ea0
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputChunk.kt
@@ -0,0 +1,56 @@
+///
+/// VoiceInputChunk.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+import com.margelo.nitro.core.ArrayBuffer
+
+/**
+ * Represents the JavaScript object/struct "VoiceInputChunk".
+ */
+@DoNotStrip
+@Keep
+data class VoiceInputChunk(
+  @DoNotStrip
+  @Keep
+  val partial: String?,
+  @DoNotStrip
+  @Keep
+  val audio: ArrayBuffer?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is VoiceInputChunk) return false
+    return Objects.deepEquals(this.partial, other.partial)
+      && Objects.deepEquals(this.audio, other.audio)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      partial,
+      audio
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(partial: String?, audio: ArrayBuffer?): VoiceInputChunk {
+      return VoiceInputChunk(partial, audio)
+    }
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputResult.kt b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputResult.kt
new file mode 100644
index 00000000..4fc57980
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputResult.kt
@@ -0,0 +1,56 @@
+///
+/// VoiceInputResult.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+import com.margelo.nitro.core.ArrayBuffer
+
+/**
+ * Represents the JavaScript object/struct "VoiceInputResult".
+ */
+@DoNotStrip
+@Keep
+data class VoiceInputResult(
+  @DoNotStrip
+  @Keep
+  val transcription: String?,
+  @DoNotStrip
+  @Keep
+  val audio: ArrayBuffer?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is VoiceInputResult) return false
+    return Objects.deepEquals(this.transcription, other.transcription)
+      && Objects.deepEquals(this.audio, other.audio)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      transcription,
+      audio
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(transcription: String?, audio: ArrayBuffer?): VoiceInputResult {
+      return VoiceInputResult(transcription, audio)
+    }
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.cpp b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.cpp
index c5baaf5b..744f60da 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.cpp
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.cpp
@@ -17,6 +17,7 @@
 #include "HybridMapTemplateSpecSwift.hpp"
 #include "HybridMessageTemplateSpecSwift.hpp"
 #include "HybridSearchTemplateSpecSwift.hpp"
+#include "HybridVoiceSpecSwift.hpp"
 #include "ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
 
@@ -46,14 +47,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(bool /* result */)>
-  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = ReactNativeAutoPlay::Func_void_bool::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
   Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeAutoPlay::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
@@ -62,14 +55,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
-  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = ReactNativeAutoPlay::Func_void_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<ArrayBuffer>& result) mutable -> void {
-      swiftClosure.call(ArrayBufferHolder(result));
-    };
-  }
-  
   // pragma MARK: std::function<void(const SafeAreaInsets& /* insets */)>
   Func_void_SafeAreaInsets create_Func_void_SafeAreaInsets(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeAutoPlay::Func_void_SafeAreaInsets::fromUnsafe(swiftClosureWrapper);
@@ -174,6 +159,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(bool /* isPanningInterfaceVisible */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool isPanningInterfaceVisible) mutable -> void {
+      swiftClosure.call(isPanningInterfaceVisible);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridGridTemplateSpec>
   std::shared_ptr<HybridGridTemplateSpec> create_std__shared_ptr_HybridGridTemplateSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeAutoPlay::HybridGridTemplateSpec_cxx swiftPart = ReactNativeAutoPlay::HybridGridTemplateSpec_cxx::fromUnsafe(swiftUnsafePointer);
@@ -309,5 +302,37 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     ReactNativeAutoPlay::HybridSearchTemplateSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
+  
+  // pragma MARK: std::function<void(const VoiceInputResult& /* result */)>
+  Func_void_VoiceInputResult create_Func_void_VoiceInputResult(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_VoiceInputResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const VoiceInputResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const VoiceInputChunk& /* chunk */)>
+  Func_void_VoiceInputChunk create_Func_void_VoiceInputChunk(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_VoiceInputChunk::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const VoiceInputChunk& chunk) mutable -> void {
+      swiftClosure.call(chunk);
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridVoiceSpec>
+  std::shared_ptr<HybridVoiceSpec> create_std__shared_ptr_HybridVoiceSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    ReactNativeAutoPlay::HybridVoiceSpec_cxx swiftPart = ReactNativeAutoPlay::HybridVoiceSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::swe::iternio::reactnativeautoplay::HybridVoiceSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridVoiceSpec_(std__shared_ptr_HybridVoiceSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::swe::iternio::reactnativeautoplay::HybridVoiceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::swe::iternio::reactnativeautoplay::HybridVoiceSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridVoiceSpec\" is not implemented in Swift!");
+    }
+    #endif
+    ReactNativeAutoPlay::HybridVoiceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.hpp b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.hpp
index f05e8385..454a1526 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.hpp
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.hpp
@@ -48,6 +48,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridMapTem
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridMessageTemplateSpec; }
 // Forward declaration of `HybridSearchTemplateSpec` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridSearchTemplateSpec; }
+// Forward declaration of `HybridVoiceSpec` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridVoiceSpec; }
 // Forward declaration of `ImageLane` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct ImageLane; }
 // Forward declaration of `KeepType` to properly resolve imports.
@@ -126,6 +128,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class TurnTyp
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibilityState; }
 // Forward declaration of `VisibleTravelEstimate` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibleTravelEstimate; }
+// Forward declaration of `VoiceInputChunk` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
+// Forward declaration of `VoiceInputResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
 // Forward declaration of `ZoomEvent` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEvent; }
 
@@ -148,6 +154,8 @@ namespace ReactNativeAutoPlay { class HybridMapTemplateSpec_cxx; }
 namespace ReactNativeAutoPlay { class HybridMessageTemplateSpec_cxx; }
 // Forward declaration of `HybridSearchTemplateSpec_cxx` to properly resolve imports.
 namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
+// Forward declaration of `HybridVoiceSpec_cxx` to properly resolve imports.
+namespace ReactNativeAutoPlay { class HybridVoiceSpec_cxx; }
 
 // Include C++ defined types
 #include "AlertActionStyle.hpp"
@@ -169,6 +177,7 @@ namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
 #include "HybridMapTemplateSpec.hpp"
 #include "HybridMessageTemplateSpec.hpp"
 #include "HybridSearchTemplateSpec.hpp"
+#include "HybridVoiceSpec.hpp"
 #include "ImageLane.hpp"
 #include "KeepType.hpp"
 #include "LaneGuidance.hpp"
@@ -208,6 +217,8 @@ namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
 #include "TurnType.hpp"
 #include "VisibilityState.hpp"
 #include "VisibleTravelEstimate.hpp"
+#include "VoiceInputChunk.hpp"
+#include "VoiceInputResult.hpp"
 #include "ZoomEvent.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
@@ -324,38 +335,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Func_void_std__optional_Location__std__optional_std__string__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<bool>>
+  // pragma MARK: std::shared_ptr<Promise<void>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
    */
-  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
-  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
-    return Promise<bool>::create();
-  }
-  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
-    return PromiseHolder<bool>(std::move(promise));
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
   }
-  
-  // pragma MARK: std::function<void(bool /* result */)>
-  /**
-   * Specialized version of `std::function<void(bool)>`.
-   */
-  using Func_void_bool = std::function<void(bool /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_bool_Wrapper final {
-  public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
-    inline void call(bool result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(bool /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
-    return Func_void_bool_Wrapper(std::move(value));
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
   }
   
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
@@ -380,67 +369,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>`.
-   */
-  using std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ = std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>;
-  inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() noexcept {
-    return Promise<std::shared_ptr<ArrayBuffer>>::create();
-  }
-  inline PromiseHolder<std::shared_ptr<ArrayBuffer>> wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> promise) noexcept {
-    return PromiseHolder<std::shared_ptr<ArrayBuffer>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::shared_ptr<ArrayBuffer>&)>`.
-   */
-  using Func_void_std__shared_ptr_ArrayBuffer_ = std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::shared_ptr<ArrayBuffer>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__shared_ptr_ArrayBuffer__Wrapper final {
-  public:
-    explicit Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>>(std::move(func))) {}
-    inline void call(ArrayBufferHolder result) const noexcept {
-      _function->operator()(result.getArrayBuffer());
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__shared_ptr_ArrayBuffer__Wrapper wrap_Func_void_std__shared_ptr_ArrayBuffer_(Func_void_std__shared_ptr_ArrayBuffer_ value) noexcept {
-    return Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::optional<double>
-  /**
-   * Specialized version of `std::optional<double>`.
-   */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
-  }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<void>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<void>>`.
-   */
-  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
-  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
-    return Promise<void>::create();
-  }
-  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
-    return PromiseHolder<void>(std::move(promise));
-  }
-  
   // pragma MARK: std::optional<bool>
   /**
    * Specialized version of `std::optional<bool>`.
@@ -478,6 +406,21 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Func_void_SafeAreaInsets_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<NitroColor>
   /**
    * Specialized version of `std::optional<NitroColor>`.
@@ -620,42 +563,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Result<std::function<void()>>::withError(error);
   }
   
-  // pragma MARK: Result<bool>
-  using Result_bool_ = Result<bool>;
-  inline Result_bool_ create_Result_bool_(bool value) noexcept {
-    return Result<bool>::withValue(std::move(value));
-  }
-  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
-    return Result<bool>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
-  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>
-  using Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ = Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>;
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<void>
-  using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() noexcept {
-    return Result<void>::withValue();
-  }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
-    return Result<void>::withError(error);
-  }
-  
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
   using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
@@ -665,6 +572,15 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+  
   // pragma MARK: std::vector<std::string>
   /**
    * Specialized version of `std::vector<std::string>`.
@@ -858,6 +774,15 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
   using std__weak_ptr_HybridClusterSpec_ = std::weak_ptr<HybridClusterSpec>;
   inline std__weak_ptr_HybridClusterSpec_ weakify_std__shared_ptr_HybridClusterSpec_(const std::shared_ptr<HybridClusterSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
   // pragma MARK: std::function<void(std::optional<bool> /* animated */)>
   /**
    * Specialized version of `std::function<void(std::optional<bool>)>`.
@@ -962,6 +887,28 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::function<void(bool /* isPanningInterfaceVisible */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* isPanningInterfaceVisible */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * isPanningInterfaceVisible * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* isPanningInterfaceVisible */)>&& func): _function(std::make_unique<std::function<void(bool /* isPanningInterfaceVisible */)>>(std::move(func))) {}
+    inline void call(bool isPanningInterfaceVisible) const noexcept {
+      _function->operator()(isPanningInterfaceVisible);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* isPanningInterfaceVisible */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::optional<std::function<void(bool /* isPanningInterfaceVisible */)>>
   /**
    * Specialized version of `std::optional<std::function<void(bool / * isPanningInterfaceVisible * /)>>`.
@@ -1634,5 +1581,133 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
   // pragma MARK: std::weak_ptr<HybridSearchTemplateSpec>
   using std__weak_ptr_HybridSearchTemplateSpec_ = std::weak_ptr<HybridSearchTemplateSpec>;
   inline std__weak_ptr_HybridSearchTemplateSpec_ weakify_std__shared_ptr_HybridSearchTemplateSpec_(const std::shared_ptr<HybridSearchTemplateSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::optional<std::shared_ptr<ArrayBuffer>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<ArrayBuffer>>`.
+   */
+  using std__optional_std__shared_ptr_ArrayBuffer__ = std::optional<std::shared_ptr<ArrayBuffer>>;
+  inline std::optional<std::shared_ptr<ArrayBuffer>> create_std__optional_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {
+    return std::optional<std::shared_ptr<ArrayBuffer>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<ArrayBuffer> get_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<VoiceInputResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<VoiceInputResult>>`.
+   */
+  using std__shared_ptr_Promise_VoiceInputResult__ = std::shared_ptr<Promise<VoiceInputResult>>;
+  inline std::shared_ptr<Promise<VoiceInputResult>> create_std__shared_ptr_Promise_VoiceInputResult__() noexcept {
+    return Promise<VoiceInputResult>::create();
+  }
+  inline PromiseHolder<VoiceInputResult> wrap_std__shared_ptr_Promise_VoiceInputResult__(std::shared_ptr<Promise<VoiceInputResult>> promise) noexcept {
+    return PromiseHolder<VoiceInputResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const VoiceInputResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const VoiceInputResult&)>`.
+   */
+  using Func_void_VoiceInputResult = std::function<void(const VoiceInputResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const VoiceInputResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_VoiceInputResult_Wrapper final {
+  public:
+    explicit Func_void_VoiceInputResult_Wrapper(std::function<void(const VoiceInputResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const VoiceInputResult& /* result */)>>(std::move(func))) {}
+    inline void call(VoiceInputResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const VoiceInputResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_VoiceInputResult create_Func_void_VoiceInputResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_VoiceInputResult_Wrapper wrap_Func_void_VoiceInputResult(Func_void_VoiceInputResult value) noexcept {
+    return Func_void_VoiceInputResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const VoiceInputChunk& /* chunk */)>
+  /**
+   * Specialized version of `std::function<void(const VoiceInputChunk&)>`.
+   */
+  using Func_void_VoiceInputChunk = std::function<void(const VoiceInputChunk& /* chunk */)>;
+  /**
+   * Wrapper class for a `std::function<void(const VoiceInputChunk& / * chunk * /)>`, this can be used from Swift.
+   */
+  class Func_void_VoiceInputChunk_Wrapper final {
+  public:
+    explicit Func_void_VoiceInputChunk_Wrapper(std::function<void(const VoiceInputChunk& /* chunk */)>&& func): _function(std::make_unique<std::function<void(const VoiceInputChunk& /* chunk */)>>(std::move(func))) {}
+    inline void call(VoiceInputChunk chunk) const noexcept {
+      _function->operator()(chunk);
+    }
+  private:
+    std::unique_ptr<std::function<void(const VoiceInputChunk& /* chunk */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_VoiceInputChunk create_Func_void_VoiceInputChunk(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_VoiceInputChunk_Wrapper wrap_Func_void_VoiceInputChunk(Func_void_VoiceInputChunk value) noexcept {
+    return Func_void_VoiceInputChunk_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const VoiceInputChunk& / * chunk * /)>>`.
+   */
+  using std__optional_std__function_void_const_VoiceInputChunk_____chunk______ = std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>;
+  inline std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>> create_std__optional_std__function_void_const_VoiceInputChunk_____chunk______(const std::function<void(const VoiceInputChunk& /* chunk */)>& value) noexcept {
+    return std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_VoiceInputChunk_____chunk______(const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const VoiceInputChunk& /* chunk */)> get_std__optional_std__function_void_const_VoiceInputChunk_____chunk______(const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridVoiceSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridVoiceSpec>`.
+   */
+  using std__shared_ptr_HybridVoiceSpec_ = std::shared_ptr<HybridVoiceSpec>;
+  std::shared_ptr<HybridVoiceSpec> create_std__shared_ptr_HybridVoiceSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridVoiceSpec_(std__shared_ptr_HybridVoiceSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridVoiceSpec>
+  using std__weak_ptr_HybridVoiceSpec_ = std::weak_ptr<HybridVoiceSpec>;
+  inline std__weak_ptr_HybridVoiceSpec_ weakify_std__shared_ptr_HybridVoiceSpec_(const std::shared_ptr<HybridVoiceSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<VoiceInputResult>>>
+  using Result_std__shared_ptr_Promise_VoiceInputResult___ = Result<std::shared_ptr<Promise<VoiceInputResult>>>;
+  inline Result_std__shared_ptr_Promise_VoiceInputResult___ create_Result_std__shared_ptr_Promise_VoiceInputResult___(const std::shared_ptr<Promise<VoiceInputResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<VoiceInputResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_VoiceInputResult___ create_Result_std__shared_ptr_Promise_VoiceInputResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<VoiceInputResult>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp
index d3d8b6e4..a8580197 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp
@@ -52,6 +52,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridMapTem
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridMessageTemplateSpec; }
 // Forward declaration of `HybridSearchTemplateSpec` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridSearchTemplateSpec; }
+// Forward declaration of `HybridVoiceSpec` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridVoiceSpec; }
 // Forward declaration of `ImageLane` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct ImageLane; }
 // Forward declaration of `InformationTemplateConfig` to properly resolve imports.
@@ -148,6 +150,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class TurnTyp
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibilityState; }
 // Forward declaration of `VisibleTravelEstimate` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibleTravelEstimate; }
+// Forward declaration of `VoiceInputChunk` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
+// Forward declaration of `VoiceInputResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
 // Forward declaration of `ZoomEvent` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEvent; }
 
@@ -174,6 +180,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "HybridMapTemplateSpec.hpp"
 #include "HybridMessageTemplateSpec.hpp"
 #include "HybridSearchTemplateSpec.hpp"
+#include "HybridVoiceSpec.hpp"
 #include "ImageLane.hpp"
 #include "InformationTemplateConfig.hpp"
 #include "KeepType.hpp"
@@ -222,6 +229,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "TurnType.hpp"
 #include "VisibilityState.hpp"
 #include "VisibleTravelEstimate.hpp"
+#include "VoiceInputChunk.hpp"
+#include "VoiceInputResult.hpp"
 #include "ZoomEvent.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
@@ -262,6 +271,8 @@ namespace ReactNativeAutoPlay { class HybridMapTemplateSpec_cxx; }
 namespace ReactNativeAutoPlay { class HybridMessageTemplateSpec_cxx; }
 // Forward declaration of `HybridSearchTemplateSpec_cxx` to properly resolve imports.
 namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
+// Forward declaration of `HybridVoiceSpec_cxx` to properly resolve imports.
+namespace ReactNativeAutoPlay { class HybridVoiceSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("ReactNativeAutoPlay-Swift.h")
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.mm b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.mm
index b987920b..41f11973 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.mm
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.mm
@@ -10,6 +10,7 @@
 #import "ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp"
 #import <type_traits>
 
+#include "HybridVoiceSpecSwift.hpp"
 #include "HybridAutoPlaySpecSwift.hpp"
 #include "HybridListTemplateSpecSwift.hpp"
 #include "HybridInformationTemplateSpecSwift.hpp"
@@ -29,6 +30,13 @@ + (void) load {
   using namespace margelo::nitro;
   using namespace margelo::nitro::swe::iternio::reactnativeautoplay;
 
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Voice",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridVoiceSpec> hybridObject = ReactNativeAutoPlay::ReactNativeAutoPlayAutolinking::createVoice();
+      return hybridObject;
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "AutoPlay",
     []() -> std::shared_ptr<HybridObject> {
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.swift b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.swift
index c99ba5ae..031d2b8f 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.swift
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.swift
@@ -12,6 +12,18 @@ import NitroModules
 public final class ReactNativeAutoPlayAutolinking {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
+  public static func createVoice() -> bridge.std__shared_ptr_HybridVoiceSpec_ {
+    let hybridObject = HybridVoice()
+    return { () -> bridge.std__shared_ptr_HybridVoiceSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isVoiceRecyclable() -> Bool {
+    return HybridVoice.self is any RecyclableView.Type
+  }
+  
   public static func createAutoPlay() -> bridge.std__shared_ptr_HybridAutoPlaySpec_ {
     let hybridObject = HybridAutoPlay()
     return { () -> bridge.std__shared_ptr_HybridAutoPlaySpec_ in
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridAutoPlaySpecSwift.hpp b/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridAutoPlaySpecSwift.hpp
index 7f7569f4..0235a04e 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridAutoPlaySpecSwift.hpp
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridAutoPlaySpecSwift.hpp
@@ -18,8 +18,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class EventNa
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibilityState; }
 // Forward declaration of `Location` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Location; }
-// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
-namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `SafeAreaInsets` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct SafeAreaInsets; }
 // Forward declaration of `NitroAction` to properly resolve imports.
@@ -46,8 +44,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include "Location.hpp"
 #include <optional>
 #include <NitroModules/Promise.hpp>
-#include <NitroModules/ArrayBuffer.hpp>
-#include <NitroModules/ArrayBufferHolder.hpp>
 #include "SafeAreaInsets.hpp"
 #include "NitroAction.hpp"
 #include <vector>
@@ -134,36 +130,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool hasVoiceInputPermission() override {
-      auto __result = _swiftPart.hasVoiceInputPermission();
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
-    inline std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override {
-      auto __result = _swiftPart.requestVoiceInputPermission();
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
-    inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) override {
-      auto __result = _swiftPart.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText);
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
-    inline void stopVoiceInput() override {
-      auto __result = _swiftPart.stopVoiceInput();
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-    }
     inline std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) override {
       auto __result = _swiftPart.setRootTemplate(templateId);
       if (__result.hasError()) [[unlikely]] {
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.cpp b/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.cpp
new file mode 100644
index 00000000..a34e3b19
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.cpp
@@ -0,0 +1,11 @@
+///
+/// HybridVoiceSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVoiceSpecSwift.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.hpp b/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.hpp
new file mode 100644
index 00000000..40606742
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.hpp
@@ -0,0 +1,116 @@
+///
+/// HybridVoiceSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVoiceSpec.hpp"
+
+// Forward declaration of `HybridVoiceSpec_cxx` to properly resolve imports.
+namespace ReactNativeAutoPlay { class HybridVoiceSpec_cxx; }
+
+// Forward declaration of `VoiceInputResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `VoiceInputChunk` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
+
+#include <NitroModules/Promise.hpp>
+#include "VoiceInputResult.hpp"
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include "VoiceInputChunk.hpp"
+#include <functional>
+
+#include "ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * The C++ part of HybridVoiceSpec_cxx.swift.
+   *
+   * HybridVoiceSpecSwift (C++) accesses HybridVoiceSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridVoiceSpec_cxx can directly inherit from the C++ class HybridVoiceSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVoiceSpecSwift: public virtual HybridVoiceSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVoiceSpecSwift(const ReactNativeAutoPlay::HybridVoiceSpec_cxx& swiftPart):
+      HybridObject(HybridVoiceSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeAutoPlay::HybridVoiceSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridVoiceSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline bool hasVoiceInputPermission() override {
+      auto __result = _swiftPart.hasVoiceInputPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override {
+      auto __result = _swiftPart.requestVoiceInputPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) override {
+      auto __result = _swiftPart.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk, language);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void stopVoiceInput() override {
+      auto __result = _swiftPart.stopVoiceInput();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    ReactNativeAutoPlay::HybridVoiceSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_VoiceInputChunk.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_VoiceInputChunk.swift
new file mode 100644
index 00000000..4d9f64df
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_VoiceInputChunk.swift
@@ -0,0 +1,46 @@
+///
+/// Func_void_VoiceInputChunk.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ chunk: VoiceInputChunk) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_VoiceInputChunk {
+  public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  private let closure: (_ chunk: VoiceInputChunk) -> Void
+
+  public init(_ closure: @escaping (_ chunk: VoiceInputChunk) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(chunk: VoiceInputChunk) -> Void {
+    self.closure(chunk)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_VoiceInputChunk`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_VoiceInputChunk>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_VoiceInputChunk {
+    return Unmanaged<Func_void_VoiceInputChunk>.fromOpaque(pointer).takeRetainedValue()
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_ArrayBuffer_.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_VoiceInputResult.swift
similarity index 60%
rename from packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_ArrayBuffer_.swift
rename to packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_VoiceInputResult.swift
index 3422d50c..4e854b3a 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_ArrayBuffer_.swift
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_VoiceInputResult.swift
@@ -1,5 +1,5 @@
 ///
-/// Func_void_std__shared_ptr_ArrayBuffer_.swift
+/// Func_void_VoiceInputResult.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,20 +8,20 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ value: ArrayBuffer) -> Void` as a class.
+ * Wraps a Swift `(_ value: VoiceInputResult) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
-public final class Func_void_std__shared_ptr_ArrayBuffer_ {
+public final class Func_void_VoiceInputResult {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
-  private let closure: (_ value: ArrayBuffer) -> Void
+  private let closure: (_ value: VoiceInputResult) -> Void
 
-  public init(_ closure: @escaping (_ value: ArrayBuffer) -> Void) {
+  public init(_ closure: @escaping (_ value: VoiceInputResult) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: ArrayBuffer) -> Void {
+  public func call(value: VoiceInputResult) -> Void {
     self.closure(value)
   }
 
@@ -35,12 +35,12 @@ public final class Func_void_std__shared_ptr_ArrayBuffer_ {
   }
 
   /**
-   * Casts an unsafe pointer to a `Func_void_std__shared_ptr_ArrayBuffer_`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_ArrayBuffer_>`.
+   * Casts an unsafe pointer to a `Func_void_VoiceInputResult`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_VoiceInputResult>`.
    * This removes one strong reference from the object!
    */
   @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_ArrayBuffer_ {
-    return Unmanaged<Func_void_std__shared_ptr_ArrayBuffer_>.fromOpaque(pointer).takeRetainedValue()
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_VoiceInputResult {
+    return Unmanaged<Func_void_VoiceInputResult>.fromOpaque(pointer).takeRetainedValue()
   }
 }
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_bool.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_bool.swift
index e066566f..e8bdadf2 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_bool.swift
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/Func_void_bool.swift
@@ -8,21 +8,21 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ isPanningInterfaceVisible: Bool) -> Void` as a class.
+ * Wraps a Swift `(_ value: Bool) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
 public final class Func_void_bool {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
-  private let closure: (_ isPanningInterfaceVisible: Bool) -> Void
+  private let closure: (_ value: Bool) -> Void
 
-  public init(_ closure: @escaping (_ isPanningInterfaceVisible: Bool) -> Void) {
+  public init(_ closure: @escaping (_ value: Bool) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(isPanningInterfaceVisible: Bool) -> Void {
-    self.closure(isPanningInterfaceVisible)
+  public func call(value: Bool) -> Void {
+    self.closure(value)
   }
 
   /**
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec.swift
index 0fd913ca..ab657099 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec.swift
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec.swift
@@ -16,10 +16,6 @@ public protocol HybridAutoPlaySpec_protocol: HybridObject {
   func addListener(eventType: EventName, callback: @escaping () -> Void) throws -> () -> Void
   func addListenerRenderState(moduleName: String, callback: @escaping (_ payload: VisibilityState) -> Void) throws -> () -> Void
   func addListenerVoiceInput(callback: @escaping (_ coordinates: Location?, _ query: String?) -> Void) throws -> () -> Void
-  func hasVoiceInputPermission() throws -> Bool
-  func requestVoiceInputPermission() throws -> Promise<Bool>
-  func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?) throws -> Promise<ArrayBuffer>
-  func stopVoiceInput() throws -> Void
   func setRootTemplate(templateId: String) throws -> Promise<Void>
   func pushTemplate(templateId: String) throws -> Promise<Void>
   func popTemplate(animate: Bool?) throws -> Promise<Void>
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec_cxx.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec_cxx.swift
index dce5aa85..16bdaff0 100644
--- a/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec_cxx.swift
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridAutoPlaySpec_cxx.swift
@@ -196,88 +196,6 @@ open class HybridAutoPlaySpec_cxx {
     }
   }
   
-  @inline(__always)
-  public final func hasVoiceInputPermission() -> bridge.Result_bool_ {
-    do {
-      let __result = try self.__implementation.hasVoiceInputPermission()
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_bool_(__exceptionPtr)
-    }
-  }
-  
-  @inline(__always)
-  public final func requestVoiceInputPermission() -> bridge.Result_std__shared_ptr_Promise_bool___ {
-    do {
-      let __result = try self.__implementation.requestVoiceInputPermission()
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
-        __result
-          .then({ __result in __promiseHolder.resolve(__result) })
-          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
-        return __promise
-      }()
-      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
-    }
-  }
-  
-  @inline(__always)
-  public final func startVoiceInput(silenceThresholdMs: bridge.std__optional_double_, maxDurationMs: bridge.std__optional_double_, listeningText: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ {
-    do {
-      let __result = try self.__implementation.startVoiceInput(silenceThresholdMs: { () -> Double? in
-        if bridge.has_value_std__optional_double_(silenceThresholdMs) {
-          let __unwrapped = bridge.get_std__optional_double_(silenceThresholdMs)
-          return __unwrapped
-        } else {
-          return nil
-        }
-      }(), maxDurationMs: { () -> Double? in
-        if bridge.has_value_std__optional_double_(maxDurationMs) {
-          let __unwrapped = bridge.get_std__optional_double_(maxDurationMs)
-          return __unwrapped
-        } else {
-          return nil
-        }
-      }(), listeningText: { () -> String? in
-        if bridge.has_value_std__optional_std__string_(listeningText) {
-          let __unwrapped = bridge.get_std__optional_std__string_(listeningText)
-          return String(__unwrapped)
-        } else {
-          return nil
-        }
-      }())
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(__promise)
-        __result
-          .then({ __result in __promiseHolder.resolve(__result.getArrayBuffer()) })
-          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
-        return __promise
-      }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__exceptionPtr)
-    }
-  }
-  
-  @inline(__always)
-  public final func stopVoiceInput() -> bridge.Result_void_ {
-    do {
-      try self.__implementation.stopVoiceInput()
-      return bridge.create_Result_void_()
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
-    }
-  }
-  
   @inline(__always)
   public final func setRootTemplate(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridVoiceSpec.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridVoiceSpec.swift
new file mode 100644
index 00000000..5beae3b0
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridVoiceSpec.swift
@@ -0,0 +1,58 @@
+///
+/// HybridVoiceSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// See ``HybridVoiceSpec``
+public protocol HybridVoiceSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func hasVoiceInputPermission() throws -> Bool
+  func requestVoiceInputPermission() throws -> Promise<Bool>
+  func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, preferSpeechToText: Bool?, onChunk: ((_ chunk: VoiceInputChunk) -> Void)?, language: String?) throws -> Promise<VoiceInputResult>
+  func stopVoiceInput() throws -> Void
+}
+
+public extension HybridVoiceSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject Voice]"
+  }
+}
+
+/// See ``HybridVoiceSpec``
+open class HybridVoiceSpec_base {
+  private weak var cxxWrapper: HybridVoiceSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridVoiceSpec_cxx {
+  #if DEBUG
+    guard self is any HybridVoiceSpec else {
+      fatalError("`self` is not a `HybridVoiceSpec`! Did you accidentally inherit from `HybridVoiceSpec_base` instead of `HybridVoiceSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridVoiceSpec_cxx(self as! any HybridVoiceSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the Voice HybridObject.
+ * Implement this protocol to create Swift-based instances of Voice.
+ * ```swift
+ * class HybridVoice : HybridVoiceSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridVoiceSpec = HybridVoiceSpec_protocol & HybridVoiceSpec_base
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridVoiceSpec_cxx.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridVoiceSpec_cxx.swift
new file mode 100644
index 00000000..7c39f271
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/HybridVoiceSpec_cxx.swift
@@ -0,0 +1,234 @@
+///
+/// HybridVoiceSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridVoiceSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridVoiceSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift`)
+   * from `ReactNativeAutoPlay-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridVoiceSpec` Swift protocol.
+   */
+  private var __implementation: any HybridVoiceSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridVoiceSpec_
+
+  /**
+   * Create a new `HybridVoiceSpec_cxx` that wraps the given `HybridVoiceSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridVoiceSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridVoiceSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridVoiceSpec() -> any HybridVoiceSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridVoiceSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridVoiceSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridVoiceSpec_cxx {
+    return Unmanaged<HybridVoiceSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridVoiceSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridVoiceSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridVoiceSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridVoiceSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridVoiceSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func hasVoiceInputPermission() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.hasVoiceInputPermission()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func requestVoiceInputPermission() -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.requestVoiceInputPermission()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func startVoiceInput(silenceThresholdMs: bridge.std__optional_double_, maxDurationMs: bridge.std__optional_double_, listeningText: bridge.std__optional_std__string_, preferSpeechToText: bridge.std__optional_bool_, onChunk: bridge.std__optional_std__function_void_const_VoiceInputChunk_____chunk______, language: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_Promise_VoiceInputResult___ {
+    do {
+      let __result = try self.__implementation.startVoiceInput(silenceThresholdMs: { () -> Double? in
+        if bridge.has_value_std__optional_double_(silenceThresholdMs) {
+          let __unwrapped = bridge.get_std__optional_double_(silenceThresholdMs)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), maxDurationMs: { () -> Double? in
+        if bridge.has_value_std__optional_double_(maxDurationMs) {
+          let __unwrapped = bridge.get_std__optional_double_(maxDurationMs)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), listeningText: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(listeningText) {
+          let __unwrapped = bridge.get_std__optional_std__string_(listeningText)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), preferSpeechToText: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(preferSpeechToText) {
+          let __unwrapped = bridge.get_std__optional_bool_(preferSpeechToText)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), onChunk: { () -> ((_ chunk: VoiceInputChunk) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_VoiceInputChunk_____chunk______(onChunk) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_VoiceInputChunk_____chunk______(onChunk)
+          return { () -> (VoiceInputChunk) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_VoiceInputChunk(__unwrapped)
+            return { (__chunk: VoiceInputChunk) -> Void in
+              __wrappedFunction.call(__chunk)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }(), language: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(language) {
+          let __unwrapped = bridge.get_std__optional_std__string_(language)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_VoiceInputResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_VoiceInputResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_VoiceInputResult__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_VoiceInputResult___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_VoiceInputResult___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func stopVoiceInput() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.stopVoiceInput()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/VoiceInputChunk.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/VoiceInputChunk.swift
new file mode 100644
index 00000000..aab07208
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/VoiceInputChunk.swift
@@ -0,0 +1,60 @@
+///
+/// VoiceInputChunk.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `VoiceInputChunk`, backed by a C++ struct.
+ */
+public typealias VoiceInputChunk = margelo.nitro.swe.iternio.reactnativeautoplay.VoiceInputChunk
+
+public extension VoiceInputChunk {
+  private typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  /**
+   * Create a new instance of `VoiceInputChunk`.
+   */
+  init(partial: String?, audio: ArrayBuffer?) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = partial {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__shared_ptr_ArrayBuffer__ in
+      if let __unwrappedValue = audio {
+        return bridge.create_std__optional_std__shared_ptr_ArrayBuffer__(__unwrappedValue.getArrayBuffer())
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var partial: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__partial) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__partial)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var audio: ArrayBuffer? {
+    return { () -> ArrayBuffer? in
+      if bridge.has_value_std__optional_std__shared_ptr_ArrayBuffer__(self.__audio) {
+        let __unwrapped = bridge.get_std__optional_std__shared_ptr_ArrayBuffer__(self.__audio)
+        return ArrayBuffer(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/ios/swift/VoiceInputResult.swift b/packages/react-native-autoplay/nitrogen/generated/ios/swift/VoiceInputResult.swift
new file mode 100644
index 00000000..4d79802c
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/ios/swift/VoiceInputResult.swift
@@ -0,0 +1,60 @@
+///
+/// VoiceInputResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `VoiceInputResult`, backed by a C++ struct.
+ */
+public typealias VoiceInputResult = margelo.nitro.swe.iternio.reactnativeautoplay.VoiceInputResult
+
+public extension VoiceInputResult {
+  private typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  /**
+   * Create a new instance of `VoiceInputResult`.
+   */
+  init(transcription: String?, audio: ArrayBuffer?) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = transcription {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__shared_ptr_ArrayBuffer__ in
+      if let __unwrappedValue = audio {
+        return bridge.create_std__optional_std__shared_ptr_ArrayBuffer__(__unwrappedValue.getArrayBuffer())
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var transcription: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__transcription) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__transcription)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var audio: ArrayBuffer? {
+    return { () -> ArrayBuffer? in
+      if bridge.has_value_std__optional_std__shared_ptr_ArrayBuffer__(self.__audio) {
+        let __unwrapped = bridge.get_std__optional_std__shared_ptr_ArrayBuffer__(self.__audio)
+        return ArrayBuffer(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+}
diff --git a/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp
index 4d7c18b9..7edb2b4a 100644
--- a/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp
+++ b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp
@@ -17,10 +17,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       prototype.registerHybridMethod("addListener", &HybridAutoPlaySpec::addListener);
       prototype.registerHybridMethod("addListenerRenderState", &HybridAutoPlaySpec::addListenerRenderState);
       prototype.registerHybridMethod("addListenerVoiceInput", &HybridAutoPlaySpec::addListenerVoiceInput);
-      prototype.registerHybridMethod("hasVoiceInputPermission", &HybridAutoPlaySpec::hasVoiceInputPermission);
-      prototype.registerHybridMethod("requestVoiceInputPermission", &HybridAutoPlaySpec::requestVoiceInputPermission);
-      prototype.registerHybridMethod("startVoiceInput", &HybridAutoPlaySpec::startVoiceInput);
-      prototype.registerHybridMethod("stopVoiceInput", &HybridAutoPlaySpec::stopVoiceInput);
       prototype.registerHybridMethod("setRootTemplate", &HybridAutoPlaySpec::setRootTemplate);
       prototype.registerHybridMethod("pushTemplate", &HybridAutoPlaySpec::pushTemplate);
       prototype.registerHybridMethod("popTemplate", &HybridAutoPlaySpec::popTemplate);
diff --git a/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.hpp b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.hpp
index d0f3fd6a..d9f5af8b 100644
--- a/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.hpp
+++ b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridAutoPlaySpec.hpp
@@ -31,7 +31,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 #include "Location.hpp"
 #include <optional>
 #include <NitroModules/Promise.hpp>
-#include <NitroModules/ArrayBuffer.hpp>
 #include "SafeAreaInsets.hpp"
 #include "NitroAction.hpp"
 #include <vector>
@@ -70,10 +69,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       virtual std::function<void()> addListener(EventName eventType, const std::function<void()>& callback) = 0;
       virtual std::function<void()> addListenerRenderState(const std::string& moduleName, const std::function<void(VisibilityState /* payload */)>& callback) = 0;
       virtual std::function<void()> addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) = 0;
-      virtual bool hasVoiceInputPermission() = 0;
-      virtual std::shared_ptr<Promise<bool>> requestVoiceInputPermission() = 0;
-      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) = 0;
-      virtual void stopVoiceInput() = 0;
       virtual std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) = 0;
       virtual std::shared_ptr<Promise<void>> pushTemplate(const std::string& templateId) = 0;
       virtual std::shared_ptr<Promise<void>> popTemplate(std::optional<bool> animate) = 0;
diff --git a/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridVoiceSpec.cpp b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridVoiceSpec.cpp
new file mode 100644
index 00000000..c76dffb1
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridVoiceSpec.cpp
@@ -0,0 +1,24 @@
+///
+/// HybridVoiceSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVoiceSpec.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  void HybridVoiceSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("hasVoiceInputPermission", &HybridVoiceSpec::hasVoiceInputPermission);
+      prototype.registerHybridMethod("requestVoiceInputPermission", &HybridVoiceSpec::requestVoiceInputPermission);
+      prototype.registerHybridMethod("startVoiceInput", &HybridVoiceSpec::startVoiceInput);
+      prototype.registerHybridMethod("stopVoiceInput", &HybridVoiceSpec::stopVoiceInput);
+    });
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridVoiceSpec.hpp b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridVoiceSpec.hpp
new file mode 100644
index 00000000..8e7c655e
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/shared/c++/HybridVoiceSpec.hpp
@@ -0,0 +1,73 @@
+///
+/// HybridVoiceSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `VoiceInputResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
+// Forward declaration of `VoiceInputChunk` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
+
+#include <NitroModules/Promise.hpp>
+#include "VoiceInputResult.hpp"
+#include <optional>
+#include <string>
+#include "VoiceInputChunk.hpp"
+#include <functional>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Voice`
+   * Inherit this class to create instances of `HybridVoiceSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVoice: public HybridVoiceSpec {
+   * public:
+   *   HybridVoice(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVoiceSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVoiceSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVoiceSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual bool hasVoiceInputPermission() = 0;
+      virtual std::shared_ptr<Promise<bool>> requestVoiceInputPermission() = 0;
+      virtual std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) = 0;
+      virtual void stopVoiceInput() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Voice";
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
diff --git a/packages/react-native-autoplay/nitrogen/generated/shared/c++/VoiceInputChunk.hpp b/packages/react-native-autoplay/nitrogen/generated/shared/c++/VoiceInputChunk.hpp
new file mode 100644
index 00000000..ff05d533
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/shared/c++/VoiceInputChunk.hpp
@@ -0,0 +1,89 @@
+///
+/// VoiceInputChunk.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * A struct which can be represented as a JavaScript object (VoiceInputChunk).
+   */
+  struct VoiceInputChunk final {
+  public:
+    std::optional<std::string> partial     SWIFT_PRIVATE;
+    std::optional<std::shared_ptr<ArrayBuffer>> audio     SWIFT_PRIVATE;
+
+  public:
+    VoiceInputChunk() = default;
+    explicit VoiceInputChunk(std::optional<std::string> partial, std::optional<std::shared_ptr<ArrayBuffer>> audio): partial(partial), audio(audio) {}
+
+  public:
+    friend bool operator==(const VoiceInputChunk& lhs, const VoiceInputChunk& rhs) = default;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ VoiceInputChunk <> JS VoiceInputChunk (object)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputChunk> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputChunk fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputChunk(
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "partial"))),
+        JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "audio")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputChunk& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "partial"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.partial));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "audio"), JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::toJSI(runtime, arg.audio));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "partial")))) return false;
+      if (!JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "audio")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-autoplay/nitrogen/generated/shared/c++/VoiceInputResult.hpp b/packages/react-native-autoplay/nitrogen/generated/shared/c++/VoiceInputResult.hpp
new file mode 100644
index 00000000..753c0b7e
--- /dev/null
+++ b/packages/react-native-autoplay/nitrogen/generated/shared/c++/VoiceInputResult.hpp
@@ -0,0 +1,89 @@
+///
+/// VoiceInputResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * A struct which can be represented as a JavaScript object (VoiceInputResult).
+   */
+  struct VoiceInputResult final {
+  public:
+    std::optional<std::string> transcription     SWIFT_PRIVATE;
+    std::optional<std::shared_ptr<ArrayBuffer>> audio     SWIFT_PRIVATE;
+
+  public:
+    VoiceInputResult() = default;
+    explicit VoiceInputResult(std::optional<std::string> transcription, std::optional<std::shared_ptr<ArrayBuffer>> audio): transcription(transcription), audio(audio) {}
+
+  public:
+    friend bool operator==(const VoiceInputResult& lhs, const VoiceInputResult& rhs) = default;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ VoiceInputResult <> JS VoiceInputResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputResult> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputResult(
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "transcription"))),
+        JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "audio")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::VoiceInputResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "transcription"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.transcription));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "audio"), JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::toJSI(runtime, arg.audio));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "transcription")))) return false;
+      if (!JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "audio")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-autoplay/package.json b/packages/react-native-autoplay/package.json
index a9a4ab78..428e8ee2 100644
--- a/packages/react-native-autoplay/package.json
+++ b/packages/react-native-autoplay/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",
diff --git a/packages/react-native-autoplay/src/hybrid/HybridVoice.ts b/packages/react-native-autoplay/src/hybrid/HybridVoice.ts
new file mode 100644
index 00000000..016400a3
--- /dev/null
+++ b/packages/react-native-autoplay/src/hybrid/HybridVoice.ts
@@ -0,0 +1,79 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { Voice } from '../specs/Voice.nitro';
+import type { VoiceInputOptions, VoiceInputResult } from '../types/Voice';
+
+const _native = NitroModules.createHybridObject<Voice>('Voice');
+
+type StartVoiceInput = {
+  (
+    options: VoiceInputOptions & Required<Pick<VoiceInputOptions, 'onChunk'>>
+  ): Promise<VoiceInputResult>;
+  (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
+};
+
+const startVoiceInput: StartVoiceInput = async (options?: VoiceInputOptions) => {
+  const {
+    onChunk,
+    silenceThresholdMs,
+    maxDurationMs,
+    listeningText,
+    preferSpeechToText,
+    language,
+  } = options ?? {};
+
+  return await _native.startVoiceInput(
+    silenceThresholdMs,
+    maxDurationMs,
+    listeningText,
+    preferSpeechToText,
+    onChunk,
+    language
+  );
+};
+
+export const HybridVoice = {
+  /**
+   * Returns true if all permissions required for voice input are granted.
+   * On iOS: checks both microphone and speech recognition authorization.
+   * On Android: checks RECORD_AUDIO permission.
+   */
+  hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
+  /**
+   * Request all permissions required for voice input.
+   * On iOS: requests microphone permission then speech recognition authorization.
+   * On Android: requests RECORD_AUDIO via car context when connected, otherwise
+   * via the React Native application context.
+   * Returns true only if all required permissions were granted.
+   */
+  requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
+  /**
+   * Start an in-app voice session.
+   *
+   * When preferSpeechToText is true:
+   *   iOS — streams audio buffers into SFSpeechRecognizer during recording;
+   *          onChunk fires with partial transcription results; resolves with
+   *          { transcription } or falls back to { audio } if unavailable.
+   *   Android — checks SpeechRecognizer availability upfront; if available it
+   *              owns the mic and streams partial results via onChunk; if not
+   *              available falls back to PCM recording.
+   *
+   * When preferSpeechToText is false (default):
+   *   Both platforms record raw PCM; onChunk fires with audio chunks;
+   *   resolves with { audio }.
+   *
+   * @param silenceThresholdMs  ms of silence before auto-stop (default 1500)
+   * @param maxDurationMs       hard cap on recording duration (default 10000)
+   * @param listeningText       iOS only — text shown on CPVoiceControlTemplate
+   * @param preferSpeechToText  request STT transcription instead of raw PCM
+   * @param onChunk             optional streaming callback
+   * @param language            specify the language for the SpeechRecognizer, falls back to system language if not set
+   */
+  startVoiceInput,
+  /**
+   * Stop the active voice session early.
+   * For PCM mode: resolves startVoiceInput with audio captured so far.
+   * For STT mode: finalises the recognition request.
+   * No-op if no session is active.
+   */
+  stopVoiceInput: () => _native.stopVoiceInput(),
+};
diff --git a/packages/react-native-autoplay/src/index.ts b/packages/react-native-autoplay/src/index.ts
index 21fb2c56..d13a3c72 100644
--- a/packages/react-native-autoplay/src/index.ts
+++ b/packages/react-native-autoplay/src/index.ts
@@ -3,11 +3,12 @@ import { NitroModules } from 'react-native-nitro-modules';
 import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
+import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
 
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
 
-export { HybridAndroidAutoTelemetry, HybridAutoPlay };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
 
 export const HybridAndroidAutomotive =
   Platform.OS === 'android'
@@ -54,6 +55,7 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
+export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
 export type {
   AlertPriority,
   NavigationAlert as Alert,
diff --git a/packages/react-native-autoplay/src/specs/AutoPlay.nitro.ts b/packages/react-native-autoplay/src/specs/AutoPlay.nitro.ts
index 426bb943..926ad762 100644
--- a/packages/react-native-autoplay/src/specs/AutoPlay.nitro.ts
+++ b/packages/react-native-autoplay/src/specs/AutoPlay.nitro.ts
@@ -44,43 +44,6 @@ export interface AutoPlay extends HybridObject<{ android: 'kotlin'; ios: 'swift'
     callback: (coordinates: Location | undefined, query: string | undefined) => void
   ): CleanupCallback;
 
-  /**
-   * Returns true if microphone permission has already been granted.
-   */
-  hasVoiceInputPermission(): boolean;
-
-  /**
-   * Request microphone permission from the user.
-   * On Android: uses the car context when Android Auto is connected, otherwise
-   * falls back to the React Native application context.
-   * On iOS: uses AVAudioApplication (iOS 17+) or AVAudioSession (iOS 15–16).
-   * Returns true if permission was granted, false if denied.
-   */
-  requestVoiceInputPermission(): Promise<boolean>;
-
-  /**
-   * Start an in-app voice recording session.
-   * On Android: acquires audio focus and captures via CarAudioRecord when
-   * Android Auto is connected, otherwise uses standard AudioRecord.
-   * On iOS: presents CPVoiceControlTemplate (when a car is connected) and
-   * captures audio via AVAudioEngine.
-   * Resolves with the complete raw PCM buffer (16 kHz, 16-bit, mono) when
-   * silence is detected, the max duration is reached, or stopVoiceInput() is called.
-   * Rejects if microphone permission has not been granted or recording fails to start.
-   */
-  startVoiceInput(
-    silenceThresholdMs?: number,
-    maxDurationMs?: number,
-    listeningText?: string
-  ): Promise<ArrayBuffer>;
-
-  /**
-   * Stop the active voice recording session early. Causes the Promise returned
-   * by startVoiceInput() to resolve with the audio captured so far.
-   * No-op if no recording is in progress.
-   */
-  stopVoiceInput(): void;
-
   /**
    * sets the specified template as root template, initializes a new stack
    * Promise might contain an error message in case setting root template failed
diff --git a/packages/react-native-autoplay/src/specs/Voice.nitro.ts b/packages/react-native-autoplay/src/specs/Voice.nitro.ts
new file mode 100644
index 00000000..d0d400c7
--- /dev/null
+++ b/packages/react-native-autoplay/src/specs/Voice.nitro.ts
@@ -0,0 +1,16 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { VoiceInputChunk, VoiceInputResult } from '../types/Voice';
+
+export interface Voice extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
+  hasVoiceInputPermission(): boolean;
+  requestVoiceInputPermission(): Promise<boolean>;
+  startVoiceInput(
+    silenceThresholdMs?: number,
+    maxDurationMs?: number,
+    listeningText?: string,
+    preferSpeechToText?: boolean,
+    onChunk?: (chunk: VoiceInputChunk) => void,
+    language?: string
+  ): Promise<VoiceInputResult>;
+  stopVoiceInput(): void;
+}
diff --git a/packages/react-native-autoplay/src/types/Voice.ts b/packages/react-native-autoplay/src/types/Voice.ts
new file mode 100644
index 00000000..74908a36
--- /dev/null
+++ b/packages/react-native-autoplay/src/types/Voice.ts
@@ -0,0 +1,18 @@
+export interface VoiceInputChunk {
+  partial?: string;
+  audio?: ArrayBuffer;
+}
+
+export interface VoiceInputResult {
+  transcription?: string;
+  audio?: ArrayBuffer;
+}
+
+export interface VoiceInputOptions {
+  silenceThresholdMs?: number;
+  maxDurationMs?: number;
+  listeningText?: string;
+  preferSpeechToText?: boolean;
+  onChunk?: (chunk: VoiceInputChunk) => void;
+  language?: string;
+}