@thatkid02/react-native-pdf-viewer 0.0.1

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

@@ -0,0 +1,273 @@
+///
+/// JHybridPdfViewerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridPdfViewerSpec.hpp"
+
+// Forward declaration of `LoadCompleteEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct LoadCompleteEvent; }
+// Forward declaration of `PageChangeEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct PageChangeEvent; }
+// Forward declaration of `ScaleChangeEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct ScaleChangeEvent; }
+// Forward declaration of `ErrorEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct ErrorEvent; }
+// Forward declaration of `ThumbnailGeneratedEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct ThumbnailGeneratedEvent; }
+// Forward declaration of `LoadingChangeEvent` to properly resolve imports.
+namespace margelo::nitro::pdfviewer { struct LoadingChangeEvent; }
+
+#include <string>
+#include <optional>
+#include "LoadCompleteEvent.hpp"
+#include <functional>
+#include "JFunc_void_LoadCompleteEvent.hpp"
+#include "JLoadCompleteEvent.hpp"
+#include "PageChangeEvent.hpp"
+#include "JFunc_void_PageChangeEvent.hpp"
+#include "JPageChangeEvent.hpp"
+#include "ScaleChangeEvent.hpp"
+#include "JFunc_void_ScaleChangeEvent.hpp"
+#include "JScaleChangeEvent.hpp"
+#include "ErrorEvent.hpp"
+#include "JFunc_void_ErrorEvent.hpp"
+#include "JErrorEvent.hpp"
+#include "ThumbnailGeneratedEvent.hpp"
+#include "JFunc_void_ThumbnailGeneratedEvent.hpp"
+#include "JThumbnailGeneratedEvent.hpp"
+#include "LoadingChangeEvent.hpp"
+#include "JFunc_void_LoadingChangeEvent.hpp"
+#include "JLoadingChangeEvent.hpp"
+
+namespace margelo::nitro::pdfviewer {
+
+  jni::local_ref<JHybridPdfViewerSpec::jhybriddata> JHybridPdfViewerSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridPdfViewerSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridPdfViewerSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridPdfViewerSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridPdfViewerSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  std::optional<std::string> JHybridPdfViewerSpec::getSource() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSource");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setSource(const std::optional<std::string>& source) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* source */)>("setSource");
+    method(_javaPart, source.has_value() ? jni::make_jstring(source.value()) : nullptr);
+  }
+  std::optional<bool> JHybridPdfViewerSpec::getHorizontal() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getHorizontal");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setHorizontal(std::optional<bool> horizontal) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* horizontal */)>("setHorizontal");
+    method(_javaPart, horizontal.has_value() ? jni::JBoolean::valueOf(horizontal.value()) : nullptr);
+  }
+  std::optional<bool> JHybridPdfViewerSpec::getEnablePaging() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnablePaging");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setEnablePaging(std::optional<bool> enablePaging) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* enablePaging */)>("setEnablePaging");
+    method(_javaPart, enablePaging.has_value() ? jni::JBoolean::valueOf(enablePaging.value()) : nullptr);
+  }
+  std::optional<double> JHybridPdfViewerSpec::getSpacing() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getSpacing");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setSpacing(std::optional<double> spacing) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* spacing */)>("setSpacing");
+    method(_javaPart, spacing.has_value() ? jni::JDouble::valueOf(spacing.value()) : nullptr);
+  }
+  std::optional<bool> JHybridPdfViewerSpec::getEnableZoom() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnableZoom");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setEnableZoom(std::optional<bool> enableZoom) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* enableZoom */)>("setEnableZoom");
+    method(_javaPart, enableZoom.has_value() ? jni::JBoolean::valueOf(enableZoom.value()) : nullptr);
+  }
+  std::optional<double> JHybridPdfViewerSpec::getMinScale() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMinScale");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setMinScale(std::optional<double> minScale) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* minScale */)>("setMinScale");
+    method(_javaPart, minScale.has_value() ? jni::JDouble::valueOf(minScale.value()) : nullptr);
+  }
+  std::optional<double> JHybridPdfViewerSpec::getMaxScale() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxScale");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setMaxScale(std::optional<double> maxScale) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxScale */)>("setMaxScale");
+    method(_javaPart, maxScale.has_value() ? jni::JDouble::valueOf(maxScale.value()) : nullptr);
+  }
+  std::optional<bool> JHybridPdfViewerSpec::getShowsActivityIndicator() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsActivityIndicator");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setShowsActivityIndicator(std::optional<bool> showsActivityIndicator) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsActivityIndicator */)>("setShowsActivityIndicator");
+    method(_javaPart, showsActivityIndicator.has_value() ? jni::JBoolean::valueOf(showsActivityIndicator.value()) : nullptr);
+  }
+  std::optional<std::function<void(const LoadCompleteEvent& /* event */)>> JHybridPdfViewerSpec::getOnLoadComplete() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_LoadCompleteEvent::javaobject>()>("getOnLoadComplete_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const LoadCompleteEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_LoadCompleteEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_LoadCompleteEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](LoadCompleteEvent event) -> void {
+          return __resultRef->invoke(event);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setOnLoadComplete(const std::optional<std::function<void(const LoadCompleteEvent& /* event */)>>& onLoadComplete) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_LoadCompleteEvent::javaobject> /* onLoadComplete */)>("setOnLoadComplete_cxx");
+    method(_javaPart, onLoadComplete.has_value() ? JFunc_void_LoadCompleteEvent_cxx::fromCpp(onLoadComplete.value()) : nullptr);
+  }
+  std::optional<std::function<void(const PageChangeEvent& /* event */)>> JHybridPdfViewerSpec::getOnPageChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_PageChangeEvent::javaobject>()>("getOnPageChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const PageChangeEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_PageChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_PageChangeEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](PageChangeEvent event) -> void {
+          return __resultRef->invoke(event);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setOnPageChange(const std::optional<std::function<void(const PageChangeEvent& /* event */)>>& onPageChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_PageChangeEvent::javaobject> /* onPageChange */)>("setOnPageChange_cxx");
+    method(_javaPart, onPageChange.has_value() ? JFunc_void_PageChangeEvent_cxx::fromCpp(onPageChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(const ScaleChangeEvent& /* event */)>> JHybridPdfViewerSpec::getOnScaleChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_ScaleChangeEvent::javaobject>()>("getOnScaleChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const ScaleChangeEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_ScaleChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_ScaleChangeEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](ScaleChangeEvent event) -> void {
+          return __resultRef->invoke(event);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setOnScaleChange(const std::optional<std::function<void(const ScaleChangeEvent& /* event */)>>& onScaleChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ScaleChangeEvent::javaobject> /* onScaleChange */)>("setOnScaleChange_cxx");
+    method(_javaPart, onScaleChange.has_value() ? JFunc_void_ScaleChangeEvent_cxx::fromCpp(onScaleChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(const ErrorEvent& /* event */)>> JHybridPdfViewerSpec::getOnError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_ErrorEvent::javaobject>()>("getOnError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const ErrorEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_ErrorEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_ErrorEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](ErrorEvent event) -> void {
+          return __resultRef->invoke(event);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setOnError(const std::optional<std::function<void(const ErrorEvent& /* event */)>>& onError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ErrorEvent::javaobject> /* onError */)>("setOnError_cxx");
+    method(_javaPart, onError.has_value() ? JFunc_void_ErrorEvent_cxx::fromCpp(onError.value()) : nullptr);
+  }
+  std::optional<std::function<void(const ThumbnailGeneratedEvent& /* event */)>> JHybridPdfViewerSpec::getOnThumbnailGenerated() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_ThumbnailGeneratedEvent::javaobject>()>("getOnThumbnailGenerated_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const ThumbnailGeneratedEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_ThumbnailGeneratedEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_ThumbnailGeneratedEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](ThumbnailGeneratedEvent event) -> void {
+          return __resultRef->invoke(event);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setOnThumbnailGenerated(const std::optional<std::function<void(const ThumbnailGeneratedEvent& /* event */)>>& onThumbnailGenerated) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ThumbnailGeneratedEvent::javaobject> /* onThumbnailGenerated */)>("setOnThumbnailGenerated_cxx");
+    method(_javaPart, onThumbnailGenerated.has_value() ? JFunc_void_ThumbnailGeneratedEvent_cxx::fromCpp(onThumbnailGenerated.value()) : nullptr);
+  }
+  std::optional<std::function<void(const LoadingChangeEvent& /* event */)>> JHybridPdfViewerSpec::getOnLoadingChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_LoadingChangeEvent::javaobject>()>("getOnLoadingChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const LoadingChangeEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_LoadingChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_LoadingChangeEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](LoadingChangeEvent event) -> void {
+          return __resultRef->invoke(event);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setOnLoadingChange(const std::optional<std::function<void(const LoadingChangeEvent& /* event */)>>& onLoadingChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_LoadingChangeEvent::javaobject> /* onLoadingChange */)>("setOnLoadingChange_cxx");
+    method(_javaPart, onLoadingChange.has_value() ? JFunc_void_LoadingChangeEvent_cxx::fromCpp(onLoadingChange.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridPdfViewerSpec::goToPage(double page) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* page */)>("goToPage");
+    method(_javaPart, page);
+  }
+  void JHybridPdfViewerSpec::setScale(double scale) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* scale */)>("setScale");
+    method(_javaPart, scale);
+  }
+  void JHybridPdfViewerSpec::generateThumbnail(double page) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* page */)>("generateThumbnail");
+    method(_javaPart, page);
+  }
+  void JHybridPdfViewerSpec::generateAllThumbnails() {
+    static const auto method = javaClassStatic()->getMethod<void()>("generateAllThumbnails");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::pdfviewer

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

@@ -0,0 +1,94 @@
+///
+/// HybridPdfViewerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridPdfViewerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  class JHybridPdfViewerSpec: public jni::HybridClass<JHybridPdfViewerSpec, JHybridObject>,
+                              public virtual HybridPdfViewerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/HybridPdfViewerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridPdfViewerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridPdfViewerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridPdfViewerSpec() 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;
+
+  public:
+    inline const jni::global_ref<JHybridPdfViewerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::string> getSource() override;
+    void setSource(const std::optional<std::string>& source) override;
+    std::optional<bool> getHorizontal() override;
+    void setHorizontal(std::optional<bool> horizontal) override;
+    std::optional<bool> getEnablePaging() override;
+    void setEnablePaging(std::optional<bool> enablePaging) override;
+    std::optional<double> getSpacing() override;
+    void setSpacing(std::optional<double> spacing) override;
+    std::optional<bool> getEnableZoom() override;
+    void setEnableZoom(std::optional<bool> enableZoom) override;
+    std::optional<double> getMinScale() override;
+    void setMinScale(std::optional<double> minScale) override;
+    std::optional<double> getMaxScale() override;
+    void setMaxScale(std::optional<double> maxScale) override;
+    std::optional<bool> getShowsActivityIndicator() override;
+    void setShowsActivityIndicator(std::optional<bool> showsActivityIndicator) override;
+    std::optional<std::function<void(const LoadCompleteEvent& /* event */)>> getOnLoadComplete() override;
+    void setOnLoadComplete(const std::optional<std::function<void(const LoadCompleteEvent& /* event */)>>& onLoadComplete) override;
+    std::optional<std::function<void(const PageChangeEvent& /* event */)>> getOnPageChange() override;
+    void setOnPageChange(const std::optional<std::function<void(const PageChangeEvent& /* event */)>>& onPageChange) override;
+    std::optional<std::function<void(const ScaleChangeEvent& /* event */)>> getOnScaleChange() override;
+    void setOnScaleChange(const std::optional<std::function<void(const ScaleChangeEvent& /* event */)>>& onScaleChange) override;
+    std::optional<std::function<void(const ErrorEvent& /* event */)>> getOnError() override;
+    void setOnError(const std::optional<std::function<void(const ErrorEvent& /* event */)>>& onError) override;
+    std::optional<std::function<void(const ThumbnailGeneratedEvent& /* event */)>> getOnThumbnailGenerated() override;
+    void setOnThumbnailGenerated(const std::optional<std::function<void(const ThumbnailGeneratedEvent& /* event */)>>& onThumbnailGenerated) override;
+    std::optional<std::function<void(const LoadingChangeEvent& /* event */)>> getOnLoadingChange() override;
+    void setOnLoadingChange(const std::optional<std::function<void(const LoadingChangeEvent& /* event */)>>& onLoadingChange) override;
+
+  public:
+    // Methods
+    void goToPage(double page) override;
+    void setScale(double scale) override;
+    void generateThumbnail(double page) override;
+    void generateAllThumbnails() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridPdfViewerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::pdfviewer

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

@@ -0,0 +1,61 @@
+///
+/// JLoadCompleteEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "LoadCompleteEvent.hpp"
+
+
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LoadCompleteEvent" and the the Kotlin data class "LoadCompleteEvent".
+   */
+  struct JLoadCompleteEvent final: public jni::JavaClass<JLoadCompleteEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/LoadCompleteEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LoadCompleteEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LoadCompleteEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPageCount = clazz->getField<double>("pageCount");
+      double pageCount = this->getFieldValue(fieldPageCount);
+      static const auto fieldPageWidth = clazz->getField<double>("pageWidth");
+      double pageWidth = this->getFieldValue(fieldPageWidth);
+      static const auto fieldPageHeight = clazz->getField<double>("pageHeight");
+      double pageHeight = this->getFieldValue(fieldPageHeight);
+      return LoadCompleteEvent(
+        pageCount,
+        pageWidth,
+        pageHeight
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLoadCompleteEvent::javaobject> fromCpp(const LoadCompleteEvent& value) {
+      return newInstance(
+        value.pageCount,
+        value.pageWidth,
+        value.pageHeight
+      );
+    }
+  };
+
+} // namespace margelo::nitro::pdfviewer

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

@@ -0,0 +1,53 @@
+///
+/// JLoadingChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "LoadingChangeEvent.hpp"
+
+
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LoadingChangeEvent" and the the Kotlin data class "LoadingChangeEvent".
+   */
+  struct JLoadingChangeEvent final: public jni::JavaClass<JLoadingChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/LoadingChangeEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LoadingChangeEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LoadingChangeEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIsLoading = clazz->getField<jboolean>("isLoading");
+      jboolean isLoading = this->getFieldValue(fieldIsLoading);
+      return LoadingChangeEvent(
+        static_cast<bool>(isLoading)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLoadingChangeEvent::javaobject> fromCpp(const LoadingChangeEvent& value) {
+      return newInstance(
+        value.isLoading
+      );
+    }
+  };
+
+} // namespace margelo::nitro::pdfviewer

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

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

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

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

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

@@ -0,0 +1,57 @@
+///
+/// JThumbnailGeneratedEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ThumbnailGeneratedEvent.hpp"
+
+#include <string>
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ThumbnailGeneratedEvent" and the the Kotlin data class "ThumbnailGeneratedEvent".
+   */
+  struct JThumbnailGeneratedEvent final: public jni::JavaClass<JThumbnailGeneratedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/ThumbnailGeneratedEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ThumbnailGeneratedEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ThumbnailGeneratedEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPage = clazz->getField<double>("page");
+      double page = this->getFieldValue(fieldPage);
+      static const auto fieldUri = clazz->getField<jni::JString>("uri");
+      jni::local_ref<jni::JString> uri = this->getFieldValue(fieldUri);
+      return ThumbnailGeneratedEvent(
+        page,
+        uri->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<JThumbnailGeneratedEvent::javaobject> fromCpp(const ThumbnailGeneratedEvent& value) {
+      return newInstance(
+        value.page,
+        jni::make_jstring(value.uri)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::pdfviewer