react-native-nitro-geolocation 1.1.4 → 1.2.1

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

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

package/nitrogen/generated/android/c++/{JModernGeolocationConfiguration.hpp → JGeolocationConfiguration.hpp}

@@ -1,5 +1,5 @@
 ///
-/// JModernGeolocationConfiguration.hpp
+/// JGeolocationConfiguration.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include "ModernGeolocationConfiguration.hpp"
+#include "GeolocationConfiguration.hpp"
 
 #include "AuthorizationLevel.hpp"
 #include "JAuthorizationLevel.hpp"
@@ -21,19 +21,19 @@ namespace margelo::nitro::nitrogeolocation {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "ModernGeolocationConfiguration" and the the Kotlin data class "ModernGeolocationConfiguration".
+   * The C++ JNI bridge between the C++ struct "GeolocationConfiguration" and the the Kotlin data class "GeolocationConfiguration".
    */
-  struct JModernGeolocationConfiguration final: public jni::JavaClass<JModernGeolocationConfiguration> {
+  struct JGeolocationConfiguration final: public jni::JavaClass<JGeolocationConfiguration> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/ModernGeolocationConfiguration;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeolocationConfiguration;";
 
   public:
     /**
-     * Convert this Java/Kotlin-based struct to the C++ struct ModernGeolocationConfiguration by copying all values to C++.
+     * Convert this Java/Kotlin-based struct to the C++ struct GeolocationConfiguration by copying all values to C++.
      */
     [[maybe_unused]]
     [[nodiscard]]
-    ModernGeolocationConfiguration toCpp() const {
+    GeolocationConfiguration 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);
@@ -43,7 +43,7 @@ namespace margelo::nitro::nitrogeolocation {
       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(
+      return GeolocationConfiguration(
         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,
@@ -56,8 +56,8 @@ namespace margelo::nitro::nitrogeolocation {
      * 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 jni::local_ref<JGeolocationConfiguration::javaobject> fromCpp(const GeolocationConfiguration& value) {
+      using JSignature = JGeolocationConfiguration(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(

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

@@ -12,7 +12,9 @@
 
 #include "GeolocationCoordinates.hpp"
 #include "JGeolocationCoordinates.hpp"
+#include "JLocationProviderUsed.hpp"
 #include "JNullableDouble.hpp"
+#include "LocationProviderUsed.hpp"
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>
@@ -41,9 +43,15 @@ namespace margelo::nitro::nitrogeolocation {
       jni::local_ref<JGeolocationCoordinates> coords = this->getFieldValue(fieldCoords);
       static const auto fieldTimestamp = clazz->getField<double>("timestamp");
       double timestamp = this->getFieldValue(fieldTimestamp);
+      static const auto fieldMocked = clazz->getField<jni::JBoolean>("mocked");
+      jni::local_ref<jni::JBoolean> mocked = this->getFieldValue(fieldMocked);
+      static const auto fieldProvider = clazz->getField<JLocationProviderUsed>("provider");
+      jni::local_ref<JLocationProviderUsed> provider = this->getFieldValue(fieldProvider);
       return GeolocationResponse(
         coords->toCpp(),
-        timestamp
+        timestamp,
+        mocked != nullptr ? std::make_optional(static_cast<bool>(mocked->value())) : std::nullopt,
+        provider != nullptr ? std::make_optional(provider->toCpp()) : std::nullopt
       );
     }
 
@@ -53,13 +61,15 @@ namespace margelo::nitro::nitrogeolocation {
      */
     [[maybe_unused]]
     static jni::local_ref<JGeolocationResponse::javaobject> fromCpp(const GeolocationResponse& value) {
-      using JSignature = JGeolocationResponse(jni::alias_ref<JGeolocationCoordinates>, double);
+      using JSignature = JGeolocationResponse(jni::alias_ref<JGeolocationCoordinates>, double, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JLocationProviderUsed>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         JGeolocationCoordinates::fromCpp(value.coords),
-        value.timestamp
+        value.timestamp,
+        value.mocked.has_value() ? jni::JBoolean::valueOf(value.mocked.value()) : nullptr,
+        value.provider.has_value() ? JLocationProviderUsed::fromCpp(value.provider.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,69 @@
+///
+/// JHeading.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Heading.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Heading" and the the Kotlin data class "Heading".
+   */
+  struct JHeading final: public jni::JavaClass<JHeading> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Heading;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Heading by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Heading toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMagneticHeading = clazz->getField<double>("magneticHeading");
+      double magneticHeading = this->getFieldValue(fieldMagneticHeading);
+      static const auto fieldTrueHeading = clazz->getField<jni::JDouble>("trueHeading");
+      jni::local_ref<jni::JDouble> trueHeading = this->getFieldValue(fieldTrueHeading);
+      static const auto fieldAccuracy = clazz->getField<jni::JDouble>("accuracy");
+      jni::local_ref<jni::JDouble> accuracy = this->getFieldValue(fieldAccuracy);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return Heading(
+        magneticHeading,
+        trueHeading != nullptr ? std::make_optional(trueHeading->value()) : std::nullopt,
+        accuracy != nullptr ? std::make_optional(accuracy->value()) : std::nullopt,
+        timestamp
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JHeading::javaobject> fromCpp(const Heading& value) {
+      using JSignature = JHeading(double, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.magneticHeading,
+        value.trueHeading.has_value() ? jni::JDouble::valueOf(value.trueHeading.value()) : nullptr,
+        value.accuracy.has_value() ? jni::JDouble::valueOf(value.accuracy.value()) : nullptr,
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

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

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

@@ -7,23 +7,31 @@
 
 #include "JHybridNitroGeolocationCompatSpec.hpp"
 
-// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
+// Forward declaration of `CompatGeolocationConfigurationInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationConfigurationInternal; }
 // 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 `GeolocationResponse` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// Forward declaration of `CompatGeolocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationError; }
+// Forward declaration of `CompatGeolocationResponse` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationResponse; }
 // 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 `CompatGeolocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationOptions; }
+// Forward declaration of `LocationAccuracyOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAccuracyOptions; }
+// Forward declaration of `AndroidAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidAccuracyPreset; }
+// Forward declaration of `IOSAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSAccuracyPreset; }
+// Forward declaration of `IOSActivityType` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSActivityType; }
 
-#include "RNConfigurationInternal.hpp"
-#include "JRNConfigurationInternal.hpp"
+#include "CompatGeolocationConfigurationInternal.hpp"
+#include "JCompatGeolocationConfigurationInternal.hpp"
 #include "AuthorizationLevelInternal.hpp"
 #include <optional>
 #include "JAuthorizationLevelInternal.hpp"
@@ -32,21 +40,29 @@ namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
 #include <functional>
 #include "JFunc_void.hpp"
 #include <NitroModules/JNICallable.hpp>
-#include "GeolocationError.hpp"
-#include "JFunc_void_GeolocationError.hpp"
-#include "JGeolocationError.hpp"
+#include "CompatGeolocationError.hpp"
+#include "JFunc_void_CompatGeolocationError.hpp"
+#include "JCompatGeolocationError.hpp"
 #include <string>
-#include "GeolocationResponse.hpp"
-#include "JFunc_void_GeolocationResponse.hpp"
-#include "JGeolocationResponse.hpp"
+#include "CompatGeolocationResponse.hpp"
+#include "JFunc_void_CompatGeolocationResponse.hpp"
+#include "JCompatGeolocationResponse.hpp"
 #include "GeolocationCoordinates.hpp"
 #include "JGeolocationCoordinates.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
 #include "JNullableDouble.hpp"
 #include <NitroModules/JNull.hpp>
-#include "GeolocationOptions.hpp"
-#include "JGeolocationOptions.hpp"
+#include "CompatGeolocationOptions.hpp"
+#include "JCompatGeolocationOptions.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include "JLocationAccuracyOptions.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "JAndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "JIOSAccuracyPreset.hpp"
+#include "IOSActivityType.hpp"
+#include "JIOSActivityType.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -81,21 +97,21 @@ namespace margelo::nitro::nitrogeolocation {
   
 
   // Methods
-  void JHybridNitroGeolocationCompatSpec::setRNConfiguration(const RNConfigurationInternal& config) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JRNConfigurationInternal> /* config */)>("setRNConfiguration");
-    method(_javaPart, JRNConfigurationInternal::fromCpp(config));
+  void JHybridNitroGeolocationCompatSpec::setRNConfiguration(const CompatGeolocationConfigurationInternal& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCompatGeolocationConfigurationInternal> /* config */)>("setRNConfiguration");
+    method(_javaPart, JCompatGeolocationConfigurationInternal::fromCpp(config));
   }
-  void JHybridNitroGeolocationCompatSpec::requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) {
-    static const auto method = _javaPart->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);
+  void JHybridNitroGeolocationCompatSpec::requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* success */, jni::alias_ref<JFunc_void_CompatGeolocationError::javaobject> /* error */)>("requestAuthorization_cxx");
+    method(_javaPart, success.has_value() ? JFunc_void_cxx::fromCpp(success.value()) : nullptr, error.has_value() ? JFunc_void_CompatGeolocationError_cxx::fromCpp(error.value()) : nullptr);
   }
-  void JHybridNitroGeolocationCompatSpec::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 = _javaPart->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);
+  void JHybridNitroGeolocationCompatSpec::getCurrentPosition(const std::function<void(const CompatGeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error, const std::optional<CompatGeolocationOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_CompatGeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_CompatGeolocationError::javaobject> /* error */, jni::alias_ref<JCompatGeolocationOptions> /* options */)>("getCurrentPosition_cxx");
+    method(_javaPart, JFunc_void_CompatGeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_CompatGeolocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JCompatGeolocationOptions::fromCpp(options.value()) : nullptr);
   }
-  double JHybridNitroGeolocationCompatSpec::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 = _javaPart->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);
+  double JHybridNitroGeolocationCompatSpec::watchPosition(const std::function<void(const CompatGeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error, const std::optional<CompatGeolocationOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_CompatGeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_CompatGeolocationError::javaobject> /* error */, jni::alias_ref<JCompatGeolocationOptions> /* options */)>("watchPosition_cxx");
+    auto __result = method(_javaPart, JFunc_void_CompatGeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_CompatGeolocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JCompatGeolocationOptions::fromCpp(options.value()) : nullptr);
     return __result;
   }
   void JHybridNitroGeolocationCompatSpec::clearWatch(double watchId) {

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

@@ -54,10 +54,10 @@ 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 setRNConfiguration(const CompatGeolocationConfigurationInternal& config) override;
+    void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error) override;
+    void getCurrentPosition(const std::function<void(const CompatGeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error, const std::optional<CompatGeolocationOptions>& options) override;
+    double watchPosition(const std::function<void(const CompatGeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error, const std::optional<CompatGeolocationOptions>& options) override;
     void clearWatch(double watchId) override;
     void stopObserving() override;