react-native-yolo 0.0.4 → 0.0.7

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

@@ -0,0 +1,78 @@
+///
+/// JHybridYoloModelSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridYoloModelSpec.hpp"
+
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
+
+#include "Detection.hpp"
+#include <vector>
+#include "JDetection.hpp"
+#include "BoundingBox.hpp"
+#include "JBoundingBox.hpp"
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
+#include <VisionCamera/JHybridFrameSpec.hpp>
+
+namespace margelo::nitro::yolo {
+
+  std::shared_ptr<JHybridYoloModelSpec> JHybridYoloModelSpec::JavaPart::getJHybridYoloModelSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridYoloModelSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridYoloModelSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridYoloModelSpec::CxxPart::jhybriddata> JHybridYoloModelSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridYoloModelSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridYoloModelSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridYoloModelSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridYoloModelSpec>(castJavaPart);
+  }
+
+  void JHybridYoloModelSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridYoloModelSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::vector<Detection> JHybridYoloModelSpec::detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDetection>>(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("detect");
+    auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<Detection> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
+  void JHybridYoloModelSpec::close() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("close");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::yolo

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

@@ -0,0 +1,64 @@
+///
+/// HybridYoloModelSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridYoloModelSpec.hpp"
+
+
+
+
+namespace margelo::nitro::yolo {
+
+  using namespace facebook;
+
+  class JHybridYoloModelSpec: public virtual HybridYoloModelSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/HybridYoloModelSpec;";
+      std::shared_ptr<JHybridYoloModelSpec> getJHybridYoloModelSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/HybridYoloModelSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridYoloModelSpec(const jni::local_ref<JHybridYoloModelSpec::JavaPart>& javaPart):
+      HybridObject(HybridYoloModelSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridYoloModelSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridYoloModelSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
+    void close() override;
+
+  private:
+    jni::global_ref<JHybridYoloModelSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::yolo

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

@@ -7,11 +7,15 @@
 
 #include "JHybridYoloSpec.hpp"
 
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 
-#include <string>
 #include <memory>
+#include "HybridYoloModelSpec.hpp"
+#include "JHybridYoloModelSpec.hpp"
+#include <string>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <VisionCamera/JHybridFrameSpec.hpp>
 
@@ -48,14 +52,10 @@ namespace margelo::nitro::yolo {
   
 
   // Methods
-  double JHybridYoloSpec::sum(double num1, double num2) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<double(double /* num1 */, double /* num2 */)>("sum");
-    auto __result = method(_javaPart, num1, num2);
-    return __result;
-  }
-  void JHybridYoloSpec::loadModel(const std::string& modelPath) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* modelPath */)>("loadModel");
-    method(_javaPart, jni::make_jstring(modelPath));
+  std::shared_ptr<HybridYoloModelSpec> JHybridYoloSpec::loadModel(const std::string& modelPath) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridYoloModelSpec::JavaPart>(jni::alias_ref<jni::JString> /* modelPath */)>("loadModel");
+    auto __result = method(_javaPart, jni::make_jstring(modelPath));
+    return __result->getJHybridYoloModelSpec();
   }
   std::string JHybridYoloSpec::frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("frameToBase64");

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

@@ -54,8 +54,7 @@ namespace margelo::nitro::yolo {
 
   public:
     // Methods
-    double sum(double num1, double num2) override;
-    void loadModel(const std::string& modelPath) override;
+    std::shared_ptr<HybridYoloModelSpec> loadModel(const std::string& modelPath) override;
     std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
 
   private:

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/BoundingBox.kt

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

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/Detection.kt

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

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/HybridYoloModelSpec.kt

@@ -0,0 +1,59 @@
+///
+/// HybridYoloModelSpec.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.yolo
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.camera.HybridFrameSpec
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the YoloModel HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of YoloModel.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridYoloModelSpec: HybridObject() {
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun detect(frame: com.margelo.nitro.camera.HybridFrameSpec): Array<Detection>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun close(): Unit
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject YoloModel]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridYoloModelSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridYoloModelSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridYoloModelSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/HybridYoloSpec.kt

@@ -31,11 +31,7 @@ abstract class HybridYoloSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun sum(num1: Double, num2: Double): Double
-  
-  @DoNotStrip
-  @Keep
-  abstract fun loadModel(modelPath: String): Unit
+  abstract fun loadModel(modelPath: String): HybridYoloModelSpec
   
   @DoNotStrip
   @Keep

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Bridge.cpp

@@ -8,6 +8,7 @@
 #include "Yolo-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
+#include "HybridYoloModelSpecSwift.hpp"
 #include "HybridYoloSpecSwift.hpp"
 #include "Yolo-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
@@ -25,6 +26,22 @@ namespace margelo::nitro::yolo::bridge::swift {
     return margelo::nitro::camera::bridge::swift::get_std__shared_ptr_HybridFrameSpec_(cppType);
   }
   
+  // pragma MARK: std::shared_ptr<HybridYoloModelSpec>
+  std::shared_ptr<HybridYoloModelSpec> create_std__shared_ptr_HybridYoloModelSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    Yolo::HybridYoloModelSpec_cxx swiftPart = Yolo::HybridYoloModelSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::yolo::HybridYoloModelSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridYoloModelSpec_(std__shared_ptr_HybridYoloModelSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::yolo::HybridYoloModelSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::yolo::HybridYoloModelSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridYoloModelSpec\" is not implemented in Swift!");
+    }
+    #endif
+    Yolo::HybridYoloModelSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridYoloSpec>
   std::shared_ptr<HybridYoloSpec> create_std__shared_ptr_HybridYoloSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     Yolo::HybridYoloSpec_cxx swiftPart = Yolo::HybridYoloSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -8,24 +8,36 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridYoloSpec` to properly resolve imports.
 namespace margelo::nitro::yolo { class HybridYoloSpec; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
 namespace VisionCamera { class HybridFrameSpec_cxx; }
+// Forward declaration of `HybridYoloModelSpec_cxx` to properly resolve imports.
+namespace Yolo { class HybridYoloModelSpec_cxx; }
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 
 // Include C++ defined types
+#include "BoundingBox.hpp"
+#include "Detection.hpp"
+#include "HybridYoloModelSpec.hpp"
 #include "HybridYoloSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <exception>
 #include <memory>
 #include <string>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -33,6 +45,17 @@ namespace Yolo { class HybridYoloSpec_cxx; }
  */
 namespace margelo::nitro::yolo::bridge::swift {
 
+  // pragma MARK: std::vector<Detection>
+  /**
+   * Specialized version of `std::vector<Detection>`.
+   */
+  using std__vector_Detection_ = std::vector<Detection>;
+  inline std::vector<Detection> create_std__vector_Detection_(size_t size) noexcept {
+    std::vector<Detection> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>`.
@@ -45,25 +68,25 @@ namespace margelo::nitro::yolo::bridge::swift {
   using std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>;
   inline std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::shared_ptr<HybridYoloSpec>
+  // pragma MARK: std::shared_ptr<HybridYoloModelSpec>
   /**
-   * Specialized version of `std::shared_ptr<HybridYoloSpec>`.
+   * Specialized version of `std::shared_ptr<HybridYoloModelSpec>`.
    */
-  using std__shared_ptr_HybridYoloSpec_ = std::shared_ptr<HybridYoloSpec>;
-  std::shared_ptr<HybridYoloSpec> create_std__shared_ptr_HybridYoloSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridYoloSpec_(std__shared_ptr_HybridYoloSpec_ cppType);
+  using std__shared_ptr_HybridYoloModelSpec_ = std::shared_ptr<HybridYoloModelSpec>;
+  std::shared_ptr<HybridYoloModelSpec> create_std__shared_ptr_HybridYoloModelSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridYoloModelSpec_(std__shared_ptr_HybridYoloModelSpec_ cppType);
   
-  // pragma MARK: std::weak_ptr<HybridYoloSpec>
-  using std__weak_ptr_HybridYoloSpec_ = std::weak_ptr<HybridYoloSpec>;
-  inline std__weak_ptr_HybridYoloSpec_ weakify_std__shared_ptr_HybridYoloSpec_(const std::shared_ptr<HybridYoloSpec>& strong) noexcept { return strong; }
+  // pragma MARK: std::weak_ptr<HybridYoloModelSpec>
+  using std__weak_ptr_HybridYoloModelSpec_ = std::weak_ptr<HybridYoloModelSpec>;
+  inline std__weak_ptr_HybridYoloModelSpec_ weakify_std__shared_ptr_HybridYoloModelSpec_(const std::shared_ptr<HybridYoloModelSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<double>
-  using Result_double_ = Result<double>;
-  inline Result_double_ create_Result_double_(double value) noexcept {
-    return Result<double>::withValue(std::move(value));
+  // pragma MARK: Result<std::vector<Detection>>
+  using Result_std__vector_Detection__ = Result<std::vector<Detection>>;
+  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::vector<Detection>& value) noexcept {
+    return Result<std::vector<Detection>>::withValue(value);
   }
-  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
-    return Result<double>::withError(error);
+  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<Detection>>::withError(error);
   }
   
   // pragma MARK: Result<void>
@@ -75,6 +98,27 @@ namespace margelo::nitro::yolo::bridge::swift {
     return Result<void>::withError(error);
   }
   
+  // pragma MARK: std::shared_ptr<HybridYoloSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridYoloSpec>`.
+   */
+  using std__shared_ptr_HybridYoloSpec_ = std::shared_ptr<HybridYoloSpec>;
+  std::shared_ptr<HybridYoloSpec> create_std__shared_ptr_HybridYoloSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridYoloSpec_(std__shared_ptr_HybridYoloSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridYoloSpec>
+  using std__weak_ptr_HybridYoloSpec_ = std::weak_ptr<HybridYoloSpec>;
+  inline std__weak_ptr_HybridYoloSpec_ weakify_std__shared_ptr_HybridYoloSpec_(const std::shared_ptr<HybridYoloSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<HybridYoloModelSpec>>
+  using Result_std__shared_ptr_HybridYoloModelSpec__ = Result<std::shared_ptr<HybridYoloModelSpec>>;
+  inline Result_std__shared_ptr_HybridYoloModelSpec__ create_Result_std__shared_ptr_HybridYoloModelSpec__(const std::shared_ptr<HybridYoloModelSpec>& value) noexcept {
+    return Result<std::shared_ptr<HybridYoloModelSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_HybridYoloModelSpec__ create_Result_std__shared_ptr_HybridYoloModelSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<HybridYoloModelSpec>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::string>
   using Result_std__string_ = Result<std::string>;
   inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {

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

@@ -8,18 +8,28 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridYoloSpec` to properly resolve imports.
 namespace margelo::nitro::yolo { class HybridYoloSpec; }
 
 // Include C++ defined types
+#include "BoundingBox.hpp"
+#include "Detection.hpp"
+#include "HybridYoloModelSpec.hpp"
 #include "HybridYoloSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <exception>
 #include <memory>
 #include <string>
+#include <vector>
 
 // C++ helpers for Swift
 #include "Yolo-Swift-Cxx-Bridge.hpp"
@@ -33,6 +43,8 @@ namespace margelo::nitro::yolo { class HybridYoloSpec; }
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
 namespace VisionCamera { class HybridFrameSpec_cxx; }
+// Forward declaration of `HybridYoloModelSpec_cxx` to properly resolve imports.
+namespace Yolo { class HybridYoloModelSpec_cxx; }
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 

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

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