@gmessier/nitro-speech 0.4.2 → 0.4.4

package/ios/HybridRecognizer.swift

@@ -1,16 +1,22 @@
 import Foundation
 import NitroModules
+import AVFoundation
 
 class HybridRecognizer: HybridRecognizerSpec  {
+    var prewarmOptions: SpeechRecognitionPrewarm?
     var config: SpeechRecognitionConfig?
+    var hardwareFormat: AVAudioFormat?
     
     var onReadyForSpeech: (() -> Void)?
     var onRecordingStopped: (() -> Void)?
     var onResult: (([String]) -> Void)?
+    var onResultFallback: (([String]) -> Void)?
     var onAutoFinishProgress: ((Double) -> Void)?
+    var onAutoFinishProgressFallback: ((Double) -> Void)?
     var onError: ((String) -> Void)?
     var onPermissionDenied: (() -> Void)?
     var onVolumeChange: ((VolumeChangeEvent) -> Void)?
+    var onVolumeChangeFallback: ((VolumeChangeEvent) -> Void)?
     
     private let coordinator = Coordinator()
     private var paramsHash: String?
@@ -24,12 +30,18 @@ class HybridRecognizer: HybridRecognizerSpec  {
     private let lg = Lg(prefix: "HybridRecognizer")
     
     @discardableResult
-    func prewarm(defaultParams: SpeechRecognitionConfig?) -> Promise<Void> {
+    func prewarm(
+        defaultParams: SpeechRecognitionConfig?,
+        options: SpeechRecognitionPrewarm?
+    ) -> Promise<Void> {
+        prewarmOptions = options
         return Promise.async(.userInitiated) { [weak self] in
+            // Ignore when standalone prewarm triggered for active session
+            guard self?.engine?.isActive != true else { return }
             // Ensure correct engine is selected based on params and ios version
             await self?.ensureEngine(params: defaultParams)
             // try to preload assets and check if speech engine is available on OS level
-            await self?.engine?.prewarm(for: .prewarm)
+            await self?.engine?.prewarm(for: .prewarm, options)
         }
     }
     
@@ -37,7 +49,7 @@ class HybridRecognizer: HybridRecognizerSpec  {
         Task {
             // Ensure correct engine is selected based on params and ios version
             await ensureEngine(params: params)
-            engine?.start()
+            await engine?.start()
         }
     }
     
@@ -108,6 +120,8 @@ class HybridRecognizer: HybridRecognizerSpec  {
 
 protocol RecognizerDelegate: AnyObject {
     var config: SpeechRecognitionConfig? { get }
+    var hardwareFormat: AVAudioFormat? { get }
+    func setHardwareFormat(format: AVAudioFormat)
     func softlyUpdateConfig(newConfig: MutableSpeechRecognitionConfig?)
     func reselectEngine(forPrewarm: Bool)
     func readyForSpeech()
@@ -120,6 +134,9 @@ protocol RecognizerDelegate: AnyObject {
 }
 
 extension HybridRecognizer: RecognizerDelegate {
+    func setHardwareFormat(format: AVAudioFormat) {
+        hardwareFormat = format
+    }
     func softlyUpdateConfig(newConfig: MutableSpeechRecognitionConfig?) {
         if let newConfig {
             config = SpeechRecognitionConfig(
@@ -154,12 +171,29 @@ extension HybridRecognizer: RecognizerDelegate {
     
     func result(batches: [String]) {
         self.lg.log("[onResult] \(batches)")
-        self.onResult?(batches)
+        if onResult != nil {
+            onResultFallback = onResult
+        }
+        
+        if (onResultFallback == nil) {
+            self.lg.log("onResultFallback -> nil")
+        }
+        
+        onResultFallback?(batches)
     }
     
     func autoFinishProgress(timeLeftMs: Double) {
         self.lg.log("[onAutoFinishProgress] \(timeLeftMs)ms")
-        self.onAutoFinishProgress?(timeLeftMs)
+        
+        if onAutoFinishProgress != nil {
+            onAutoFinishProgressFallback = onAutoFinishProgress
+        }
+        
+        if (onAutoFinishProgressFallback == nil) {
+            self.lg.log("onAutoFinishProgressFallback -> nil")
+        }
+        
+        onAutoFinishProgressFallback?(timeLeftMs)
     }
     
     func error(message: String) {
@@ -173,8 +207,15 @@ extension HybridRecognizer: RecognizerDelegate {
     }
     
     func volumeChange(event: VolumeChangeEvent) {
-        // self.lg.log("[onVolumeChange] \(event.rawVolume)")
-        self.onVolumeChange?(event)
+        if onVolumeChange != nil {
+            onVolumeChangeFallback = onVolumeChange
+        }
+        
+        if (onVolumeChangeFallback == nil) {
+            self.lg.log("onVolumeChangeFallback -> nil")
+        }
+        
+        onVolumeChangeFallback?(event)
     }
     
     func reselectEngine(forPrewarm: Bool) {
@@ -184,7 +225,7 @@ extension HybridRecognizer: RecognizerDelegate {
         engine = nil
         // Try to prewarm with another candidate
         if forPrewarm {
-            self.prewarm(defaultParams: config)
+            self.prewarm(defaultParams: config, options: prewarmOptions)
         } else {
             // Try to start with another candidate
             self.startListening(params: config)

package/ios/Shared/AutoStopper.swift

@@ -5,7 +5,7 @@ final class AutoStopper {
     private static let defaultProgressIntervalMs = 1000.0
     private static let minProgressIntervalMs = 50.0
 
-    private let lg = Lg(prefix: "AutoStopper", disable: false)
+    private let lg = Lg(prefix: "AutoStopper", disable: true)
     
     private let queue = DispatchQueue(label: "com.margelo.nitrospeech.autostopper")
 

package/ios/Shared/Permissions.swift

@@ -2,58 +2,23 @@ import Foundation
 import Speech
 import AVFoundation
 
-final class Permissions {
-    private let onGranted: () async -> Void
-    private let onDenied: (() -> Void)?
-    private let onError: ((String) -> Void)?
-    
-    init(
-        onGranted: @escaping () async -> Void,
-        onDenied: (() -> Void)?,
-        onError: ((String) -> Void)?
-    ) {
-        self.onGranted = onGranted
-        self.onDenied = onDenied
-        self.onError = onError
-    }
-    
-    private func requestMicrophonePermission() async {
-        // Request permission to record.
-        if #available(iOS 17.0, *) {
-            if await AVAudioApplication.requestRecordPermission() {
-                await self.onGranted()
-                return
-            }
-            self.onDenied?()
-            return
-        }
-        AVAudioSession.sharedInstance().requestRecordPermission { [weak self] granted in
-            Task { @MainActor in
-                guard let self else { return }
-                if granted {
-                    await self.onGranted()
-                    return
-                }
-                self.onDenied?()
+enum Permissions {
+    static func requestAuthorization() async -> SFSpeechRecognizerAuthorizationStatus {
+        return await withCheckedContinuation { continuation in
+            SFSpeechRecognizer.requestAuthorization { authStatus in
+                continuation.resume(returning: authStatus)
             }
         }
     }
     
-    func requestAuthorization() {
-        SFSpeechRecognizer.requestAuthorization { authStatus in
-            Task { @MainActor in
-                switch authStatus {
-                    case .authorized:
-                        await self.requestMicrophonePermission()
-                    case .denied, .restricted:
-                        self.onDenied?()
-                    case .notDetermined:
-                        self.onError?("Speech recognition not determined")
-                    @unknown default:
-                        self.onError?("Unknown authorization status")
-                }
+    static func requestMicrophonePermission() async -> Bool {
+        if #available(iOS 17.0, *) {
+            return await AVAudioApplication.requestRecordPermission()
+        }
+        return await withCheckedContinuation { continuation in
+            AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                continuation.resume(returning: granted)
             }
         }
     }
-    
 }

package/ios/Shared/Utils.swift

@@ -44,7 +44,8 @@ enum Utils {
         }
         let preset = switch params.iosPreset {
             case nil: "n"
-            case .shortform: "s"
+            // Both presets prioritize Dictation
+            case .shortform, .speed: "s"
             case .general: "g"
         }
         let atypicalSpeech = switch params.iosAtypicalSpeech {

package/lib/Recognizer/methods.d.ts

@@ -1,10 +1,10 @@
-import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from './types';
-export declare const recognizerPrewarm: (params?: SpeechRecognitionConfig) => Promise<void>;
-export declare const recognizerStartListening: (params?: SpeechRecognitionConfig) => void;
-export declare const recognizerStopListening: () => void;
-export declare const recognizerResetAutoFinishTime: () => void;
-export declare const recognizerAddAutoFinishTime: (additionalTimeMs?: number) => void;
-export declare const recognizerUpdateConfig: (newConfig?: MutableSpeechRecognitionConfig, resetAutoFinishTime?: boolean) => void;
-export declare const recognizerGetIsActive: () => boolean;
-export declare const recognizerGetVoiceInputVolume: () => import("./types").VolumeChangeEvent;
-export declare const recognizerGetSupportedLocalesIOS: () => string[];
+import type { RecognizerMethods } from './types';
+export declare const recognizerPrewarm: RecognizerMethods['prewarm'];
+export declare const recognizerStartListening: RecognizerMethods['startListening'];
+export declare const recognizerStopListening: RecognizerMethods['stopListening'];
+export declare const recognizerResetAutoFinishTime: RecognizerMethods['resetAutoFinishTime'];
+export declare const recognizerAddAutoFinishTime: RecognizerMethods['addAutoFinishTime'];
+export declare const recognizerUpdateConfig: RecognizerMethods['updateConfig'];
+export declare const recognizerGetIsActive: RecognizerMethods['getIsActive'];
+export declare const recognizerGetVoiceInputVolume: RecognizerMethods['getVoiceInputVolume'];
+export declare const recognizerGetSupportedLocalesIOS: RecognizerMethods['getSupportedLocalesIOS'];

package/lib/Recognizer/methods.js

@@ -1,7 +1,7 @@
 import { SpeechRecognizer } from './SpeechRecognizer';
-export const recognizerPrewarm = (params) => {
+export const recognizerPrewarm = (params, options) => {
     'worklet';
-    return SpeechRecognizer.prewarm(params);
+    return SpeechRecognizer.prewarm(params, options);
 };
 export const recognizerStartListening = (params) => {
     'worklet';

package/lib/Recognizer/types.d.ts

@@ -1,6 +1,7 @@
 import type { Recognizer as RecognizerSpec } from '../specs/Recognizer.nitro';
 import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from '../specs/SpeechRecognitionConfig';
 import type { VolumeChangeEvent } from '../specs/VolumeChangeEvent';
+import type { SpeechRecognitionPrewarm } from '../specs/SpeechRecognitionPrewarm';
 type RecognizerCallbacks = Pick<RecognizerSpec, 'onReadyForSpeech' | 'onRecordingStopped' | 'onResult' | 'onAutoFinishProgress' | 'onError' | 'onPermissionDenied' | 'onVolumeChange'>;
 type RecognizerMethods = Pick<RecognizerSpec, 'prewarm' | 'startListening' | 'stopListening' | 'resetAutoFinishTime' | 'addAutoFinishTime' | 'updateConfig' | 'getIsActive' | 'getVoiceInputVolume' | 'getSupportedLocalesIOS'>;
-export type { RecognizerSpec, SpeechRecognitionConfig, MutableSpeechRecognitionConfig, VolumeChangeEvent, RecognizerCallbacks, RecognizerMethods, };
+export type { RecognizerSpec, SpeechRecognitionConfig, SpeechRecognitionPrewarm, MutableSpeechRecognitionConfig, VolumeChangeEvent, RecognizerCallbacks, RecognizerMethods, };

package/lib/index.d.ts

@@ -4,4 +4,4 @@ export { useRecognizerIsActive, speechRecognizerActiveStateHandler, } from './Re
 export { SpeechRecognizer } from './Recognizer/SpeechRecognizer';
 export { RecognizerRef } from './Recognizer/RecognizerRef';
 export { NitroSpeech } from './NitroSpeech';
-export { type RecognizerSpec, type SpeechRecognitionConfig, type MutableSpeechRecognitionConfig, type VolumeChangeEvent, type RecognizerCallbacks, type RecognizerMethods, } from './Recognizer/types';
+export { type RecognizerSpec, type SpeechRecognitionConfig, type SpeechRecognitionPrewarm, type MutableSpeechRecognitionConfig, type VolumeChangeEvent, type RecognizerCallbacks, type RecognizerMethods, } from './Recognizer/types';

package/lib/specs/Recognizer.nitro.d.ts

@@ -1,6 +1,7 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from './SpeechRecognitionConfig';
 import type { VolumeChangeEvent } from './VolumeChangeEvent';
+import type { SpeechRecognitionPrewarm } from './SpeechRecognitionPrewarm';
 export interface Recognizer extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
@@ -27,7 +28,7 @@ export interface Recognizer extends HybridObject<{
      *  });
      * ```
      */
-    prewarm(defaultParams?: SpeechRecognitionConfig): Promise<void>;
+    prewarm(defaultParams?: SpeechRecognitionConfig, options?: SpeechRecognitionPrewarm): Promise<void>;
     /**
      * Try to start the speech recognition.
      *

package/lib/specs/SpeechRecognitionConfig.d.ts

@@ -22,7 +22,7 @@ interface ParamsAndroid {
      */
     androidDisableBatchHandling?: boolean;
 }
-type IosPreset = 'shortform' | 'general';
+type IosPreset = 'shortform' | 'general' | 'speed';
 interface ParamsIOS {
     /**
      * Add punctuation to speech recognition results
@@ -33,9 +33,13 @@ interface ParamsIOS {
      */
     iosAddPunctuation?: boolean;
     /**
-     * `"shortForm"` - for a short phrase or sentence, also disables punctuation
+     * `"shortForm"` - For a short phrase or sentence, also disables punctuation
      *
-     * `"general"` - for longer speeches, more accurate but delayed response
+     * `"speed"` - Gives priority to speed over accuracy
+     *
+     * `"general"` - For longer speeches, more accurate but delayed response
+     *
+     * @note preset may be overridden by other properties
      *
      * @since iOS 26.0+
      *

package/lib/specs/SpeechRecognitionPrewarm.d.ts

@@ -0,0 +1,10 @@
+export interface SpeechRecognitionPrewarm {
+    /**
+     * If permission is not granted, will request it.
+     *
+     * if permission is set, does nothing.
+     *
+     * @default true
+     */
+    requestPermission?: boolean;
+}

package/lib/specs/SpeechRecognitionPrewarm.js

@@ -0,0 +1 @@
+export {};

package/nitrogen/generated/android/c++/JHybridRecognizerSpec.cpp

@@ -15,6 +15,8 @@ namespace margelo::nitro::nitrospeech { struct SpeechRecognitionConfig; }
 namespace margelo::nitro::nitrospeech { enum class HapticFeedbackStyle; }
 // Forward declaration of `IosPreset` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { enum class IosPreset; }
+// Forward declaration of `SpeechRecognitionPrewarm` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechRecognitionPrewarm; }
 // Forward declaration of `MutableSpeechRecognitionConfig` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 
@@ -39,6 +41,8 @@ namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 #include "JHapticFeedbackStyle.hpp"
 #include "IosPreset.hpp"
 #include "JIosPreset.hpp"
+#include "SpeechRecognitionPrewarm.hpp"
+#include "JSpeechRecognitionPrewarm.hpp"
 #include "MutableSpeechRecognitionConfig.hpp"
 #include "JMutableSpeechRecognitionConfig.hpp"
 
@@ -193,9 +197,9 @@ namespace margelo::nitro::nitrospeech {
   }
 
   // Methods
-  std::shared_ptr<Promise<void>> JHybridRecognizerSpec::prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JSpeechRecognitionConfig> /* defaultParams */)>("prewarm");
-    auto __result = method(_javaPart, defaultParams.has_value() ? JSpeechRecognitionConfig::fromCpp(defaultParams.value()) : nullptr);
+  std::shared_ptr<Promise<void>> JHybridRecognizerSpec::prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams, const std::optional<SpeechRecognitionPrewarm>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JSpeechRecognitionConfig> /* defaultParams */, jni::alias_ref<JSpeechRecognitionPrewarm> /* options */)>("prewarm");
+    auto __result = method(_javaPart, defaultParams.has_value() ? JSpeechRecognitionConfig::fromCpp(defaultParams.value()) : nullptr, options.has_value() ? JSpeechRecognitionPrewarm::fromCpp(options.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<void>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {

package/nitrogen/generated/android/c++/JHybridRecognizerSpec.hpp

@@ -67,7 +67,7 @@ namespace margelo::nitro::nitrospeech {
 
   public:
     // Methods
-    std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) override;
+    std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams, const std::optional<SpeechRecognitionPrewarm>& options) override;
     void startListening(const std::optional<SpeechRecognitionConfig>& params) override;
     void stopListening() override;
     void resetAutoFinishTime() override;

package/nitrogen/generated/android/c++/JIosPreset.hpp

@@ -48,6 +48,9 @@ namespace margelo::nitro::nitrospeech {
         case IosPreset::GENERAL:
           static const auto fieldGENERAL = clazz->getStaticField<JIosPreset>("GENERAL");
           return clazz->getStaticFieldValue(fieldGENERAL);
+        case IosPreset::SPEED:
+          static const auto fieldSPEED = clazz->getStaticField<JIosPreset>("SPEED");
+          return clazz->getStaticFieldValue(fieldSPEED);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));
           throw std::invalid_argument("Invalid enum value (" + stringValue + "!");

package/nitrogen/generated/android/c++/JSpeechRecognitionPrewarm.hpp

@@ -0,0 +1,57 @@
+///
+/// JSpeechRecognitionPrewarm.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 "SpeechRecognitionPrewarm.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrospeech {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "SpeechRecognitionPrewarm" and the the Kotlin data class "SpeechRecognitionPrewarm".
+   */
+  struct JSpeechRecognitionPrewarm final: public jni::JavaClass<JSpeechRecognitionPrewarm> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/SpeechRecognitionPrewarm;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct SpeechRecognitionPrewarm by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    SpeechRecognitionPrewarm toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRequestPermission = clazz->getField<jni::JBoolean>("requestPermission");
+      jni::local_ref<jni::JBoolean> requestPermission = this->getFieldValue(fieldRequestPermission);
+      return SpeechRecognitionPrewarm(
+        requestPermission != nullptr ? std::make_optional(static_cast<bool>(requestPermission->value())) : 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<JSpeechRecognitionPrewarm::javaobject> fromCpp(const SpeechRecognitionPrewarm& value) {
+      using JSignature = JSpeechRecognitionPrewarm(jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.requestPermission.has_value() ? jni::JBoolean::valueOf(value.requestPermission.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrospeech

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/HybridRecognizerSpec.kt

@@ -127,7 +127,7 @@ abstract class HybridRecognizerSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun prewarm(defaultParams: SpeechRecognitionConfig?): Promise<Unit>
+  abstract fun prewarm(defaultParams: SpeechRecognitionConfig?, options: SpeechRecognitionPrewarm?): Promise<Unit>
   
   @DoNotStrip
   @Keep

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/IosPreset.kt

@@ -17,7 +17,8 @@ import com.facebook.proguard.annotations.DoNotStrip
 @Keep
 enum class IosPreset(@DoNotStrip @Keep val value: Int) {
   SHORTFORM(0),
-  GENERAL(1);
+  GENERAL(1),
+  SPEED(2);
 
   companion object
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/SpeechRecognitionPrewarm.kt

@@ -0,0 +1,51 @@
+///
+/// SpeechRecognitionPrewarm.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.nitrospeech
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "SpeechRecognitionPrewarm".
+ */
+@DoNotStrip
+@Keep
+data class SpeechRecognitionPrewarm(
+  @DoNotStrip
+  @Keep
+  val requestPermission: Boolean?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is SpeechRecognitionPrewarm) return false
+    return Objects.deepEquals(this.requestPermission, other.requestPermission)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      requestPermission
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(requestPermission: Boolean?): SpeechRecognitionPrewarm {
+      return SpeechRecognitionPrewarm(requestPermission)
+    }
+  }
+}

package/nitrogen/generated/ios/NitroSpeech-Swift-Cxx-Bridge.hpp

@@ -20,6 +20,8 @@ namespace margelo::nitro::nitrospeech { enum class IosPreset; }
 namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 // Forward declaration of `SpeechRecognitionConfig` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct SpeechRecognitionConfig; }
+// Forward declaration of `SpeechRecognitionPrewarm` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechRecognitionPrewarm; }
 // Forward declaration of `VolumeChangeEvent` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct VolumeChangeEvent; }
 
@@ -36,6 +38,7 @@ namespace NitroSpeech { class HybridRecognizerSpec_cxx; }
 #include "IosPreset.hpp"
 #include "MutableSpeechRecognitionConfig.hpp"
 #include "SpeechRecognitionConfig.hpp"
+#include "SpeechRecognitionPrewarm.hpp"
 #include "VolumeChangeEvent.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -249,6 +252,21 @@ namespace margelo::nitro::nitrospeech::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<SpeechRecognitionPrewarm>
+  /**
+   * Specialized version of `std::optional<SpeechRecognitionPrewarm>`.
+   */
+  using std__optional_SpeechRecognitionPrewarm_ = std::optional<SpeechRecognitionPrewarm>;
+  inline std::optional<SpeechRecognitionPrewarm> create_std__optional_SpeechRecognitionPrewarm_(const SpeechRecognitionPrewarm& value) noexcept {
+    return std::optional<SpeechRecognitionPrewarm>(value);
+  }
+  inline bool has_value_std__optional_SpeechRecognitionPrewarm_(const std::optional<SpeechRecognitionPrewarm>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SpeechRecognitionPrewarm get_std__optional_SpeechRecognitionPrewarm_(const std::optional<SpeechRecognitionPrewarm>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<MutableSpeechRecognitionConfig>
   /**
    * Specialized version of `std::optional<MutableSpeechRecognitionConfig>`.

package/nitrogen/generated/ios/NitroSpeech-Swift-Cxx-Umbrella.hpp

@@ -20,6 +20,8 @@ namespace margelo::nitro::nitrospeech { enum class IosPreset; }
 namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 // Forward declaration of `SpeechRecognitionConfig` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct SpeechRecognitionConfig; }
+// Forward declaration of `SpeechRecognitionPrewarm` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechRecognitionPrewarm; }
 // Forward declaration of `VolumeChangeEvent` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct VolumeChangeEvent; }
 
@@ -30,6 +32,7 @@ namespace margelo::nitro::nitrospeech { struct VolumeChangeEvent; }
 #include "IosPreset.hpp"
 #include "MutableSpeechRecognitionConfig.hpp"
 #include "SpeechRecognitionConfig.hpp"
+#include "SpeechRecognitionPrewarm.hpp"
 #include "VolumeChangeEvent.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>

package/nitrogen/generated/ios/c++/HybridRecognizerSpecSwift.hpp

@@ -20,6 +20,8 @@ namespace margelo::nitro::nitrospeech { struct SpeechRecognitionConfig; }
 namespace margelo::nitro::nitrospeech { enum class HapticFeedbackStyle; }
 // Forward declaration of `IosPreset` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { enum class IosPreset; }
+// Forward declaration of `SpeechRecognitionPrewarm` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechRecognitionPrewarm; }
 // Forward declaration of `MutableSpeechRecognitionConfig` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 
@@ -32,6 +34,7 @@ namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 #include "SpeechRecognitionConfig.hpp"
 #include "HapticFeedbackStyle.hpp"
 #include "IosPreset.hpp"
+#include "SpeechRecognitionPrewarm.hpp"
 #include "MutableSpeechRecognitionConfig.hpp"
 
 #include "NitroSpeech-Swift-Cxx-Umbrella.hpp"
@@ -132,8 +135,8 @@ namespace margelo::nitro::nitrospeech {
 
   public:
     // Methods
-    inline std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) override {
-      auto __result = _swiftPart.prewarm(defaultParams);
+    inline std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams, const std::optional<SpeechRecognitionPrewarm>& options) override {
+      auto __result = _swiftPart.prewarm(defaultParams, options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/HybridRecognizerSpec.swift

@@ -19,7 +19,7 @@ public protocol HybridRecognizerSpec_protocol: HybridObject {
   var onVolumeChange: ((_ event: VolumeChangeEvent) -> Void)? { get set }
 
   // Methods
-  func prewarm(defaultParams: SpeechRecognitionConfig?) throws -> Promise<Void>
+  func prewarm(defaultParams: SpeechRecognitionConfig?, options: SpeechRecognitionPrewarm?) throws -> Promise<Void>
   func startListening(params: SpeechRecognitionConfig?) throws -> Void
   func stopListening() throws -> Void
   func resetAutoFinishTime() throws -> Void

package/nitrogen/generated/ios/swift/HybridRecognizerSpec_cxx.swift

@@ -353,9 +353,9 @@ open class HybridRecognizerSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func prewarm(defaultParams: bridge.std__optional_SpeechRecognitionConfig_) -> bridge.Result_std__shared_ptr_Promise_void___ {
+  public final func prewarm(defaultParams: bridge.std__optional_SpeechRecognitionConfig_, options: bridge.std__optional_SpeechRecognitionPrewarm_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      let __result = try self.__implementation.prewarm(defaultParams: defaultParams.value)
+      let __result = try self.__implementation.prewarm(defaultParams: defaultParams.value, options: options.value)
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)

package/nitrogen/generated/ios/swift/IosPreset.swift

@@ -21,6 +21,8 @@ public extension IosPreset {
         self = .shortform
       case "general":
         self = .general
+      case "speed":
+        self = .speed
       default:
         return nil
     }
@@ -35,6 +37,8 @@ public extension IosPreset {
         return "shortform"
       case .general:
         return "general"
+      case .speed:
+        return "speed"
     }
   }
 }