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

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

@@ -0,0 +1,84 @@
+///
+/// JFunc_void_UnifiedRiveEvent.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 "UnifiedRiveEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JUnifiedRiveEvent.hpp"
+#include <string>
+#include "RiveEventType.hpp"
+#include "JRiveEventType.hpp"
+#include <optional>
+#include <variant>
+#include <unordered_map>
+#include "JEventPropertiesOutput.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: UnifiedRiveEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_UnifiedRiveEvent: public jni::JavaClass<JFunc_void_UnifiedRiveEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_UnifiedRiveEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_UnifiedRiveEvent` instance holds through JNI.
+     */
+    void invoke(const UnifiedRiveEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JUnifiedRiveEvent> /* event */)>("invoke");
+      method(self(), JUnifiedRiveEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_UnifiedRiveEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_UnifiedRiveEvent_cxx final: public jni::HybridClass<JFunc_void_UnifiedRiveEvent_cxx, JFunc_void_UnifiedRiveEvent> {
+  public:
+    static jni::local_ref<JFunc_void_UnifiedRiveEvent::javaobject> fromCpp(const std::function<void(const UnifiedRiveEvent& /* event */)>& func) {
+      return JFunc_void_UnifiedRiveEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_UnifiedRiveEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JUnifiedRiveEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const UnifiedRiveEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_UnifiedRiveEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_UnifiedRiveEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_UnifiedRiveEvent_cxx(const std::function<void(const UnifiedRiveEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const UnifiedRiveEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool.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 `(value: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool value) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* value */)>("invoke");
+      method(self(), value);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* value */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean value) {
+      _func(static_cast<bool>(value));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* value */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* value */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* value */)> _func;
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double.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 `(value: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double value) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* value */)>("invoke");
+      method(self(), value);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* value */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double value) {
+      _func(value);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* value */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* value */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* value */)> _func;
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.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 <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(value: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& value) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* value */)>("invoke");
+      method(self(), jni::make_jstring(value));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* value */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> value) {
+      _func(value->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* value */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* value */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* value */)> _func;
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,134 @@
+///
+/// JHybridRiveFileFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridRiveFileFactorySpec.hpp"
+
+// Forward declaration of `HybridRiveFileSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveFileSpec; }
+// Forward declaration of `ReferencedAssetsType` to properly resolve imports.
+namespace margelo::nitro::rive { struct ReferencedAssetsType; }
+// Forward declaration of `ResolvedReferencedAsset` to properly resolve imports.
+namespace margelo::nitro::rive { struct ResolvedReferencedAsset; }
+// Forward declaration of `HybridRiveImageSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageSpec; }
+
+#include <memory>
+#include "HybridRiveFileSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JHybridRiveFileSpec.hpp"
+#include <string>
+#include "ReferencedAssetsType.hpp"
+#include <optional>
+#include "JReferencedAssetsType.hpp"
+#include "ResolvedReferencedAsset.hpp"
+#include <unordered_map>
+#include "JResolvedReferencedAsset.hpp"
+#include "HybridRiveImageSpec.hpp"
+#include "JHybridRiveImageSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+
+namespace margelo::nitro::rive {
+
+  jni::local_ref<JHybridRiveFileFactorySpec::jhybriddata> JHybridRiveFileFactorySpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridRiveFileFactorySpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridRiveFileFactorySpec::initHybrid),
+    });
+  }
+
+  size_t JHybridRiveFileFactorySpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridRiveFileFactorySpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridRiveFileFactorySpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> JHybridRiveFileFactorySpec::fromURL(const std::string& url, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jboolean /* loadCdn */, jni::alias_ref<JReferencedAssetsType> /* referencedAssets */)>("fromURL");
+    auto __result = method(_javaPart, jni::make_jstring(url), loadCdn, referencedAssets.has_value() ? JReferencedAssetsType::fromCpp(referencedAssets.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::shared_ptr<HybridRiveFileSpec>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JHybridRiveFileSpec::javaobject>(__boxedResult);
+        __promise->resolve(__result->cthis()->shared_cast<JHybridRiveFileSpec>());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> JHybridRiveFileFactorySpec::fromFileURL(const std::string& fileURL, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* fileURL */, jboolean /* loadCdn */, jni::alias_ref<JReferencedAssetsType> /* referencedAssets */)>("fromFileURL");
+    auto __result = method(_javaPart, jni::make_jstring(fileURL), loadCdn, referencedAssets.has_value() ? JReferencedAssetsType::fromCpp(referencedAssets.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::shared_ptr<HybridRiveFileSpec>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JHybridRiveFileSpec::javaobject>(__boxedResult);
+        __promise->resolve(__result->cthis()->shared_cast<JHybridRiveFileSpec>());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> JHybridRiveFileFactorySpec::fromResource(const std::string& resource, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* resource */, jboolean /* loadCdn */, jni::alias_ref<JReferencedAssetsType> /* referencedAssets */)>("fromResource");
+    auto __result = method(_javaPart, jni::make_jstring(resource), loadCdn, referencedAssets.has_value() ? JReferencedAssetsType::fromCpp(referencedAssets.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::shared_ptr<HybridRiveFileSpec>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JHybridRiveFileSpec::javaobject>(__boxedResult);
+        __promise->resolve(__result->cthis()->shared_cast<JHybridRiveFileSpec>());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> JHybridRiveFileFactorySpec::fromBytes(const std::shared_ptr<ArrayBuffer>& bytes, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JArrayBuffer::javaobject> /* bytes */, jboolean /* loadCdn */, jni::alias_ref<JReferencedAssetsType> /* referencedAssets */)>("fromBytes");
+    auto __result = method(_javaPart, JArrayBuffer::wrap(bytes), loadCdn, referencedAssets.has_value() ? JReferencedAssetsType::fromCpp(referencedAssets.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::shared_ptr<HybridRiveFileSpec>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JHybridRiveFileSpec::javaobject>(__boxedResult);
+        __promise->resolve(__result->cthis()->shared_cast<JHybridRiveFileSpec>());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,68 @@
+///
+/// HybridRiveFileFactorySpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridRiveFileFactorySpec.hpp"
+
+
+
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  class JHybridRiveFileFactorySpec: public jni::HybridClass<JHybridRiveFileFactorySpec, JHybridObject>,
+                                    public virtual HybridRiveFileFactorySpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/HybridRiveFileFactorySpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridRiveFileFactorySpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridRiveFileFactorySpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridRiveFileFactorySpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridRiveFileFactorySpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromURL(const std::string& url, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override;
+    std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromFileURL(const std::string& fileURL, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override;
+    std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromResource(const std::string& resource, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override;
+    std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromBytes(const std::shared_ptr<ArrayBuffer>& bytes, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridRiveFileFactorySpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,96 @@
+///
+/// JHybridRiveFileSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridRiveFileSpec.hpp"
+
+// Forward declaration of `HybridViewModelSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelSpec; }
+// Forward declaration of `ArtboardBy` to properly resolve imports.
+namespace margelo::nitro::rive { struct ArtboardBy; }
+// Forward declaration of `ArtboardByTypes` to properly resolve imports.
+namespace margelo::nitro::rive { enum class ArtboardByTypes; }
+// Forward declaration of `ReferencedAssetsType` to properly resolve imports.
+namespace margelo::nitro::rive { struct ReferencedAssetsType; }
+// Forward declaration of `ResolvedReferencedAsset` to properly resolve imports.
+namespace margelo::nitro::rive { struct ResolvedReferencedAsset; }
+// Forward declaration of `HybridRiveImageSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageSpec; }
+
+#include <optional>
+#include <memory>
+#include "HybridViewModelSpec.hpp"
+#include "JHybridViewModelSpec.hpp"
+#include <string>
+#include "ArtboardBy.hpp"
+#include "JArtboardBy.hpp"
+#include "ArtboardByTypes.hpp"
+#include "JArtboardByTypes.hpp"
+#include "ReferencedAssetsType.hpp"
+#include "JReferencedAssetsType.hpp"
+#include "ResolvedReferencedAsset.hpp"
+#include <unordered_map>
+#include "JResolvedReferencedAsset.hpp"
+#include "HybridRiveImageSpec.hpp"
+#include "JHybridRiveImageSpec.hpp"
+
+namespace margelo::nitro::rive {
+
+  jni::local_ref<JHybridRiveFileSpec::jhybriddata> JHybridRiveFileSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridRiveFileSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridRiveFileSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridRiveFileSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridRiveFileSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridRiveFileSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<double> JHybridRiveFileSpec::getViewModelCount() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getViewModelCount");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+
+  // Methods
+  std::optional<std::shared_ptr<HybridViewModelSpec>> JHybridRiveFileSpec::viewModelByIndex(double index) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridViewModelSpec::javaobject>(double /* index */)>("viewModelByIndex");
+    auto __result = method(_javaPart, index);
+    return __result != nullptr ? std::make_optional(__result->cthis()->shared_cast<JHybridViewModelSpec>()) : std::nullopt;
+  }
+  std::optional<std::shared_ptr<HybridViewModelSpec>> JHybridRiveFileSpec::viewModelByName(const std::string& name) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridViewModelSpec::javaobject>(jni::alias_ref<jni::JString> /* name */)>("viewModelByName");
+    auto __result = method(_javaPart, jni::make_jstring(name));
+    return __result != nullptr ? std::make_optional(__result->cthis()->shared_cast<JHybridViewModelSpec>()) : std::nullopt;
+  }
+  std::optional<std::shared_ptr<HybridViewModelSpec>> JHybridRiveFileSpec::defaultArtboardViewModel(const std::optional<ArtboardBy>& artboardBy) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridViewModelSpec::javaobject>(jni::alias_ref<JArtboardBy> /* artboardBy */)>("defaultArtboardViewModel");
+    auto __result = method(_javaPart, artboardBy.has_value() ? JArtboardBy::fromCpp(artboardBy.value()) : nullptr);
+    return __result != nullptr ? std::make_optional(__result->cthis()->shared_cast<JHybridViewModelSpec>()) : std::nullopt;
+  }
+  void JHybridRiveFileSpec::updateReferencedAssets(const ReferencedAssetsType& referencedAssets) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JReferencedAssetsType> /* referencedAssets */)>("updateReferencedAssets");
+    method(_javaPart, JReferencedAssetsType::fromCpp(referencedAssets));
+  }
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,68 @@
+///
+/// HybridRiveFileSpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridRiveFileSpec.hpp"
+
+
+
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  class JHybridRiveFileSpec: public jni::HybridClass<JHybridRiveFileSpec, JHybridObject>,
+                             public virtual HybridRiveFileSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/HybridRiveFileSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridRiveFileSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridRiveFileSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridRiveFileSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridRiveFileSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<double> getViewModelCount() override;
+
+  public:
+    // Methods
+    std::optional<std::shared_ptr<HybridViewModelSpec>> viewModelByIndex(double index) override;
+    std::optional<std::shared_ptr<HybridViewModelSpec>> viewModelByName(const std::string& name) override;
+    std::optional<std::shared_ptr<HybridViewModelSpec>> defaultArtboardViewModel(const std::optional<ArtboardBy>& artboardBy) override;
+    void updateReferencedAssets(const ReferencedAssetsType& referencedAssets) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridRiveFileSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::rive