react-native-nitro-geolocation 0.1.1 → 0.2.0

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

@@ -7,41 +7,51 @@
 
 #include "JHybridNitroGeolocationSpec.hpp"
 
-// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
-// Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
-// Forward declaration of `LocationProviderInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { enum class LocationProviderInternal; }
-// Forward declaration of `GeolocationError` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
+// Forward declaration of `PermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
 // Forward declaration of `GeolocationResponse` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
 // Forward declaration of `GeolocationCoordinates` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
-// Forward declaration of `GeolocationOptions` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
+// Forward declaration of `ModernGeolocationConfiguration` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ModernGeolocationConfiguration; }
+// Forward declaration of `AuthorizationLevel` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevel; }
+// Forward declaration of `LocationProvider` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProvider; }
+// Forward declaration of `LocationRequestOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationRequestOptions; }
+// Forward declaration of `LocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationError; }
 
-#include "RNConfigurationInternal.hpp"
-#include "JRNConfigurationInternal.hpp"
-#include "AuthorizationLevelInternal.hpp"
-#include <optional>
-#include "JAuthorizationLevelInternal.hpp"
-#include "LocationProviderInternal.hpp"
-#include "JLocationProviderInternal.hpp"
-#include <functional>
-#include "JFunc_void.hpp"
-#include "GeolocationError.hpp"
-#include "JFunc_void_GeolocationError.hpp"
-#include "JGeolocationError.hpp"
-#include <string>
+#include "PermissionStatus.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JPermissionStatus.hpp"
 #include "GeolocationResponse.hpp"
-#include "JFunc_void_GeolocationResponse.hpp"
 #include "JGeolocationResponse.hpp"
 #include "GeolocationCoordinates.hpp"
 #include "JGeolocationCoordinates.hpp"
-#include "GeolocationOptions.hpp"
-#include "JGeolocationOptions.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+#include <string>
+#include "ModernGeolocationConfiguration.hpp"
+#include "JModernGeolocationConfiguration.hpp"
+#include "AuthorizationLevel.hpp"
+#include "JAuthorizationLevel.hpp"
+#include "LocationProvider.hpp"
+#include "JLocationProvider.hpp"
+#include "LocationRequestOptions.hpp"
+#include "JLocationRequestOptions.hpp"
+#include <functional>
+#include "JFunc_void_GeolocationResponse.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "LocationError.hpp"
+#include "JFunc_void_LocationError.hpp"
+#include "JLocationError.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -65,30 +75,76 @@ namespace margelo::nitro::nitrogeolocation {
     method(_javaPart);
   }
 
+  std::string JHybridNitroGeolocationSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
   // Properties
   
 
   // Methods
-  void JHybridNitroGeolocationSpec::setRNConfiguration(const RNConfigurationInternal& config) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNConfigurationInternal> /* config */)>("setRNConfiguration");
-    method(_javaPart, JRNConfigurationInternal::fromCpp(config));
+  void JHybridNitroGeolocationSpec::setConfiguration(const ModernGeolocationConfiguration& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JModernGeolocationConfiguration> /* config */)>("setConfiguration");
+    method(_javaPart, JModernGeolocationConfiguration::fromCpp(config));
+  }
+  std::shared_ptr<Promise<PermissionStatus>> JHybridNitroGeolocationSpec::checkPermission() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("checkPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<PermissionStatus>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionStatus>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  void JHybridNitroGeolocationSpec::requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* success */, jni::alias_ref<JFunc_void_GeolocationError::javaobject> /* error */)>("requestAuthorization_cxx");
-    method(_javaPart, success.has_value() ? JFunc_void_cxx::fromCpp(success.value()) : nullptr, error.has_value() ? JFunc_void_GeolocationError_cxx::fromCpp(error.value()) : nullptr);
+  std::shared_ptr<Promise<PermissionStatus>> JHybridNitroGeolocationSpec::requestPermission() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<PermissionStatus>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionStatus>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  void JHybridNitroGeolocationSpec::getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_GeolocationError::javaobject> /* error */, jni::alias_ref<JGeolocationOptions> /* options */)>("getCurrentPosition_cxx");
-    method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_GeolocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JGeolocationOptions::fromCpp(options.value()) : nullptr);
+  std::shared_ptr<Promise<GeolocationResponse>> JHybridNitroGeolocationSpec::getCurrentPosition(const std::optional<LocationRequestOptions>& options) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JLocationRequestOptions> /* options */)>("getCurrentPosition");
+    auto __result = method(_javaPart, options.has_value() ? JLocationRequestOptions::fromCpp(options.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<GeolocationResponse>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JGeolocationResponse>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  double JHybridNitroGeolocationSpec::watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) {
-    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_GeolocationError::javaobject> /* error */, jni::alias_ref<JGeolocationOptions> /* options */)>("watchPosition_cxx");
-    auto __result = method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_GeolocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JGeolocationOptions::fromCpp(options.value()) : nullptr);
-    return __result;
+  std::string JHybridNitroGeolocationSpec::watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */, jni::alias_ref<JLocationRequestOptions> /* options */)>("watchPosition_cxx");
+    auto __result = method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JLocationRequestOptions::fromCpp(options.value()) : nullptr);
+    return __result->toStdString();
   }
