@gmessier/nitro-speech 0.4.3 → 0.4.4

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/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

@@ -39,6 +39,8 @@ interface ParamsIOS {
      *
      * `"general"` - For longer speeches, more accurate but delayed response
      *
+     * @note preset may be overridden by other properties
+     *
      * @since iOS 26.0+
      *
      * @default "general"

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++/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/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/SpeechRecognitionPrewarm.swift

@@ -0,0 +1,42 @@
+///
+/// SpeechRecognitionPrewarm.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 `SpeechRecognitionPrewarm`, backed by a C++ struct.
+ */
+public typealias SpeechRecognitionPrewarm = margelo.nitro.nitrospeech.SpeechRecognitionPrewarm
+
+public extension SpeechRecognitionPrewarm {
+  private typealias bridge = margelo.nitro.nitrospeech.bridge.swift
+
+  /**
+   * Create a new instance of `SpeechRecognitionPrewarm`.
+   */
+  init(requestPermission: Bool?) {
+    self.init({ () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = requestPermission {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var requestPermission: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__requestPermission) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__requestPermission)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/shared/c++/HybridRecognizerSpec.hpp

@@ -17,6 +17,8 @@
 namespace margelo::nitro::nitrospeech { struct VolumeChangeEvent; }
 // 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 `MutableSpeechRecognitionConfig` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 
@@ -27,6 +29,7 @@ namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 #include "VolumeChangeEvent.hpp"
 #include <NitroModules/Promise.hpp>
 #include "SpeechRecognitionConfig.hpp"
+#include "SpeechRecognitionPrewarm.hpp"
 #include "MutableSpeechRecognitionConfig.hpp"
 
 namespace margelo::nitro::nitrospeech {
@@ -73,7 +76,7 @@ namespace margelo::nitro::nitrospeech {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) = 0;
+      virtual std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams, const std::optional<SpeechRecognitionPrewarm>& options) = 0;
       virtual void startListening(const std::optional<SpeechRecognitionConfig>& params) = 0;
       virtual void stopListening() = 0;
       virtual void resetAutoFinishTime() = 0;

package/nitrogen/generated/shared/c++/SpeechRecognitionPrewarm.hpp

@@ -0,0 +1,83 @@
+///
+/// SpeechRecognitionPrewarm.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 <optional>
+
+namespace margelo::nitro::nitrospeech {
+
+  /**
+   * A struct which can be represented as a JavaScript object (SpeechRecognitionPrewarm).
+   */
+  struct SpeechRecognitionPrewarm final {
+  public:
+    std::optional<bool> requestPermission     SWIFT_PRIVATE;
+
+  public:
+    SpeechRecognitionPrewarm() = default;
+    explicit SpeechRecognitionPrewarm(std::optional<bool> requestPermission): requestPermission(requestPermission) {}
+
+  public:
+    friend bool operator==(const SpeechRecognitionPrewarm& lhs, const SpeechRecognitionPrewarm& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrospeech
+
+namespace margelo::nitro {
+
+  // C++ SpeechRecognitionPrewarm <> JS SpeechRecognitionPrewarm (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrospeech::SpeechRecognitionPrewarm> final {
+    static inline margelo::nitro::nitrospeech::SpeechRecognitionPrewarm fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrospeech::SpeechRecognitionPrewarm(
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "requestPermission")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrospeech::SpeechRecognitionPrewarm& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "requestPermission"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.requestPermission));
+      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<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "requestPermission")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmessier/nitro-speech",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "React Native Real-time Speech Recognition Library powered by Nitro Modules",
   "main": "./lib/index.js",
   "module": "./lib/index.js",