react-native-nitro-modal 0.1.0

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

@@ -0,0 +1,344 @@
+///
+/// JHybridNitroModalSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroModalSpec.hpp"
+
+// Forward declaration of `ModalMode` to properly resolve imports.
+namespace margelo::nitro::nitromodal { enum class ModalMode; }
+// Forward declaration of `SheetDetent` to properly resolve imports.
+namespace margelo::nitro::nitromodal { enum class SheetDetent; }
+// Forward declaration of `KeyboardBehavior` to properly resolve imports.
+namespace margelo::nitro::nitromodal { enum class KeyboardBehavior; }
+// Forward declaration of `PopupAnimation` to properly resolve imports.
+namespace margelo::nitro::nitromodal { enum class PopupAnimation; }
+// Forward declaration of `DismissReason` to properly resolve imports.
+namespace margelo::nitro::nitromodal { enum class DismissReason; }
+// Forward declaration of `ModalContentArea` to properly resolve imports.
+namespace margelo::nitro::nitromodal { struct ModalContentArea; }
+
+#include "ModalMode.hpp"
+#include "JModalMode.hpp"
+#include "SheetDetent.hpp"
+#include <vector>
+#include "JSheetDetent.hpp"
+#include <optional>
+#include "KeyboardBehavior.hpp"
+#include "JKeyboardBehavior.hpp"
+#include "PopupAnimation.hpp"
+#include "JPopupAnimation.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "DismissReason.hpp"
+#include "JFunc_void_DismissReason.hpp"
+#include "JDismissReason.hpp"
+#include "JFunc_void_double.hpp"
+#include "ModalContentArea.hpp"
+#include "JFunc_void_ModalContentArea.hpp"
+#include "JModalContentArea.hpp"
+
+namespace margelo::nitro::nitromodal {
+
+  std::shared_ptr<JHybridNitroModalSpec> JHybridNitroModalSpec::JavaPart::getJHybridNitroModalSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNitroModalSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNitroModalSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNitroModalSpec::CxxPart::jhybriddata> JHybridNitroModalSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNitroModalSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNitroModalSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNitroModalSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNitroModalSpec>(castJavaPart);
+  }
+
+  void JHybridNitroModalSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroModalSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  bool JHybridNitroModalSpec::getIsOpen() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isOpen");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroModalSpec::setIsOpen(bool isOpen) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isOpen */)>("setOpen");
+    method(_javaPart, isOpen);
+  }
+  ModalMode JHybridNitroModalSpec::getMode() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JModalMode>()>("getMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridNitroModalSpec::setMode(ModalMode mode) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JModalMode> /* mode */)>("setMode");
+    method(_javaPart, JModalMode::fromCpp(mode));
+  }
+  std::vector<SheetDetent> JHybridNitroModalSpec::getDetents() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JSheetDetent>>()>("getDetents");
+    auto __result = method(_javaPart);
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<SheetDetent> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
+  void JHybridNitroModalSpec::setDetents(const std::vector<SheetDetent>& detents) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JSheetDetent>> /* detents */)>("setDetents");
+    method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<JSheetDetent>> __array = jni::JArrayClass<JSheetDetent>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = JSheetDetent::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(detents));
+  }
+  double JHybridNitroModalSpec::getInitialDetentIndex() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getInitialDetentIndex");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroModalSpec::setInitialDetentIndex(double initialDetentIndex) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* initialDetentIndex */)>("setInitialDetentIndex");
+    method(_javaPart, initialDetentIndex);
+  }
+  double JHybridNitroModalSpec::getBackdropColor() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getBackdropColor");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroModalSpec::setBackdropColor(double backdropColor) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* backdropColor */)>("setBackdropColor");
+    method(_javaPart, backdropColor);
+  }
+  double JHybridNitroModalSpec::getBackdropOpacity() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getBackdropOpacity");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroModalSpec::setBackdropOpacity(double backdropOpacity) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* backdropOpacity */)>("setBackdropOpacity");
+    method(_javaPart, backdropOpacity);
+  }
+  double JHybridNitroModalSpec::getBackdropBlurRadius() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getBackdropBlurRadius");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroModalSpec::setBackdropBlurRadius(double backdropBlurRadius) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* backdropBlurRadius */)>("setBackdropBlurRadius");
+    method(_javaPart, backdropBlurRadius);
+  }
+  bool JHybridNitroModalSpec::getDismissOnBackdropPress() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getDismissOnBackdropPress");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroModalSpec::setDismissOnBackdropPress(bool dismissOnBackdropPress) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* dismissOnBackdropPress */)>("setDismissOnBackdropPress");
+    method(_javaPart, dismissOnBackdropPress);
+  }
+  bool JHybridNitroModalSpec::getDismissOnSwipe() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getDismissOnSwipe");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroModalSpec::setDismissOnSwipe(bool dismissOnSwipe) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* dismissOnSwipe */)>("setDismissOnSwipe");
+    method(_javaPart, dismissOnSwipe);
+  }
+  bool JHybridNitroModalSpec::getDismissOnBackButton() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getDismissOnBackButton");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroModalSpec::setDismissOnBackButton(bool dismissOnBackButton) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* dismissOnBackButton */)>("setDismissOnBackButton");
+    method(_javaPart, dismissOnBackButton);
+  }
+  bool JHybridNitroModalSpec::getGrabberVisible() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getGrabberVisible");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroModalSpec::setGrabberVisible(bool grabberVisible) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* grabberVisible */)>("setGrabberVisible");
+    method(_javaPart, grabberVisible);
+  }
+  double JHybridNitroModalSpec::getCornerRadius() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getCornerRadius");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroModalSpec::setCornerRadius(double cornerRadius) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* cornerRadius */)>("setCornerRadius");
+    method(_javaPart, cornerRadius);
+  }
+  std::optional<double> JHybridNitroModalSpec::getContentBackgroundColor() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getContentBackgroundColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setContentBackgroundColor(std::optional<double> contentBackgroundColor) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* contentBackgroundColor */)>("setContentBackgroundColor");
+    method(_javaPart, contentBackgroundColor.has_value() ? jni::JDouble::valueOf(contentBackgroundColor.value()) : nullptr);
+  }
+  KeyboardBehavior JHybridNitroModalSpec::getKeyboardBehavior() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JKeyboardBehavior>()>("getKeyboardBehavior");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridNitroModalSpec::setKeyboardBehavior(KeyboardBehavior keyboardBehavior) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JKeyboardBehavior> /* keyboardBehavior */)>("setKeyboardBehavior");
+    method(_javaPart, JKeyboardBehavior::fromCpp(keyboardBehavior));
+  }
+  PopupAnimation JHybridNitroModalSpec::getPopupAnimation() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPopupAnimation>()>("getPopupAnimation");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridNitroModalSpec::setPopupAnimation(PopupAnimation popupAnimation) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JPopupAnimation> /* popupAnimation */)>("setPopupAnimation");
+    method(_javaPart, JPopupAnimation::fromCpp(popupAnimation));
+  }
+  std::optional<std::function<void()>> JHybridNitroModalSpec::getOnPresent() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnPresent_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setOnPresent(const std::optional<std::function<void()>>& onPresent) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onPresent */)>("setOnPresent_cxx");
+    method(_javaPart, onPresent.has_value() ? JFunc_void_cxx::fromCpp(onPresent.value()) : nullptr);
+  }
+  std::optional<std::function<void(DismissReason /* reason */)>> JHybridNitroModalSpec::getOnDismiss() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_DismissReason::javaobject>()>("getOnDismiss_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(DismissReason /* reason */)> {
+      if (__result->isInstanceOf(JFunc_void_DismissReason_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_DismissReason_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_DismissReason, void(DismissReason)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setOnDismiss(const std::optional<std::function<void(DismissReason /* reason */)>>& onDismiss) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_DismissReason::javaobject> /* onDismiss */)>("setOnDismiss_cxx");
+    method(_javaPart, onDismiss.has_value() ? JFunc_void_DismissReason_cxx::fromCpp(onDismiss.value()) : nullptr);
+  }
+  std::optional<std::function<void(double /* index */)>> JHybridNitroModalSpec::getOnDetentChange() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOnDetentChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* index */)> {
+      if (__result->isInstanceOf(JFunc_void_double_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_double_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double, void(double)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setOnDetentChange(const std::optional<std::function<void(double /* index */)>>& onDetentChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double::javaobject> /* onDetentChange */)>("setOnDetentChange_cxx");
+    method(_javaPart, onDetentChange.has_value() ? JFunc_void_double_cxx::fromCpp(onDetentChange.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroModalSpec::getOnBackdropPress() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnBackdropPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setOnBackdropPress(const std::optional<std::function<void()>>& onBackdropPress) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onBackdropPress */)>("setOnBackdropPress_cxx");
+    method(_javaPart, onBackdropPress.has_value() ? JFunc_void_cxx::fromCpp(onBackdropPress.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroModalSpec::getOnBackButtonPress() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnBackButtonPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setOnBackButtonPress(const std::optional<std::function<void()>>& onBackButtonPress) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onBackButtonPress */)>("setOnBackButtonPress_cxx");
+    method(_javaPart, onBackButtonPress.has_value() ? JFunc_void_cxx::fromCpp(onBackButtonPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const ModalContentArea& /* area */)>> JHybridNitroModalSpec::getOnContentAreaChange() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_ModalContentArea::javaobject>()>("getOnContentAreaChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const ModalContentArea& /* area */)> {
+      if (__result->isInstanceOf(JFunc_void_ModalContentArea_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_ModalContentArea_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_ModalContentArea, void(ModalContentArea)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroModalSpec::setOnContentAreaChange(const std::optional<std::function<void(const ModalContentArea& /* area */)>>& onContentAreaChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ModalContentArea::javaobject> /* onContentAreaChange */)>("setOnContentAreaChange_cxx");
+    method(_javaPart, onContentAreaChange.has_value() ? JFunc_void_ModalContentArea_cxx::fromCpp(onContentAreaChange.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridNitroModalSpec::present() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("present");
+    method(_javaPart);
+  }
+  void JHybridNitroModalSpec::dismiss() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("dismiss");
+    method(_javaPart);
+  }
+  void JHybridNitroModalSpec::snapToDetent(double index) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* index */)>("snapToDetent");
+    method(_javaPart, index);
+  }
+
+} // namespace margelo::nitro::nitromodal

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

@@ -0,0 +1,106 @@
+///
+/// HybridNitroModalSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroModalSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitromodal {
+
+  using namespace facebook;
+
+  class JHybridNitroModalSpec: public virtual HybridNitroModalSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitromodal/HybridNitroModalSpec;";
+      std::shared_ptr<JHybridNitroModalSpec> getJHybridNitroModalSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitromodal/HybridNitroModalSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNitroModalSpec(const jni::local_ref<JHybridNitroModalSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroModalSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroModalSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroModalSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    bool getIsOpen() override;
+    void setIsOpen(bool isOpen) override;
+    ModalMode getMode() override;
+    void setMode(ModalMode mode) override;
+    std::vector<SheetDetent> getDetents() override;
+    void setDetents(const std::vector<SheetDetent>& detents) override;
+    double getInitialDetentIndex() override;
+    void setInitialDetentIndex(double initialDetentIndex) override;
+    double getBackdropColor() override;
+    void setBackdropColor(double backdropColor) override;
+    double getBackdropOpacity() override;
+    void setBackdropOpacity(double backdropOpacity) override;
+    double getBackdropBlurRadius() override;
+    void setBackdropBlurRadius(double backdropBlurRadius) override;
+    bool getDismissOnBackdropPress() override;
+    void setDismissOnBackdropPress(bool dismissOnBackdropPress) override;
+    bool getDismissOnSwipe() override;
+    void setDismissOnSwipe(bool dismissOnSwipe) override;
+    bool getDismissOnBackButton() override;
+    void setDismissOnBackButton(bool dismissOnBackButton) override;
+    bool getGrabberVisible() override;
+    void setGrabberVisible(bool grabberVisible) override;
+    double getCornerRadius() override;
+    void setCornerRadius(double cornerRadius) override;
+    std::optional<double> getContentBackgroundColor() override;
+    void setContentBackgroundColor(std::optional<double> contentBackgroundColor) override;
+    KeyboardBehavior getKeyboardBehavior() override;
+    void setKeyboardBehavior(KeyboardBehavior keyboardBehavior) override;
+    PopupAnimation getPopupAnimation() override;
+    void setPopupAnimation(PopupAnimation popupAnimation) override;
+    std::optional<std::function<void()>> getOnPresent() override;
+    void setOnPresent(const std::optional<std::function<void()>>& onPresent) override;
+    std::optional<std::function<void(DismissReason /* reason */)>> getOnDismiss() override;
+    void setOnDismiss(const std::optional<std::function<void(DismissReason /* reason */)>>& onDismiss) override;
+    std::optional<std::function<void(double /* index */)>> getOnDetentChange() override;
+    void setOnDetentChange(const std::optional<std::function<void(double /* index */)>>& onDetentChange) override;
+    std::optional<std::function<void()>> getOnBackdropPress() override;
+    void setOnBackdropPress(const std::optional<std::function<void()>>& onBackdropPress) override;
+    std::optional<std::function<void()>> getOnBackButtonPress() override;
+    void setOnBackButtonPress(const std::optional<std::function<void()>>& onBackButtonPress) override;
+    std::optional<std::function<void(const ModalContentArea& /* area */)>> getOnContentAreaChange() override;
+    void setOnContentAreaChange(const std::optional<std::function<void(const ModalContentArea& /* area */)>>& onContentAreaChange) override;
+
+  public:
+    // Methods
+    void present() override;
+    void dismiss() override;
+    void snapToDetent(double index) override;
+
+  private:
+    jni::global_ref<JHybridNitroModalSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitromodal

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

@@ -0,0 +1,61 @@
+///
+/// JKeyboardBehavior.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 "KeyboardBehavior.hpp"
+
+namespace margelo::nitro::nitromodal {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "KeyboardBehavior" and the Kotlin enum "KeyboardBehavior".
+   */
+  struct JKeyboardBehavior final: public jni::JavaClass<JKeyboardBehavior> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitromodal/KeyboardBehavior;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum KeyboardBehavior.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    KeyboardBehavior toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<KeyboardBehavior>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JKeyboardBehavior> fromCpp(KeyboardBehavior value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case KeyboardBehavior::PAN:
+          static const auto fieldPAN = clazz->getStaticField<JKeyboardBehavior>("PAN");
+          return clazz->getStaticFieldValue(fieldPAN);
+        case KeyboardBehavior::RESIZE:
+          static const auto fieldRESIZE = clazz->getStaticField<JKeyboardBehavior>("RESIZE");
+          return clazz->getStaticFieldValue(fieldRESIZE);
+        case KeyboardBehavior::NONE:
+          static const auto fieldNONE = clazz->getStaticField<JKeyboardBehavior>("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::nitromodal

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

@@ -0,0 +1,61 @@
+///
+/// JModalContentArea.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 "ModalContentArea.hpp"
+
+
+
+namespace margelo::nitro::nitromodal {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ModalContentArea" and the Kotlin data class "ModalContentArea".
+   */
+  struct JModalContentArea final: public jni::JavaClass<JModalContentArea> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitromodal/ModalContentArea;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ModalContentArea by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ModalContentArea toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      return ModalContentArea(
+        width,
+        height
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JModalContentArea::javaobject> fromCpp(const ModalContentArea& value) {
+      using JSignature = JModalContentArea(double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.width,
+        value.height
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromodal

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

@@ -0,0 +1,58 @@
+///
+/// JModalMode.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 "ModalMode.hpp"
+
+namespace margelo::nitro::nitromodal {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ModalMode" and the Kotlin enum "ModalMode".
+   */
+  struct JModalMode final: public jni::JavaClass<JModalMode> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitromodal/ModalMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ModalMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ModalMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ModalMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JModalMode> fromCpp(ModalMode value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case ModalMode::BOTTOMSHEET:
+          static const auto fieldBOTTOMSHEET = clazz->getStaticField<JModalMode>("BOTTOMSHEET");
+          return clazz->getStaticFieldValue(fieldBOTTOMSHEET);
+        case ModalMode::POPUP:
+          static const auto fieldPOPUP = clazz->getStaticField<JModalMode>("POPUP");
+          return clazz->getStaticFieldValue(fieldPOPUP);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitromodal