@rive-app/react-native 0.1.1-beta.0

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

@@ -0,0 +1,80 @@
+///
+/// JAlignment.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Alignment.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "Alignment" and the the Kotlin enum "Alignment".
+   */
+  struct JAlignment final: public jni::JavaClass<JAlignment> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Alignment;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum Alignment.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Alignment toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<Alignment>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAlignment> fromCpp(Alignment value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTOPLEFT = clazz->getStaticField<JAlignment>("TOPLEFT");
+      static const auto fieldTOPCENTER = clazz->getStaticField<JAlignment>("TOPCENTER");
+      static const auto fieldTOPRIGHT = clazz->getStaticField<JAlignment>("TOPRIGHT");
+      static const auto fieldCENTERLEFT = clazz->getStaticField<JAlignment>("CENTERLEFT");
+      static const auto fieldCENTER = clazz->getStaticField<JAlignment>("CENTER");
+      static const auto fieldCENTERRIGHT = clazz->getStaticField<JAlignment>("CENTERRIGHT");
+      static const auto fieldBOTTOMLEFT = clazz->getStaticField<JAlignment>("BOTTOMLEFT");
+      static const auto fieldBOTTOMCENTER = clazz->getStaticField<JAlignment>("BOTTOMCENTER");
+      static const auto fieldBOTTOMRIGHT = clazz->getStaticField<JAlignment>("BOTTOMRIGHT");
+      
+      switch (value) {
+        case Alignment::TOPLEFT:
+          return clazz->getStaticFieldValue(fieldTOPLEFT);
+        case Alignment::TOPCENTER:
+          return clazz->getStaticFieldValue(fieldTOPCENTER);
+        case Alignment::TOPRIGHT:
+          return clazz->getStaticFieldValue(fieldTOPRIGHT);
+        case Alignment::CENTERLEFT:
+          return clazz->getStaticFieldValue(fieldCENTERLEFT);
+        case Alignment::CENTER:
+          return clazz->getStaticFieldValue(fieldCENTER);
+        case Alignment::CENTERRIGHT:
+          return clazz->getStaticFieldValue(fieldCENTERRIGHT);
+        case Alignment::BOTTOMLEFT:
+          return clazz->getStaticFieldValue(fieldBOTTOMLEFT);
+        case Alignment::BOTTOMCENTER:
+          return clazz->getStaticFieldValue(fieldBOTTOMCENTER);
+        case Alignment::BOTTOMRIGHT:
+          return clazz->getStaticFieldValue(fieldBOTTOMRIGHT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,68 @@
+///
+/// JArtboardBy.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ArtboardBy.hpp"
+
+#include "ArtboardByTypes.hpp"
+#include "JArtboardByTypes.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ArtboardBy" and the the Kotlin data class "ArtboardBy".
+   */
+  struct JArtboardBy final: public jni::JavaClass<JArtboardBy> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/ArtboardBy;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ArtboardBy by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ArtboardBy toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<JArtboardByTypes>("type");
+      jni::local_ref<JArtboardByTypes> type = this->getFieldValue(fieldType);
+      static const auto fieldIndex = clazz->getField<jni::JDouble>("index");
+      jni::local_ref<jni::JDouble> index = this->getFieldValue(fieldIndex);
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      return ArtboardBy(
+        type->toCpp(),
+        index != nullptr ? std::make_optional(index->value()) : std::nullopt,
+        name != nullptr ? std::make_optional(name->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JArtboardBy::javaobject> fromCpp(const ArtboardBy& value) {
+      using JSignature = JArtboardBy(jni::alias_ref<JArtboardByTypes>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JArtboardByTypes::fromCpp(value.type),
+        value.index.has_value() ? jni::JDouble::valueOf(value.index.value()) : nullptr,
+        value.name.has_value() ? jni::make_jstring(value.name.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,59 @@
+///
+/// JArtboardByTypes.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ArtboardByTypes.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ArtboardByTypes" and the the Kotlin enum "ArtboardByTypes".
+   */
+  struct JArtboardByTypes final: public jni::JavaClass<JArtboardByTypes> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/ArtboardByTypes;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ArtboardByTypes.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ArtboardByTypes toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ArtboardByTypes>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JArtboardByTypes> fromCpp(ArtboardByTypes value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldINDEX = clazz->getStaticField<JArtboardByTypes>("INDEX");
+      static const auto fieldNAME = clazz->getStaticField<JArtboardByTypes>("NAME");
+      
+      switch (value) {
+        case ArtboardByTypes::INDEX:
+          return clazz->getStaticFieldValue(fieldINDEX);
+        case ArtboardByTypes::NAME:
+          return clazz->getStaticFieldValue(fieldNAME);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,57 @@
+///
+/// JDataBindByName.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DataBindByName.hpp"
+
+#include <string>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DataBindByName" and the the Kotlin data class "DataBindByName".
+   */
+  struct JDataBindByName final: public jni::JavaClass<JDataBindByName> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/DataBindByName;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DataBindByName by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DataBindByName toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldByName = clazz->getField<jni::JString>("byName");
+      jni::local_ref<jni::JString> byName = this->getFieldValue(fieldByName);
+      return DataBindByName(
+        byName->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDataBindByName::javaobject> fromCpp(const DataBindByName& value) {
+      using JSignature = JDataBindByName(jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.byName)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,59 @@
+///
+/// JDataBindMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DataBindMode.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "DataBindMode" and the the Kotlin enum "DataBindMode".
+   */
+  struct JDataBindMode final: public jni::JavaClass<JDataBindMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/DataBindMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum DataBindMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DataBindMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<DataBindMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JDataBindMode> fromCpp(DataBindMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAUTO = clazz->getStaticField<JDataBindMode>("AUTO");
+      static const auto fieldNONE = clazz->getStaticField<JDataBindMode>("NONE");
+      
+      switch (value) {
+        case DataBindMode::AUTO:
+          return clazz->getStaticFieldValue(fieldAUTO);
+        case DataBindMode::NONE:
+          return clazz->getStaticFieldValue(fieldNONE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,30 @@
+///
+/// JEventPropertiesOutput.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JEventPropertiesOutput.hpp"
+
+namespace margelo::nitro::rive {
+  /**
+   * Converts JEventPropertiesOutput to std::variant<bool, std::string, double>
+   */
+  std::variant<bool, std::string, double> JEventPropertiesOutput::toCpp() const {
+    if (isInstanceOf(JEventPropertiesOutput_impl::First::javaClassStatic())) {
+      // It's a `bool`
+      auto jniValue = static_cast<const JEventPropertiesOutput_impl::First*>(this)->getValue();
+      return static_cast<bool>(jniValue);
+    } else if (isInstanceOf(JEventPropertiesOutput_impl::Second::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JEventPropertiesOutput_impl::Second*>(this)->getValue();
+      return jniValue->toStdString();
+    } else if (isInstanceOf(JEventPropertiesOutput_impl::Third::javaClassStatic())) {
+      // It's a `double`
+      auto jniValue = static_cast<const JEventPropertiesOutput_impl::Third*>(this)->getValue();
+      return jniValue;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,83 @@
+///
+/// JEventPropertiesOutput.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "EventPropertiesOutput".
+   */
+  class JEventPropertiesOutput: public jni::JavaClass<JEventPropertiesOutput> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/EventPropertiesOutput;";
+
+    static jni::local_ref<JEventPropertiesOutput> create_0(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JEventPropertiesOutput(jboolean)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JEventPropertiesOutput> create_1(jni::alias_ref<jni::JString> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JEventPropertiesOutput(jni::alias_ref<jni::JString>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JEventPropertiesOutput> create_2(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JEventPropertiesOutput(double)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JEventPropertiesOutput> fromCpp(const std::variant<bool, std::string, double>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(std::get<0>(variant));
+        case 1: return create_1(jni::make_jstring(std::get<1>(variant)));
+        case 2: return create_2(std::get<2>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<bool, std::string, double> toCpp() const;
+  };
+
+  namespace JEventPropertiesOutput_impl {
+    class First: public jni::JavaClass<First, JEventPropertiesOutput> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/EventPropertiesOutput$First;";
+    
+      [[nodiscard]] jboolean getValue() const {
+        static const auto field = javaClassStatic()->getField<jboolean>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second: public jni::JavaClass<Second, JEventPropertiesOutput> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/EventPropertiesOutput$Second;";
+    
+      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JString>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Third: public jni::JavaClass<Third, JEventPropertiesOutput> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/EventPropertiesOutput$Third;";
+    
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JEventPropertiesOutput_impl
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,77 @@
+///
+/// JFit.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Fit.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "Fit" and the the Kotlin enum "Fit".
+   */
+  struct JFit final: public jni::JavaClass<JFit> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Fit;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum Fit.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Fit toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<Fit>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JFit> fromCpp(Fit value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFILL = clazz->getStaticField<JFit>("FILL");
+      static const auto fieldCONTAIN = clazz->getStaticField<JFit>("CONTAIN");
+      static const auto fieldCOVER = clazz->getStaticField<JFit>("COVER");
+      static const auto fieldFITWIDTH = clazz->getStaticField<JFit>("FITWIDTH");
+      static const auto fieldFITHEIGHT = clazz->getStaticField<JFit>("FITHEIGHT");
+      static const auto fieldNONE = clazz->getStaticField<JFit>("NONE");
+      static const auto fieldSCALEDOWN = clazz->getStaticField<JFit>("SCALEDOWN");
+      static const auto fieldLAYOUT = clazz->getStaticField<JFit>("LAYOUT");
+      
+      switch (value) {
+        case Fit::FILL:
+          return clazz->getStaticFieldValue(fieldFILL);
+        case Fit::CONTAIN:
+          return clazz->getStaticFieldValue(fieldCONTAIN);
+        case Fit::COVER:
+          return clazz->getStaticFieldValue(fieldCOVER);
+        case Fit::FITWIDTH:
+          return clazz->getStaticFieldValue(fieldFITWIDTH);
+        case Fit::FITHEIGHT:
+          return clazz->getStaticFieldValue(fieldFITHEIGHT);
+        case Fit::NONE:
+          return clazz->getStaticFieldValue(fieldNONE);
+        case Fit::SCALEDOWN:
+          return clazz->getStaticFieldValue(fieldSCALEDOWN);
+        case Fit::LAYOUT:
+          return clazz->getStaticFieldValue(fieldLAYOUT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_RiveError.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "RiveError.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JRiveError.hpp"
+#include <string>
+#include "RiveErrorType.hpp"
+#include "JRiveErrorType.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(error: RiveError) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_RiveError: public jni::JavaClass<JFunc_void_RiveError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_RiveError;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_RiveError` instance holds through JNI.
+     */
+    void invoke(const RiveError& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRiveError> /* error */)>("invoke");
+      method(self(), JRiveError::fromCpp(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_RiveError that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_RiveError_cxx final: public jni::HybridClass<JFunc_void_RiveError_cxx, JFunc_void_RiveError> {
+  public:
+    static jni::local_ref<JFunc_void_RiveError::javaobject> fromCpp(const std::function<void(const RiveError& /* error */)>& func) {
+      return JFunc_void_RiveError_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_RiveError_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JRiveError> error) {
+      _func(error->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const RiveError& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_RiveError_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_RiveError_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_RiveError_cxx(const std::function<void(const RiveError& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const RiveError& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::rive