@gmessier/nitro-speech 0.3.3 → 0.4.0

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

@@ -12,17 +12,27 @@
 // Forward declaration of `HybridRecognizerSpec_cxx` to properly resolve imports.
 namespace NitroSpeech { class HybridRecognizerSpec_cxx; }
 
-// Forward declaration of `SpeechToTextParams` to properly resolve imports.
-namespace margelo::nitro::nitrospeech { struct SpeechToTextParams; }
+// Forward declaration of `VolumeChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct VolumeChangeEvent; }
+// Forward declaration of `SpeechRecognitionConfig` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechRecognitionConfig; }
 // Forward declaration of `HapticFeedbackStyle` to properly resolve imports.
 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 `MutableSpeechRecognitionConfig` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 
 #include <functional>
 #include <optional>
 #include <string>
 #include <vector>
-#include "SpeechToTextParams.hpp"
+#include "VolumeChangeEvent.hpp"
+#include <NitroModules/Promise.hpp>
+#include "SpeechRecognitionConfig.hpp"
 #include "HapticFeedbackStyle.hpp"
+#include "IosPreset.hpp"
+#include "MutableSpeechRecognitionConfig.hpp"
 
 #include "NitroSpeech-Swift-Cxx-Umbrella.hpp"
 
@@ -112,18 +122,26 @@ namespace margelo::nitro::nitrospeech {
     inline void setOnPermissionDenied(const std::optional<std::function<void()>>& onPermissionDenied) noexcept override {
       _swiftPart.setOnPermissionDenied(onPermissionDenied);
     }
-    inline std::optional<std::function<void(double /* normVolume */)>> getOnVolumeChange() noexcept override {
+    inline std::optional<std::function<void(const VolumeChangeEvent& /* event */)>> getOnVolumeChange() noexcept override {
       auto __result = _swiftPart.getOnVolumeChange();
       return __result;
     }
-    inline void setOnVolumeChange(const std::optional<std::function<void(double /* normVolume */)>>& onVolumeChange) noexcept override {
+    inline void setOnVolumeChange(const std::optional<std::function<void(const VolumeChangeEvent& /* event */)>>& onVolumeChange) noexcept override {
       _swiftPart.setOnVolumeChange(onVolumeChange);
     }
 
   public:
     // Methods
-    inline void startListening(const SpeechToTextParams& params) override {
-      auto __result = _swiftPart.startListening(std::forward<decltype(params)>(params));
+    inline std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) override {
+      auto __result = _swiftPart.prewarm(defaultParams);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void startListening(const std::optional<SpeechRecognitionConfig>& params) override {
+      auto __result = _swiftPart.startListening(params);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -134,14 +152,20 @@ namespace margelo::nitro::nitrospeech {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void resetAutoFinishTime() override {
+      auto __result = _swiftPart.resetAutoFinishTime();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void addAutoFinishTime(std::optional<double> additionalTimeMs) override {
       auto __result = _swiftPart.addAutoFinishTime(additionalTimeMs);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void updateAutoFinishTime(double newTimeMs, std::optional<bool> withRefresh) override {
-      auto __result = _swiftPart.updateAutoFinishTime(std::forward<decltype(newTimeMs)>(newTimeMs), withRefresh);
+    inline void updateConfig(const std::optional<MutableSpeechRecognitionConfig>& newConfig, std::optional<bool> resetAutoFinishTime) override {
+      auto __result = _swiftPart.updateConfig(newConfig, resetAutoFinishTime);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -154,6 +178,14 @@ namespace margelo::nitro::nitrospeech {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::vector<std::string> getSupportedLocalesIOS() override {
+      auto __result = _swiftPart.getSupportedLocalesIOS();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroSpeech::HybridRecognizerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void_VolumeChangeEvent.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_VolumeChangeEvent.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 `(_ event: VolumeChangeEvent) -> 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_VolumeChangeEvent {
+  public typealias bridge = margelo.nitro.nitrospeech.bridge.swift
+
+  private let closure: (_ event: VolumeChangeEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: VolumeChangeEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: VolumeChangeEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * 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_VolumeChangeEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_VolumeChangeEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_VolumeChangeEvent {
+    return Unmanaged<Func_void_VolumeChangeEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_std__exception_ptr.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 `(_ error: Error) -> 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__exception_ptr {
+  public typealias bridge = margelo.nitro.nitrospeech.bridge.swift
+
+  private let closure: (_ error: Error) -> Void
+
+  public init(_ closure: @escaping (_ error: Error) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(error: std.exception_ptr) -> Void {
+    self.closure(RuntimeError.from(cppError: error))
+  }
+
+  /**
+   * 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_std__exception_ptr`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__exception_ptr>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__exception_ptr {
+    return Unmanaged<Func_void_std__exception_ptr>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

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

@@ -16,14 +16,17 @@ public protocol HybridRecognizerSpec_protocol: HybridObject {
   var onAutoFinishProgress: ((_ timeLeftMs: Double) -> Void)? { get set }
   var onError: ((_ message: String) -> Void)? { get set }
   var onPermissionDenied: (() -> Void)? { get set }
-  var onVolumeChange: ((_ normVolume: Double) -> Void)? { get set }
+  var onVolumeChange: ((_ event: VolumeChangeEvent) -> Void)? { get set }
 
   // Methods
-  func startListening(params: SpeechToTextParams) throws -> Void
+  func prewarm(defaultParams: SpeechRecognitionConfig?) throws -> Promise<Void>
+  func startListening(params: SpeechRecognitionConfig?) throws -> Void
   func stopListening() throws -> Void
+  func resetAutoFinishTime() throws -> Void
   func addAutoFinishTime(additionalTimeMs: Double?) throws -> Void
-  func updateAutoFinishTime(newTimeMs: Double, withRefresh: Bool?) throws -> Void
+  func updateConfig(newConfig: MutableSpeechRecognitionConfig?, resetAutoFinishTime: Bool?) throws -> Void
   func getIsActive() throws -> Bool
+  func getSupportedLocalesIOS() throws -> [String]
 }
 
 public extension HybridRecognizerSpec_protocol {

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

@@ -319,14 +319,14 @@ open class HybridRecognizerSpec_cxx {
     }
   }
   
-  public final var onVolumeChange: bridge.std__optional_std__function_void_double____normVolume______ {
+  public final var onVolumeChange: bridge.std__optional_std__function_void_const_VolumeChangeEvent_____event______ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_std__function_void_double____normVolume______ in
+      return { () -> bridge.std__optional_std__function_void_const_VolumeChangeEvent_____event______ in
         if let __unwrappedValue = self.__implementation.onVolumeChange {
-          return bridge.create_std__optional_std__function_void_double____normVolume______({ () -> bridge.Func_void_double in
-            let __closureWrapper = Func_void_double(__unwrappedValue)
-            return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+          return bridge.create_std__optional_std__function_void_const_VolumeChangeEvent_____event______({ () -> bridge.Func_void_VolumeChangeEvent in
+            let __closureWrapper = Func_void_VolumeChangeEvent(__unwrappedValue)
+            return bridge.create_Func_void_VolumeChangeEvent(__closureWrapper.toUnsafe())
           }())
         } else {
           return .init()
@@ -335,13 +335,13 @@ open class HybridRecognizerSpec_cxx {
     }
     @inline(__always)
     set {
-      self.__implementation.onVolumeChange = { () -> ((_ normVolume: Double) -> Void)? in
-        if bridge.has_value_std__optional_std__function_void_double____normVolume______(newValue) {
-          let __unwrapped = bridge.get_std__optional_std__function_void_double____normVolume______(newValue)
-          return { () -> (Double) -> Void in
-            let __wrappedFunction = bridge.wrap_Func_void_double(__unwrapped)
-            return { (__normVolume: Double) -> Void in
-              __wrappedFunction.call(__normVolume)
+      self.__implementation.onVolumeChange = { () -> ((_ event: VolumeChangeEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_VolumeChangeEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_VolumeChangeEvent_____event______(newValue)
+          return { () -> (VolumeChangeEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_VolumeChangeEvent(__unwrapped)
+            return { (__event: VolumeChangeEvent) -> Void in
+              __wrappedFunction.call(__event)
             }
           }()
         } else {
@@ -353,9 +353,28 @@ open class HybridRecognizerSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func startListening(params: SpeechToTextParams) -> bridge.Result_void_ {
+  public final func prewarm(defaultParams: bridge.std__optional_SpeechRecognitionConfig_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.startListening(params: params)
+      let __result = try self.__implementation.prewarm(defaultParams: defaultParams.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)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func startListening(params: bridge.std__optional_SpeechRecognitionConfig_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.startListening(params: params.value)
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -374,6 +393,17 @@ open class HybridRecognizerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func resetAutoFinishTime() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.resetAutoFinishTime()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func addAutoFinishTime(additionalTimeMs: bridge.std__optional_double_) -> bridge.Result_void_ {
     do {
@@ -393,11 +423,11 @@ open class HybridRecognizerSpec_cxx {
   }
   
   @inline(__always)
-  public final func updateAutoFinishTime(newTimeMs: Double, withRefresh: bridge.std__optional_bool_) -> bridge.Result_void_ {
+  public final func updateConfig(newConfig: bridge.std__optional_MutableSpeechRecognitionConfig_, resetAutoFinishTime: bridge.std__optional_bool_) -> bridge.Result_void_ {
     do {
-      try self.__implementation.updateAutoFinishTime(newTimeMs: newTimeMs, withRefresh: { () -> Bool? in
-        if bridge.has_value_std__optional_bool_(withRefresh) {
-          let __unwrapped = bridge.get_std__optional_bool_(withRefresh)
+      try self.__implementation.updateConfig(newConfig: newConfig.value, resetAutoFinishTime: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(resetAutoFinishTime) {
+          let __unwrapped = bridge.get_std__optional_bool_(resetAutoFinishTime)
           return __unwrapped
         } else {
           return nil
@@ -421,4 +451,22 @@ open class HybridRecognizerSpec_cxx {
       return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getSupportedLocalesIOS() -> bridge.Result_std__vector_std__string__ {
+    do {
+      let __result = try self.__implementation.getSupportedLocalesIOS()
+      let __resultCpp = { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(__result.count)
+        for __item in __result {
+          __vector.push_back(std.string(__item))
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_std__string__(__exceptionPtr)
+    }
+  }
 }

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

@@ -0,0 +1,40 @@
+///
+/// IosPreset.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `IosPreset`, backed by a C++ enum.
+ */
+public typealias IosPreset = margelo.nitro.nitrospeech.IosPreset
+
+public extension IosPreset {
+  /**
+   * Get a IosPreset for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "shortform":
+        self = .shortform
+      case "general":
+        self = .general
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this IosPreset represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .shortform:
+        return "shortform"
+      case .general:
+        return "general"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/MutableSpeechRecognitionConfig.swift

@@ -0,0 +1,118 @@
+///
+/// MutableSpeechRecognitionConfig.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 `MutableSpeechRecognitionConfig`, backed by a C++ struct.
+ */
+public typealias MutableSpeechRecognitionConfig = margelo.nitro.nitrospeech.MutableSpeechRecognitionConfig
+
+public extension MutableSpeechRecognitionConfig {
+  private typealias bridge = margelo.nitro.nitrospeech.bridge.swift
+
+  /**
+   * Create a new instance of `MutableSpeechRecognitionConfig`.
+   */
+  init(autoFinishRecognitionMs: Double?, autoFinishProgressIntervalMs: Double?, resetAutoFinishVoiceSensitivity: Double?, disableRepeatingFilter: Bool?, startHapticFeedbackStyle: HapticFeedbackStyle?, stopHapticFeedbackStyle: HapticFeedbackStyle?) {
+    self.init({ () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = autoFinishRecognitionMs {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = autoFinishProgressIntervalMs {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = resetAutoFinishVoiceSensitivity {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = disableRepeatingFilter {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_HapticFeedbackStyle_ in
+      if let __unwrappedValue = startHapticFeedbackStyle {
+        return bridge.create_std__optional_HapticFeedbackStyle_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_HapticFeedbackStyle_ in
+      if let __unwrappedValue = stopHapticFeedbackStyle {
+        return bridge.create_std__optional_HapticFeedbackStyle_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var autoFinishRecognitionMs: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__autoFinishRecognitionMs) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__autoFinishRecognitionMs)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var autoFinishProgressIntervalMs: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__autoFinishProgressIntervalMs) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__autoFinishProgressIntervalMs)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var resetAutoFinishVoiceSensitivity: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__resetAutoFinishVoiceSensitivity) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__resetAutoFinishVoiceSensitivity)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var disableRepeatingFilter: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__disableRepeatingFilter) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__disableRepeatingFilter)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var startHapticFeedbackStyle: HapticFeedbackStyle? {
+    return self.__startHapticFeedbackStyle.value
+  }
+  
+  @inline(__always)
+  var stopHapticFeedbackStyle: HapticFeedbackStyle? {
+    return self.__stopHapticFeedbackStyle.value
+  }
+}