-  void JHybridNitroGeolocationSpec::clearWatch(double watchId) {
-    static const auto method = javaClassStatic()->getMethod<void(double /* watchId */)>("clearWatch");
-    method(_javaPart, watchId);
+  void JHybridNitroGeolocationSpec::unwatch(const std::string& token) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* token */)>("unwatch");
+    method(_javaPart, jni::make_jstring(token));
   }
   void JHybridNitroGeolocationSpec::stopObserving() {
     static const auto method = javaClassStatic()->getMethod<void()>("stopObserving");

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

@@ -41,6 +41,7 @@ namespace margelo::nitro::nitrogeolocation {
   public:
     size_t getExternalMemorySize() noexcept override;
     void dispose() noexcept override;
+    std::string toString() override;
 
   public:
     inline const jni::global_ref<JHybridNitroGeolocationSpec::javaobject>& getJavaPart() const noexcept {
@@ -53,11 +54,12 @@ namespace margelo::nitro::nitrogeolocation {
 
   public:
     // Methods
-    void setRNConfiguration(const RNConfigurationInternal& config) override;
-    void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) override;
-    void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override;
-    double watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override;
-    void clearWatch(double watchId) override;
+    void setConfiguration(const ModernGeolocationConfiguration& config) override;
+    std::shared_ptr<Promise<PermissionStatus>> checkPermission() override;
+    std::shared_ptr<Promise<PermissionStatus>> requestPermission() override;
+    std::shared_ptr<Promise<GeolocationResponse>> getCurrentPosition(const std::optional<LocationRequestOptions>& options) override;
+    std::string watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) override;
+    void unwatch(const std::string& token) override;
     void stopObserving() override;
 
   private:

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

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

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

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

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

@@ -41,16 +41,15 @@ namespace margelo::nitro::nitrogeolocation {
     [[maybe_unused]]
     static jni::alias_ref<JLocationProviderInternal> fromCpp(LocationProviderInternal value) {
       static const auto clazz = javaClassStatic();
-      static const auto fieldAUTO = clazz->getStaticField<JLocationProviderInternal>("AUTO");
-      static const auto fieldPLAYSERVICES = clazz->getStaticField<JLocationProviderInternal>("PLAYSERVICES");
-      static const auto fieldANDROID_PLATFORM = clazz->getStaticField<JLocationProviderInternal>("ANDROID_PLATFORM");
-      
       switch (value) {
         case LocationProviderInternal::AUTO:
+          static const auto fieldAUTO = clazz->getStaticField<JLocationProviderInternal>("AUTO");
           return clazz->getStaticFieldValue(fieldAUTO);
         case LocationProviderInternal::PLAYSERVICES:
+          static const auto fieldPLAYSERVICES = clazz->getStaticField<JLocationProviderInternal>("PLAYSERVICES");
           return clazz->getStaticFieldValue(fieldPLAYSERVICES);
         case LocationProviderInternal::ANDROID_PLATFORM:
+          static const auto fieldANDROID_PLATFORM = clazz->getStaticField<JLocationProviderInternal>("ANDROID_PLATFORM");
           return clazz->getStaticFieldValue(fieldANDROID_PLATFORM);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));

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

@@ -0,0 +1,81 @@
+///
+/// JLocationRequestOptions.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 "LocationRequestOptions.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LocationRequestOptions" and the the Kotlin data class "LocationRequestOptions".
+   */
+  struct JLocationRequestOptions final: public jni::JavaClass<JLocationRequestOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/LocationRequestOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LocationRequestOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationRequestOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTimeout = clazz->getField<jni::JDouble>("timeout");
+      jni::local_ref<jni::JDouble> timeout = this->getFieldValue(fieldTimeout);
+      static const auto fieldMaximumAge = clazz->getField<jni::JDouble>("maximumAge");
+      jni::local_ref<jni::JDouble> maximumAge = this->getFieldValue(fieldMaximumAge);
+      static const auto fieldEnableHighAccuracy = clazz->getField<jni::JBoolean>("enableHighAccuracy");
+      jni::local_ref<jni::JBoolean> enableHighAccuracy = this->getFieldValue(fieldEnableHighAccuracy);
+      static const auto fieldInterval = clazz->getField<jni::JDouble>("interval");
+      jni::local_ref<jni::JDouble> interval = this->getFieldValue(fieldInterval);
+      static const auto fieldFastestInterval = clazz->getField<jni::JDouble>("fastestInterval");
+      jni::local_ref<jni::JDouble> fastestInterval = this->getFieldValue(fieldFastestInterval);
+      static const auto fieldDistanceFilter = clazz->getField<jni::JDouble>("distanceFilter");
+      jni::local_ref<jni::JDouble> distanceFilter = this->getFieldValue(fieldDistanceFilter);
+      static const auto fieldUseSignificantChanges = clazz->getField<jni::JBoolean>("useSignificantChanges");
+      jni::local_ref<jni::JBoolean> useSignificantChanges = this->getFieldValue(fieldUseSignificantChanges);
+      return LocationRequestOptions(
+        timeout != nullptr ? std::make_optional(timeout->value()) : std::nullopt,
+        maximumAge != nullptr ? std::make_optional(maximumAge->value()) : std::nullopt,
+        enableHighAccuracy != nullptr ? std::make_optional(static_cast<bool>(enableHighAccuracy->value())) : std::nullopt,
+        interval != nullptr ? std::make_optional(interval->value()) : std::nullopt,
+        fastestInterval != nullptr ? std::make_optional(fastestInterval->value()) : std::nullopt,
+        distanceFilter != nullptr ? std::make_optional(distanceFilter->value()) : std::nullopt,
+        useSignificantChanges != nullptr ? std::make_optional(static_cast<bool>(useSignificantChanges->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<JLocationRequestOptions::javaobject> fromCpp(const LocationRequestOptions& value) {
+      using JSignature = JLocationRequestOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.timeout.has_value() ? jni::JDouble::valueOf(value.timeout.value()) : nullptr,
+        value.maximumAge.has_value() ? jni::JDouble::valueOf(value.maximumAge.value()) : nullptr,
+        value.enableHighAccuracy.has_value() ? jni::JBoolean::valueOf(value.enableHighAccuracy.value()) : nullptr,
+        value.interval.has_value() ? jni::JDouble::valueOf(value.interval.value()) : nullptr,
+        value.fastestInterval.has_value() ? jni::JDouble::valueOf(value.fastestInterval.value()) : nullptr,
+        value.distanceFilter.has_value() ? jni::JDouble::valueOf(value.distanceFilter.value()) : nullptr,
+        value.useSignificantChanges.has_value() ? jni::JBoolean::valueOf(value.useSignificantChanges.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,73 @@
+///
+/// JModernGeolocationConfiguration.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 "ModernGeolocationConfiguration.hpp"
+
+#include "AuthorizationLevel.hpp"
+#include "JAuthorizationLevel.hpp"
+#include "JLocationProvider.hpp"
+#include "LocationProvider.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ModernGeolocationConfiguration" and the the Kotlin data class "ModernGeolocationConfiguration".
+   */
+  struct JModernGeolocationConfiguration final: public jni::JavaClass<JModernGeolocationConfiguration> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/ModernGeolocationConfiguration;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ModernGeolocationConfiguration by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ModernGeolocationConfiguration toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAutoRequestPermission = clazz->getField<jni::JBoolean>("autoRequestPermission");
+      jni::local_ref<jni::JBoolean> autoRequestPermission = this->getFieldValue(fieldAutoRequestPermission);
+      static const auto fieldAuthorizationLevel = clazz->getField<JAuthorizationLevel>("authorizationLevel");
+      jni::local_ref<JAuthorizationLevel> authorizationLevel = this->getFieldValue(fieldAuthorizationLevel);
+      static const auto fieldEnableBackgroundLocationUpdates = clazz->getField<jni::JBoolean>("enableBackgroundLocationUpdates");
+      jni::local_ref<jni::JBoolean> enableBackgroundLocationUpdates = this->getFieldValue(fieldEnableBackgroundLocationUpdates);
+      static const auto fieldLocationProvider = clazz->getField<JLocationProvider>("locationProvider");
+      jni::local_ref<JLocationProvider> locationProvider = this->getFieldValue(fieldLocationProvider);
+      return ModernGeolocationConfiguration(
+        autoRequestPermission != nullptr ? std::make_optional(static_cast<bool>(autoRequestPermission->value())) : std::nullopt,
+        authorizationLevel != nullptr ? std::make_optional(authorizationLevel->toCpp()) : std::nullopt,
+        enableBackgroundLocationUpdates != nullptr ? std::make_optional(static_cast<bool>(enableBackgroundLocationUpdates->value())) : std::nullopt,
+        locationProvider != nullptr ? std::make_optional(locationProvider->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<JModernGeolocationConfiguration::javaobject> fromCpp(const ModernGeolocationConfiguration& value) {
+      using JSignature = JModernGeolocationConfiguration(jni::alias_ref<jni::JBoolean>, jni::alias_ref<JAuthorizationLevel>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JLocationProvider>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.autoRequestPermission.has_value() ? jni::JBoolean::valueOf(value.autoRequestPermission.value()) : nullptr,
+        value.authorizationLevel.has_value() ? JAuthorizationLevel::fromCpp(value.authorizationLevel.value()) : nullptr,
+        value.enableBackgroundLocationUpdates.has_value() ? jni::JBoolean::valueOf(value.enableBackgroundLocationUpdates.value()) : nullptr,
+        value.locationProvider.has_value() ? JLocationProvider::fromCpp(value.locationProvider.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,26 @@
+///
+/// JNullableDouble.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JNullableDouble.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+  /**
+   * Converts JNullableDouble to std::variant<nitro::NullType, double>
+   */
+  std::variant<nitro::NullType, double> JNullableDouble::toCpp() const {
+    if (isInstanceOf(JNullableDouble_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JNullableDouble_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JNullableDouble_impl::Second::javaClassStatic())) {
+      // It's a `double`
+      auto jniValue = static_cast<const JNullableDouble_impl::Second*>(this)->getValue();
+      return jniValue;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,69 @@
+///
+/// JNullableDouble.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "NullableDouble".
+   */
+  class JNullableDouble: public jni::JavaClass<JNullableDouble> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/NullableDouble;";
+
+    static jni::local_ref<JNullableDouble> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JNullableDouble(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JNullableDouble> create_1(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JNullableDouble(double)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JNullableDouble> fromCpp(const std::variant<nitro::NullType, double>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(std::get<1>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, double> toCpp() const;
+  };
+
+  namespace JNullableDouble_impl {
+    class First final: public jni::JavaClass<First, JNullableDouble> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/NullableDouble$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JNullableDouble> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/NullableDouble$Second;";
+    
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JNullableDouble_impl
+} // namespace margelo::nitro::nitrogeolocation