@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,593 @@
+///
+/// JHybridNitroMapSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroMapSpec.hpp"
+
+// Forward declaration of `MapProvider` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapProvider; }
+// Forward declaration of `Region` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Region; }
+// Forward declaration of `MapType` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapType; }
+// Forward declaration of `MapStyleElement` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapStyleElement; }
+// Forward declaration of `MapStyler` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapStyler; }
+// Forward declaration of `ClusterConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ClusterConfig; }
+// Forward declaration of `ClusterStrategy` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class ClusterStrategy; }
+// Forward declaration of `MarkerColor` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerColor; }
+// Forward declaration of `ClusterAnimationStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class ClusterAnimationStyle; }
+// Forward declaration of `MapPressEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapPressEvent; }
+// Forward declaration of `Coordinate` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Coordinate; }
+// Forward declaration of `Point` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Point; }
+// Forward declaration of `RegionChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct RegionChangeEvent; }
+// Forward declaration of `MarkerPressEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerPressEvent; }
+// Forward declaration of `MarkerDragEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerDragEvent; }
+// Forward declaration of `ClusterPressEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ClusterPressEvent; }
+// Forward declaration of `MapError` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapError; }
+// Forward declaration of `Camera` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Camera; }
+// Forward declaration of `MapBoundaries` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapBoundaries; }
+// Forward declaration of `EdgePadding` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct EdgePadding; }
+// Forward declaration of `MarkerData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerData; }
+// Forward declaration of `MarkerConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerConfig; }
+// Forward declaration of `MarkerStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MarkerStyle; }
+// Forward declaration of `ImageMarkerConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ImageMarkerConfig; }
+// Forward declaration of `PriceMarkerStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PriceMarkerStyle; }
+// Forward declaration of `MarkerAnimation` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
+
+#include "MapProvider.hpp"
+#include <optional>
+#include "JMapProvider.hpp"
+#include "Region.hpp"
+#include "JRegion.hpp"
+#include "MapType.hpp"
+#include "JMapType.hpp"
+#include "MapStyleElement.hpp"
+#include <vector>
+#include "JMapStyleElement.hpp"
+#include <string>
+#include "MapStyler.hpp"
+#include "JMapStyler.hpp"
+#include "ClusterConfig.hpp"
+#include "JClusterConfig.hpp"
+#include "ClusterStrategy.hpp"
+#include "JClusterStrategy.hpp"
+#include "MarkerColor.hpp"
+#include <variant>
+#include "JColorValue.hpp"
+#include "JMarkerColor.hpp"
+#include "ClusterAnimationStyle.hpp"
+#include "JClusterAnimationStyle.hpp"
+#include "MapPressEvent.hpp"
+#include <functional>
+#include "JFunc_void_MapPressEvent.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JMapPressEvent.hpp"
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+#include "Point.hpp"
+#include "JPoint.hpp"
+#include "JFunc_void.hpp"
+#include "RegionChangeEvent.hpp"
+#include "JFunc_void_RegionChangeEvent.hpp"
+#include "JRegionChangeEvent.hpp"
+#include "MarkerPressEvent.hpp"
+#include "JFunc_void_MarkerPressEvent.hpp"
+#include "JMarkerPressEvent.hpp"
+#include "MarkerDragEvent.hpp"
+#include "JFunc_void_MarkerDragEvent.hpp"
+#include "JMarkerDragEvent.hpp"
+#include "ClusterPressEvent.hpp"
+#include "JFunc_void_ClusterPressEvent.hpp"
+#include "JClusterPressEvent.hpp"
+#include "MapError.hpp"
+#include "JFunc_void_MapError.hpp"
+#include "JMapError.hpp"
+#include "Camera.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JCamera.hpp"
+#include "MapBoundaries.hpp"
+#include "JMapBoundaries.hpp"
+#include "EdgePadding.hpp"
+#include "JEdgePadding.hpp"
+#include "MarkerData.hpp"
+#include "JMarkerData.hpp"
+#include "MarkerConfig.hpp"
+#include "JMarkerConfig.hpp"
+#include "MarkerStyle.hpp"
+#include "JMarkerStyle.hpp"
+#include "ImageMarkerConfig.hpp"
+#include "JImageMarkerConfig.hpp"
+#include "PriceMarkerStyle.hpp"
+#include "JPriceMarkerStyle.hpp"
+#include "JVariant_String_MarkerColor.hpp"
+#include "MarkerAnimation.hpp"
+#include "JMarkerAnimation.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  jni::local_ref<JHybridNitroMapSpec::jhybriddata> JHybridNitroMapSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroMapSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroMapSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroMapSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroMapSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridNitroMapSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<MapProvider> JHybridNitroMapSpec::getProvider() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JMapProvider>()>("getProvider");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setProvider(std::optional<MapProvider> provider) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMapProvider> /* provider */)>("setProvider");
+    method(_javaPart, provider.has_value() ? JMapProvider::fromCpp(provider.value()) : nullptr);
+  }
+  std::optional<Region> JHybridNitroMapSpec::getInitialRegion() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRegion>()>("getInitialRegion");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setInitialRegion(const std::optional<Region>& initialRegion) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRegion> /* initialRegion */)>("setInitialRegion");
+    method(_javaPart, initialRegion.has_value() ? JRegion::fromCpp(initialRegion.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getShowsUserLocation() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsUserLocation");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setShowsUserLocation(std::optional<bool> showsUserLocation) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsUserLocation */)>("setShowsUserLocation");
+    method(_javaPart, showsUserLocation.has_value() ? jni::JBoolean::valueOf(showsUserLocation.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getZoomEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getZoomEnabled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setZoomEnabled(std::optional<bool> zoomEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* zoomEnabled */)>("setZoomEnabled");
+    method(_javaPart, zoomEnabled.has_value() ? jni::JBoolean::valueOf(zoomEnabled.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getScrollEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getScrollEnabled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setScrollEnabled(std::optional<bool> scrollEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* scrollEnabled */)>("setScrollEnabled");
+    method(_javaPart, scrollEnabled.has_value() ? jni::JBoolean::valueOf(scrollEnabled.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getRotateEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getRotateEnabled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setRotateEnabled(std::optional<bool> rotateEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* rotateEnabled */)>("setRotateEnabled");
+    method(_javaPart, rotateEnabled.has_value() ? jni::JBoolean::valueOf(rotateEnabled.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getPitchEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getPitchEnabled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setPitchEnabled(std::optional<bool> pitchEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* pitchEnabled */)>("setPitchEnabled");
+    method(_javaPart, pitchEnabled.has_value() ? jni::JBoolean::valueOf(pitchEnabled.value()) : nullptr);
+  }
+  std::optional<MapType> JHybridNitroMapSpec::getMapType() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JMapType>()>("getMapType");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setMapType(std::optional<MapType> mapType) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMapType> /* mapType */)>("setMapType");
+    method(_javaPart, mapType.has_value() ? JMapType::fromCpp(mapType.value()) : nullptr);
+  }
+  std::optional<std::vector<MapStyleElement>> JHybridNitroMapSpec::getCustomMapStyle() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMapStyleElement>>()>("getCustomMapStyle");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<MapStyleElement> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setCustomMapStyle(const std::optional<std::vector<MapStyleElement>>& customMapStyle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JMapStyleElement>> /* customMapStyle */)>("setCustomMapStyle");
+    method(_javaPart, customMapStyle.has_value() ? [&]() {
+      size_t __size = customMapStyle.value().size();
+      jni::local_ref<jni::JArrayClass<JMapStyleElement>> __array = jni::JArrayClass<JMapStyleElement>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = customMapStyle.value()[__i];
+        auto __elementJni = JMapStyleElement::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getShowsMyLocationButton() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsMyLocationButton");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setShowsMyLocationButton(std::optional<bool> showsMyLocationButton) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsMyLocationButton */)>("setShowsMyLocationButton");
+    method(_javaPart, showsMyLocationButton.has_value() ? jni::JBoolean::valueOf(showsMyLocationButton.value()) : nullptr);
+  }
+  std::optional<ClusterConfig> JHybridNitroMapSpec::getClusterConfig() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JClusterConfig>()>("getClusterConfig");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setClusterConfig(const std::optional<ClusterConfig>& clusterConfig) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JClusterConfig> /* clusterConfig */)>("setClusterConfig");
+    method(_javaPart, clusterConfig.has_value() ? JClusterConfig::fromCpp(clusterConfig.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getDarkMode() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getDarkMode");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setDarkMode(std::optional<bool> darkMode) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* darkMode */)>("setDarkMode");
+    method(_javaPart, darkMode.has_value() ? jni::JBoolean::valueOf(darkMode.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MapPressEvent& /* event */)>> JHybridNitroMapSpec::getOnPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MapPressEvent::javaobject>()>("getOnPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MapPressEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_MapPressEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MapPressEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MapPressEvent, void(MapPressEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MapPressEvent::javaobject> /* onPress */)>("setOnPress_cxx");
+    method(_javaPart, onPress.has_value() ? JFunc_void_MapPressEvent_cxx::fromCpp(onPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MapPressEvent& /* event */)>> JHybridNitroMapSpec::getOnLongPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MapPressEvent::javaobject>()>("getOnLongPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MapPressEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_MapPressEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MapPressEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MapPressEvent, void(MapPressEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnLongPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onLongPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MapPressEvent::javaobject> /* onLongPress */)>("setOnLongPress_cxx");
+    method(_javaPart, onLongPress.has_value() ? JFunc_void_MapPressEvent_cxx::fromCpp(onLongPress.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroMapSpec::getOnMapReady() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnMapReady_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 JHybridNitroMapSpec::setOnMapReady(const std::optional<std::function<void()>>& onMapReady) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onMapReady */)>("setOnMapReady_cxx");
+    method(_javaPart, onMapReady.has_value() ? JFunc_void_cxx::fromCpp(onMapReady.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RegionChangeEvent& /* region */)>> JHybridNitroMapSpec::getOnRegionChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RegionChangeEvent::javaobject>()>("getOnRegionChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RegionChangeEvent& /* region */)> {
+      if (__result->isInstanceOf(JFunc_void_RegionChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RegionChangeEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_RegionChangeEvent, void(RegionChangeEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnRegionChange(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& onRegionChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RegionChangeEvent::javaobject> /* onRegionChange */)>("setOnRegionChange_cxx");
+    method(_javaPart, onRegionChange.has_value() ? JFunc_void_RegionChangeEvent_cxx::fromCpp(onRegionChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RegionChangeEvent& /* region */)>> JHybridNitroMapSpec::getOnRegionChangeComplete() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RegionChangeEvent::javaobject>()>("getOnRegionChangeComplete_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RegionChangeEvent& /* region */)> {
+      if (__result->isInstanceOf(JFunc_void_RegionChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RegionChangeEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_RegionChangeEvent, void(RegionChangeEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnRegionChangeComplete(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& onRegionChangeComplete) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RegionChangeEvent::javaobject> /* onRegionChangeComplete */)>("setOnRegionChangeComplete_cxx");
+    method(_javaPart, onRegionChangeComplete.has_value() ? JFunc_void_RegionChangeEvent_cxx::fromCpp(onRegionChangeComplete.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MarkerPressEvent& /* event */)>> JHybridNitroMapSpec::getOnMarkerPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MarkerPressEvent::javaobject>()>("getOnMarkerPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MarkerPressEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_MarkerPressEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MarkerPressEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MarkerPressEvent, void(MarkerPressEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnMarkerPress(const std::optional<std::function<void(const MarkerPressEvent& /* event */)>>& onMarkerPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MarkerPressEvent::javaobject> /* onMarkerPress */)>("setOnMarkerPress_cxx");
+    method(_javaPart, onMarkerPress.has_value() ? JFunc_void_MarkerPressEvent_cxx::fromCpp(onMarkerPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MarkerDragEvent& /* event */)>> JHybridNitroMapSpec::getOnMarkerDragStart() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MarkerDragEvent::javaobject>()>("getOnMarkerDragStart_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MarkerDragEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_MarkerDragEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MarkerDragEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MarkerDragEvent, void(MarkerDragEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnMarkerDragStart(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragStart) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MarkerDragEvent::javaobject> /* onMarkerDragStart */)>("setOnMarkerDragStart_cxx");
+    method(_javaPart, onMarkerDragStart.has_value() ? JFunc_void_MarkerDragEvent_cxx::fromCpp(onMarkerDragStart.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MarkerDragEvent& /* event */)>> JHybridNitroMapSpec::getOnMarkerDrag() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MarkerDragEvent::javaobject>()>("getOnMarkerDrag_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MarkerDragEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_MarkerDragEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MarkerDragEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MarkerDragEvent, void(MarkerDragEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnMarkerDrag(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDrag) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MarkerDragEvent::javaobject> /* onMarkerDrag */)>("setOnMarkerDrag_cxx");
+    method(_javaPart, onMarkerDrag.has_value() ? JFunc_void_MarkerDragEvent_cxx::fromCpp(onMarkerDrag.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MarkerDragEvent& /* event */)>> JHybridNitroMapSpec::getOnMarkerDragEnd() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MarkerDragEvent::javaobject>()>("getOnMarkerDragEnd_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MarkerDragEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_MarkerDragEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MarkerDragEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MarkerDragEvent, void(MarkerDragEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnMarkerDragEnd(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragEnd) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MarkerDragEvent::javaobject> /* onMarkerDragEnd */)>("setOnMarkerDragEnd_cxx");
+    method(_javaPart, onMarkerDragEnd.has_value() ? JFunc_void_MarkerDragEvent_cxx::fromCpp(onMarkerDragEnd.value()) : nullptr);
+  }
+  std::optional<std::function<void(const ClusterPressEvent& /* event */)>> JHybridNitroMapSpec::getOnClusterPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_ClusterPressEvent::javaobject>()>("getOnClusterPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const ClusterPressEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_ClusterPressEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_ClusterPressEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_ClusterPressEvent, void(ClusterPressEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnClusterPress(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& onClusterPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ClusterPressEvent::javaobject> /* onClusterPress */)>("setOnClusterPress_cxx");
+    method(_javaPart, onClusterPress.has_value() ? JFunc_void_ClusterPressEvent_cxx::fromCpp(onClusterPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MapError& /* error */)>> JHybridNitroMapSpec::getOnError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MapError::javaobject>()>("getOnError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MapError& /* error */)> {
+      if (__result->isInstanceOf(JFunc_void_MapError_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MapError_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MapError, void(MapError)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnError(const std::optional<std::function<void(const MapError& /* error */)>>& onError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MapError::javaobject> /* onError */)>("setOnError_cxx");
+    method(_javaPart, onError.has_value() ? JFunc_void_MapError_cxx::fromCpp(onError.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridNitroMapSpec::animateToRegion(const Region& region, std::optional<double> duration) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRegion> /* region */, jni::alias_ref<jni::JDouble> /* duration */)>("animateToRegion");
+    method(_javaPart, JRegion::fromCpp(region), duration.has_value() ? jni::JDouble::valueOf(duration.value()) : nullptr);
+  }
+  void JHybridNitroMapSpec::fitToCoordinates(const std::vector<Coordinate>& coordinates, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JCoordinate>> /* coordinates */, jni::alias_ref<JEdgePadding> /* edgePadding */, jni::alias_ref<jni::JBoolean> /* animated */)>("fitToCoordinates");
+    method(_javaPart, [&]() {
+      size_t __size = coordinates.size();
+      jni::local_ref<jni::JArrayClass<JCoordinate>> __array = jni::JArrayClass<JCoordinate>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = coordinates[__i];
+        auto __elementJni = JCoordinate::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(), edgePadding.has_value() ? JEdgePadding::fromCpp(edgePadding.value()) : nullptr, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr);
+  }
+  void JHybridNitroMapSpec::animateCamera(const Camera& camera, std::optional<double> duration) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCamera> /* camera */, jni::alias_ref<jni::JDouble> /* duration */)>("animateCamera");
+    method(_javaPart, JCamera::fromCpp(camera), duration.has_value() ? jni::JDouble::valueOf(duration.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<Camera>> JHybridNitroMapSpec::getCamera() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCamera");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<Camera>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JCamera>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridNitroMapSpec::setCamera(const Camera& camera) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCamera> /* camera */)>("setCamera");
+    method(_javaPart, JCamera::fromCpp(camera));
+  }
+  void JHybridNitroMapSpec::setMapStyle(const std::optional<std::vector<MapStyleElement>>& style) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JMapStyleElement>> /* style */)>("setMapStyle");
+    method(_javaPart, style.has_value() ? [&]() {
+      size_t __size = style.value().size();
+      jni::local_ref<jni::JArrayClass<JMapStyleElement>> __array = jni::JArrayClass<JMapStyleElement>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = style.value()[__i];
+        auto __elementJni = JMapStyleElement::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::shared_ptr<Promise<MapBoundaries>> JHybridNitroMapSpec::getMapBoundaries() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getMapBoundaries");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<MapBoundaries>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JMapBoundaries>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridNitroMapSpec::setIsDarkMode(bool enabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setIsDarkMode");
+    method(_javaPart, enabled);
+  }
+  void JHybridNitroMapSpec::addMarker(const MarkerData& marker) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMarkerData> /* marker */)>("addMarker");
+    method(_javaPart, JMarkerData::fromCpp(marker));
+  }
+  void JHybridNitroMapSpec::addMarkers(const std::vector<MarkerData>& markers) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JMarkerData>> /* markers */)>("addMarkers");
+    method(_javaPart, [&]() {
+      size_t __size = markers.size();
+      jni::local_ref<jni::JArrayClass<JMarkerData>> __array = jni::JArrayClass<JMarkerData>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = markers[__i];
+        auto __elementJni = JMarkerData::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }());
+  }
+  void JHybridNitroMapSpec::updateMarker(const MarkerData& marker) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMarkerData> /* marker */)>("updateMarker");
+    method(_javaPart, JMarkerData::fromCpp(marker));
+  }
+  void JHybridNitroMapSpec::removeMarker(const std::string& id) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("removeMarker");
+    method(_javaPart, jni::make_jstring(id));
+  }
+  void JHybridNitroMapSpec::selectMarker(const std::string& id) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("selectMarker");
+    method(_javaPart, jni::make_jstring(id));
+  }
+  void JHybridNitroMapSpec::clearMarkers() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearMarkers");
+    method(_javaPart);
+  }
+  void JHybridNitroMapSpec::setClusteringEnabled(bool enabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setClusteringEnabled");
+    method(_javaPart, enabled);
+  }
+  void JHybridNitroMapSpec::refreshClusters() {
+    static const auto method = javaClassStatic()->getMethod<void()>("refreshClusters");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitromap