react-native-yolo 0.0.2 → 0.0.4

package/lib/typescript/src/specs/yolo.nitro.d.ts

@@ -1,11 +1,11 @@
-import type { HybridView, HybridViewProps, HybridViewMethods } from 'react-native-nitro-modules';
-export interface YoloProps extends HybridViewProps {
-    isRed: boolean;
-}
-export interface YoloMethods extends HybridViewMethods {
-}
-export type Yolo = HybridView<YoloProps, YoloMethods, {
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { Frame } from 'react-native-vision-camera';
+export interface Yolo extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
-}>;
+}> {
+    sum(num1: number, num2: number): number;
+    loadModel(modelPath: string): void;
+    frameToBase64(frame: Frame): string;
+}
 //# sourceMappingURL=yolo.nitro.d.ts.map

package/lib/typescript/src/specs/yolo.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yolo.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/yolo.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAEnC,MAAM,WAAW,SAAU,SAAQ,eAAe;IAC/C,KAAK,EAAE,OAAO,CAAA;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,iBAAiB;CAAG;AAEzD,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,SAAS,EAAE,WAAW,EAAE;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA"}
+{"version":3,"file":"yolo.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/yolo.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAA;AAEvD,MAAM,WAAW,IAAK,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAC7E,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACvC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;CACpC"}

package/nitro.json

@@ -1,30 +1,30 @@
-{
-  "$schema": "https://nitro.margelo.com/nitro.schema.json",
-  "cxxNamespace": [
-    "yolo"
-  ],
-  "ios": {
-    "iosModuleName": "Yolo"
-  },
-  "android": {
-    "androidNamespace": [
-      "yolo"
-    ],
-    "androidCxxLibName": "Yolo"
-  },
-  "autolinking": {
-    "Yolo": {
-      "ios": {
-        "language": "swift",
-        "implementationClassName": "HybridYolo"
-      },
-      "android": {
-        "language": "kotlin",
-        "implementationClassName": "HybridYolo"
-      }
-    }
-  },
-  "ignorePaths": [
-    "**/node_modules"
-  ]
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": [
+    "yolo"
+  ],
+  "ios": {
+    "iosModuleName": "Yolo"
+  },
+  "android": {
+    "androidNamespace": [
+      "yolo"
+    ],
+    "androidCxxLibName": "Yolo"
+  },
+  "autolinking": {
+    "Yolo": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridYolo"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridYolo"
+      }
+    }
+  },
+  "ignorePaths": [
+    "**/node_modules"
+  ]
 }

package/nitrogen/generated/android/Yolo+autolinking.cmake

@@ -34,10 +34,8 @@ target_sources(
   ../nitrogen/generated/android/YoloOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridYoloSpec.cpp
-  ../nitrogen/generated/shared/c++/views/HybridYoloComponent.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridYoloSpec.cpp
-  ../nitrogen/generated/android/c++/views/JHybridYoloStateUpdater.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/YoloOnLoad.cpp

@@ -16,7 +16,6 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridYoloSpec.hpp"
-#include "views/JHybridYoloStateUpdater.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::yolo {
@@ -42,7 +41,6 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::yolo::JHybridYoloSpec::CxxPart::registerNatives();
-  margelo::nitro::yolo::views::JHybridYoloStateUpdater::registerNatives();
 
   // Register Nitro Hybrid Objects
   HybridObjectRegistry::registerHybridObjectConstructor(

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

@@ -7,9 +7,13 @@
 
 #include "JHybridYoloSpec.hpp"
 
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
 
-
-
+#include <string>
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
+#include <VisionCamera/JHybridFrameSpec.hpp>
 
 namespace margelo::nitro::yolo {
 
@@ -41,17 +45,22 @@ namespace margelo::nitro::yolo {
   }
 
   // Properties
-  bool JHybridYoloSpec::getIsRed() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isRed");
-    auto __result = method(_javaPart);
-    return static_cast<bool>(__result);
-  }
-  void JHybridYoloSpec::setIsRed(bool isRed) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isRed */)>("setRed");
-    method(_javaPart, isRed);
-  }
+  
 
   // 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::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");
+    auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
+    return __result->toStdString();
+  }
 
 } // namespace margelo::nitro::yolo

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

@@ -50,12 +50,13 @@ namespace margelo::nitro::yolo {
 
   public:
     // Properties
-    bool getIsRed() override;
-    void setIsRed(bool isRed) override;
+    
 
   public:
     // Methods
-    
+    double sum(double num1, double num2) override;
+    void loadModel(const std::string& modelPath) override;
+    std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
 
   private:
     jni::global_ref<JHybridYoloSpec::JavaPart> _javaPart;

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

@@ -10,8 +10,8 @@ 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
-import com.margelo.nitro.views.HybridView
 
 /**
  * A Kotlin class representing the Yolo HybridObject.
@@ -24,16 +24,22 @@ import com.margelo.nitro.views.HybridView
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridYoloSpec: HybridView() {
+abstract class HybridYoloSpec: HybridObject() {
   // Properties
-  @get:DoNotStrip
-  @get:Keep
-  @set:DoNotStrip
-  @set:Keep
-  abstract var isRed: Boolean
+  
 
   // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun sum(num1: Double, num2: Double): Double
+  
+  @DoNotStrip
+  @Keep
+  abstract fun loadModel(modelPath: String): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun frameToBase64(frame: com.margelo.nitro.camera.HybridFrameSpec): String
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

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

@@ -11,9 +11,20 @@
 #include "HybridYoloSpecSwift.hpp"
 #include "Yolo-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
+#include <VisionCamera/VisionCamera-Swift-Cxx-Bridge.hpp>
 
 namespace margelo::nitro::yolo::bridge::swift {
 
+  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>
+  std::shared_ptr<margelo::nitro::camera::HybridFrameSpec> create_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    // Implemented in VisionCamera
+    return margelo::nitro::camera::bridge::swift::create_std__shared_ptr_HybridFrameSpec_(swiftUnsafePointer);
+  }
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ cppType) {
+    // Implemented in VisionCamera
+    return margelo::nitro::camera::bridge::swift::get_std__shared_ptr_HybridFrameSpec_(cppType);
+  }
+  
   // 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,16 +8,24 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
 // 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 `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 
 // Include C++ defined types
 #include "HybridYoloSpec.hpp"
+#include <NitroModules/Result.hpp>
+#include <VisionCamera/HybridFrameSpec.hpp>
+#include <exception>
 #include <memory>
+#include <string>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -25,6 +33,18 @@ namespace Yolo { class HybridYoloSpec_cxx; }
  */
 namespace margelo::nitro::yolo::bridge::swift {
 
+  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>;
+  std::shared_ptr<margelo::nitro::camera::HybridFrameSpec> create_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>
+  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>
   /**
    * Specialized version of `std::shared_ptr<HybridYoloSpec>`.
@@ -36,5 +56,32 @@ namespace margelo::nitro::yolo::bridge::swift {
   // 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<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) noexcept {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
+    return Result<double>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::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 {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
 
 } // namespace margelo::nitro::yolo::bridge::swift

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

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

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

@@ -12,9 +12,12 @@
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
 
-
-
+#include <string>
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
 
 #include "Yolo-Swift-Cxx-Umbrella.hpp"
 
@@ -62,16 +65,32 @@ namespace margelo::nitro::yolo {
 
   public:
     // Properties
-    inline bool getIsRed() noexcept override {
-      return _swiftPart.isRed();
-    }
-    inline void setIsRed(bool isRed) noexcept override {
-      _swiftPart.setIsRed(std::forward<decltype(isRed)>(isRed));
-    }
+    
 
   public:
     // Methods
-    
+    inline double sum(double num1, double num2) override {
+      auto __result = _swiftPart.sum(std::forward<decltype(num1)>(num1), std::forward<decltype(num2)>(num2));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void loadModel(const std::string& modelPath) override {
+      auto __result = _swiftPart.loadModel(modelPath);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
+      auto __result = _swiftPart.frameToBase64(frame);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     Yolo::HybridYoloSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridYoloSpec.swift

@@ -5,15 +5,18 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
+import VisionCamera
 import NitroModules
 
 /// See ``HybridYoloSpec``
-public protocol HybridYoloSpec_protocol: HybridObject, HybridView {
+public protocol HybridYoloSpec_protocol: HybridObject {
   // Properties
-  var isRed: Bool { get set }
+  
 
   // Methods
-  
+  func sum(num1: Double, num2: Double) throws -> Double
+  func loadModel(modelPath: String) throws -> Void
+  func frameToBase64(frame: (any HybridFrameSpec)) throws -> String
 }
 
 public extension HybridYoloSpec_protocol {

package/nitrogen/generated/ios/swift/HybridYoloSpec_cxx.swift

@@ -6,6 +6,7 @@
 ///
 
 import NitroModules
+import VisionCamera
 
 /**
  * A class implementation that bridges HybridYoloSpec over to C++.
@@ -121,36 +122,45 @@ open class HybridYoloSpec_cxx {
   }
 
   // Properties
-  public final var isRed: Bool {
-    @inline(__always)
-    get {
-      return self.__implementation.isRed
-    }
-    @inline(__always)
-    set {
-      self.__implementation.isRed = newValue
-    }
-  }
+  
 
   // Methods
-  public final func getView() -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(__implementation.view).toOpaque()
-  }
-  
-  public final func beforeUpdate() {
-    __implementation.beforeUpdate()
-  }
-  
-  public final func afterUpdate() {
-    __implementation.afterUpdate()
+  @inline(__always)
+  public final func sum(num1: Double, num2: Double) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.sum(num1: num1, num2: num2)
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
   }
   
-  public final func maybePrepareForRecycle() {
-    guard let recyclable = __implementation as? any RecyclableView else { return }
-    recyclable.prepareForRecycle()
+  @inline(__always)
+  public final func loadModel(modelPath: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.loadModel(modelPath: String(modelPath))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
   }
   
-  public final func onDropView() {
-    __implementation.onDropView()
+  @inline(__always)
+  public final func frameToBase64(frame: bridge.std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_) -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.frameToBase64(frame: { () -> any HybridFrameSpec in
+        let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(frame)
+        let __instance = HybridFrameSpec_cxx.fromUnsafe(__unsafePointer)
+        return __instance.getHybridFrameSpec()
+      }())
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
   }
 }

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

@@ -14,8 +14,9 @@ namespace margelo::nitro::yolo {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
-      prototype.registerHybridGetter("isRed", &HybridYoloSpec::getIsRed);
-      prototype.registerHybridSetter("isRed", &HybridYoloSpec::setIsRed);
+      prototype.registerHybridMethod("sum", &HybridYoloSpec::sum);
+      prototype.registerHybridMethod("loadModel", &HybridYoloSpec::loadModel);
+      prototype.registerHybridMethod("frameToBase64", &HybridYoloSpec::frameToBase64);
     });
   }
 

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

@@ -13,9 +13,12 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
 
-
-
+#include <string>
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
 
 namespace margelo::nitro::yolo {
 
@@ -44,12 +47,13 @@ namespace margelo::nitro::yolo {
 
     public:
       // Properties
-      virtual bool getIsRed() = 0;
-      virtual void setIsRed(bool isRed) = 0;
+      
 
     public:
       // Methods
-      
+      virtual double sum(double num1, double num2) = 0;
+      virtual void loadModel(const std::string& modelPath) = 0;
+      virtual std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) = 0;
 
     protected:
       // Hybrid Setup