@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,125 @@
+///
+/// HybridNitroMapSpec.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 "HybridNitroMapSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  class JHybridNitroMapSpec: public jni::HybridClass<JHybridNitroMapSpec, JHybridObject>,
+                             public virtual HybridNitroMapSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/HybridNitroMapSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroMapSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroMapSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroMapSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroMapSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<MapProvider> getProvider() override;
+    void setProvider(std::optional<MapProvider> provider) override;
+    std::optional<Region> getInitialRegion() override;
+    void setInitialRegion(const std::optional<Region>& initialRegion) override;
+    std::optional<bool> getShowsUserLocation() override;
+    void setShowsUserLocation(std::optional<bool> showsUserLocation) override;
+    std::optional<bool> getZoomEnabled() override;
+    void setZoomEnabled(std::optional<bool> zoomEnabled) override;
+    std::optional<bool> getScrollEnabled() override;
+    void setScrollEnabled(std::optional<bool> scrollEnabled) override;
+    std::optional<bool> getRotateEnabled() override;
+    void setRotateEnabled(std::optional<bool> rotateEnabled) override;
+    std::optional<bool> getPitchEnabled() override;
+    void setPitchEnabled(std::optional<bool> pitchEnabled) override;
+    std::optional<MapType> getMapType() override;
+    void setMapType(std::optional<MapType> mapType) override;
+    std::optional<std::vector<MapStyleElement>> getCustomMapStyle() override;
+    void setCustomMapStyle(const std::optional<std::vector<MapStyleElement>>& customMapStyle) override;
+    std::optional<bool> getShowsMyLocationButton() override;
+    void setShowsMyLocationButton(std::optional<bool> showsMyLocationButton) override;
+    std::optional<ClusterConfig> getClusterConfig() override;
+    void setClusterConfig(const std::optional<ClusterConfig>& clusterConfig) override;
+    std::optional<bool> getDarkMode() override;
+    void setDarkMode(std::optional<bool> darkMode) override;
+    std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnPress() override;
+    void setOnPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onPress) override;
+    std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnLongPress() override;
+    void setOnLongPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onLongPress) override;
+    std::optional<std::function<void()>> getOnMapReady() override;
+    void setOnMapReady(const std::optional<std::function<void()>>& onMapReady) override;
+    std::optional<std::function<void(const RegionChangeEvent& /* region */)>> getOnRegionChange() override;
+    void setOnRegionChange(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& onRegionChange) override;
+    std::optional<std::function<void(const RegionChangeEvent& /* region */)>> getOnRegionChangeComplete() override;
+    void setOnRegionChangeComplete(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& onRegionChangeComplete) override;
+    std::optional<std::function<void(const MarkerPressEvent& /* event */)>> getOnMarkerPress() override;
+    void setOnMarkerPress(const std::optional<std::function<void(const MarkerPressEvent& /* event */)>>& onMarkerPress) override;
+    std::optional<std::function<void(const MarkerDragEvent& /* event */)>> getOnMarkerDragStart() override;
+    void setOnMarkerDragStart(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragStart) override;
+    std::optional<std::function<void(const MarkerDragEvent& /* event */)>> getOnMarkerDrag() override;
+    void setOnMarkerDrag(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDrag) override;
+    std::optional<std::function<void(const MarkerDragEvent& /* event */)>> getOnMarkerDragEnd() override;
+    void setOnMarkerDragEnd(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragEnd) override;
+    std::optional<std::function<void(const ClusterPressEvent& /* event */)>> getOnClusterPress() override;
+    void setOnClusterPress(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& onClusterPress) override;
+    std::optional<std::function<void(const MapError& /* error */)>> getOnError() override;
+    void setOnError(const std::optional<std::function<void(const MapError& /* error */)>>& onError) override;
+
+  public:
+    // Methods
+    void animateToRegion(const Region& region, std::optional<double> duration) override;
+    void fitToCoordinates(const std::vector<Coordinate>& coordinates, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) override;
+    void animateCamera(const Camera& camera, std::optional<double> duration) override;
+    std::shared_ptr<Promise<Camera>> getCamera() override;
+    void setCamera(const Camera& camera) override;
+    void setMapStyle(const std::optional<std::vector<MapStyleElement>>& style) override;
+    std::shared_ptr<Promise<MapBoundaries>> getMapBoundaries() override;
+    void setIsDarkMode(bool enabled) override;
+    void addMarker(const MarkerData& marker) override;
+    void addMarkers(const std::vector<MarkerData>& markers) override;
+    void updateMarker(const MarkerData& marker) override;
+    void removeMarker(const std::string& id) override;
+    void selectMarker(const std::string& id) override;
+    void clearMarkers() override;
+    void setClusteringEnabled(bool enabled) override;
+    void refreshClusters() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroMapSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,86 @@
+///
+/// JImageMarkerConfig.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 "ImageMarkerConfig.hpp"
+
+#include "JColorValue.hpp"
+#include "JMarkerColor.hpp"
+#include "MarkerColor.hpp"
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ImageMarkerConfig" and the the Kotlin data class "ImageMarkerConfig".
+   */
+  struct JImageMarkerConfig final: public jni::JavaClass<JImageMarkerConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ImageMarkerConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ImageMarkerConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ImageMarkerConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldImageUrl = clazz->getField<jni::JString>("imageUrl");
+      jni::local_ref<jni::JString> imageUrl = this->getFieldValue(fieldImageUrl);
+      static const auto fieldImageBase64 = clazz->getField<jni::JString>("imageBase64");
+      jni::local_ref<jni::JString> imageBase64 = this->getFieldValue(fieldImageBase64);
+      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);
+      static const auto fieldCornerRadius = clazz->getField<double>("cornerRadius");
+      double cornerRadius = this->getFieldValue(fieldCornerRadius);
+      static const auto fieldBorderWidth = clazz->getField<double>("borderWidth");
+      double borderWidth = this->getFieldValue(fieldBorderWidth);
+      static const auto fieldBorderColor = clazz->getField<JColorValue>("borderColor");
+      jni::local_ref<JColorValue> borderColor = this->getFieldValue(fieldBorderColor);
+      return ImageMarkerConfig(
+        imageUrl != nullptr ? std::make_optional(imageUrl->toStdString()) : std::nullopt,
+        imageBase64 != nullptr ? std::make_optional(imageBase64->toStdString()) : std::nullopt,
+        width,
+        height,
+        cornerRadius,
+        borderWidth,
+        borderColor->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JImageMarkerConfig::javaobject> fromCpp(const ImageMarkerConfig& value) {
+      using JSignature = JImageMarkerConfig(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, double, double, double, jni::alias_ref<JColorValue>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.imageUrl.has_value() ? jni::make_jstring(value.imageUrl.value()) : nullptr,
+        value.imageBase64.has_value() ? jni::make_jstring(value.imageBase64.value()) : nullptr,
+        value.width,
+        value.height,
+        value.cornerRadius,
+        value.borderWidth,
+        JColorValue::fromCpp(value.borderColor)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,62 @@
+///
+/// JMapBoundaries.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 "MapBoundaries.hpp"
+
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MapBoundaries" and the the Kotlin data class "MapBoundaries".
+   */
+  struct JMapBoundaries final: public jni::JavaClass<JMapBoundaries> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/MapBoundaries;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MapBoundaries by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MapBoundaries toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNorthEast = clazz->getField<JCoordinate>("northEast");
+      jni::local_ref<JCoordinate> northEast = this->getFieldValue(fieldNorthEast);
+      static const auto fieldSouthWest = clazz->getField<JCoordinate>("southWest");
+      jni::local_ref<JCoordinate> southWest = this->getFieldValue(fieldSouthWest);
+      return MapBoundaries(
+        northEast->toCpp(),
+        southWest->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMapBoundaries::javaobject> fromCpp(const MapBoundaries& value) {
+      using JSignature = JMapBoundaries(jni::alias_ref<JCoordinate>, jni::alias_ref<JCoordinate>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JCoordinate::fromCpp(value.northEast),
+        JCoordinate::fromCpp(value.southWest)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,61 @@
+///
+/// JMapError.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 "MapError.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MapError" and the the Kotlin data class "MapError".
+   */
+  struct JMapError final: public jni::JavaClass<JMapError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/MapError;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MapError by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MapError toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCode = clazz->getField<jni::JString>("code");
+      jni::local_ref<jni::JString> code = this->getFieldValue(fieldCode);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      return MapError(
+        code->toStdString(),
+        message->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<JMapError::javaobject> fromCpp(const MapError& value) {
+      using JSignature = JMapError(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.code),
+        jni::make_jstring(value.message)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,64 @@
+///
+/// JMapPressEvent.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 "MapPressEvent.hpp"
+
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+#include "JPoint.hpp"
+#include "Point.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MapPressEvent" and the the Kotlin data class "MapPressEvent".
+   */
+  struct JMapPressEvent final: public jni::JavaClass<JMapPressEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/MapPressEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MapPressEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MapPressEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCoordinate = clazz->getField<JCoordinate>("coordinate");
+      jni::local_ref<JCoordinate> coordinate = this->getFieldValue(fieldCoordinate);
+      static const auto fieldPosition = clazz->getField<JPoint>("position");
+      jni::local_ref<JPoint> position = this->getFieldValue(fieldPosition);
+      return MapPressEvent(
+        coordinate->toCpp(),
+        position->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMapPressEvent::javaobject> fromCpp(const MapPressEvent& value) {
+      using JSignature = JMapPressEvent(jni::alias_ref<JCoordinate>, jni::alias_ref<JPoint>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JCoordinate::fromCpp(value.coordinate),
+        JPoint::fromCpp(value.position)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

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

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

@@ -0,0 +1,87 @@
+///
+/// JMapStyleElement.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 "MapStyleElement.hpp"
+
+#include "JMapStyler.hpp"
+#include "MapStyler.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MapStyleElement" and the the Kotlin data class "MapStyleElement".
+   */
+  struct JMapStyleElement final: public jni::JavaClass<JMapStyleElement> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/MapStyleElement;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MapStyleElement by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MapStyleElement toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFeatureType = clazz->getField<jni::JString>("featureType");
+      jni::local_ref<jni::JString> featureType = this->getFieldValue(fieldFeatureType);
+      static const auto fieldElementType = clazz->getField<jni::JString>("elementType");
+      jni::local_ref<jni::JString> elementType = this->getFieldValue(fieldElementType);
+      static const auto fieldStylers = clazz->getField<jni::JArrayClass<JMapStyler>>("stylers");
+      jni::local_ref<jni::JArrayClass<JMapStyler>> stylers = this->getFieldValue(fieldStylers);
+      return MapStyleElement(
+        featureType != nullptr ? std::make_optional(featureType->toStdString()) : std::nullopt,
+        elementType != nullptr ? std::make_optional(elementType->toStdString()) : std::nullopt,
+        [&]() {
+          size_t __size = stylers->size();
+          std::vector<MapStyler> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = stylers->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<JMapStyleElement::javaobject> fromCpp(const MapStyleElement& value) {
+      using JSignature = JMapStyleElement(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayClass<JMapStyler>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.featureType.has_value() ? jni::make_jstring(value.featureType.value()) : nullptr,
+        value.elementType.has_value() ? jni::make_jstring(value.elementType.value()) : nullptr,
+        [&]() {
+          size_t __size = value.stylers.size();
+          jni::local_ref<jni::JArrayClass<JMapStyler>> __array = jni::JArrayClass<JMapStyler>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.stylers[__i];
+            auto __elementJni = JMapStyler::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,78 @@
+///
+/// JMapStyler.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 "MapStyler.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MapStyler" and the the Kotlin data class "MapStyler".
+   */
+  struct JMapStyler final: public jni::JavaClass<JMapStyler> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/MapStyler;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MapStyler by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MapStyler toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldColor = clazz->getField<jni::JString>("color");
+      jni::local_ref<jni::JString> color = this->getFieldValue(fieldColor);
+      static const auto fieldVisibility = clazz->getField<jni::JString>("visibility");
+      jni::local_ref<jni::JString> visibility = this->getFieldValue(fieldVisibility);
+      static const auto fieldWeight = clazz->getField<jni::JDouble>("weight");
+      jni::local_ref<jni::JDouble> weight = this->getFieldValue(fieldWeight);
+      static const auto fieldSaturation = clazz->getField<jni::JDouble>("saturation");
+      jni::local_ref<jni::JDouble> saturation = this->getFieldValue(fieldSaturation);
+      static const auto fieldLightness = clazz->getField<jni::JDouble>("lightness");
+      jni::local_ref<jni::JDouble> lightness = this->getFieldValue(fieldLightness);
+      static const auto fieldGamma = clazz->getField<jni::JDouble>("gamma");
+      jni::local_ref<jni::JDouble> gamma = this->getFieldValue(fieldGamma);
+      return MapStyler(
+        color != nullptr ? std::make_optional(color->toStdString()) : std::nullopt,
+        visibility != nullptr ? std::make_optional(visibility->toStdString()) : std::nullopt,
+        weight != nullptr ? std::make_optional(weight->value()) : std::nullopt,
+        saturation != nullptr ? std::make_optional(saturation->value()) : std::nullopt,
+        lightness != nullptr ? std::make_optional(lightness->value()) : std::nullopt,
+        gamma != nullptr ? std::make_optional(gamma->value()) : 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<JMapStyler::javaobject> fromCpp(const MapStyler& value) {
+      using JSignature = JMapStyler(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.color.has_value() ? jni::make_jstring(value.color.value()) : nullptr,
+        value.visibility.has_value() ? jni::make_jstring(value.visibility.value()) : nullptr,
+        value.weight.has_value() ? jni::JDouble::valueOf(value.weight.value()) : nullptr,
+        value.saturation.has_value() ? jni::JDouble::valueOf(value.saturation.value()) : nullptr,
+        value.lightness.has_value() ? jni::JDouble::valueOf(value.lightness.value()) : nullptr,
+        value.gamma.has_value() ? jni::JDouble::valueOf(value.gamma.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap