react-native-nitro-mlx 0.3.0 → 0.4.0

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

@@ -8,16 +8,28 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct GenerationStats; }
 // Forward declaration of `HybridLLMSpec` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { class HybridLLMSpec; }
 // Forward declaration of `HybridModelManagerSpec` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { class HybridModelManagerSpec; }
+// Forward declaration of `HybridSTTSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridSTTSpec; }
+// Forward declaration of `HybridTTSSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridTTSSpec; }
 // Forward declaration of `LLMLoadOptions` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMLoadOptions; }
 // Forward declaration of `LLMMessage` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
+// Forward declaration of `STTLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct STTLoadOptions; }
+// Forward declaration of `TTSGenerateOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSGenerateOptions; }
+// Forward declaration of `TTSLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSLoadOptions; }
 // Forward declaration of `ToolDefinition` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct ToolDefinition; }
 // Forward declaration of `ToolParameter` to properly resolve imports.
@@ -28,16 +40,27 @@ namespace margelo::nitro::mlxreactnative { struct ToolParameter; }
 namespace MLXReactNative { class HybridLLMSpec_cxx; }
 // Forward declaration of `HybridModelManagerSpec_cxx` to properly resolve imports.
 namespace MLXReactNative { class HybridModelManagerSpec_cxx; }
+// Forward declaration of `HybridSTTSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridSTTSpec_cxx; }
+// Forward declaration of `HybridTTSSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridTTSSpec_cxx; }
 
 // Include C++ defined types
 #include "GenerationStats.hpp"
 #include "HybridLLMSpec.hpp"
 #include "HybridModelManagerSpec.hpp"
+#include "HybridSTTSpec.hpp"
+#include "HybridTTSSpec.hpp"
 #include "LLMLoadOptions.hpp"
 #include "LLMMessage.hpp"
+#include "STTLoadOptions.hpp"
+#include "TTSGenerateOptions.hpp"
+#include "TTSLoadOptions.hpp"
 #include "ToolDefinition.hpp"
 #include "ToolParameter.hpp"
 #include <NitroModules/AnyMap.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -567,5 +590,147 @@ namespace margelo::nitro::mlxreactnative::bridge::swift {
   inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withError(error);
   }
+  
+  // pragma MARK: std::optional<STTLoadOptions>
+  /**
+   * Specialized version of `std::optional<STTLoadOptions>`.
+   */
+  using std__optional_STTLoadOptions_ = std::optional<STTLoadOptions>;
+  inline std::optional<STTLoadOptions> create_std__optional_STTLoadOptions_(const STTLoadOptions& value) noexcept {
+    return std::optional<STTLoadOptions>(value);
+  }
+  inline bool has_value_std__optional_STTLoadOptions_(const std::optional<STTLoadOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline STTLoadOptions get_std__optional_STTLoadOptions_(const std::optional<STTLoadOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridSTTSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridSTTSpec>`.
+   */
+  using std__shared_ptr_HybridSTTSpec_ = std::shared_ptr<HybridSTTSpec>;
+  std::shared_ptr<HybridSTTSpec> create_std__shared_ptr_HybridSTTSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridSTTSpec_(std__shared_ptr_HybridSTTSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridSTTSpec>
+  using std__weak_ptr_HybridSTTSpec_ = std::weak_ptr<HybridSTTSpec>;
+  inline std__weak_ptr_HybridSTTSpec_ weakify_std__shared_ptr_HybridSTTSpec_(const std::shared_ptr<HybridSTTSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<TTSLoadOptions>
+  /**
+   * Specialized version of `std::optional<TTSLoadOptions>`.
+   */
+  using std__optional_TTSLoadOptions_ = std::optional<TTSLoadOptions>;
+  inline std::optional<TTSLoadOptions> create_std__optional_TTSLoadOptions_(const TTSLoadOptions& value) noexcept {
+    return std::optional<TTSLoadOptions>(value);
+  }
+  inline bool has_value_std__optional_TTSLoadOptions_(const std::optional<TTSLoadOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TTSLoadOptions get_std__optional_TTSLoadOptions_(const std::optional<TTSLoadOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::optional<TTSGenerateOptions>
+  /**
+   * Specialized version of `std::optional<TTSGenerateOptions>`.
+   */
+  using std__optional_TTSGenerateOptions_ = std::optional<TTSGenerateOptions>;
+  inline std::optional<TTSGenerateOptions> create_std__optional_TTSGenerateOptions_(const TTSGenerateOptions& value) noexcept {
+    return std::optional<TTSGenerateOptions>(value);
+  }
+  inline bool has_value_std__optional_TTSGenerateOptions_(const std::optional<TTSGenerateOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TTSGenerateOptions get_std__optional_TTSGenerateOptions_(const std::optional<TTSGenerateOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridTTSSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridTTSSpec>`.
+   */
+  using std__shared_ptr_HybridTTSSpec_ = std::shared_ptr<HybridTTSSpec>;
+  std::shared_ptr<HybridTTSSpec> create_std__shared_ptr_HybridTTSSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridTTSSpec_(std__shared_ptr_HybridTTSSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridTTSSpec>
+  using std__weak_ptr_HybridTTSSpec_ = std::weak_ptr<HybridTTSSpec>;
+  inline std__weak_ptr_HybridTTSSpec_ weakify_std__shared_ptr_HybridTTSSpec_(const std::shared_ptr<HybridTTSSpec>& strong) noexcept { return strong; }
+  
+  // 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);
+  }
 
 } // namespace margelo::nitro::mlxreactnative::bridge::swift

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

@@ -14,10 +14,20 @@ namespace margelo::nitro::mlxreactnative { struct GenerationStats; }
 namespace margelo::nitro::mlxreactnative { class HybridLLMSpec; }
 // Forward declaration of `HybridModelManagerSpec` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { class HybridModelManagerSpec; }
+// Forward declaration of `HybridSTTSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridSTTSpec; }
+// Forward declaration of `HybridTTSSpec` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { class HybridTTSSpec; }
 // Forward declaration of `LLMLoadOptions` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMLoadOptions; }
 // Forward declaration of `LLMMessage` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct LLMMessage; }
+// Forward declaration of `STTLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct STTLoadOptions; }
+// Forward declaration of `TTSGenerateOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSGenerateOptions; }
+// Forward declaration of `TTSLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSLoadOptions; }
 // Forward declaration of `ToolDefinition` to properly resolve imports.
 namespace margelo::nitro::mlxreactnative { struct ToolDefinition; }
 // Forward declaration of `ToolParameter` to properly resolve imports.
@@ -27,11 +37,17 @@ namespace margelo::nitro::mlxreactnative { struct ToolParameter; }
 #include "GenerationStats.hpp"
 #include "HybridLLMSpec.hpp"
 #include "HybridModelManagerSpec.hpp"
+#include "HybridSTTSpec.hpp"
+#include "HybridTTSSpec.hpp"
 #include "LLMLoadOptions.hpp"
 #include "LLMMessage.hpp"
+#include "STTLoadOptions.hpp"
+#include "TTSGenerateOptions.hpp"
+#include "TTSLoadOptions.hpp"
 #include "ToolDefinition.hpp"
 #include "ToolParameter.hpp"
 #include <NitroModules/AnyMap.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -55,6 +71,10 @@ namespace margelo::nitro::mlxreactnative { struct ToolParameter; }
 namespace MLXReactNative { class HybridLLMSpec_cxx; }
 // Forward declaration of `HybridModelManagerSpec_cxx` to properly resolve imports.
 namespace MLXReactNative { class HybridModelManagerSpec_cxx; }
+// Forward declaration of `HybridSTTSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridSTTSpec_cxx; }
+// Forward declaration of `HybridTTSSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridTTSSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("MLXReactNative-Swift.h")

package/nitrogen/generated/ios/MLXReactNativeAutolinking.mm

@@ -12,6 +12,8 @@
 
 #include "HybridLLMSpecSwift.hpp"
 #include "HybridModelManagerSpecSwift.hpp"
+#include "HybridTTSSpecSwift.hpp"
+#include "HybridSTTSpecSwift.hpp"
 
 @interface MLXReactNativeAutolinking : NSObject
 @end
@@ -36,6 +38,20 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "TTS",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridTTSSpec> hybridObject = MLXReactNative::MLXReactNativeAutolinking::createTTS();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "STT",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridSTTSpec> hybridObject = MLXReactNative::MLXReactNativeAutolinking::createSTT();
+      return hybridObject;
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/MLXReactNativeAutolinking.swift

@@ -37,4 +37,34 @@ public final class MLXReactNativeAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridTTSSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridTTSSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridTTS`).
+   */
+  public static func createTTS() -> bridge.std__shared_ptr_HybridTTSSpec_ {
+    let hybridObject = HybridTTS()
+    return { () -> bridge.std__shared_ptr_HybridTTSSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridSTTSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridSTTSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridSTT`).
+   */
+  public static func createSTT() -> bridge.std__shared_ptr_HybridSTTSpec_ {
+    let hybridObject = HybridSTT()
+    return { () -> bridge.std__shared_ptr_HybridSTTSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
 }

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

@@ -125,6 +125,14 @@ namespace margelo::nitro::mlxreactnative {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<std::string>> streamWithEvents(const std::string& prompt, const std::function<void(const std::string& /* eventJson */)>& onEvent) override {
+      auto __result = _swiftPart.streamWithEvents(prompt, onEvent);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void stop() override {
       auto __result = _swiftPart.stop();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/c++/HybridSTTSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridSTTSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridSTTSpecSwift.hpp"
+
+namespace margelo::nitro::mlxreactnative {
+} // namespace margelo::nitro::mlxreactnative

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

@@ -0,0 +1,149 @@
+///
+/// HybridSTTSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridSTTSpec.hpp"
+
+// Forward declaration of `HybridSTTSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridSTTSpec_cxx; }
+
+// Forward declaration of `STTLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct STTLoadOptions; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include "STTLoadOptions.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+
+#include "MLXReactNative-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::mlxreactnative {
+
+  /**
+   * The C++ part of HybridSTTSpec_cxx.swift.
+   *
+   * HybridSTTSpecSwift (C++) accesses HybridSTTSpec_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, HybridSTTSpec_cxx can directly inherit from the C++ class HybridSTTSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridSTTSpecSwift: public virtual HybridSTTSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridSTTSpecSwift(const MLXReactNative::HybridSTTSpec_cxx& swiftPart):
+      HybridObject(HybridSTTSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline MLXReactNative::HybridSTTSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline bool getIsLoaded() noexcept override {
+      return _swiftPart.isLoaded();
+    }
+    inline bool getIsTranscribing() noexcept override {
+      return _swiftPart.isTranscribing();
+    }
+    inline bool getIsListening() noexcept override {
+      return _swiftPart.isListening();
+    }
+    inline std::string getModelId() noexcept override {
+      auto __result = _swiftPart.getModelId();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> load(const std::string& modelId, const std::optional<STTLoadOptions>& options) override {
+      auto __result = _swiftPart.load(modelId, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> transcribe(const std::shared_ptr<ArrayBuffer>& audio) override {
+      auto __result = _swiftPart.transcribe(ArrayBufferHolder(audio));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> transcribeStream(const std::shared_ptr<ArrayBuffer>& audio, const std::function<void(const std::string& /* token */)>& onToken) override {
+      auto __result = _swiftPart.transcribeStream(ArrayBufferHolder(audio), onToken);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> startListening() override {
+      auto __result = _swiftPart.startListening();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> transcribeBuffer() override {
+      auto __result = _swiftPart.transcribeBuffer();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> stopListening() override {
+      auto __result = _swiftPart.stopListening();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void stop() override {
+      auto __result = _swiftPart.stop();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void unload() override {
+      auto __result = _swiftPart.unload();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    MLXReactNative::HybridSTTSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::mlxreactnative

package/nitrogen/generated/ios/c++/HybridTTSSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridTTSSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridTTSSpecSwift.hpp"
+
+namespace margelo::nitro::mlxreactnative {
+} // namespace margelo::nitro::mlxreactnative

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

@@ -0,0 +1,128 @@
+///
+/// HybridTTSSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridTTSSpec.hpp"
+
+// Forward declaration of `HybridTTSSpec_cxx` to properly resolve imports.
+namespace MLXReactNative { class HybridTTSSpec_cxx; }
+
+// Forward declaration of `TTSLoadOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSLoadOptions; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `TTSGenerateOptions` to properly resolve imports.
+namespace margelo::nitro::mlxreactnative { struct TTSGenerateOptions; }
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include "TTSLoadOptions.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include "TTSGenerateOptions.hpp"
+
+#include "MLXReactNative-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::mlxreactnative {
+
+  /**
+   * The C++ part of HybridTTSSpec_cxx.swift.
+   *
+   * HybridTTSSpecSwift (C++) accesses HybridTTSSpec_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, HybridTTSSpec_cxx can directly inherit from the C++ class HybridTTSSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridTTSSpecSwift: public virtual HybridTTSSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridTTSSpecSwift(const MLXReactNative::HybridTTSSpec_cxx& swiftPart):
+      HybridObject(HybridTTSSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline MLXReactNative::HybridTTSSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline bool getIsLoaded() noexcept override {
+      return _swiftPart.isLoaded();
+    }
+    inline bool getIsGenerating() noexcept override {
+      return _swiftPart.isGenerating();
+    }
+    inline std::string getModelId() noexcept override {
+      auto __result = _swiftPart.getModelId();
+      return __result;
+    }
+    inline double getSampleRate() noexcept override {
+      return _swiftPart.getSampleRate();
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> load(const std::string& modelId, const std::optional<TTSLoadOptions>& options) override {
+      auto __result = _swiftPart.load(modelId, options);
+      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>>> generate(const std::string& text, const std::optional<TTSGenerateOptions>& options) override {
+      auto __result = _swiftPart.generate(text, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> stream(const std::string& text, const std::function<void(const std::shared_ptr<ArrayBuffer>& /* audio */)>& onAudioChunk, const std::optional<TTSGenerateOptions>& options) override {
+      auto __result = _swiftPart.stream(text, onAudioChunk, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void stop() override {
+      auto __result = _swiftPart.stop();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void unload() override {
+      auto __result = _swiftPart.unload();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    MLXReactNative::HybridTTSSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::mlxreactnative