react-native-google-maps-plus 0.1.0 → 1.0.0-dev.2

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

@@ -0,0 +1,118 @@
+///
+/// HybridRNGoogleMapsPlusViewSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridRNGoogleMapsPlusViewSpec.hpp"
+
+
+
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  class JHybridRNGoogleMapsPlusViewSpec: public jni::HybridClass<JHybridRNGoogleMapsPlusViewSpec, JHybridObject>,
+                                         public virtual HybridRNGoogleMapsPlusViewSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/HybridRNGoogleMapsPlusViewSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridRNGoogleMapsPlusViewSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridRNGoogleMapsPlusViewSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridRNGoogleMapsPlusViewSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+
+  public:
+    inline const jni::global_ref<JHybridRNGoogleMapsPlusViewSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<RNInitialProps> getInitialProps() override;
+    void setInitialProps(const std::optional<RNInitialProps>& initialProps) override;
+    std::optional<bool> getBuildingEnabled() override;
+    void setBuildingEnabled(std::optional<bool> buildingEnabled) override;
+    std::optional<bool> getTrafficEnabled() override;
+    void setTrafficEnabled(std::optional<bool> trafficEnabled) override;
+    std::optional<std::string> getCustomMapStyle() override;
+    void setCustomMapStyle(const std::optional<std::string>& customMapStyle) override;
+    std::optional<RNUserInterfaceStyle> getUserInterfaceStyle() override;
+    void setUserInterfaceStyle(std::optional<RNUserInterfaceStyle> userInterfaceStyle) override;
+    std::optional<double> getMinZoomLevel() override;
+    void setMinZoomLevel(std::optional<double> minZoomLevel) override;
+    std::optional<double> getMaxZoomLevel() override;
+    void setMaxZoomLevel(std::optional<double> maxZoomLevel) override;
+    std::optional<RNMapPadding> getMapPadding() override;
+    void setMapPadding(const std::optional<RNMapPadding>& mapPadding) override;
+    std::optional<RNMapType> getMapType() override;
+    void setMapType(std::optional<RNMapType> mapType) override;
+    std::optional<std::vector<RNMarker>> getMarkers() override;
+    void setMarkers(const std::optional<std::vector<RNMarker>>& markers) override;
+    std::optional<std::vector<RNPolygon>> getPolygons() override;
+    void setPolygons(const std::optional<std::vector<RNPolygon>>& polygons) override;
+    std::optional<std::vector<RNPolyline>> getPolylines() override;
+    void setPolylines(const std::optional<std::vector<RNPolyline>>& polylines) override;
+    std::optional<std::vector<RNCircle>> getCircles() override;
+    void setCircles(const std::optional<std::vector<RNCircle>>& circles) override;
+    std::optional<std::function<void(RNMapErrorCode /* error */)>> getOnMapError() override;
+    void setOnMapError(const std::optional<std::function<void(RNMapErrorCode /* error */)>>& onMapError) override;
+    std::optional<std::function<void(bool /* ready */)>> getOnMapReady() override;
+    void setOnMapReady(const std::optional<std::function<void(bool /* ready */)>>& onMapReady) override;
+    std::optional<std::function<void(const RNLocation& /* location */)>> getOnLocationUpdate() override;
+    void setOnLocationUpdate(const std::optional<std::function<void(const RNLocation& /* location */)>>& onLocationUpdate) override;
+    std::optional<std::function<void(RNLocationErrorCode /* error */)>> getOnLocationError() override;
+    void setOnLocationError(const std::optional<std::function<void(RNLocationErrorCode /* error */)>>& onLocationError) override;
+    std::optional<std::function<void(const RNLatLng& /* coordinate */)>> getOnMapPress() override;
+    void setOnMapPress(const std::optional<std::function<void(const RNLatLng& /* coordinate */)>>& onMapPress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnMarkerPress() override;
+    void setOnMarkerPress(const std::optional<std::function<void(const std::string& /* id */)>>& onMarkerPress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnPolylinePress() override;
+    void setOnPolylinePress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolylinePress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnPolygonPress() override;
+    void setOnPolygonPress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolygonPress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnCirclePress() override;
+    void setOnCirclePress(const std::optional<std::function<void(const std::string& /* id */)>>& onCirclePress) override;
+    std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChangeStart() override;
+    void setOnCameraChangeStart(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChangeStart) override;
+    std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChange() override;
+    void setOnCameraChange(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChange) override;
+    std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChangeComplete() override;
+    void setOnCameraChangeComplete(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChangeComplete) override;
+
+  public:
+    // Methods
+    void setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMS) override;
+    void setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMS) override;
+    void showLocationDialog() override;
+    void openLocationSettings() override;
+    std::shared_ptr<Promise<RNLocationPermissionResult>> requestLocationPermission() override;
+    bool isGooglePlayServicesAvailable() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridRNGoogleMapsPlusViewSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,62 @@
+///
+/// JRNAndroidLocationPermissionResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNAndroidLocationPermissionResult.hpp"
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RNAndroidLocationPermissionResult" and the the Kotlin enum "RNAndroidLocationPermissionResult".
+   */
+  struct JRNAndroidLocationPermissionResult final: public jni::JavaClass<JRNAndroidLocationPermissionResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNAndroidLocationPermissionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RNAndroidLocationPermissionResult.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNAndroidLocationPermissionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RNAndroidLocationPermissionResult>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRNAndroidLocationPermissionResult> fromCpp(RNAndroidLocationPermissionResult value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldGRANTED = clazz->getStaticField<JRNAndroidLocationPermissionResult>("GRANTED");
+      static const auto fieldDENIED = clazz->getStaticField<JRNAndroidLocationPermissionResult>("DENIED");
+      static const auto fieldNEVER_ASK_AGAIN = clazz->getStaticField<JRNAndroidLocationPermissionResult>("NEVER_ASK_AGAIN");
+      
+      switch (value) {
+        case RNAndroidLocationPermissionResult::GRANTED:
+          return clazz->getStaticFieldValue(fieldGRANTED);
+        case RNAndroidLocationPermissionResult::DENIED:
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case RNAndroidLocationPermissionResult::NEVER_ASK_AGAIN:
+          return clazz->getStaticFieldValue(fieldNEVER_ASK_AGAIN);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,67 @@
+///
+/// JRNCamera.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNCamera.hpp"
+
+#include "JRNLatLng.hpp"
+#include "RNLatLng.hpp"
+#include <optional>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNCamera" and the the Kotlin data class "RNCamera".
+   */
+  struct JRNCamera final: public jni::JavaClass<JRNCamera> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNCamera;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNCamera by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNCamera toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCenter = clazz->getField<JRNLatLng>("center");
+      jni::local_ref<JRNLatLng> center = this->getFieldValue(fieldCenter);
+      static const auto fieldZoom = clazz->getField<jni::JDouble>("zoom");
+      jni::local_ref<jni::JDouble> zoom = this->getFieldValue(fieldZoom);
+      static const auto fieldBearing = clazz->getField<jni::JDouble>("bearing");
+      jni::local_ref<jni::JDouble> bearing = this->getFieldValue(fieldBearing);
+      static const auto fieldTilt = clazz->getField<jni::JDouble>("tilt");
+      jni::local_ref<jni::JDouble> tilt = this->getFieldValue(fieldTilt);
+      return RNCamera(
+        center != nullptr ? std::make_optional(center->toCpp()) : std::nullopt,
+        zoom != nullptr ? std::make_optional(zoom->value()) : std::nullopt,
+        bearing != nullptr ? std::make_optional(bearing->value()) : std::nullopt,
+        tilt != nullptr ? std::make_optional(tilt->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<JRNCamera::javaobject> fromCpp(const RNCamera& value) {
+      return newInstance(
+        value.center.has_value() ? JRNLatLng::fromCpp(value.center.value()) : nullptr,
+        value.zoom.has_value() ? jni::JDouble::valueOf(value.zoom.value()) : nullptr,
+        value.bearing.has_value() ? jni::JDouble::valueOf(value.bearing.value()) : nullptr,
+        value.tilt.has_value() ? jni::JDouble::valueOf(value.tilt.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,84 @@
+///
+/// JRNCircle.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNCircle.hpp"
+
+#include "JRNLatLng.hpp"
+#include "RNLatLng.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNCircle" and the the Kotlin data class "RNCircle".
+   */
+  struct JRNCircle final: public jni::JavaClass<JRNCircle> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNCircle;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNCircle by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNCircle toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldPressable = clazz->getField<jni::JBoolean>("pressable");
+      jni::local_ref<jni::JBoolean> pressable = this->getFieldValue(fieldPressable);
+      static const auto fieldZIndex = clazz->getField<jni::JDouble>("zIndex");
+      jni::local_ref<jni::JDouble> zIndex = this->getFieldValue(fieldZIndex);
+      static const auto fieldCenter = clazz->getField<JRNLatLng>("center");
+      jni::local_ref<JRNLatLng> center = this->getFieldValue(fieldCenter);
+      static const auto fieldRadius = clazz->getField<jni::JDouble>("radius");
+      jni::local_ref<jni::JDouble> radius = this->getFieldValue(fieldRadius);
+      static const auto fieldStrokeWidth = clazz->getField<jni::JDouble>("strokeWidth");
+      jni::local_ref<jni::JDouble> strokeWidth = this->getFieldValue(fieldStrokeWidth);
+      static const auto fieldStrokeColor = clazz->getField<jni::JString>("strokeColor");
+      jni::local_ref<jni::JString> strokeColor = this->getFieldValue(fieldStrokeColor);
+      static const auto fieldFillColor = clazz->getField<jni::JString>("fillColor");
+      jni::local_ref<jni::JString> fillColor = this->getFieldValue(fieldFillColor);
+      return RNCircle(
+        id->toStdString(),
+        pressable != nullptr ? std::make_optional(static_cast<bool>(pressable->value())) : std::nullopt,
+        zIndex != nullptr ? std::make_optional(zIndex->value()) : std::nullopt,
+        center->toCpp(),
+        radius != nullptr ? std::make_optional(radius->value()) : std::nullopt,
+        strokeWidth != nullptr ? std::make_optional(strokeWidth->value()) : std::nullopt,
+        strokeColor != nullptr ? std::make_optional(strokeColor->toStdString()) : std::nullopt,
+        fillColor != nullptr ? std::make_optional(fillColor->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JRNCircle::javaobject> fromCpp(const RNCircle& value) {
+      return newInstance(
+        jni::make_jstring(value.id),
+        value.pressable.has_value() ? jni::JBoolean::valueOf(value.pressable.value()) : nullptr,
+        value.zIndex.has_value() ? jni::JDouble::valueOf(value.zIndex.value()) : nullptr,
+        JRNLatLng::fromCpp(value.center),
+        value.radius.has_value() ? jni::JDouble::valueOf(value.radius.value()) : nullptr,
+        value.strokeWidth.has_value() ? jni::JDouble::valueOf(value.strokeWidth.value()) : nullptr,
+        value.strokeColor.has_value() ? jni::make_jstring(value.strokeColor.value()) : nullptr,
+        value.fillColor.has_value() ? jni::make_jstring(value.fillColor.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,59 @@
+///
+/// JRNIOSPermissionResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNIOSPermissionResult.hpp"
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RNIOSPermissionResult" and the the Kotlin enum "RNIOSPermissionResult".
+   */
+  struct JRNIOSPermissionResult final: public jni::JavaClass<JRNIOSPermissionResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNIOSPermissionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RNIOSPermissionResult.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNIOSPermissionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RNIOSPermissionResult>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRNIOSPermissionResult> fromCpp(RNIOSPermissionResult value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDENIED = clazz->getStaticField<JRNIOSPermissionResult>("DENIED");
+      static const auto fieldAUTHORIZED = clazz->getStaticField<JRNIOSPermissionResult>("AUTHORIZED");
+      
+      switch (value) {
+        case RNIOSPermissionResult::DENIED:
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case RNIOSPermissionResult::AUTHORIZED:
+          return clazz->getStaticFieldValue(fieldAUTHORIZED);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,66 @@
+///
+/// JRNInitialProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNInitialProps.hpp"
+
+#include "JRNCamera.hpp"
+#include "JRNLatLng.hpp"
+#include "RNCamera.hpp"
+#include "RNLatLng.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNInitialProps" and the the Kotlin data class "RNInitialProps".
+   */
+  struct JRNInitialProps final: public jni::JavaClass<JRNInitialProps> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNInitialProps;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNInitialProps by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNInitialProps toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMapId = clazz->getField<jni::JString>("mapId");
+      jni::local_ref<jni::JString> mapId = this->getFieldValue(fieldMapId);
+      static const auto fieldLiteMode = clazz->getField<jni::JBoolean>("liteMode");
+      jni::local_ref<jni::JBoolean> liteMode = this->getFieldValue(fieldLiteMode);
+      static const auto fieldInitialCamera = clazz->getField<JRNCamera>("initialCamera");
+      jni::local_ref<JRNCamera> initialCamera = this->getFieldValue(fieldInitialCamera);
+      return RNInitialProps(
+        mapId != nullptr ? std::make_optional(mapId->toStdString()) : std::nullopt,
+        liteMode != nullptr ? std::make_optional(static_cast<bool>(liteMode->value())) : std::nullopt,
+        initialCamera != nullptr ? std::make_optional(initialCamera->toCpp()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JRNInitialProps::javaobject> fromCpp(const RNInitialProps& value) {
+      return newInstance(
+        value.mapId.has_value() ? jni::make_jstring(value.mapId.value()) : nullptr,
+        value.liteMode.has_value() ? jni::JBoolean::valueOf(value.liteMode.value()) : nullptr,
+        value.initialCamera.has_value() ? JRNCamera::fromCpp(value.initialCamera.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

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

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

@@ -0,0 +1,62 @@
+///
+/// JRNLineCapType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNLineCapType.hpp"
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RNLineCapType" and the the Kotlin enum "RNLineCapType".
+   */
+  struct JRNLineCapType final: public jni::JavaClass<JRNLineCapType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNLineCapType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RNLineCapType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNLineCapType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RNLineCapType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRNLineCapType> fromCpp(RNLineCapType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBUTT = clazz->getStaticField<JRNLineCapType>("BUTT");
+      static const auto fieldROUND = clazz->getStaticField<JRNLineCapType>("ROUND");
+      static const auto fieldSQUARE = clazz->getStaticField<JRNLineCapType>("SQUARE");
+      
+      switch (value) {
+        case RNLineCapType::BUTT:
+          return clazz->getStaticFieldValue(fieldBUTT);
+        case RNLineCapType::ROUND:
+          return clazz->getStaticFieldValue(fieldROUND);
+        case RNLineCapType::SQUARE:
+          return clazz->getStaticFieldValue(fieldSQUARE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,62 @@
+///
+/// JRNLineJoinType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNLineJoinType.hpp"
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RNLineJoinType" and the the Kotlin enum "RNLineJoinType".
+   */
+  struct JRNLineJoinType final: public jni::JavaClass<JRNLineJoinType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNLineJoinType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RNLineJoinType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNLineJoinType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RNLineJoinType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRNLineJoinType> fromCpp(RNLineJoinType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldROUND = clazz->getStaticField<JRNLineJoinType>("ROUND");
+      static const auto fieldMITER = clazz->getStaticField<JRNLineJoinType>("MITER");
+      static const auto fieldBEVEL = clazz->getStaticField<JRNLineJoinType>("BEVEL");
+      
+      switch (value) {
+        case RNLineJoinType::ROUND:
+          return clazz->getStaticFieldValue(fieldROUND);
+        case RNLineJoinType::MITER:
+          return clazz->getStaticFieldValue(fieldMITER);
+        case RNLineJoinType::BEVEL:
+          return clazz->getStaticFieldValue(fieldBEVEL);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus