react-native-nitro-geolocation 0.0.1 → 0.1.1

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

@@ -0,0 +1,74 @@
+///
+/// JFunc_void.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 <functional>
+
+#include <functional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_GeolocationError.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 <functional>
+
+#include "GeolocationError.hpp"
+#include <functional>
+#include "JGeolocationError.hpp"
+#include <string>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(error: GeolocationError) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_GeolocationError: public jni::JavaClass<JFunc_void_GeolocationError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_GeolocationError;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_GeolocationError` instance holds through JNI.
+     */
+    void invoke(const GeolocationError& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JGeolocationError> /* error */)>("invoke");
+      method(self(), JGeolocationError::fromCpp(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_GeolocationError that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_GeolocationError_cxx final: public jni::HybridClass<JFunc_void_GeolocationError_cxx, JFunc_void_GeolocationError> {
+  public:
+    static jni::local_ref<JFunc_void_GeolocationError::javaobject> fromCpp(const std::function<void(const GeolocationError& /* error */)>& func) {
+      return JFunc_void_GeolocationError_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_GeolocationError_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JGeolocationError> error) {
+      _func(error->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const GeolocationError& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_GeolocationError_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_GeolocationError_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_GeolocationError_cxx(const std::function<void(const GeolocationError& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const GeolocationError& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,79 @@
+///
+/// JFunc_void_GeolocationResponse.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 <functional>
+
+#include "GeolocationResponse.hpp"
+#include <functional>
+#include "JGeolocationResponse.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(position: GeolocationResponse) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_GeolocationResponse: public jni::JavaClass<JFunc_void_GeolocationResponse> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_GeolocationResponse;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_GeolocationResponse` instance holds through JNI.
+     */
+    void invoke(const GeolocationResponse& position) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JGeolocationResponse> /* position */)>("invoke");
+      method(self(), JGeolocationResponse::fromCpp(position));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_GeolocationResponse that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_GeolocationResponse_cxx final: public jni::HybridClass<JFunc_void_GeolocationResponse_cxx, JFunc_void_GeolocationResponse> {
+  public:
+    static jni::local_ref<JFunc_void_GeolocationResponse::javaobject> fromCpp(const std::function<void(const GeolocationResponse& /* position */)>& func) {
+      return JFunc_void_GeolocationResponse_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_GeolocationResponse_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JGeolocationResponse> position) {
+      _func(position->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const GeolocationResponse& /* position */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_GeolocationResponse_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_GeolocationResponse_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_GeolocationResponse_cxx(const std::function<void(const GeolocationResponse& /* position */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const GeolocationResponse& /* position */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,77 @@
+///
+/// JGeolocationCoordinates.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 "GeolocationCoordinates.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GeolocationCoordinates" and the the Kotlin data class "GeolocationCoordinates".
+   */
+  struct JGeolocationCoordinates final: public jni::JavaClass<JGeolocationCoordinates> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeolocationCoordinates;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GeolocationCoordinates by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeolocationCoordinates 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);
+      static const auto fieldAltitude = clazz->getField<jni::JDouble>("altitude");
+      jni::local_ref<jni::JDouble> altitude = this->getFieldValue(fieldAltitude);
+      static const auto fieldAccuracy = clazz->getField<double>("accuracy");
+      double accuracy = this->getFieldValue(fieldAccuracy);
+      static const auto fieldAltitudeAccuracy = clazz->getField<jni::JDouble>("altitudeAccuracy");
+      jni::local_ref<jni::JDouble> altitudeAccuracy = this->getFieldValue(fieldAltitudeAccuracy);
+      static const auto fieldHeading = clazz->getField<jni::JDouble>("heading");
+      jni::local_ref<jni::JDouble> heading = this->getFieldValue(fieldHeading);
+      static const auto fieldSpeed = clazz->getField<jni::JDouble>("speed");
+      jni::local_ref<jni::JDouble> speed = this->getFieldValue(fieldSpeed);
+      return GeolocationCoordinates(
+        latitude,
+        longitude,
+        altitude != nullptr ? std::make_optional(altitude->value()) : std::nullopt,
+        accuracy,
+        altitudeAccuracy != nullptr ? std::make_optional(altitudeAccuracy->value()) : std::nullopt,
+        heading != nullptr ? std::make_optional(heading->value()) : std::nullopt,
+        speed != nullptr ? std::make_optional(speed->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<JGeolocationCoordinates::javaobject> fromCpp(const GeolocationCoordinates& value) {
+      return newInstance(
+        value.latitude,
+        value.longitude,
+        value.altitude.has_value() ? jni::JDouble::valueOf(value.altitude.value()) : nullptr,
+        value.accuracy,
+        value.altitudeAccuracy.has_value() ? jni::JDouble::valueOf(value.altitudeAccuracy.value()) : nullptr,
+        value.heading.has_value() ? jni::JDouble::valueOf(value.heading.value()) : nullptr,
+        value.speed.has_value() ? jni::JDouble::valueOf(value.speed.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,69 @@
+///
+/// JGeolocationError.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 "GeolocationError.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GeolocationError" and the the Kotlin data class "GeolocationError".
+   */
+  struct JGeolocationError final: public jni::JavaClass<JGeolocationError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeolocationError;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GeolocationError by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeolocationError 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);
+      static const auto fieldPERMISSION_DENIED = clazz->getField<double>("PERMISSION_DENIED");
+      double PERMISSION_DENIED = this->getFieldValue(fieldPERMISSION_DENIED);
+      static const auto fieldPOSITION_UNAVAILABLE = clazz->getField<double>("POSITION_UNAVAILABLE");
+      double POSITION_UNAVAILABLE = this->getFieldValue(fieldPOSITION_UNAVAILABLE);
+      static const auto fieldTIMEOUT = clazz->getField<double>("TIMEOUT");
+      double TIMEOUT = this->getFieldValue(fieldTIMEOUT);
+      return GeolocationError(
+        code,
+        message->toStdString(),
+        PERMISSION_DENIED,
+        POSITION_UNAVAILABLE,
+        TIMEOUT
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JGeolocationError::javaobject> fromCpp(const GeolocationError& value) {
+      return newInstance(
+        value.code,
+        jni::make_jstring(value.message),
+        value.PERMISSION_DENIED,
+        value.POSITION_UNAVAILABLE,
+        value.TIMEOUT
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,77 @@
+///
+/// JGeolocationOptions.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 "GeolocationOptions.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GeolocationOptions" and the the Kotlin data class "GeolocationOptions".
+   */
+  struct JGeolocationOptions final: public jni::JavaClass<JGeolocationOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeolocationOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GeolocationOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeolocationOptions 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 GeolocationOptions(
+        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<JGeolocationOptions::javaobject> fromCpp(const GeolocationOptions& value) {
+      return newInstance(
+        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++/JGeolocationResponse.hpp

@@ -0,0 +1,59 @@
+///
+/// JGeolocationResponse.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 "GeolocationResponse.hpp"
+
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GeolocationResponse" and the the Kotlin data class "GeolocationResponse".
+   */
+  struct JGeolocationResponse final: public jni::JavaClass<JGeolocationResponse> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeolocationResponse;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GeolocationResponse by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeolocationResponse toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCoords = clazz->getField<JGeolocationCoordinates>("coords");
+      jni::local_ref<JGeolocationCoordinates> coords = this->getFieldValue(fieldCoords);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return GeolocationResponse(
+        coords->toCpp(),
+        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<JGeolocationResponse::javaobject> fromCpp(const GeolocationResponse& value) {
+      return newInstance(
+        JGeolocationCoordinates::fromCpp(value.coords),
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,98 @@
+///
+/// JHybridNitroGeolocationSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#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 `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; }
+
+#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 "GeolocationResponse.hpp"
+#include "JFunc_void_GeolocationResponse.hpp"
+#include "JGeolocationResponse.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include "GeolocationOptions.hpp"
+#include "JGeolocationOptions.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  jni::local_ref<JHybridNitroGeolocationSpec::jhybriddata> JHybridNitroGeolocationSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroGeolocationSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroGeolocationSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroGeolocationSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroGeolocationSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // 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::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);
+  }
+  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);
+  }
+  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;
+  }
+  void JHybridNitroGeolocationSpec::clearWatch(double watchId) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* watchId */)>("clearWatch");
+    method(_javaPart, watchId);
+  }
+  void JHybridNitroGeolocationSpec::stopObserving() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stopObserving");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitrogeolocation