react-native-google-maps-plus 1.3.0-dev.1 → 1.3.0-dev.3

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

@@ -63,6 +63,10 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNMapErrorCode; }
 namespace margelo::nitro::rngooglemapsplus { struct RNLocation; }
 // Forward declaration of `RNLocationErrorCode` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNLocationErrorCode; }
+// Forward declaration of `RNIndoorBuilding` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorBuilding; }
+// Forward declaration of `RNIndoorLevel` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorLevel; }
 // Forward declaration of `RNRegion` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNRegion; }
 // Forward declaration of `RNLocationPermissionResult` to properly resolve imports.
@@ -71,6 +75,16 @@ namespace margelo::nitro::rngooglemapsplus { struct RNLocationPermissionResult;
 namespace margelo::nitro::rngooglemapsplus { enum class RNAndroidLocationPermissionResult; }
 // Forward declaration of `RNIOSPermissionResult` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
+// Forward declaration of `RNLatLngBounds` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNLatLngBounds; }
+// Forward declaration of `RNSnapshotOptions` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSnapshotOptions; }
+// Forward declaration of `RNSize` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSize; }
+// Forward declaration of `RNSnapshotFormat` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNSnapshotFormat; }
+// Forward declaration of `RNSnapshotResultType` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNSnapshotResultType; }
 
 #include "RNInitialProps.hpp"
 #include <optional>
@@ -139,17 +153,33 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
 #include "JFunc_void_RNLatLng.hpp"
 #include "JFunc_void_std__optional_std__string_.hpp"
 #include "JFunc_void_std__optional_std__string__RNLatLng.hpp"
+#include "RNIndoorBuilding.hpp"
+#include "JFunc_void_RNIndoorBuilding.hpp"
+#include "JRNIndoorBuilding.hpp"
+#include "RNIndoorLevel.hpp"
+#include "JRNIndoorLevel.hpp"
+#include "JFunc_void_RNIndoorLevel.hpp"
 #include "RNRegion.hpp"
 #include "JFunc_void_RNRegion_RNCamera_bool.hpp"
 #include "JRNRegion.hpp"
-#include "RNLocationPermissionResult.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
+#include "RNLocationPermissionResult.hpp"
 #include "JRNLocationPermissionResult.hpp"
 #include "RNAndroidLocationPermissionResult.hpp"
 #include "JRNAndroidLocationPermissionResult.hpp"
 #include "RNIOSPermissionResult.hpp"
 #include "JRNIOSPermissionResult.hpp"
+#include "RNLatLngBounds.hpp"
+#include "JRNLatLngBounds.hpp"
+#include "RNSnapshotOptions.hpp"
+#include "JRNSnapshotOptions.hpp"
+#include "RNSize.hpp"
+#include "JRNSize.hpp"
+#include "RNSnapshotFormat.hpp"
+#include "JRNSnapshotFormat.hpp"
+#include "RNSnapshotResultType.hpp"
+#include "JRNSnapshotResultType.hpp"
 
 namespace margelo::nitro::rngooglemapsplus {
 
@@ -666,6 +696,44 @@ namespace margelo::nitro::rngooglemapsplus {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__optional_std__string__RNLatLng::javaobject> /* onMarkerDragEnd */)>("setOnMarkerDragEnd_cxx");
     method(_javaPart, onMarkerDragEnd.has_value() ? JFunc_void_std__optional_std__string__RNLatLng_cxx::fromCpp(onMarkerDragEnd.value()) : nullptr);
   }
+  std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>> JHybridRNGoogleMapsPlusViewSpec::getOnIndoorBuildingFocused() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNIndoorBuilding::javaobject>()>("getOnIndoorBuildingFocused_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNIndoorBuilding& /* indoorBuilding */)> {
+      if (__result->isInstanceOf(JFunc_void_RNIndoorBuilding_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNIndoorBuilding_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNIndoorBuilding indoorBuilding) -> void {
+          return __resultRef->invoke(indoorBuilding);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setOnIndoorBuildingFocused(const std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>& onIndoorBuildingFocused) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNIndoorBuilding::javaobject> /* onIndoorBuildingFocused */)>("setOnIndoorBuildingFocused_cxx");
+    method(_javaPart, onIndoorBuildingFocused.has_value() ? JFunc_void_RNIndoorBuilding_cxx::fromCpp(onIndoorBuildingFocused.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>> JHybridRNGoogleMapsPlusViewSpec::getOnIndoorLevelActivated() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNIndoorLevel::javaobject>()>("getOnIndoorLevelActivated_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNIndoorLevel& /* indoorLevel */)> {
+      if (__result->isInstanceOf(JFunc_void_RNIndoorLevel_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNIndoorLevel_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNIndoorLevel indoorLevel) -> void {
+          return __resultRef->invoke(indoorLevel);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setOnIndoorLevelActivated(const std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>& onIndoorLevelActivated) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNIndoorLevel::javaobject> /* onIndoorLevelActivated */)>("setOnIndoorLevelActivated_cxx");
+    method(_javaPart, onIndoorLevelActivated.has_value() ? JFunc_void_RNIndoorLevel_cxx::fromCpp(onIndoorLevelActivated.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);
@@ -725,12 +793,12 @@ namespace margelo::nitro::rngooglemapsplus {
   }
 
   // Methods
-  void JHybridRNGoogleMapsPlusViewSpec::setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMS) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNCamera> /* camera */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JDouble> /* durationMS */)>("setCamera");
-    method(_javaPart, JRNCamera::fromCpp(camera), animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, durationMS.has_value() ? jni::JDouble::valueOf(durationMS.value()) : nullptr);
+  void JHybridRNGoogleMapsPlusViewSpec::setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMs) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNCamera> /* camera */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JDouble> /* durationMs */)>("setCamera");
+    method(_javaPart, JRNCamera::fromCpp(camera), animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, durationMs.has_value() ? jni::JDouble::valueOf(durationMs.value()) : nullptr);
   }
-  void JHybridRNGoogleMapsPlusViewSpec::setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMS) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNLatLng>> /* coordinates */, jni::alias_ref<JRNMapPadding> /* padding */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JDouble> /* durationMS */)>("setCameraToCoordinates");
+  void JHybridRNGoogleMapsPlusViewSpec::setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMs) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNLatLng>> /* coordinates */, jni::alias_ref<JRNMapPadding> /* padding */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JDouble> /* durationMs */)>("setCameraToCoordinates");
     method(_javaPart, [&]() {
       size_t __size = coordinates.size();
       jni::local_ref<jni::JArrayClass<JRNLatLng>> __array = jni::JArrayClass<JRNLatLng>::newArray(__size);
@@ -739,7 +807,31 @@ namespace margelo::nitro::rngooglemapsplus {
         __array->setElement(__i, *JRNLatLng::fromCpp(__element));
       }
       return __array;
-    }(), padding.has_value() ? JRNMapPadding::fromCpp(padding.value()) : nullptr, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, durationMS.has_value() ? jni::JDouble::valueOf(durationMS.value()) : nullptr);
+    }(), padding.has_value() ? JRNMapPadding::fromCpp(padding.value()) : nullptr, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, durationMs.has_value() ? jni::JDouble::valueOf(durationMs.value()) : nullptr);
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::setCameraBounds(const std::optional<RNLatLngBounds>& bounds) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNLatLngBounds> /* bounds */)>("setCameraBounds");
+    method(_javaPart, bounds.has_value() ? JRNLatLngBounds::fromCpp(bounds.value()) : nullptr);
+  }
+  void JHybridRNGoogleMapsPlusViewSpec::animateToBounds(const RNLatLngBounds& bounds, std::optional<double> padding, std::optional<double> durationMs, std::optional<bool> lockBounds) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNLatLngBounds> /* bounds */, jni::alias_ref<jni::JDouble> /* padding */, jni::alias_ref<jni::JDouble> /* durationMs */, jni::alias_ref<jni::JBoolean> /* lockBounds */)>("animateToBounds");
+    method(_javaPart, JRNLatLngBounds::fromCpp(bounds), padding.has_value() ? jni::JDouble::valueOf(padding.value()) : nullptr, durationMs.has_value() ? jni::JDouble::valueOf(durationMs.value()) : nullptr, lockBounds.has_value() ? jni::JBoolean::valueOf(lockBounds.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<std::optional<std::string>>> JHybridRNGoogleMapsPlusViewSpec::snapshot(const RNSnapshotOptions& options) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JRNSnapshotOptions> /* options */)>("snapshot");
+    auto __result = method(_javaPart, JRNSnapshotOptions::fromCpp(options));
+    return [&]() {
+      auto __promise = Promise<std::optional<std::string>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt);
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   void JHybridRNGoogleMapsPlusViewSpec::showLocationDialog() {
     static const auto method = javaClassStatic()->getMethod<void()>("showLocationDialog");

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

@@ -109,6 +109,10 @@ namespace margelo::nitro::rngooglemapsplus {
     void setOnMarkerDrag(const std::optional<std::function<void(const std::optional<std::string>& /* id */, const RNLatLng& /* location */)>>& onMarkerDrag) override;
     std::optional<std::function<void(const std::optional<std::string>& /* id */, const RNLatLng& /* location */)>> getOnMarkerDragEnd() override;
     void setOnMarkerDragEnd(const std::optional<std::function<void(const std::optional<std::string>& /* id */, const RNLatLng& /* location */)>>& onMarkerDragEnd) override;
+    std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>> getOnIndoorBuildingFocused() override;
+    void setOnIndoorBuildingFocused(const std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>& onIndoorBuildingFocused) override;
+    std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>> getOnIndoorLevelActivated() override;
+    void setOnIndoorLevelActivated(const std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>& onIndoorLevelActivated) 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;
@@ -118,8 +122,11 @@ namespace margelo::nitro::rngooglemapsplus {
 
   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 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 setCameraBounds(const std::optional<RNLatLngBounds>& bounds) override;
+    void animateToBounds(const RNLatLngBounds& bounds, std::optional<double> padding, std::optional<double> durationMs, std::optional<bool> lockBounds) override;
+    std::shared_ptr<Promise<std::optional<std::string>>> snapshot(const RNSnapshotOptions& options) override;
     void showLocationDialog() override;
     void openLocationSettings() override;
     std::shared_ptr<Promise<RNLocationPermissionResult>> requestLocationPermission() override;

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

@@ -0,0 +1,86 @@
+///
+/// JRNIndoorBuilding.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 "RNIndoorBuilding.hpp"
+
+#include "JRNIndoorLevel.hpp"
+#include "RNIndoorLevel.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNIndoorBuilding" and the the Kotlin data class "RNIndoorBuilding".
+   */
+  struct JRNIndoorBuilding final: public jni::JavaClass<JRNIndoorBuilding> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNIndoorBuilding;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNIndoorBuilding by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNIndoorBuilding toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldActiveLevelIndex = clazz->getField<jni::JDouble>("activeLevelIndex");
+      jni::local_ref<jni::JDouble> activeLevelIndex = this->getFieldValue(fieldActiveLevelIndex);
+      static const auto fieldDefaultLevelIndex = clazz->getField<jni::JDouble>("defaultLevelIndex");
+      jni::local_ref<jni::JDouble> defaultLevelIndex = this->getFieldValue(fieldDefaultLevelIndex);
+      static const auto fieldLevels = clazz->getField<jni::JArrayClass<JRNIndoorLevel>>("levels");
+      jni::local_ref<jni::JArrayClass<JRNIndoorLevel>> levels = this->getFieldValue(fieldLevels);
+      static const auto fieldUnderground = clazz->getField<jni::JBoolean>("underground");
+      jni::local_ref<jni::JBoolean> underground = this->getFieldValue(fieldUnderground);
+      return RNIndoorBuilding(
+        activeLevelIndex != nullptr ? std::make_optional(activeLevelIndex->value()) : std::nullopt,
+        defaultLevelIndex != nullptr ? std::make_optional(defaultLevelIndex->value()) : std::nullopt,
+        [&]() {
+          size_t __size = levels->size();
+          std::vector<RNIndoorLevel> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = levels->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        underground != nullptr ? std::make_optional(static_cast<bool>(underground->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<JRNIndoorBuilding::javaobject> fromCpp(const RNIndoorBuilding& value) {
+      return newInstance(
+        value.activeLevelIndex.has_value() ? jni::JDouble::valueOf(value.activeLevelIndex.value()) : nullptr,
+        value.defaultLevelIndex.has_value() ? jni::JDouble::valueOf(value.defaultLevelIndex.value()) : nullptr,
+        [&]() {
+          size_t __size = value.levels.size();
+          jni::local_ref<jni::JArrayClass<JRNIndoorLevel>> __array = jni::JArrayClass<JRNIndoorLevel>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.levels[__i];
+            __array->setElement(__i, *JRNIndoorLevel::fromCpp(__element));
+          }
+          return __array;
+        }(),
+        value.underground.has_value() ? jni::JBoolean::valueOf(value.underground.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,66 @@
+///
+/// JRNIndoorLevel.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 "RNIndoorLevel.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNIndoorLevel" and the the Kotlin data class "RNIndoorLevel".
+   */
+  struct JRNIndoorLevel final: public jni::JavaClass<JRNIndoorLevel> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNIndoorLevel;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNIndoorLevel by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNIndoorLevel toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIndex = clazz->getField<double>("index");
+      double index = this->getFieldValue(fieldIndex);
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldShortName = clazz->getField<jni::JString>("shortName");
+      jni::local_ref<jni::JString> shortName = this->getFieldValue(fieldShortName);
+      static const auto fieldActive = clazz->getField<jni::JBoolean>("active");
+      jni::local_ref<jni::JBoolean> active = this->getFieldValue(fieldActive);
+      return RNIndoorLevel(
+        index,
+        name != nullptr ? std::make_optional(name->toStdString()) : std::nullopt,
+        shortName != nullptr ? std::make_optional(shortName->toStdString()) : std::nullopt,
+        active != nullptr ? std::make_optional(static_cast<bool>(active->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<JRNIndoorLevel::javaobject> fromCpp(const RNIndoorLevel& value) {
+      return newInstance(
+        value.index,
+        value.name.has_value() ? jni::make_jstring(value.name.value()) : nullptr,
+        value.shortName.has_value() ? jni::make_jstring(value.shortName.value()) : nullptr,
+        value.active.has_value() ? jni::JBoolean::valueOf(value.active.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

@@ -0,0 +1,58 @@
+///
+/// JRNLatLngBounds.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 "RNLatLngBounds.hpp"
+
+#include "JRNLatLng.hpp"
+#include "RNLatLng.hpp"
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNLatLngBounds" and the the Kotlin data class "RNLatLngBounds".
+   */
+  struct JRNLatLngBounds final: public jni::JavaClass<JRNLatLngBounds> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNLatLngBounds;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNLatLngBounds by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNLatLngBounds toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNorthEast = clazz->getField<JRNLatLng>("northEast");
+      jni::local_ref<JRNLatLng> northEast = this->getFieldValue(fieldNorthEast);
+      static const auto fieldSouthWest = clazz->getField<JRNLatLng>("southWest");
+      jni::local_ref<JRNLatLng> southWest = this->getFieldValue(fieldSouthWest);
+      return RNLatLngBounds(
+        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<JRNLatLngBounds::javaobject> fromCpp(const RNLatLngBounds& value) {
+      return newInstance(
+        JRNLatLng::fromCpp(value.northEast),
+        JRNLatLng::fromCpp(value.southWest)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

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

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

@@ -0,0 +1,62 @@
+///
+/// JRNSnapshotFormat.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 "RNSnapshotFormat.hpp"
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RNSnapshotFormat" and the the Kotlin enum "RNSnapshotFormat".
+   */
+  struct JRNSnapshotFormat final: public jni::JavaClass<JRNSnapshotFormat> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNSnapshotFormat;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RNSnapshotFormat.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNSnapshotFormat toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RNSnapshotFormat>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRNSnapshotFormat> fromCpp(RNSnapshotFormat value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPNG = clazz->getStaticField<JRNSnapshotFormat>("PNG");
+      static const auto fieldJPG = clazz->getStaticField<JRNSnapshotFormat>("JPG");
+      static const auto fieldJPEG = clazz->getStaticField<JRNSnapshotFormat>("JPEG");
+      
+      switch (value) {
+        case RNSnapshotFormat::PNG:
+          return clazz->getStaticFieldValue(fieldPNG);
+        case RNSnapshotFormat::JPG:
+          return clazz->getStaticFieldValue(fieldJPG);
+        case RNSnapshotFormat::JPEG:
+          return clazz->getStaticFieldValue(fieldJPEG);
+        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++/JRNSnapshotOptions.hpp

@@ -0,0 +1,71 @@
+///
+/// JRNSnapshotOptions.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 "RNSnapshotOptions.hpp"
+
+#include "JRNSize.hpp"
+#include "JRNSnapshotFormat.hpp"
+#include "JRNSnapshotResultType.hpp"
+#include "RNSize.hpp"
+#include "RNSnapshotFormat.hpp"
+#include "RNSnapshotResultType.hpp"
+#include <optional>
+
+namespace margelo::nitro::rngooglemapsplus {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RNSnapshotOptions" and the the Kotlin data class "RNSnapshotOptions".
+   */
+  struct JRNSnapshotOptions final: public jni::JavaClass<JRNSnapshotOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/rngooglemapsplus/RNSnapshotOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RNSnapshotOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNSnapshotOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSize = clazz->getField<JRNSize>("size");
+      jni::local_ref<JRNSize> size = this->getFieldValue(fieldSize);
+      static const auto fieldFormat = clazz->getField<JRNSnapshotFormat>("format");
+      jni::local_ref<JRNSnapshotFormat> format = this->getFieldValue(fieldFormat);
+      static const auto fieldQuality = clazz->getField<double>("quality");
+      double quality = this->getFieldValue(fieldQuality);
+      static const auto fieldResultType = clazz->getField<JRNSnapshotResultType>("resultType");
+      jni::local_ref<JRNSnapshotResultType> resultType = this->getFieldValue(fieldResultType);
+      return RNSnapshotOptions(
+        size != nullptr ? std::make_optional(size->toCpp()) : std::nullopt,
+        format->toCpp(),
+        quality,
+        resultType->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<JRNSnapshotOptions::javaobject> fromCpp(const RNSnapshotOptions& value) {
+      return newInstance(
+        value.size.has_value() ? JRNSize::fromCpp(value.size.value()) : nullptr,
+        JRNSnapshotFormat::fromCpp(value.format),
+        value.quality,
+        JRNSnapshotResultType::fromCpp(value.resultType)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rngooglemapsplus

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

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