react-native-nitro-onnx 0.1.0

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

@@ -0,0 +1,105 @@
+///
+/// AsrResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::onnx::speech {
+
+  /**
+   * A struct which can be represented as a JavaScript object (AsrResult).
+   */
+  struct AsrResult final {
+  public:
+    std::string text     SWIFT_PRIVATE;
+    std::optional<double> score     SWIFT_PRIVATE;
+    std::optional<double> startMs     SWIFT_PRIVATE;
+    std::optional<double> endMs     SWIFT_PRIVATE;
+    std::optional<std::vector<double>> timestamps     SWIFT_PRIVATE;
+    std::optional<std::string> json     SWIFT_PRIVATE;
+
+  public:
+    AsrResult() = default;
+    explicit AsrResult(std::string text, std::optional<double> score, std::optional<double> startMs, std::optional<double> endMs, std::optional<std::vector<double>> timestamps, std::optional<std::string> json): text(text), score(score), startMs(startMs), endMs(endMs), timestamps(timestamps), json(json) {}
+
+  public:
+    friend bool operator==(const AsrResult& lhs, const AsrResult& rhs) = default;
+  };
+
+} // namespace margelo::nitro::onnx::speech
+
+namespace margelo::nitro {
+
+  // C++ AsrResult <> JS AsrResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::onnx::speech::AsrResult> final {
+    static inline margelo::nitro::onnx::speech::AsrResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::onnx::speech::AsrResult(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "text"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "score"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "startMs"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "endMs"))),
+        JSIConverter<std::optional<std::vector<double>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamps"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "json")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::onnx::speech::AsrResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "text"), JSIConverter<std::string>::toJSI(runtime, arg.text));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "score"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.score));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "startMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.startMs));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "endMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.endMs));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "timestamps"), JSIConverter<std::optional<std::vector<double>>>::toJSI(runtime, arg.timestamps));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "json"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.json));
+      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::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "text")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "score")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "startMs")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "endMs")))) return false;
+      if (!JSIConverter<std::optional<std::vector<double>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamps")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "json")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridOfflineAsrSpec.cpp

@@ -0,0 +1,25 @@
+///
+/// HybridOfflineAsrSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOfflineAsrSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  void HybridOfflineAsrSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("load", &HybridOfflineAsrSpec::load);
+      prototype.registerHybridMethod("isLoaded", &HybridOfflineAsrSpec::isLoaded);
+      prototype.registerHybridMethod("recognize", &HybridOfflineAsrSpec::recognize);
+      prototype.registerHybridMethod("recognizeFile", &HybridOfflineAsrSpec::recognizeFile);
+      prototype.registerHybridMethod("unload", &HybridOfflineAsrSpec::unload);
+    });
+  }
+
+} // namespace margelo::nitro::onnx::speech

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

@@ -0,0 +1,73 @@
+///
+/// HybridOfflineAsrSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `AsrModelConfig` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct AsrModelConfig; }
+// Forward declaration of `AsrResult` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct AsrResult; }
+
+#include <NitroModules/Promise.hpp>
+#include "AsrModelConfig.hpp"
+#include "AsrResult.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+
+namespace margelo::nitro::onnx::speech {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `OfflineAsr`
+   * Inherit this class to create instances of `HybridOfflineAsrSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridOfflineAsr: public HybridOfflineAsrSpec {
+   * public:
+   *   HybridOfflineAsr(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridOfflineAsrSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridOfflineAsrSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridOfflineAsrSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> load(const AsrModelConfig& config) = 0;
+      virtual bool isLoaded() = 0;
+      virtual std::shared_ptr<Promise<AsrResult>> recognize(const std::shared_ptr<ArrayBuffer>& samples) = 0;
+      virtual std::shared_ptr<Promise<AsrResult>> recognizeFile(const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<void>> unload() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "OfflineAsr";
+  };
+
+} // namespace margelo::nitro::onnx::speech

package/nitrogen/generated/shared/c++/HybridOnnxSpeechSpec.cpp

@@ -0,0 +1,27 @@
+///
+/// HybridOnnxSpeechSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOnnxSpeechSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  void HybridOnnxSpeechSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("version", &HybridOnnxSpeechSpec::getVersion);
+      prototype.registerHybridMethod("createVad", &HybridOnnxSpeechSpec::createVad);
+      prototype.registerHybridMethod("createOfflineAsr", &HybridOnnxSpeechSpec::createOfflineAsr);
+      prototype.registerHybridMethod("createStreamingAsr", &HybridOnnxSpeechSpec::createStreamingAsr);
+      prototype.registerHybridMethod("createTts", &HybridOnnxSpeechSpec::createTts);
+      prototype.registerHybridMethod("createSpeakerManager", &HybridOnnxSpeechSpec::createSpeakerManager);
+      prototype.registerHybridMethod("isQualcommCpu", &HybridOnnxSpeechSpec::isQualcommCpu);
+    });
+  }
+
+} // namespace margelo::nitro::onnx::speech

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

@@ -0,0 +1,82 @@
+///
+/// HybridOnnxSpeechSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridVadSpec` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { class HybridVadSpec; }
+// Forward declaration of `HybridOfflineAsrSpec` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { class HybridOfflineAsrSpec; }
+// Forward declaration of `HybridStreamingAsrSpec` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { class HybridStreamingAsrSpec; }
+// Forward declaration of `HybridTtsSpec` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { class HybridTtsSpec; }
+// Forward declaration of `HybridSpeakerManagerSpec` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { class HybridSpeakerManagerSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridVadSpec.hpp"
+#include "HybridOfflineAsrSpec.hpp"
+#include "HybridStreamingAsrSpec.hpp"
+#include "HybridTtsSpec.hpp"
+#include "HybridSpeakerManagerSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `OnnxSpeech`
+   * Inherit this class to create instances of `HybridOnnxSpeechSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridOnnxSpeech: public HybridOnnxSpeechSpec {
+   * public:
+   *   HybridOnnxSpeech(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridOnnxSpeechSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridOnnxSpeechSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridOnnxSpeechSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getVersion() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridVadSpec> createVad() = 0;
+      virtual std::shared_ptr<HybridOfflineAsrSpec> createOfflineAsr() = 0;
+      virtual std::shared_ptr<HybridStreamingAsrSpec> createStreamingAsr() = 0;
+      virtual std::shared_ptr<HybridTtsSpec> createTts() = 0;
+      virtual std::shared_ptr<HybridSpeakerManagerSpec> createSpeakerManager() = 0;
+      virtual bool isQualcommCpu() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "OnnxSpeech";
+  };
+
+} // namespace margelo::nitro::onnx::speech

package/nitrogen/generated/shared/c++/HybridSpeakerManagerSpec.cpp

@@ -0,0 +1,28 @@
+///
+/// HybridSpeakerManagerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSpeakerManagerSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  void HybridSpeakerManagerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("load", &HybridSpeakerManagerSpec::load);
+      prototype.registerHybridMethod("isLoaded", &HybridSpeakerManagerSpec::isLoaded);
+      prototype.registerHybridMethod("computeEmbedding", &HybridSpeakerManagerSpec::computeEmbedding);
+      prototype.registerHybridMethod("registerSpeaker", &HybridSpeakerManagerSpec::registerSpeaker);
+      prototype.registerHybridMethod("registerSpeakerFromFile", &HybridSpeakerManagerSpec::registerSpeakerFromFile);
+      prototype.registerHybridMethod("listSpeakers", &HybridSpeakerManagerSpec::listSpeakers);
+      prototype.registerHybridMethod("removeSpeaker", &HybridSpeakerManagerSpec::removeSpeaker);
+      prototype.registerHybridMethod("unload", &HybridSpeakerManagerSpec::unload);
+    });
+  }
+
+} // namespace margelo::nitro::onnx::speech

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

@@ -0,0 +1,77 @@
+///
+/// HybridSpeakerManagerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `SpeakerEmbeddingConfig` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct SpeakerEmbeddingConfig; }
+// Forward declaration of `RegisteredSpeaker` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct RegisteredSpeaker; }
+
+#include <NitroModules/Promise.hpp>
+#include "SpeakerEmbeddingConfig.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include "RegisteredSpeaker.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::onnx::speech {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SpeakerManager`
+   * Inherit this class to create instances of `HybridSpeakerManagerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSpeakerManager: public HybridSpeakerManagerSpec {
+   * public:
+   *   HybridSpeakerManager(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSpeakerManagerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSpeakerManagerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSpeakerManagerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> load(const SpeakerEmbeddingConfig& config) = 0;
+      virtual bool isLoaded() = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> computeEmbedding(const std::shared_ptr<ArrayBuffer>& samples) = 0;
+      virtual std::shared_ptr<Promise<RegisteredSpeaker>> registerSpeaker(const std::string& id, const std::string& name, const std::shared_ptr<ArrayBuffer>& embedding) = 0;
+      virtual std::shared_ptr<Promise<RegisteredSpeaker>> registerSpeakerFromFile(const std::string& id, const std::string& name, const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<std::vector<RegisteredSpeaker>>> listSpeakers() = 0;
+      virtual std::shared_ptr<Promise<void>> removeSpeaker(const std::string& id) = 0;
+      virtual std::shared_ptr<Promise<void>> unload() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SpeakerManager";
+  };
+
+} // namespace margelo::nitro::onnx::speech

package/nitrogen/generated/shared/c++/HybridStreamingAsrSpec.cpp

@@ -0,0 +1,32 @@
+///
+/// HybridStreamingAsrSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridStreamingAsrSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  void HybridStreamingAsrSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("onPartialResult", &HybridStreamingAsrSpec::getOnPartialResult);
+      prototype.registerHybridSetter("onPartialResult", &HybridStreamingAsrSpec::setOnPartialResult);
+      prototype.registerHybridGetter("onFinalResult", &HybridStreamingAsrSpec::getOnFinalResult);
+      prototype.registerHybridSetter("onFinalResult", &HybridStreamingAsrSpec::setOnFinalResult);
+      prototype.registerHybridGetter("onError", &HybridStreamingAsrSpec::getOnError);
+      prototype.registerHybridSetter("onError", &HybridStreamingAsrSpec::setOnError);
+      prototype.registerHybridMethod("load", &HybridStreamingAsrSpec::load);
+      prototype.registerHybridMethod("isLoaded", &HybridStreamingAsrSpec::isLoaded);
+      prototype.registerHybridMethod("acceptWaveform", &HybridStreamingAsrSpec::acceptWaveform);
+      prototype.registerHybridMethod("finalize", &HybridStreamingAsrSpec::finalize);
+      prototype.registerHybridMethod("reset", &HybridStreamingAsrSpec::reset);
+      prototype.registerHybridMethod("unload", &HybridStreamingAsrSpec::unload);
+    });
+  }
+
+} // namespace margelo::nitro::onnx::speech

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

@@ -0,0 +1,81 @@
+///
+/// HybridStreamingAsrSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `AsrResult` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct AsrResult; }
+// Forward declaration of `AsrModelConfig` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct AsrModelConfig; }
+
+#include "AsrResult.hpp"
+#include <functional>
+#include <optional>
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include "AsrModelConfig.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::onnx::speech {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `StreamingAsr`
+   * Inherit this class to create instances of `HybridStreamingAsrSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridStreamingAsr: public HybridStreamingAsrSpec {
+   * public:
+   *   HybridStreamingAsr(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridStreamingAsrSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridStreamingAsrSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridStreamingAsrSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::function<void(const AsrResult& /* result */)>> getOnPartialResult() = 0;
+      virtual void setOnPartialResult(const std::optional<std::function<void(const AsrResult& /* result */)>>& onPartialResult) = 0;
+      virtual std::optional<std::function<void(const AsrResult& /* result */)>> getOnFinalResult() = 0;
+      virtual void setOnFinalResult(const std::optional<std::function<void(const AsrResult& /* result */)>>& onFinalResult) = 0;
+      virtual std::optional<std::function<void(const std::string& /* error */)>> getOnError() = 0;
+      virtual void setOnError(const std::optional<std::function<void(const std::string& /* error */)>>& onError) = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> load(const AsrModelConfig& config) = 0;
+      virtual bool isLoaded() = 0;
+      virtual std::shared_ptr<Promise<void>> acceptWaveform(const std::shared_ptr<ArrayBuffer>& samples) = 0;
+      virtual std::shared_ptr<Promise<AsrResult>> finalize() = 0;
+      virtual std::shared_ptr<Promise<void>> reset() = 0;
+      virtual std::shared_ptr<Promise<void>> unload() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "StreamingAsr";
+  };
+
+} // namespace margelo::nitro::onnx::speech

package/nitrogen/generated/shared/c++/HybridTtsSpec.cpp

@@ -0,0 +1,26 @@
+///
+/// HybridTtsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTtsSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  void HybridTtsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("load", &HybridTtsSpec::load);
+      prototype.registerHybridMethod("isLoaded", &HybridTtsSpec::isLoaded);
+      prototype.registerHybridMethod("synthesize", &HybridTtsSpec::synthesize);
+      prototype.registerHybridMethod("synthesizeWithSpeaker", &HybridTtsSpec::synthesizeWithSpeaker);
+      prototype.registerHybridMethod("saveWav", &HybridTtsSpec::saveWav);
+      prototype.registerHybridMethod("unload", &HybridTtsSpec::unload);
+    });
+  }
+
+} // namespace margelo::nitro::onnx::speech

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

@@ -0,0 +1,74 @@
+///
+/// HybridTtsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `TtsModelConfig` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct TtsModelConfig; }
+// Forward declaration of `TtsResult` to properly resolve imports.
+namespace margelo::nitro::onnx::speech { struct TtsResult; }
+
+#include <NitroModules/Promise.hpp>
+#include "TtsModelConfig.hpp"
+#include "TtsResult.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::onnx::speech {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Tts`
+   * Inherit this class to create instances of `HybridTtsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTts: public HybridTtsSpec {
+   * public:
+   *   HybridTts(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTtsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTtsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTtsSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> load(const TtsModelConfig& config) = 0;
+      virtual bool isLoaded() = 0;
+      virtual std::shared_ptr<Promise<TtsResult>> synthesize(const std::string& text, std::optional<double> speed) = 0;
+      virtual std::shared_ptr<Promise<TtsResult>> synthesizeWithSpeaker(const std::string& text, const std::string& speakerId, std::optional<double> speed) = 0;
+      virtual std::shared_ptr<Promise<void>> saveWav(const TtsResult& result, const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<void>> unload() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Tts";
+  };
+
+} // namespace margelo::nitro::onnx::speech

package/nitrogen/generated/shared/c++/HybridVadSpec.cpp

@@ -0,0 +1,31 @@
+///
+/// HybridVadSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVadSpec.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+  void HybridVadSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("onSpeechStart", &HybridVadSpec::getOnSpeechStart);
+      prototype.registerHybridSetter("onSpeechStart", &HybridVadSpec::setOnSpeechStart);
+      prototype.registerHybridGetter("onSpeechEnd", &HybridVadSpec::getOnSpeechEnd);
+      prototype.registerHybridSetter("onSpeechEnd", &HybridVadSpec::setOnSpeechEnd);
+      prototype.registerHybridGetter("onError", &HybridVadSpec::getOnError);
+      prototype.registerHybridSetter("onError", &HybridVadSpec::setOnError);
+      prototype.registerHybridMethod("initialize", &HybridVadSpec::initialize);
+      prototype.registerHybridMethod("isInitialized", &HybridVadSpec::isInitialized);
+      prototype.registerHybridMethod("process", &HybridVadSpec::process);
+      prototype.registerHybridMethod("pullSegments", &HybridVadSpec::pullSegments);
+      prototype.registerHybridMethod("reset", &HybridVadSpec::reset);
+    });
+  }
+
+} // namespace margelo::nitro::onnx::speech