react-native-readium 4.0.2 → 5.0.0-rc.1

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

@@ -0,0 +1,85 @@
+///
+/// JDecorationActivatedEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DecorationActivatedEvent.hpp"
+
+#include "Decoration.hpp"
+#include "DecorationStyle.hpp"
+#include "JDecoration.hpp"
+#include "JDecorationStyle.hpp"
+#include "JLocator.hpp"
+#include "JLocatorLocations.hpp"
+#include "JLocatorText.hpp"
+#include "JPoint.hpp"
+#include "JRect.hpp"
+#include "Locator.hpp"
+#include "LocatorLocations.hpp"
+#include "LocatorText.hpp"
+#include "Point.hpp"
+#include "Rect.hpp"
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DecorationActivatedEvent" and the the Kotlin data class "DecorationActivatedEvent".
+   */
+  struct JDecorationActivatedEvent final: public jni::JavaClass<JDecorationActivatedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/DecorationActivatedEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DecorationActivatedEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DecorationActivatedEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDecoration = clazz->getField<JDecoration>("decoration");
+      jni::local_ref<JDecoration> decoration = this->getFieldValue(fieldDecoration);
+      static const auto fieldGroup = clazz->getField<jni::JString>("group");
+      jni::local_ref<jni::JString> group = this->getFieldValue(fieldGroup);
+      static const auto fieldRect = clazz->getField<JRect>("rect");
+      jni::local_ref<JRect> rect = this->getFieldValue(fieldRect);
+      static const auto fieldPoint = clazz->getField<JPoint>("point");
+      jni::local_ref<JPoint> point = this->getFieldValue(fieldPoint);
+      return DecorationActivatedEvent(
+        decoration->toCpp(),
+        group->toStdString(),
+        rect != nullptr ? std::make_optional(rect->toCpp()) : std::nullopt,
+        point != nullptr ? std::make_optional(point->toCpp()) : 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<JDecorationActivatedEvent::javaobject> fromCpp(const DecorationActivatedEvent& value) {
+      using JSignature = JDecorationActivatedEvent(jni::alias_ref<JDecoration>, jni::alias_ref<jni::JString>, jni::alias_ref<JRect>, jni::alias_ref<JPoint>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JDecoration::fromCpp(value.decoration),
+        jni::make_jstring(value.group),
+        value.rect.has_value() ? JRect::fromCpp(value.rect.value()) : nullptr,
+        value.point.has_value() ? JPoint::fromCpp(value.point.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::readium

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

@@ -0,0 +1,92 @@
+///
+/// JDecorationGroup.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DecorationGroup.hpp"
+
+#include "Decoration.hpp"
+#include "DecorationStyle.hpp"
+#include "JDecoration.hpp"
+#include "JDecorationStyle.hpp"
+#include "JLocator.hpp"
+#include "JLocatorLocations.hpp"
+#include "JLocatorText.hpp"
+#include "Locator.hpp"
+#include "LocatorLocations.hpp"
+#include "LocatorText.hpp"
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DecorationGroup" and the the Kotlin data class "DecorationGroup".
+   */
+  struct JDecorationGroup final: public jni::JavaClass<JDecorationGroup> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/DecorationGroup;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DecorationGroup by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DecorationGroup toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldDecorations = clazz->getField<jni::JArrayClass<JDecoration>>("decorations");
+      jni::local_ref<jni::JArrayClass<JDecoration>> decorations = this->getFieldValue(fieldDecorations);
+      return DecorationGroup(
+        name->toStdString(),
+        [&]() {
+          size_t __size = decorations->size();
+          std::vector<Decoration> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = decorations->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDecorationGroup::javaobject> fromCpp(const DecorationGroup& value) {
+      using JSignature = JDecorationGroup(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayClass<JDecoration>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.name),
+        [&]() {
+          size_t __size = value.decorations.size();
+          jni::local_ref<jni::JArrayClass<JDecoration>> __array = jni::JArrayClass<JDecoration>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.decorations[__i];
+            auto __elementJni = JDecoration::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::readium

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

@@ -0,0 +1,86 @@
+///
+/// JDecorationStyle.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DecorationStyle.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DecorationStyle" and the the Kotlin data class "DecorationStyle".
+   */
+  struct JDecorationStyle final: public jni::JavaClass<JDecorationStyle> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/DecorationStyle;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DecorationStyle by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DecorationStyle toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<jni::JString>("type");
+      jni::local_ref<jni::JString> type = this->getFieldValue(fieldType);
+      static const auto fieldTint = clazz->getField<jni::JString>("tint");
+      jni::local_ref<jni::JString> tint = this->getFieldValue(fieldTint);
+      static const auto fieldIsActive = clazz->getField<jni::JBoolean>("isActive");
+      jni::local_ref<jni::JBoolean> isActive = this->getFieldValue(fieldIsActive);
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldHtml = clazz->getField<jni::JString>("html");
+      jni::local_ref<jni::JString> html = this->getFieldValue(fieldHtml);
+      static const auto fieldCss = clazz->getField<jni::JString>("css");
+      jni::local_ref<jni::JString> css = this->getFieldValue(fieldCss);
+      static const auto fieldLayout = clazz->getField<jni::JString>("layout");
+      jni::local_ref<jni::JString> layout = this->getFieldValue(fieldLayout);
+      static const auto fieldWidth = clazz->getField<jni::JString>("width");
+      jni::local_ref<jni::JString> width = this->getFieldValue(fieldWidth);
+      return DecorationStyle(
+        type->toStdString(),
+        tint != nullptr ? std::make_optional(tint->toStdString()) : std::nullopt,
+        isActive != nullptr ? std::make_optional(static_cast<bool>(isActive->value())) : std::nullopt,
+        id != nullptr ? std::make_optional(id->toStdString()) : std::nullopt,
+        html != nullptr ? std::make_optional(html->toStdString()) : std::nullopt,
+        css != nullptr ? std::make_optional(css->toStdString()) : std::nullopt,
+        layout != nullptr ? std::make_optional(layout->toStdString()) : std::nullopt,
+        width != nullptr ? std::make_optional(width->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<JDecorationStyle::javaobject> fromCpp(const DecorationStyle& value) {
+      using JSignature = JDecorationStyle(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, 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.type),
+        value.tint.has_value() ? jni::make_jstring(value.tint.value()) : nullptr,
+        value.isActive.has_value() ? jni::JBoolean::valueOf(value.isActive.value()) : nullptr,
+        value.id.has_value() ? jni::make_jstring(value.id.value()) : nullptr,
+        value.html.has_value() ? jni::make_jstring(value.html.value()) : nullptr,
+        value.css.has_value() ? jni::make_jstring(value.css.value()) : nullptr,
+        value.layout.has_value() ? jni::make_jstring(value.layout.value()) : nullptr,
+        value.width.has_value() ? jni::make_jstring(value.width.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::readium

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

@@ -0,0 +1,94 @@
+///
+/// JFunc_void_DecorationActivatedEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "DecorationActivatedEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JDecorationActivatedEvent.hpp"
+#include "Decoration.hpp"
+#include "JDecoration.hpp"
+#include <string>
+#include "Locator.hpp"
+#include "JLocator.hpp"
+#include <optional>
+#include "LocatorLocations.hpp"
+#include "JLocatorLocations.hpp"
+#include "LocatorText.hpp"
+#include "JLocatorText.hpp"
+#include "DecorationStyle.hpp"
+#include "JDecorationStyle.hpp"
+#include <unordered_map>
+#include "Rect.hpp"
+#include "JRect.hpp"
+#include "Point.hpp"
+#include "JPoint.hpp"
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: DecorationActivatedEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_DecorationActivatedEvent: public jni::JavaClass<JFunc_void_DecorationActivatedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Func_void_DecorationActivatedEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_DecorationActivatedEvent` instance holds through JNI.
+     */
+    void invoke(const DecorationActivatedEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JDecorationActivatedEvent> /* event */)>("invoke");
+      method(self(), JDecorationActivatedEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_DecorationActivatedEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_DecorationActivatedEvent_cxx final: public jni::HybridClass<JFunc_void_DecorationActivatedEvent_cxx, JFunc_void_DecorationActivatedEvent> {
+  public:
+    static jni::local_ref<JFunc_void_DecorationActivatedEvent::javaobject> fromCpp(const std::function<void(const DecorationActivatedEvent& /* event */)>& func) {
+      return JFunc_void_DecorationActivatedEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_DecorationActivatedEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JDecorationActivatedEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const DecorationActivatedEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Func_void_DecorationActivatedEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_DecorationActivatedEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_DecorationActivatedEvent_cxx(const std::function<void(const DecorationActivatedEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const DecorationActivatedEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::readium

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

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

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

@@ -0,0 +1,102 @@
+///
+/// JFunc_void_PublicationReadyEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "PublicationReadyEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPublicationReadyEvent.hpp"
+#include "Link.hpp"
+#include <vector>
+#include "JLink.hpp"
+#include <string>
+#include <optional>
+#include "Locator.hpp"
+#include "JLocator.hpp"
+#include "LocatorLocations.hpp"
+#include "JLocatorLocations.hpp"
+#include "LocatorText.hpp"
+#include "JLocatorText.hpp"
+#include "PublicationMetadata.hpp"
+#include "JPublicationMetadata.hpp"
+#include "Accessibility.hpp"
+#include "JAccessibility.hpp"
+#include "AccessibilityCertification.hpp"
+#include "JAccessibilityCertification.hpp"
+#include "Contributor.hpp"
+#include "JContributor.hpp"
+#include "Subject.hpp"
+#include "JSubject.hpp"
+#include "BelongsTo.hpp"
+#include "JBelongsTo.hpp"
+#include "SeriesInfo.hpp"
+#include "JSeriesInfo.hpp"
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: PublicationReadyEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PublicationReadyEvent: public jni::JavaClass<JFunc_void_PublicationReadyEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Func_void_PublicationReadyEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PublicationReadyEvent` instance holds through JNI.
+     */
+    void invoke(const PublicationReadyEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPublicationReadyEvent> /* event */)>("invoke");
+      method(self(), JPublicationReadyEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PublicationReadyEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PublicationReadyEvent_cxx final: public jni::HybridClass<JFunc_void_PublicationReadyEvent_cxx, JFunc_void_PublicationReadyEvent> {
+  public:
+    static jni::local_ref<JFunc_void_PublicationReadyEvent::javaobject> fromCpp(const std::function<void(const PublicationReadyEvent& /* event */)>& func) {
+      return JFunc_void_PublicationReadyEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PublicationReadyEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPublicationReadyEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PublicationReadyEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Func_void_PublicationReadyEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PublicationReadyEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PublicationReadyEvent_cxx(const std::function<void(const PublicationReadyEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PublicationReadyEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::readium

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

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