react-native-nitro-geolocation 1.1.4 → 1.2.0

package/nitrogen/generated/ios/NitroGeolocation-Swift-Cxx-Umbrella.hpp

@@ -8,53 +8,101 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AccuracyAuthorization` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AccuracyAuthorization; }
+// Forward declaration of `AndroidAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidAccuracyPreset; }
+// Forward declaration of `AndroidGranularity` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidGranularity; }
 // Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
 // Forward declaration of `AuthorizationLevel` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevel; }
+// 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 `CompatGeolocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationOptions; }
+// Forward declaration of `CompatGeolocationResponse` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct CompatGeolocationResponse; }
+// 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 `GeolocationConfiguration` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationConfiguration; }
 // Forward declaration of `GeolocationCoordinates` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
-// Forward declaration of `GeolocationError` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
-// Forward declaration of `GeolocationOptions` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
 // Forward declaration of `GeolocationResponse` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// Forward declaration of `HeadingOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct HeadingOptions; }
+// Forward declaration of `Heading` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct Heading; }
 // Forward declaration of `HybridNitroGeolocationCompatSpec` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { class HybridNitroGeolocationCompatSpec; }
 // Forward declaration of `HybridNitroGeolocationSpec` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { class HybridNitroGeolocationSpec; }
+// 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; }
+// Forward declaration of `LocationAccuracyOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAccuracyOptions; }
+// Forward declaration of `LocationAvailability` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAvailability; }
 // Forward declaration of `LocationError` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct LocationError; }
 // Forward declaration of `LocationProviderInternal` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class LocationProviderInternal; }
+// Forward declaration of `LocationProviderStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationProviderStatus; }
+// Forward declaration of `LocationProviderUsed` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderUsed; }
 // 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 `ModernGeolocationConfiguration` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct ModernGeolocationConfiguration; }
+// Forward declaration of `LocationSettingsOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationSettingsOptions; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
-// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
+// Forward declaration of `ReverseGeocodedAddress` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ReverseGeocodedAddress; }
 
 // Include C++ defined types
+#include "AccuracyAuthorization.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "AndroidGranularity.hpp"
 #include "AuthorizationLevel.hpp"
 #include "AuthorizationLevelInternal.hpp"
+#include "CompatGeolocationConfigurationInternal.hpp"
+#include "CompatGeolocationError.hpp"
+#include "CompatGeolocationOptions.hpp"
+#include "CompatGeolocationResponse.hpp"
+#include "GeocodedLocation.hpp"
+#include "GeocodingCoordinates.hpp"
+#include "GeolocationConfiguration.hpp"
 #include "GeolocationCoordinates.hpp"
-#include "GeolocationError.hpp"
-#include "GeolocationOptions.hpp"
 #include "GeolocationResponse.hpp"
+#include "Heading.hpp"
+#include "HeadingOptions.hpp"
 #include "HybridNitroGeolocationCompatSpec.hpp"
 #include "HybridNitroGeolocationSpec.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "IOSActivityType.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include "LocationAvailability.hpp"
 #include "LocationError.hpp"
 #include "LocationProvider.hpp"
 #include "LocationProviderInternal.hpp"
+#include "LocationProviderStatus.hpp"
+#include "LocationProviderUsed.hpp"
 #include "LocationRequestOptions.hpp"
-#include "ModernGeolocationConfiguration.hpp"
+#include "LocationSettingsOptions.hpp"
 #include "PermissionStatus.hpp"
-#include "RNConfigurationInternal.hpp"
+#include "ReverseGeocodedAddress.hpp"
 #include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
@@ -64,6 +112,7 @@ namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
 #include <optional>
 #include <string>
 #include <variant>
+#include <vector>
 
 // C++ helpers for Swift
 #include "NitroGeolocation-Swift-Cxx-Bridge.hpp"

package/nitrogen/generated/ios/c++/HybridNitroGeolocationCompatSpecSwift.hpp

@@ -12,33 +12,45 @@
 // Forward declaration of `HybridNitroGeolocationCompatSpec_cxx` to properly resolve imports.
 namespace NitroGeolocation { class HybridNitroGeolocationCompatSpec_cxx; }
 
-// 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 "CompatGeolocationConfigurationInternal.hpp"
 #include "AuthorizationLevelInternal.hpp"
 #include <optional>
 #include "LocationProviderInternal.hpp"
 #include <functional>
-#include "GeolocationError.hpp"
+#include "CompatGeolocationError.hpp"
 #include <string>
-#include "GeolocationResponse.hpp"
+#include "CompatGeolocationResponse.hpp"
 #include "GeolocationCoordinates.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
-#include "GeolocationOptions.hpp"
+#include "CompatGeolocationOptions.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "IOSActivityType.hpp"
 
 #include "NitroGeolocation-Swift-Cxx-Umbrella.hpp"
 
@@ -90,25 +102,25 @@ namespace margelo::nitro::nitrogeolocation {
 
   public:
     // Methods
-    inline void setRNConfiguration(const RNConfigurationInternal& config) override {
+    inline void setRNConfiguration(const CompatGeolocationConfigurationInternal& config) override {
       auto __result = _swiftPart.setRNConfiguration(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) override {
+    inline void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& error) override {
       auto __result = _swiftPart.requestAuthorization(success, error);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline 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 {
+    inline 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 {
       auto __result = _swiftPart.getCurrentPosition(success, error, options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline 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 {
+    inline 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 {
       auto __result = _swiftPart.watchPosition(success, error, options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/c++/HybridNitroGeolocationSpecSwift.hpp

@@ -12,37 +12,83 @@
 // Forward declaration of `HybridNitroGeolocationSpec_cxx` to properly resolve imports.
 namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
 
-// 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 `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 `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 `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 `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 `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; }
 // 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 `AndroidGranularity` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidGranularity; }
+// Forward declaration of `IOSActivityType` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSActivityType; }
+// 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 <optional>
 #include "AuthorizationLevel.hpp"
 #include "LocationProvider.hpp"
 #include "PermissionStatus.hpp"
 #include <NitroModules/Promise.hpp>
+#include <functional>
+#include "LocationError.hpp"
+#include <string>
+#include "LocationProviderStatus.hpp"
+#include "LocationAvailability.hpp"
+#include "LocationSettingsOptions.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "AccuracyAuthorization.hpp"
 #include "GeolocationResponse.hpp"
 #include "GeolocationCoordinates.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
+#include "LocationProviderUsed.hpp"
 #include "LocationRequestOptions.hpp"
-#include <string>
-#include <functional>
-#include "LocationError.hpp"
+#include "AndroidGranularity.hpp"
+#include "IOSActivityType.hpp"
+#include "GeocodedLocation.hpp"
+#include <vector>
+#include "GeocodingCoordinates.hpp"
+#include "ReverseGeocodedAddress.hpp"
+#include "Heading.hpp"
+#include "HeadingOptions.hpp"
 
 #include "NitroGeolocation-Swift-Cxx-Umbrella.hpp"
 
@@ -94,7 +140,7 @@ namespace margelo::nitro::nitrogeolocation {
 
   public:
     // Methods
-    inline void setConfiguration(const ModernGeolocationConfiguration& config) override {
+    inline void setConfiguration(const GeolocationConfiguration& config) override {
       auto __result = _swiftPart.setConfiguration(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -108,16 +154,88 @@ namespace margelo::nitro::nitrogeolocation {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<PermissionStatus>> requestPermission() override {
-      auto __result = _swiftPart.requestPermission();
+    inline void requestPermission(const std::function<void(PermissionStatus /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override {
+      auto __result = _swiftPart.requestPermission(success, error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<bool>> hasServicesEnabled() override {
+      auto __result = _swiftPart.hasServicesEnabled();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<LocationProviderStatus>> getProviderStatus() override {
+      auto __result = _swiftPart.getProviderStatus();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<LocationAvailability>> getLocationAvailability() override {
+      auto __result = _swiftPart.getLocationAvailability();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline 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) override {
+      auto __result = _swiftPart.requestLocationSettings(success, error, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<AccuracyAuthorization>> getAccuracyAuthorization() override {
+      auto __result = _swiftPart.getAccuracyAuthorization();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<GeolocationResponse>> getCurrentPosition(const std::optional<LocationRequestOptions>& options) override {
-      auto __result = _swiftPart.getCurrentPosition(options);
+    inline void requestTemporaryFullAccuracy(const std::string& purposeKey, const std::function<void(AccuracyAuthorization /* authorization */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override {
+      auto __result = _swiftPart.requestTemporaryFullAccuracy(purposeKey, success, error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.getCurrentPosition(success, error, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.getLastKnownPosition(success, error, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.geocode(address, success, error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.reverseGeocode(std::forward<decltype(coords)>(coords), success, error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void getHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override {
+      auto __result = _swiftPart.getHeading(success, error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.watchHeading(success, error, options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/AccuracyAuthorization.swift

@@ -0,0 +1,44 @@
+///
+/// AccuracyAuthorization.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AccuracyAuthorization`, backed by a C++ enum.
+ */
+public typealias AccuracyAuthorization = margelo.nitro.nitrogeolocation.AccuracyAuthorization
+
+public extension AccuracyAuthorization {
+  /**
+   * Get a AccuracyAuthorization for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "reduced":
+        self = .reduced
+      case "full":
+        self = .full
+      case "unknown":
+        self = .unknown
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AccuracyAuthorization represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .reduced:
+        return "reduced"
+      case .full:
+        return "full"
+      case .unknown:
+        return "unknown"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/AndroidAccuracyPreset.swift

@@ -0,0 +1,48 @@
+///
+/// AndroidAccuracyPreset.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AndroidAccuracyPreset`, backed by a C++ enum.
+ */
+public typealias AndroidAccuracyPreset = margelo.nitro.nitrogeolocation.AndroidAccuracyPreset
+
+public extension AndroidAccuracyPreset {
+  /**
+   * Get a AndroidAccuracyPreset for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "high":
+        self = .high
+      case "balanced":
+        self = .balanced
+      case "low":
+        self = .low
+      case "passive":
+        self = .passive
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AndroidAccuracyPreset represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .high:
+        return "high"
+      case .balanced:
+        return "balanced"
+      case .low:
+        return "low"
+      case .passive:
+        return "passive"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/AndroidGranularity.swift

@@ -0,0 +1,44 @@
+///
+/// AndroidGranularity.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AndroidGranularity`, backed by a C++ enum.
+ */
+public typealias AndroidGranularity = margelo.nitro.nitrogeolocation.AndroidGranularity
+
+public extension AndroidGranularity {
+  /**
+   * Get a AndroidGranularity for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "permission":
+        self = .permission
+      case "coarse":
+        self = .coarse
+      case "fine":
+        self = .fine
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AndroidGranularity represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .permission:
+        return "permission"
+      case .coarse:
+        return "coarse"
+      case .fine:
+        return "fine"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/{RNConfigurationInternal.swift → CompatGeolocationConfigurationInternal.swift}

@@ -1,5 +1,5 @@
 ///
-/// RNConfigurationInternal.swift
+/// CompatGeolocationConfigurationInternal.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,15 +8,15 @@
 import NitroModules
 
 /**
- * Represents an instance of `RNConfigurationInternal`, backed by a C++ struct.
+ * Represents an instance of `CompatGeolocationConfigurationInternal`, backed by a C++ struct.
  */
-public typealias RNConfigurationInternal = margelo.nitro.nitrogeolocation.RNConfigurationInternal
+public typealias CompatGeolocationConfigurationInternal = margelo.nitro.nitrogeolocation.CompatGeolocationConfigurationInternal
 
-public extension RNConfigurationInternal {
+public extension CompatGeolocationConfigurationInternal {
   private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
 
   /**
-   * Create a new instance of `RNConfigurationInternal`.
+   * Create a new instance of `CompatGeolocationConfigurationInternal`.
    */
   init(skipPermissionRequests: Bool, authorizationLevel: AuthorizationLevelInternal?, enableBackgroundLocationUpdates: Bool?, locationProvider: LocationProviderInternal?) {
     self.init(skipPermissionRequests, { () -> bridge.std__optional_AuthorizationLevelInternal_ in

package/nitrogen/generated/ios/swift/{GeolocationError.swift → CompatGeolocationError.swift}

@@ -1,5 +1,5 @@
 ///
-/// GeolocationError.swift
+/// CompatGeolocationError.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,15 +8,15 @@
 import NitroModules
 
 /**
- * Represents an instance of `GeolocationError`, backed by a C++ struct.
+ * Represents an instance of `CompatGeolocationError`, backed by a C++ struct.
  */
-public typealias GeolocationError = margelo.nitro.nitrogeolocation.GeolocationError
+public typealias CompatGeolocationError = margelo.nitro.nitrogeolocation.CompatGeolocationError
 
-public extension GeolocationError {
+public extension CompatGeolocationError {
   private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
 
   /**
-   * Create a new instance of `GeolocationError`.
+   * Create a new instance of `CompatGeolocationError`.
    */
   init(code: Double, message: String, PERMISSION_DENIED: Double, POSITION_UNAVAILABLE: Double, TIMEOUT: Double) {
     self.init(code, std.string(message), PERMISSION_DENIED, POSITION_UNAVAILABLE, TIMEOUT)