react-native-nitro-geolocation 1.1.4 → 1.2.1

package/nitrogen/generated/shared/c++/{ModernGeolocationConfiguration.hpp → GeolocationConfiguration.hpp}

@@ -1,5 +1,5 @@
 ///
-/// ModernGeolocationConfiguration.hpp
+/// GeolocationConfiguration.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -40,9 +40,9 @@ namespace margelo::nitro::nitrogeolocation { enum class LocationProvider; }
 namespace margelo::nitro::nitrogeolocation {
 
   /**
-   * A struct which can be represented as a JavaScript object (ModernGeolocationConfiguration).
+   * A struct which can be represented as a JavaScript object (GeolocationConfiguration).
    */
-  struct ModernGeolocationConfiguration final {
+  struct GeolocationConfiguration final {
   public:
     std::optional<bool> autoRequestPermission     SWIFT_PRIVATE;
     std::optional<AuthorizationLevel> authorizationLevel     SWIFT_PRIVATE;
@@ -50,30 +50,30 @@ namespace margelo::nitro::nitrogeolocation {
     std::optional<LocationProvider> locationProvider     SWIFT_PRIVATE;
 
   public:
-    ModernGeolocationConfiguration() = default;
-    explicit ModernGeolocationConfiguration(std::optional<bool> autoRequestPermission, std::optional<AuthorizationLevel> authorizationLevel, std::optional<bool> enableBackgroundLocationUpdates, std::optional<LocationProvider> locationProvider): autoRequestPermission(autoRequestPermission), authorizationLevel(authorizationLevel), enableBackgroundLocationUpdates(enableBackgroundLocationUpdates), locationProvider(locationProvider) {}
+    GeolocationConfiguration() = default;
+    explicit GeolocationConfiguration(std::optional<bool> autoRequestPermission, std::optional<AuthorizationLevel> authorizationLevel, std::optional<bool> enableBackgroundLocationUpdates, std::optional<LocationProvider> locationProvider): autoRequestPermission(autoRequestPermission), authorizationLevel(authorizationLevel), enableBackgroundLocationUpdates(enableBackgroundLocationUpdates), locationProvider(locationProvider) {}
 
   public:
-    friend bool operator==(const ModernGeolocationConfiguration& lhs, const ModernGeolocationConfiguration& rhs) = default;
+    friend bool operator==(const GeolocationConfiguration& lhs, const GeolocationConfiguration& rhs) = default;
   };
 
 } // namespace margelo::nitro::nitrogeolocation
 
 namespace margelo::nitro {
 
-  // C++ ModernGeolocationConfiguration <> JS ModernGeolocationConfiguration (object)
+  // C++ GeolocationConfiguration <> JS GeolocationConfiguration (object)
   template <>
-  struct JSIConverter<margelo::nitro::nitrogeolocation::ModernGeolocationConfiguration> final {
-    static inline margelo::nitro::nitrogeolocation::ModernGeolocationConfiguration fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::nitrogeolocation::GeolocationConfiguration> final {
+    static inline margelo::nitro::nitrogeolocation::GeolocationConfiguration fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return margelo::nitro::nitrogeolocation::ModernGeolocationConfiguration(
+      return margelo::nitro::nitrogeolocation::GeolocationConfiguration(
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "autoRequestPermission"))),
         JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevel>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authorizationLevel"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "enableBackgroundLocationUpdates"))),
         JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProvider>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "locationProvider")))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::ModernGeolocationConfiguration& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::GeolocationConfiguration& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "autoRequestPermission"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.autoRequestPermission));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "authorizationLevel"), JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevel>>::toJSI(runtime, arg.authorizationLevel));

package/nitrogen/generated/shared/c++/GeolocationResponse.hpp

@@ -30,8 +30,12 @@
 
 // Forward declaration of `GeolocationCoordinates` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
+// Forward declaration of `LocationProviderUsed` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderUsed; }
 
 #include "GeolocationCoordinates.hpp"
+#include <optional>
+#include "LocationProviderUsed.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -42,10 +46,12 @@ namespace margelo::nitro::nitrogeolocation {
   public:
     GeolocationCoordinates coords     SWIFT_PRIVATE;
     double timestamp     SWIFT_PRIVATE;
+    std::optional<bool> mocked     SWIFT_PRIVATE;
+    std::optional<LocationProviderUsed> provider     SWIFT_PRIVATE;
 
   public:
     GeolocationResponse() = default;
-    explicit GeolocationResponse(GeolocationCoordinates coords, double timestamp): coords(coords), timestamp(timestamp) {}
+    explicit GeolocationResponse(GeolocationCoordinates coords, double timestamp, std::optional<bool> mocked, std::optional<LocationProviderUsed> provider): coords(coords), timestamp(timestamp), mocked(mocked), provider(provider) {}
 
   public:
     friend bool operator==(const GeolocationResponse& lhs, const GeolocationResponse& rhs) = default;
@@ -62,13 +68,17 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::nitrogeolocation::GeolocationResponse(
         JSIConverter<margelo::nitro::nitrogeolocation::GeolocationCoordinates>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "coords"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamp")))
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamp"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mocked"))),
+        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderUsed>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "provider")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::GeolocationResponse& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "coords"), JSIConverter<margelo::nitro::nitrogeolocation::GeolocationCoordinates>::toJSI(runtime, arg.coords));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "timestamp"), JSIConverter<double>::toJSI(runtime, arg.timestamp));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "mocked"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.mocked));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "provider"), JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderUsed>>::toJSI(runtime, arg.provider));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -81,6 +91,8 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<margelo::nitro::nitrogeolocation::GeolocationCoordinates>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "coords")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamp")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mocked")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderUsed>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "provider")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/Heading.hpp

@@ -0,0 +1,95 @@
+///
+/// Heading.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * A struct which can be represented as a JavaScript object (Heading).
+   */
+  struct Heading final {
+  public:
+    double magneticHeading     SWIFT_PRIVATE;
+    std::optional<double> trueHeading     SWIFT_PRIVATE;
+    std::optional<double> accuracy     SWIFT_PRIVATE;
+    double timestamp     SWIFT_PRIVATE;
+
+  public:
+    Heading() = default;
+    explicit Heading(double magneticHeading, std::optional<double> trueHeading, std::optional<double> accuracy, double timestamp): magneticHeading(magneticHeading), trueHeading(trueHeading), accuracy(accuracy), timestamp(timestamp) {}
+
+  public:
+    friend bool operator==(const Heading& lhs, const Heading& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ Heading <> JS Heading (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::Heading> final {
+    static inline margelo::nitro::nitrogeolocation::Heading fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrogeolocation::Heading(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "magneticHeading"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "trueHeading"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accuracy"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamp")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::Heading& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "magneticHeading"), JSIConverter<double>::toJSI(runtime, arg.magneticHeading));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "trueHeading"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.trueHeading));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "accuracy"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.accuracy));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "timestamp"), JSIConverter<double>::toJSI(runtime, arg.timestamp));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "magneticHeading")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "trueHeading")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accuracy")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timestamp")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HeadingOptions.hpp

@@ -0,0 +1,83 @@
+///
+/// HeadingOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * A struct which can be represented as a JavaScript object (HeadingOptions).
+   */
+  struct HeadingOptions final {
+  public:
+    std::optional<double> headingFilter     SWIFT_PRIVATE;
+
+  public:
+    HeadingOptions() = default;
+    explicit HeadingOptions(std::optional<double> headingFilter): headingFilter(headingFilter) {}
+
+  public:
+    friend bool operator==(const HeadingOptions& lhs, const HeadingOptions& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ HeadingOptions <> JS HeadingOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::HeadingOptions> final {
+    static inline margelo::nitro::nitrogeolocation::HeadingOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrogeolocation::HeadingOptions(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "headingFilter")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::HeadingOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "headingFilter"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.headingFilter));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "headingFilter")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridNitroGeolocationCompatSpec.hpp

@@ -13,21 +13,21 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
-// 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 `GeolocationOptions` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
+// Forward declaration of `CompatGeolocationConfigurationInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationConfigurationInternal; }
+// 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 `CompatGeolocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationOptions; }
 
-#include "RNConfigurationInternal.hpp"
+#include "CompatGeolocationConfigurationInternal.hpp"
 #include <functional>
 #include <optional>
-#include "GeolocationError.hpp"
-#include "GeolocationResponse.hpp"
-#include "GeolocationOptions.hpp"
+#include "CompatGeolocationError.hpp"
+#include "CompatGeolocationResponse.hpp"
+#include "CompatGeolocationOptions.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -60,10 +60,10 @@ namespace margelo::nitro::nitrogeolocation {
 
     public:
       // Methods
-      virtual void setRNConfiguration(const RNConfigurationInternal& config) = 0;
-      virtual void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) = 0;
-      virtual 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) = 0;
-      virtual 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) = 0;
+      virtual void setRNConfiguration(const CompatGeolocationConfigurationInternal& config) = 0;
+      virtual void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error) = 0;
+      virtual 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) = 0;
+      virtual 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) = 0;
       virtual void clearWatch(double watchId) = 0;
       virtual void stopObserving() = 0;
 

package/nitrogen/generated/shared/c++/HybridNitroGeolocationSpec.cpp

@@ -17,7 +17,18 @@ namespace margelo::nitro::nitrogeolocation {
       prototype.registerHybridMethod("setConfiguration", &HybridNitroGeolocationSpec::setConfiguration);
       prototype.registerHybridMethod("checkPermission", &HybridNitroGeolocationSpec::checkPermission);
       prototype.registerHybridMethod("requestPermission", &HybridNitroGeolocationSpec::requestPermission);
+      prototype.registerHybridMethod("hasServicesEnabled", &HybridNitroGeolocationSpec::hasServicesEnabled);
+      prototype.registerHybridMethod("getProviderStatus", &HybridNitroGeolocationSpec::getProviderStatus);
+      prototype.registerHybridMethod("getLocationAvailability", &HybridNitroGeolocationSpec::getLocationAvailability);
+      prototype.registerHybridMethod("requestLocationSettings", &HybridNitroGeolocationSpec::requestLocationSettings);
+      prototype.registerHybridMethod("getAccuracyAuthorization", &HybridNitroGeolocationSpec::getAccuracyAuthorization);
+      prototype.registerHybridMethod("requestTemporaryFullAccuracy", &HybridNitroGeolocationSpec::requestTemporaryFullAccuracy);
       prototype.registerHybridMethod("getCurrentPosition", &HybridNitroGeolocationSpec::getCurrentPosition);
+      prototype.registerHybridMethod("getLastKnownPosition", &HybridNitroGeolocationSpec::getLastKnownPosition);
+      prototype.registerHybridMethod("geocode", &HybridNitroGeolocationSpec::geocode);
+      prototype.registerHybridMethod("reverseGeocode", &HybridNitroGeolocationSpec::reverseGeocode);
+      prototype.registerHybridMethod("getHeading", &HybridNitroGeolocationSpec::getHeading);
+      prototype.registerHybridMethod("watchHeading", &HybridNitroGeolocationSpec::watchHeading);
       prototype.registerHybridMethod("watchPosition", &HybridNitroGeolocationSpec::watchPosition);
       prototype.registerHybridMethod("unwatch", &HybridNitroGeolocationSpec::unwatch);
       prototype.registerHybridMethod("stopObserving", &HybridNitroGeolocationSpec::stopObserving);

package/nitrogen/generated/shared/c++/HybridNitroGeolocationSpec.hpp

@@ -13,26 +13,54 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-// Forward declaration of `ModernGeolocationConfiguration` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct ModernGeolocationConfiguration; }
+// Forward declaration of `GeolocationConfiguration` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationConfiguration; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
+// Forward declaration of `LocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationError; }
+// Forward declaration of `LocationProviderStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationProviderStatus; }
+// Forward declaration of `LocationAvailability` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAvailability; }
+// Forward declaration of `LocationSettingsOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationSettingsOptions; }
+// Forward declaration of `AccuracyAuthorization` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AccuracyAuthorization; }
 // Forward declaration of `GeolocationResponse` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
 // 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; }
+// Forward declaration of `GeocodedLocation` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeocodedLocation; }
+// Forward declaration of `GeocodingCoordinates` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeocodingCoordinates; }
+// Forward declaration of `ReverseGeocodedAddress` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ReverseGeocodedAddress; }
+// Forward declaration of `Heading` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct Heading; }
+// Forward declaration of `HeadingOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct HeadingOptions; }
 
-#include "ModernGeolocationConfiguration.hpp"
+#include "GeolocationConfiguration.hpp"
 #include "PermissionStatus.hpp"
 #include <NitroModules/Promise.hpp>
-#include "GeolocationResponse.hpp"
-#include "LocationRequestOptions.hpp"
-#include <optional>
-#include <string>
 #include <functional>
 #include "LocationError.hpp"
+#include <optional>
+#include "LocationProviderStatus.hpp"
+#include "LocationAvailability.hpp"
+#include "LocationSettingsOptions.hpp"
+#include "AccuracyAuthorization.hpp"
+#include <string>
+#include "GeolocationResponse.hpp"
+#include "LocationRequestOptions.hpp"
+#include "GeocodedLocation.hpp"
+#include <vector>
+#include "GeocodingCoordinates.hpp"
+#include "ReverseGeocodedAddress.hpp"
+#include "Heading.hpp"
+#include "HeadingOptions.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -65,10 +93,21 @@ namespace margelo::nitro::nitrogeolocation {
 
     public:
       // Methods
-      virtual void setConfiguration(const ModernGeolocationConfiguration& config) = 0;
+      virtual void setConfiguration(const GeolocationConfiguration& config) = 0;
       virtual std::shared_ptr<Promise<PermissionStatus>> checkPermission() = 0;
-      virtual std::shared_ptr<Promise<PermissionStatus>> requestPermission() = 0;
-      virtual std::shared_ptr<Promise<GeolocationResponse>> getCurrentPosition(const std::optional<LocationRequestOptions>& options) = 0;
+      virtual void requestPermission(const std::function<void(PermissionStatus /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) = 0;
+      virtual std::shared_ptr<Promise<bool>> hasServicesEnabled() = 0;
+      virtual std::shared_ptr<Promise<LocationProviderStatus>> getProviderStatus() = 0;
+      virtual std::shared_ptr<Promise<LocationAvailability>> getLocationAvailability() = 0;
+      virtual void requestLocationSettings(const std::function<void(const LocationProviderStatus& /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationSettingsOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<AccuracyAuthorization>> getAccuracyAuthorization() = 0;
+      virtual void requestTemporaryFullAccuracy(const std::string& purposeKey, const std::function<void(AccuracyAuthorization /* authorization */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) = 0;
+      virtual void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) = 0;
+      virtual void getLastKnownPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) = 0;
+      virtual void geocode(const std::string& address, const std::function<void(const std::vector<GeocodedLocation>& /* locations */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) = 0;
+      virtual void reverseGeocode(const GeocodingCoordinates& coords, const std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) = 0;
+      virtual void getHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) = 0;
+      virtual std::string watchHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<HeadingOptions>& options) = 0;
       virtual 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) = 0;
       virtual void unwatch(const std::string& token) = 0;
       virtual void stopObserving() = 0;

package/nitrogen/generated/shared/c++/IOSAccuracyPreset.hpp

@@ -0,0 +1,96 @@
+///
+/// IOSAccuracyPreset.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * An enum which can be represented as a JavaScript union (IOSAccuracyPreset).
+   */
+  enum class IOSAccuracyPreset {
+    BESTFORNAVIGATION      SWIFT_NAME(bestfornavigation) = 0,
+    BEST      SWIFT_NAME(best) = 1,
+    NEARESTTENMETERS      SWIFT_NAME(nearesttenmeters) = 2,
+    HUNDREDMETERS      SWIFT_NAME(hundredmeters) = 3,
+    KILOMETER      SWIFT_NAME(kilometer) = 4,
+    THREEKILOMETERS      SWIFT_NAME(threekilometers) = 5,
+    REDUCED      SWIFT_NAME(reduced) = 6,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ IOSAccuracyPreset <> JS IOSAccuracyPreset (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::IOSAccuracyPreset> final {
+    static inline margelo::nitro::nitrogeolocation::IOSAccuracyPreset fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("bestForNavigation"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::BESTFORNAVIGATION;
+        case hashString("best"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::BEST;
+        case hashString("nearestTenMeters"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::NEARESTTENMETERS;
+        case hashString("hundredMeters"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::HUNDREDMETERS;
+        case hashString("kilometer"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::KILOMETER;
+        case hashString("threeKilometers"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::THREEKILOMETERS;
+        case hashString("reduced"): return margelo::nitro::nitrogeolocation::IOSAccuracyPreset::REDUCED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum IOSAccuracyPreset - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitrogeolocation::IOSAccuracyPreset arg) {
+      switch (arg) {
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::BESTFORNAVIGATION: return JSIConverter<std::string>::toJSI(runtime, "bestForNavigation");
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::BEST: return JSIConverter<std::string>::toJSI(runtime, "best");
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::NEARESTTENMETERS: return JSIConverter<std::string>::toJSI(runtime, "nearestTenMeters");
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::HUNDREDMETERS: return JSIConverter<std::string>::toJSI(runtime, "hundredMeters");
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::KILOMETER: return JSIConverter<std::string>::toJSI(runtime, "kilometer");
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::THREEKILOMETERS: return JSIConverter<std::string>::toJSI(runtime, "threeKilometers");
+        case margelo::nitro::nitrogeolocation::IOSAccuracyPreset::REDUCED: return JSIConverter<std::string>::toJSI(runtime, "reduced");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert IOSAccuracyPreset to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("bestForNavigation"):
+        case hashString("best"):
+        case hashString("nearestTenMeters"):
+        case hashString("hundredMeters"):
+        case hashString("kilometer"):
+        case hashString("threeKilometers"):
+        case hashString("reduced"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/IOSActivityType.hpp

@@ -0,0 +1,88 @@
+///
+/// IOSActivityType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * An enum which can be represented as a JavaScript union (IOSActivityType).
+   */
+  enum class IOSActivityType {
+    OTHER      SWIFT_NAME(other) = 0,
+    AUTOMOTIVENAVIGATION      SWIFT_NAME(automotivenavigation) = 1,
+    FITNESS      SWIFT_NAME(fitness) = 2,
+    OTHERNAVIGATION      SWIFT_NAME(othernavigation) = 3,
+    AIRBORNE      SWIFT_NAME(airborne) = 4,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ IOSActivityType <> JS IOSActivityType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::IOSActivityType> final {
+    static inline margelo::nitro::nitrogeolocation::IOSActivityType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("other"): return margelo::nitro::nitrogeolocation::IOSActivityType::OTHER;
+        case hashString("automotiveNavigation"): return margelo::nitro::nitrogeolocation::IOSActivityType::AUTOMOTIVENAVIGATION;
+        case hashString("fitness"): return margelo::nitro::nitrogeolocation::IOSActivityType::FITNESS;
+        case hashString("otherNavigation"): return margelo::nitro::nitrogeolocation::IOSActivityType::OTHERNAVIGATION;
+        case hashString("airborne"): return margelo::nitro::nitrogeolocation::IOSActivityType::AIRBORNE;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum IOSActivityType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitrogeolocation::IOSActivityType arg) {
+      switch (arg) {
+        case margelo::nitro::nitrogeolocation::IOSActivityType::OTHER: return JSIConverter<std::string>::toJSI(runtime, "other");
+        case margelo::nitro::nitrogeolocation::IOSActivityType::AUTOMOTIVENAVIGATION: return JSIConverter<std::string>::toJSI(runtime, "automotiveNavigation");
+        case margelo::nitro::nitrogeolocation::IOSActivityType::FITNESS: return JSIConverter<std::string>::toJSI(runtime, "fitness");
+        case margelo::nitro::nitrogeolocation::IOSActivityType::OTHERNAVIGATION: return JSIConverter<std::string>::toJSI(runtime, "otherNavigation");
+        case margelo::nitro::nitrogeolocation::IOSActivityType::AIRBORNE: return JSIConverter<std::string>::toJSI(runtime, "airborne");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert IOSActivityType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("other"):
+        case hashString("automotiveNavigation"):
+        case hashString("fitness"):
+        case hashString("otherNavigation"):
+        case hashString("airborne"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro