react-native-google-maps-plus 1.0.2 → 1.1.0-dev.1

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

@@ -7,14 +7,20 @@
 
 #include "JHybridRNGoogleMapsPlusViewSpec.hpp"
 
+// Forward declaration of `RNInitialProps` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNInitialProps; }
 // Forward declaration of `RNCamera` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNCamera; }
 // Forward declaration of `RNLatLng` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNLatLng; }
+// Forward declaration of `RNMapUiSettings` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNMapUiSettings; }
 // Forward declaration of `RNUserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 // Forward declaration of `RNMapPadding` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMapPadding; }
+// Forward declaration of `RNMapType` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNMapType; }
 // Forward declaration of `RNMarker` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMarker; }
 // Forward declaration of `RNPosition` to properly resolve imports.
@@ -27,6 +33,18 @@ namespace margelo::nitro::rngooglemapsplus { struct RNPolyline; }
 namespace margelo::nitro::rngooglemapsplus { enum class RNLineCapType; }
 // Forward declaration of `RNLineJoinType` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNLineJoinType; }
+// Forward declaration of `RNCircle` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNCircle; }
+// Forward declaration of `RNLocationConfig` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNLocationConfig; }
+// Forward declaration of `RNAndroidLocationConfig` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNAndroidLocationConfig; }
+// Forward declaration of `RNAndroidLocationPriority` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNAndroidLocationPriority; }
+// Forward declaration of `RNIOSLocationConfig` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIOSLocationConfig; }
+// Forward declaration of `RNIOSLocationAccuracy` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNIOSLocationAccuracy; }
 // Forward declaration of `RNMapErrorCode` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNMapErrorCode; }
 // Forward declaration of `RNLocation` to properly resolve imports.
@@ -42,16 +60,22 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNAndroidLocationPermiss
 // Forward declaration of `RNIOSPermissionResult` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
 
+#include "RNInitialProps.hpp"
+#include <optional>
+#include "JRNInitialProps.hpp"
 #include <string>
 #include "RNCamera.hpp"
 #include "JRNCamera.hpp"
 #include "RNLatLng.hpp"
-#include <optional>
 #include "JRNLatLng.hpp"
+#include "RNMapUiSettings.hpp"
+#include "JRNMapUiSettings.hpp"
 #include "RNUserInterfaceStyle.hpp"
 #include "JRNUserInterfaceStyle.hpp"
 #include "RNMapPadding.hpp"
 #include "JRNMapPadding.hpp"
+#include "RNMapType.hpp"
+#include "JRNMapType.hpp"
 #include "RNMarker.hpp"
 #include <vector>
 #include "JRNMarker.hpp"
@@ -65,6 +89,18 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
 #include "JRNLineCapType.hpp"
 #include "RNLineJoinType.hpp"
 #include "JRNLineJoinType.hpp"
+#include "RNCircle.hpp"
+#include "JRNCircle.hpp"
+#include "RNLocationConfig.hpp"
+#include "JRNLocationConfig.hpp"
+#include "RNAndroidLocationConfig.hpp"
+#include "JRNAndroidLocationConfig.hpp"
+#include "RNAndroidLocationPriority.hpp"
+#include "JRNAndroidLocationPriority.hpp"
+#include "RNIOSLocationConfig.hpp"
+#include "JRNIOSLocationConfig.hpp"
+#include "RNIOSLocationAccuracy.hpp"
+#include "JRNIOSLocationAccuracy.hpp"
 #include "RNMapErrorCode.hpp"
 #include <functional>
 #include "JFunc_void_RNMapErrorCode.hpp"
@@ -113,82 +149,118 @@ namespace margelo::nitro::rngooglemapsplus {
   }
 
   // Properties
-  bool JHybridRNGoogleMapsPlusViewSpec::getBuildingEnabled() {
-    static const auto method = javaClassStatic()->getMethod<jboolean()>("getBuildingEnabled");
+  std::optional<RNInitialProps> JHybridRNGoogleMapsPlusViewSpec::getInitialProps() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNInitialProps>()>("getInitialProps");
     auto __result = method(_javaPart);
-    return static_cast<bool>(__result);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setBuildingEnabled(bool buildingEnabled) {
-    static const auto method = javaClassStatic()->getMethod<void(jboolean /* buildingEnabled */)>("setBuildingEnabled");
-    method(_javaPart, buildingEnabled);
+  void JHybridRNGoogleMapsPlusViewSpec::setInitialProps(const std::optional<RNInitialProps>& initialProps) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNInitialProps> /* initialProps */)>("setInitialProps");
+    method(_javaPart, initialProps.has_value() ? JRNInitialProps::fromCpp(initialProps.value()) : nullptr);
   }
-  bool JHybridRNGoogleMapsPlusViewSpec::getTrafficEnabled() {
-    static const auto method = javaClassStatic()->getMethod<jboolean()>("getTrafficEnabled");
+  std::optional<RNMapUiSettings> JHybridRNGoogleMapsPlusViewSpec::getUiSettings() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNMapUiSettings>()>("getUiSettings");
     auto __result = method(_javaPart);
-    return static_cast<bool>(__result);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setTrafficEnabled(bool trafficEnabled) {
-    static const auto method = javaClassStatic()->getMethod<void(jboolean /* trafficEnabled */)>("setTrafficEnabled");
-    method(_javaPart, trafficEnabled);
+  void JHybridRNGoogleMapsPlusViewSpec::setUiSettings(const std::optional<RNMapUiSettings>& uiSettings) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNMapUiSettings> /* uiSettings */)>("setUiSettings");
+    method(_javaPart, uiSettings.has_value() ? JRNMapUiSettings::fromCpp(uiSettings.value()) : nullptr);
   }
-  std::string JHybridRNGoogleMapsPlusViewSpec::getCustomMapStyle() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCustomMapStyle");
+  std::optional<bool> JHybridRNGoogleMapsPlusViewSpec::getMyLocationEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getMyLocationEnabled");
     auto __result = method(_javaPart);
-    return __result->toStdString();
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setCustomMapStyle(const std::string& customMapStyle) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* customMapStyle */)>("setCustomMapStyle");
-    method(_javaPart, jni::make_jstring(customMapStyle));
+  void JHybridRNGoogleMapsPlusViewSpec::setMyLocationEnabled(std::optional<bool> myLocationEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* myLocationEnabled */)>("setMyLocationEnabled");
+    method(_javaPart, myLocationEnabled.has_value() ? jni::JBoolean::valueOf(myLocationEnabled.value()) : nullptr);
+  }
+  std::optional<bool> JHybridRNGoogleMapsPlusViewSpec::getBuildingEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getBuildingEnabled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setBuildingEnabled(std::optional<bool> buildingEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* buildingEnabled */)>("setBuildingEnabled");
+    method(_javaPart, buildingEnabled.has_value() ? jni::JBoolean::valueOf(buildingEnabled.value()) : nullptr);
+  }
+  std::optional<bool> JHybridRNGoogleMapsPlusViewSpec::getTrafficEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getTrafficEnabled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setTrafficEnabled(std::optional<bool> trafficEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* trafficEnabled */)>("setTrafficEnabled");
+    method(_javaPart, trafficEnabled.has_value() ? jni::JBoolean::valueOf(trafficEnabled.value()) : nullptr);
   }
-  RNCamera JHybridRNGoogleMapsPlusViewSpec::getInitialCamera() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNCamera>()>("getInitialCamera");
+  std::optional<bool> JHybridRNGoogleMapsPlusViewSpec::getIndoorEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getIndoorEnabled");
     auto __result = method(_javaPart);
-    return __result->toCpp();
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setInitialCamera(const RNCamera& initialCamera) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNCamera> /* initialCamera */)>("setInitialCamera");
-    method(_javaPart, JRNCamera::fromCpp(initialCamera));
+  void JHybridRNGoogleMapsPlusViewSpec::setIndoorEnabled(std::optional<bool> indoorEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* indoorEnabled */)>("setIndoorEnabled");
+    method(_javaPart, indoorEnabled.has_value() ? jni::JBoolean::valueOf(indoorEnabled.value()) : nullptr);
   }
-  RNUserInterfaceStyle JHybridRNGoogleMapsPlusViewSpec::getUserInterfaceStyle() {
+  std::optional<std::string> JHybridRNGoogleMapsPlusViewSpec::getCustomMapStyle() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCustomMapStyle");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setCustomMapStyle(const std::optional<std::string>& customMapStyle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* customMapStyle */)>("setCustomMapStyle");
+    method(_javaPart, customMapStyle.has_value() ? jni::make_jstring(customMapStyle.value()) : nullptr);
+  }
+  std::optional<RNUserInterfaceStyle> JHybridRNGoogleMapsPlusViewSpec::getUserInterfaceStyle() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNUserInterfaceStyle>()>("getUserInterfaceStyle");
     auto __result = method(_javaPart);
-    return __result->toCpp();
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setUserInterfaceStyle(RNUserInterfaceStyle userInterfaceStyle) {
+  void JHybridRNGoogleMapsPlusViewSpec::setUserInterfaceStyle(std::optional<RNUserInterfaceStyle> userInterfaceStyle) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNUserInterfaceStyle> /* userInterfaceStyle */)>("setUserInterfaceStyle");
-    method(_javaPart, JRNUserInterfaceStyle::fromCpp(userInterfaceStyle));
+    method(_javaPart, userInterfaceStyle.has_value() ? JRNUserInterfaceStyle::fromCpp(userInterfaceStyle.value()) : nullptr);
   }
-  double JHybridRNGoogleMapsPlusViewSpec::getMinZoomLevel() {
-    static const auto method = javaClassStatic()->getMethod<double()>("getMinZoomLevel");
+  std::optional<double> JHybridRNGoogleMapsPlusViewSpec::getMinZoomLevel() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMinZoomLevel");
     auto __result = method(_javaPart);
-    return __result;
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setMinZoomLevel(double minZoomLevel) {
-    static const auto method = javaClassStatic()->getMethod<void(double /* minZoomLevel */)>("setMinZoomLevel");
-    method(_javaPart, minZoomLevel);
+  void JHybridRNGoogleMapsPlusViewSpec::setMinZoomLevel(std::optional<double> minZoomLevel) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* minZoomLevel */)>("setMinZoomLevel");
+    method(_javaPart, minZoomLevel.has_value() ? jni::JDouble::valueOf(minZoomLevel.value()) : nullptr);
   }
-  double JHybridRNGoogleMapsPlusViewSpec::getMaxZoomLevel() {
-    static const auto method = javaClassStatic()->getMethod<double()>("getMaxZoomLevel");
+  std::optional<double> JHybridRNGoogleMapsPlusViewSpec::getMaxZoomLevel() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxZoomLevel");
     auto __result = method(_javaPart);
-    return __result;
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setMaxZoomLevel(double maxZoomLevel) {
-    static const auto method = javaClassStatic()->getMethod<void(double /* maxZoomLevel */)>("setMaxZoomLevel");
-    method(_javaPart, maxZoomLevel);
+  void JHybridRNGoogleMapsPlusViewSpec::setMaxZoomLevel(std::optional<double> maxZoomLevel) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxZoomLevel */)>("setMaxZoomLevel");
+    method(_javaPart, maxZoomLevel.has_value() ? jni::JDouble::valueOf(maxZoomLevel.value()) : nullptr);
   }
-  RNMapPadding JHybridRNGoogleMapsPlusViewSpec::getMapPadding() {
+  std::optional<RNMapPadding> JHybridRNGoogleMapsPlusViewSpec::getMapPadding() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNMapPadding>()>("getMapPadding");
     auto __result = method(_javaPart);
-    return __result->toCpp();
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setMapPadding(const RNMapPadding& mapPadding) {
+  void JHybridRNGoogleMapsPlusViewSpec::setMapPadding(const std::optional<RNMapPadding>& mapPadding) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNMapPadding> /* mapPadding */)>("setMapPadding");
-    method(_javaPart, JRNMapPadding::fromCpp(mapPadding));
+    method(_javaPart, mapPadding.has_value() ? JRNMapPadding::fromCpp(mapPadding.value()) : nullptr);
   }
-  std::vector<RNMarker> JHybridRNGoogleMapsPlusViewSpec::getMarkers() {
+  std::optional<RNMapType> JHybridRNGoogleMapsPlusViewSpec::getMapType() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNMapType>()>("getMapType");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setMapType(std::optional<RNMapType> mapType) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNMapType> /* mapType */)>("setMapType");
+    method(_javaPart, mapType.has_value() ? JRNMapType::fromCpp(mapType.value()) : nullptr);
+  }
+  std::optional<std::vector<RNMarker>> JHybridRNGoogleMapsPlusViewSpec::getMarkers() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNMarker>>()>("getMarkers");
     auto __result = method(_javaPart);
-    return [&]() {
+    return __result != nullptr ? std::make_optional([&]() {
       size_t __size = __result->size();
       std::vector<RNMarker> __vector;
       __vector.reserve(__size);
@@ -197,24 +269,24 @@ namespace margelo::nitro::rngooglemapsplus {
         __vector.push_back(__element->toCpp());
       }
       return __vector;
-    }();
+    }()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setMarkers(const std::vector<RNMarker>& markers) {
+  void JHybridRNGoogleMapsPlusViewSpec::setMarkers(const std::optional<std::vector<RNMarker>>& markers) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNMarker>> /* markers */)>("setMarkers");
-    method(_javaPart, [&]() {
-      size_t __size = markers.size();
+    method(_javaPart, markers.has_value() ? [&]() {
+      size_t __size = markers.value().size();
       jni::local_ref<jni::JArrayClass<JRNMarker>> __array = jni::JArrayClass<JRNMarker>::newArray(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        const auto& __element = markers[__i];
+        const auto& __element = markers.value()[__i];
         __array->setElement(__i, *JRNMarker::fromCpp(__element));
       }
       return __array;
-    }());
+    }() : nullptr);
   }
-  std::vector<RNPolygon> JHybridRNGoogleMapsPlusViewSpec::getPolygons() {
+  std::optional<std::vector<RNPolygon>> JHybridRNGoogleMapsPlusViewSpec::getPolygons() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNPolygon>>()>("getPolygons");
     auto __result = method(_javaPart);
-    return [&]() {
+    return __result != nullptr ? std::make_optional([&]() {
       size_t __size = __result->size();
       std::vector<RNPolygon> __vector;
       __vector.reserve(__size);
@@ -223,24 +295,24 @@ namespace margelo::nitro::rngooglemapsplus {
         __vector.push_back(__element->toCpp());
       }
       return __vector;
-    }();
+    }()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setPolygons(const std::vector<RNPolygon>& polygons) {
+  void JHybridRNGoogleMapsPlusViewSpec::setPolygons(const std::optional<std::vector<RNPolygon>>& polygons) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNPolygon>> /* polygons */)>("setPolygons");
-    method(_javaPart, [&]() {
-      size_t __size = polygons.size();
+    method(_javaPart, polygons.has_value() ? [&]() {
+      size_t __size = polygons.value().size();
       jni::local_ref<jni::JArrayClass<JRNPolygon>> __array = jni::JArrayClass<JRNPolygon>::newArray(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        const auto& __element = polygons[__i];
+        const auto& __element = polygons.value()[__i];
         __array->setElement(__i, *JRNPolygon::fromCpp(__element));
       }
       return __array;
-    }());
+    }() : nullptr);
   }
-  std::vector<RNPolyline> JHybridRNGoogleMapsPlusViewSpec::getPolylines() {
+  std::optional<std::vector<RNPolyline>> JHybridRNGoogleMapsPlusViewSpec::getPolylines() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNPolyline>>()>("getPolylines");
     auto __result = method(_javaPart);
-    return [&]() {
+    return __result != nullptr ? std::make_optional([&]() {
       size_t __size = __result->size();
       std::vector<RNPolyline> __vector;
       __vector.reserve(__size);
@@ -249,19 +321,54 @@ namespace margelo::nitro::rngooglemapsplus {
         __vector.push_back(__element->toCpp());
       }
       return __vector;
-    }();
+    }()) : std::nullopt;
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setPolylines(const std::vector<RNPolyline>& polylines) {
+  void JHybridRNGoogleMapsPlusViewSpec::setPolylines(const std::optional<std::vector<RNPolyline>>& polylines) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNPolyline>> /* polylines */)>("setPolylines");
-    method(_javaPart, [&]() {
-      size_t __size = polylines.size();
+    method(_javaPart, polylines.has_value() ? [&]() {
+      size_t __size = polylines.value().size();
       jni::local_ref<jni::JArrayClass<JRNPolyline>> __array = jni::JArrayClass<JRNPolyline>::newArray(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        const auto& __element = polylines[__i];
+        const auto& __element = polylines.value()[__i];
         __array->setElement(__i, *JRNPolyline::fromCpp(__element));
       }
       return __array;
-    }());
+    }() : nullptr);
+  }
+  std::optional<std::vector<RNCircle>> JHybridRNGoogleMapsPlusViewSpec::getCircles() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNCircle>>()>("getCircles");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<RNCircle> __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 JHybridRNGoogleMapsPlusViewSpec::setCircles(const std::optional<std::vector<RNCircle>>& circles) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNCircle>> /* circles */)>("setCircles");
+    method(_javaPart, circles.has_value() ? [&]() {
+      size_t __size = circles.value().size();
+      jni::local_ref<jni::JArrayClass<JRNCircle>> __array = jni::JArrayClass<JRNCircle>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = circles.value()[__i];
+        __array->setElement(__i, *JRNCircle::fromCpp(__element));
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::optional<RNLocationConfig> JHybridRNGoogleMapsPlusViewSpec::getLocationConfig() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNLocationConfig>()>("getLocationConfig");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setLocationConfig(const std::optional<RNLocationConfig>& locationConfig) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNLocationConfig> /* locationConfig */)>("setLocationConfig");
+    method(_javaPart, locationConfig.has_value() ? JRNLocationConfig::fromCpp(locationConfig.value()) : nullptr);
   }
   std::optional<std::function<void(RNMapErrorCode /* error */)>> JHybridRNGoogleMapsPlusViewSpec::getOnMapError() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNMapErrorCode::javaobject>()>("getOnMapError_cxx");
@@ -377,6 +484,63 @@ namespace margelo::nitro::rngooglemapsplus {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onMarkerPress */)>("setOnMarkerPress_cxx");
     method(_javaPart, onMarkerPress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onMarkerPress.value()) : nullptr);
   }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridRNGoogleMapsPlusViewSpec::getOnPolylinePress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnPolylinePress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* id */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](std::string id) -> void {
+          return __resultRef->invoke(id);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setOnPolylinePress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolylinePress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onPolylinePress */)>("setOnPolylinePress_cxx");
+    method(_javaPart, onPolylinePress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onPolylinePress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridRNGoogleMapsPlusViewSpec::getOnPolygonPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnPolygonPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* id */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](std::string id) -> void {
+          return __resultRef->invoke(id);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setOnPolygonPress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolygonPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onPolygonPress */)>("setOnPolygonPress_cxx");
+    method(_javaPart, onPolygonPress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onPolygonPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridRNGoogleMapsPlusViewSpec::getOnCirclePress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnCirclePress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* id */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](std::string id) -> void {
+          return __resultRef->invoke(id);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setOnCirclePress(const std::optional<std::function<void(const std::string& /* id */)>>& onCirclePress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onCirclePress */)>("setOnCirclePress_cxx");
+    method(_javaPart, onCirclePress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onCirclePress.value()) : nullptr);
+  }
   std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> JHybridRNGoogleMapsPlusViewSpec::getOnCameraChangeStart() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject>()>("getOnCameraChangeStart_cxx");
     auto __result = method(_javaPart);

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

@@ -49,28 +49,40 @@ namespace margelo::nitro::rngooglemapsplus {
 
   public:
     // Properties
-    bool getBuildingEnabled() override;
-    void setBuildingEnabled(bool buildingEnabled) override;
-    bool getTrafficEnabled() override;
-    void setTrafficEnabled(bool trafficEnabled) override;
-    std::string getCustomMapStyle() override;
-    void setCustomMapStyle(const std::string& customMapStyle) override;
-    RNCamera getInitialCamera() override;
-    void setInitialCamera(const RNCamera& initialCamera) override;
-    RNUserInterfaceStyle getUserInterfaceStyle() override;
-    void setUserInterfaceStyle(RNUserInterfaceStyle userInterfaceStyle) override;
-    double getMinZoomLevel() override;
-    void setMinZoomLevel(double minZoomLevel) override;
-    double getMaxZoomLevel() override;
-    void setMaxZoomLevel(double maxZoomLevel) override;
-    RNMapPadding getMapPadding() override;
-    void setMapPadding(const RNMapPadding& mapPadding) override;
-    std::vector<RNMarker> getMarkers() override;
-    void setMarkers(const std::vector<RNMarker>& markers) override;
-    std::vector<RNPolygon> getPolygons() override;
-    void setPolygons(const std::vector<RNPolygon>& polygons) override;
-    std::vector<RNPolyline> getPolylines() override;
-    void setPolylines(const std::vector<RNPolyline>& polylines) override;
+    std::optional<RNInitialProps> getInitialProps() override;
+    void setInitialProps(const std::optional<RNInitialProps>& initialProps) override;
+    std::optional<RNMapUiSettings> getUiSettings() override;
+    void setUiSettings(const std::optional<RNMapUiSettings>& uiSettings) override;
+    std::optional<bool> getMyLocationEnabled() override;
+    void setMyLocationEnabled(std::optional<bool> myLocationEnabled) 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<bool> getIndoorEnabled() override;
+    void setIndoorEnabled(std::optional<bool> indoorEnabled) 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<RNLocationConfig> getLocationConfig() override;
+    void setLocationConfig(const std::optional<RNLocationConfig>& locationConfig) 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;
@@ -83,6 +95,12 @@ namespace margelo::nitro::rngooglemapsplus {
     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;

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

@@ -0,0 +1,63 @@
+///
+/// JRNAndroidLocationConfig.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 "RNAndroidLocationConfig.hpp"
+
+#include "JRNAndroidLocationPriority.hpp"
+#include "RNAndroidLocationPriority.hpp"
+#include <optional>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNAndroidLocationConfig" and the the Kotlin data class "RNAndroidLocationConfig".
+   */
+  struct JRNAndroidLocationConfig final: public jni::JavaClass<JRNAndroidLocationConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNAndroidLocationConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNAndroidLocationConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNAndroidLocationConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPriority = clazz->getField<JRNAndroidLocationPriority>("priority");
+      jni::local_ref<JRNAndroidLocationPriority> priority = this->getFieldValue(fieldPriority);
+      static const auto fieldInterval = clazz->getField<jni::JDouble>("interval");
+      jni::local_ref<jni::JDouble> interval = this->getFieldValue(fieldInterval);
+      static const auto fieldMinUpdateInterval = clazz->getField<jni::JDouble>("minUpdateInterval");
+      jni::local_ref<jni::JDouble> minUpdateInterval = this->getFieldValue(fieldMinUpdateInterval);
+      return RNAndroidLocationConfig(
+        priority != nullptr ? std::make_optional(priority->toCpp()) : std::nullopt,
+        interval != nullptr ? std::make_optional(interval->value()) : std::nullopt,
+        minUpdateInterval != nullptr ? std::make_optional(minUpdateInterval->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<JRNAndroidLocationConfig::javaobject> fromCpp(const RNAndroidLocationConfig& value) {
+      return newInstance(
+        value.priority.has_value() ? JRNAndroidLocationPriority::fromCpp(value.priority.value()) : nullptr,
+        value.interval.has_value() ? jni::JDouble::valueOf(value.interval.value()) : nullptr,
+        value.minUpdateInterval.has_value() ? jni::JDouble::valueOf(value.minUpdateInterval.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus