react-native-nitro-geolocation 1.1.3 → 1.2.0

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

@@ -8,32 +8,62 @@
 #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 `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 `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 `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 `ReverseGeocodedAddress` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ReverseGeocodedAddress; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridNitroGeolocationCompatSpec_cxx` to properly resolve imports.
@@ -42,19 +72,34 @@ namespace NitroGeolocation { class HybridNitroGeolocationCompatSpec_cxx; }
 namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
 
 // Include C++ defined types
+#include "AccuracyAuthorization.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "AndroidGranularity.hpp"
 #include "AuthorizationLevel.hpp"
 #include "AuthorizationLevelInternal.hpp"
+#include "CompatGeolocationError.hpp"
+#include "CompatGeolocationOptions.hpp"
+#include "CompatGeolocationResponse.hpp"
+#include "GeocodedLocation.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 "LocationSettingsOptions.hpp"
 #include "PermissionStatus.hpp"
+#include "ReverseGeocodedAddress.hpp"
 #include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -65,6 +110,7 @@ namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
 #include <optional>
 #include <string>
 #include <variant>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -173,6 +219,269 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(const LocationError& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const LocationError&)>`.
+   */
+  using Func_void_LocationError = std::function<void(const LocationError& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const LocationError& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_LocationError_Wrapper final {
+  public:
+    explicit Func_void_LocationError_Wrapper(std::function<void(const LocationError& /* error */)>&& func): _function(std::make_unique<std::function<void(const LocationError& /* error */)>>(std::move(func))) {}
+    inline void call(LocationError error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const LocationError& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_LocationError create_Func_void_LocationError(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_LocationError_Wrapper wrap_Func_void_LocationError(Func_void_LocationError value) noexcept {
+    return Func_void_LocationError_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const LocationError& /* error */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const LocationError& / * error * /)>>`.
+   */
+  using std__optional_std__function_void_const_LocationError_____error______ = std::optional<std::function<void(const LocationError& /* error */)>>;
+  inline std::optional<std::function<void(const LocationError& /* error */)>> create_std__optional_std__function_void_const_LocationError_____error______(const std::function<void(const LocationError& /* error */)>& value) noexcept {
+    return std::optional<std::function<void(const LocationError& /* error */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_LocationError_____error______(const std::optional<std::function<void(const LocationError& /* error */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const LocationError& /* error */)> get_std__optional_std__function_void_const_LocationError_____error______(const std::optional<std::function<void(const LocationError& /* error */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<LocationProviderStatus>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<LocationProviderStatus>>`.
+   */
+  using std__shared_ptr_Promise_LocationProviderStatus__ = std::shared_ptr<Promise<LocationProviderStatus>>;
+  inline std::shared_ptr<Promise<LocationProviderStatus>> create_std__shared_ptr_Promise_LocationProviderStatus__() noexcept {
+    return Promise<LocationProviderStatus>::create();
+  }
+  inline PromiseHolder<LocationProviderStatus> wrap_std__shared_ptr_Promise_LocationProviderStatus__(std::shared_ptr<Promise<LocationProviderStatus>> promise) noexcept {
+    return PromiseHolder<LocationProviderStatus>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const LocationProviderStatus& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const LocationProviderStatus&)>`.
+   */
+  using Func_void_LocationProviderStatus = std::function<void(const LocationProviderStatus& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const LocationProviderStatus& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_LocationProviderStatus_Wrapper final {
+  public:
+    explicit Func_void_LocationProviderStatus_Wrapper(std::function<void(const LocationProviderStatus& /* result */)>&& func): _function(std::make_unique<std::function<void(const LocationProviderStatus& /* result */)>>(std::move(func))) {}
+    inline void call(LocationProviderStatus result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const LocationProviderStatus& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_LocationProviderStatus create_Func_void_LocationProviderStatus(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_LocationProviderStatus_Wrapper wrap_Func_void_LocationProviderStatus(Func_void_LocationProviderStatus value) noexcept {
+    return Func_void_LocationProviderStatus_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<LocationAvailability>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<LocationAvailability>>`.
+   */
+  using std__shared_ptr_Promise_LocationAvailability__ = std::shared_ptr<Promise<LocationAvailability>>;
+  inline std::shared_ptr<Promise<LocationAvailability>> create_std__shared_ptr_Promise_LocationAvailability__() noexcept {
+    return Promise<LocationAvailability>::create();
+  }
+  inline PromiseHolder<LocationAvailability> wrap_std__shared_ptr_Promise_LocationAvailability__(std::shared_ptr<Promise<LocationAvailability>> promise) noexcept {
+    return PromiseHolder<LocationAvailability>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const LocationAvailability& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const LocationAvailability&)>`.
+   */
+  using Func_void_LocationAvailability = std::function<void(const LocationAvailability& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const LocationAvailability& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_LocationAvailability_Wrapper final {
+  public:
+    explicit Func_void_LocationAvailability_Wrapper(std::function<void(const LocationAvailability& /* result */)>&& func): _function(std::make_unique<std::function<void(const LocationAvailability& /* result */)>>(std::move(func))) {}
+    inline void call(LocationAvailability result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const LocationAvailability& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_LocationAvailability create_Func_void_LocationAvailability(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_LocationAvailability_Wrapper wrap_Func_void_LocationAvailability(Func_void_LocationAvailability value) noexcept {
+    return Func_void_LocationAvailability_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<AndroidAccuracyPreset>
+  /**
+   * Specialized version of `std::optional<AndroidAccuracyPreset>`.
+   */
+  using std__optional_AndroidAccuracyPreset_ = std::optional<AndroidAccuracyPreset>;
+  inline std::optional<AndroidAccuracyPreset> create_std__optional_AndroidAccuracyPreset_(const AndroidAccuracyPreset& value) noexcept {
+    return std::optional<AndroidAccuracyPreset>(value);
+  }
+  inline bool has_value_std__optional_AndroidAccuracyPreset_(const std::optional<AndroidAccuracyPreset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AndroidAccuracyPreset get_std__optional_AndroidAccuracyPreset_(const std::optional<AndroidAccuracyPreset>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<IOSAccuracyPreset>
+  /**
+   * Specialized version of `std::optional<IOSAccuracyPreset>`.
+   */
+  using std__optional_IOSAccuracyPreset_ = std::optional<IOSAccuracyPreset>;
+  inline std::optional<IOSAccuracyPreset> create_std__optional_IOSAccuracyPreset_(const IOSAccuracyPreset& value) noexcept {
+    return std::optional<IOSAccuracyPreset>(value);
+  }
+  inline bool has_value_std__optional_IOSAccuracyPreset_(const std::optional<IOSAccuracyPreset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline IOSAccuracyPreset get_std__optional_IOSAccuracyPreset_(const std::optional<IOSAccuracyPreset>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<LocationAccuracyOptions>
+  /**
+   * Specialized version of `std::optional<LocationAccuracyOptions>`.
+   */
+  using std__optional_LocationAccuracyOptions_ = std::optional<LocationAccuracyOptions>;
+  inline std::optional<LocationAccuracyOptions> create_std__optional_LocationAccuracyOptions_(const LocationAccuracyOptions& value) noexcept {
+    return std::optional<LocationAccuracyOptions>(value);
+  }
+  inline bool has_value_std__optional_LocationAccuracyOptions_(const std::optional<LocationAccuracyOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline LocationAccuracyOptions get_std__optional_LocationAccuracyOptions_(const std::optional<LocationAccuracyOptions>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<LocationSettingsOptions>
+  /**
+   * Specialized version of `std::optional<LocationSettingsOptions>`.
+   */
+  using std__optional_LocationSettingsOptions_ = std::optional<LocationSettingsOptions>;
+  inline std::optional<LocationSettingsOptions> create_std__optional_LocationSettingsOptions_(const LocationSettingsOptions& value) noexcept {
+    return std::optional<LocationSettingsOptions>(value);
+  }
+  inline bool has_value_std__optional_LocationSettingsOptions_(const std::optional<LocationSettingsOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline LocationSettingsOptions get_std__optional_LocationSettingsOptions_(const std::optional<LocationSettingsOptions>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<AccuracyAuthorization>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<AccuracyAuthorization>>`.
+   */
+  using std__shared_ptr_Promise_AccuracyAuthorization__ = std::shared_ptr<Promise<AccuracyAuthorization>>;
+  inline std::shared_ptr<Promise<AccuracyAuthorization>> create_std__shared_ptr_Promise_AccuracyAuthorization__() noexcept {
+    return Promise<AccuracyAuthorization>::create();
+  }
+  inline PromiseHolder<AccuracyAuthorization> wrap_std__shared_ptr_Promise_AccuracyAuthorization__(std::shared_ptr<Promise<AccuracyAuthorization>> promise) noexcept {
+    return PromiseHolder<AccuracyAuthorization>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(AccuracyAuthorization /* result */)>
+  /**
+   * Specialized version of `std::function<void(AccuracyAuthorization)>`.
+   */
+  using Func_void_AccuracyAuthorization = std::function<void(AccuracyAuthorization /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(AccuracyAuthorization / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_AccuracyAuthorization_Wrapper final {
+  public:
+    explicit Func_void_AccuracyAuthorization_Wrapper(std::function<void(AccuracyAuthorization /* result */)>&& func): _function(std::make_unique<std::function<void(AccuracyAuthorization /* result */)>>(std::move(func))) {}
+    inline void call(int result) const noexcept {
+      _function->operator()(static_cast<AccuracyAuthorization>(result));
+    }
+  private:
+    std::unique_ptr<std::function<void(AccuracyAuthorization /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AccuracyAuthorization create_Func_void_AccuracyAuthorization(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_AccuracyAuthorization_Wrapper wrap_Func_void_AccuracyAuthorization(Func_void_AccuracyAuthorization value) noexcept {
+    return Func_void_AccuracyAuthorization_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::variant<nitro::NullType, double>
   /**
    * Wrapper struct for `std::variant<nitro::NullType, double>`.
@@ -217,52 +526,70 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::shared_ptr<Promise<GeolocationResponse>>
+  // pragma MARK: std::optional<LocationProviderUsed>
   /**
-   * Specialized version of `std::shared_ptr<Promise<GeolocationResponse>>`.
+   * Specialized version of `std::optional<LocationProviderUsed>`.
    */
-  using std__shared_ptr_Promise_GeolocationResponse__ = std::shared_ptr<Promise<GeolocationResponse>>;
-  inline std::shared_ptr<Promise<GeolocationResponse>> create_std__shared_ptr_Promise_GeolocationResponse__() noexcept {
-    return Promise<GeolocationResponse>::create();
+  using std__optional_LocationProviderUsed_ = std::optional<LocationProviderUsed>;
+  inline std::optional<LocationProviderUsed> create_std__optional_LocationProviderUsed_(const LocationProviderUsed& value) noexcept {
+    return std::optional<LocationProviderUsed>(value);
+  }
+  inline bool has_value_std__optional_LocationProviderUsed_(const std::optional<LocationProviderUsed>& optional) noexcept {
+    return optional.has_value();
   }
-  inline PromiseHolder<GeolocationResponse> wrap_std__shared_ptr_Promise_GeolocationResponse__(std::shared_ptr<Promise<GeolocationResponse>> promise) noexcept {
-    return PromiseHolder<GeolocationResponse>(std::move(promise));
+  inline LocationProviderUsed get_std__optional_LocationProviderUsed_(const std::optional<LocationProviderUsed>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::function<void(const GeolocationResponse& /* result */)>
+  // pragma MARK: std::function<void(const GeolocationResponse& /* position */)>
   /**
    * Specialized version of `std::function<void(const GeolocationResponse&)>`.
    */
-  using Func_void_GeolocationResponse = std::function<void(const GeolocationResponse& /* result */)>;
+  using Func_void_GeolocationResponse = std::function<void(const GeolocationResponse& /* position */)>;
   /**
-   * Wrapper class for a `std::function<void(const GeolocationResponse& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const GeolocationResponse& / * position * /)>`, this can be used from Swift.
    */
   class Func_void_GeolocationResponse_Wrapper final {
   public:
-    explicit Func_void_GeolocationResponse_Wrapper(std::function<void(const GeolocationResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const GeolocationResponse& /* result */)>>(std::move(func))) {}
-    inline void call(GeolocationResponse result) const noexcept {
-      _function->operator()(result);
+    explicit Func_void_GeolocationResponse_Wrapper(std::function<void(const GeolocationResponse& /* position */)>&& func): _function(std::make_unique<std::function<void(const GeolocationResponse& /* position */)>>(std::move(func))) {}
+    inline void call(GeolocationResponse position) const noexcept {
+      _function->operator()(position);
     }
   private:
-    std::unique_ptr<std::function<void(const GeolocationResponse& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const GeolocationResponse& /* position */)>> _function;
   } SWIFT_NONCOPYABLE;
   Func_void_GeolocationResponse create_Func_void_GeolocationResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_GeolocationResponse_Wrapper wrap_Func_void_GeolocationResponse(Func_void_GeolocationResponse value) noexcept {
     return Func_void_GeolocationResponse_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<double>
+  // pragma MARK: std::optional<AndroidGranularity>
   /**
-   * Specialized version of `std::optional<double>`.
+   * Specialized version of `std::optional<AndroidGranularity>`.
    */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
+  using std__optional_AndroidGranularity_ = std::optional<AndroidGranularity>;
+  inline std::optional<AndroidGranularity> create_std__optional_AndroidGranularity_(const AndroidGranularity& value) noexcept {
+    return std::optional<AndroidGranularity>(value);
   }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline bool has_value_std__optional_AndroidGranularity_(const std::optional<AndroidGranularity>& optional) noexcept {
     return optional.has_value();
   }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline AndroidGranularity get_std__optional_AndroidGranularity_(const std::optional<AndroidGranularity>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<IOSActivityType>
+  /**
+   * Specialized version of `std::optional<IOSActivityType>`.
+   */
+  using std__optional_IOSActivityType_ = std::optional<IOSActivityType>;
+  inline std::optional<IOSActivityType> create_std__optional_IOSActivityType_(const IOSActivityType& value) noexcept {
+    return std::optional<IOSActivityType>(value);
+  }
+  inline bool has_value_std__optional_IOSActivityType_(const std::optional<IOSActivityType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline IOSActivityType get_std__optional_IOSActivityType_(const std::optional<IOSActivityType>& optional) noexcept {
     return optional.value();
   }
   
@@ -281,40 +608,106 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::function<void(const LocationError& /* error */)>
+  // pragma MARK: std::vector<GeocodedLocation>
   /**
-   * Specialized version of `std::function<void(const LocationError&)>`.
+   * Specialized version of `std::vector<GeocodedLocation>`.
    */
-  using Func_void_LocationError = std::function<void(const LocationError& /* error */)>;
+  using std__vector_GeocodedLocation_ = std::vector<GeocodedLocation>;
+  inline std::vector<GeocodedLocation> create_std__vector_GeocodedLocation_(size_t size) noexcept {
+    std::vector<GeocodedLocation> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<GeocodedLocation>& /* locations */)>
   /**
-   * Wrapper class for a `std::function<void(const LocationError& / * error * /)>`, this can be used from Swift.
+   * Specialized version of `std::function<void(const std::vector<GeocodedLocation>&)>`.
    */
-  class Func_void_LocationError_Wrapper final {
+  using Func_void_std__vector_GeocodedLocation_ = std::function<void(const std::vector<GeocodedLocation>& /* locations */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<GeocodedLocation>& / * locations * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_GeocodedLocation__Wrapper final {
   public:
-    explicit Func_void_LocationError_Wrapper(std::function<void(const LocationError& /* error */)>&& func): _function(std::make_unique<std::function<void(const LocationError& /* error */)>>(std::move(func))) {}
-    inline void call(LocationError error) const noexcept {
-      _function->operator()(error);
+    explicit Func_void_std__vector_GeocodedLocation__Wrapper(std::function<void(const std::vector<GeocodedLocation>& /* locations */)>&& func): _function(std::make_unique<std::function<void(const std::vector<GeocodedLocation>& /* locations */)>>(std::move(func))) {}
+    inline void call(std::vector<GeocodedLocation> locations) const noexcept {
+      _function->operator()(locations);
     }
   private:
-    std::unique_ptr<std::function<void(const LocationError& /* error */)>> _function;
+    std::unique_ptr<std::function<void(const std::vector<GeocodedLocation>& /* locations */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_LocationError create_Func_void_LocationError(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_LocationError_Wrapper wrap_Func_void_LocationError(Func_void_LocationError value) noexcept {
-    return Func_void_LocationError_Wrapper(std::move(value));
+  Func_void_std__vector_GeocodedLocation_ create_Func_void_std__vector_GeocodedLocation_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_GeocodedLocation__Wrapper wrap_Func_void_std__vector_GeocodedLocation_(Func_void_std__vector_GeocodedLocation_ value) noexcept {
+    return Func_void_std__vector_GeocodedLocation__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::function<void(const LocationError& /* error */)>>
+  // pragma MARK: std::vector<ReverseGeocodedAddress>
   /**
-   * Specialized version of `std::optional<std::function<void(const LocationError& / * error * /)>>`.
+   * Specialized version of `std::vector<ReverseGeocodedAddress>`.
    */
-  using std__optional_std__function_void_const_LocationError_____error______ = std::optional<std::function<void(const LocationError& /* error */)>>;
-  inline std::optional<std::function<void(const LocationError& /* error */)>> create_std__optional_std__function_void_const_LocationError_____error______(const std::function<void(const LocationError& /* error */)>& value) noexcept {
-    return std::optional<std::function<void(const LocationError& /* error */)>>(value);
+  using std__vector_ReverseGeocodedAddress_ = std::vector<ReverseGeocodedAddress>;
+  inline std::vector<ReverseGeocodedAddress> create_std__vector_ReverseGeocodedAddress_(size_t size) noexcept {
+    std::vector<ReverseGeocodedAddress> vector;
+    vector.reserve(size);
+    return vector;
   }
-  inline bool has_value_std__optional_std__function_void_const_LocationError_____error______(const std::optional<std::function<void(const LocationError& /* error */)>>& optional) noexcept {
+  
+  // pragma MARK: std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<ReverseGeocodedAddress>&)>`.
+   */
+  using Func_void_std__vector_ReverseGeocodedAddress_ = std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<ReverseGeocodedAddress>& / * addresses * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_ReverseGeocodedAddress__Wrapper final {
+  public:
+    explicit Func_void_std__vector_ReverseGeocodedAddress__Wrapper(std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>&& func): _function(std::make_unique<std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>>(std::move(func))) {}
+    inline void call(std::vector<ReverseGeocodedAddress> addresses) const noexcept {
+      _function->operator()(addresses);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_ReverseGeocodedAddress_ create_Func_void_std__vector_ReverseGeocodedAddress_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_ReverseGeocodedAddress__Wrapper wrap_Func_void_std__vector_ReverseGeocodedAddress_(Func_void_std__vector_ReverseGeocodedAddress_ value) noexcept {
+    return Func_void_std__vector_ReverseGeocodedAddress__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const Heading& /* heading */)>
+  /**
+   * Specialized version of `std::function<void(const Heading&)>`.
+   */
+  using Func_void_Heading = std::function<void(const Heading& /* heading */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Heading& / * heading * /)>`, this can be used from Swift.
+   */
+  class Func_void_Heading_Wrapper final {
+  public:
+    explicit Func_void_Heading_Wrapper(std::function<void(const Heading& /* heading */)>&& func): _function(std::make_unique<std::function<void(const Heading& /* heading */)>>(std::move(func))) {}
+    inline void call(Heading heading) const noexcept {
+      _function->operator()(heading);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Heading& /* heading */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Heading create_Func_void_Heading(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Heading_Wrapper wrap_Func_void_Heading(Func_void_Heading value) noexcept {
+    return Func_void_Heading_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<HeadingOptions>
+  /**
+   * Specialized version of `std::optional<HeadingOptions>`.
+   */
+  using std__optional_HeadingOptions_ = std::optional<HeadingOptions>;
+  inline std::optional<HeadingOptions> create_std__optional_HeadingOptions_(const HeadingOptions& value) noexcept {
+    return std::optional<HeadingOptions>(value);
+  }
+  inline bool has_value_std__optional_HeadingOptions_(const std::optional<HeadingOptions>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<void(const LocationError& /* error */)> get_std__optional_std__function_void_const_LocationError_____error______(const std::optional<std::function<void(const LocationError& /* error */)>>& optional) noexcept {
+  inline HeadingOptions get_std__optional_HeadingOptions_(const std::optional<HeadingOptions>& optional) noexcept {
     return optional.value();
   }
   
@@ -348,13 +741,40 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return Result<std::shared_ptr<Promise<PermissionStatus>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<GeolocationResponse>>>
-  using Result_std__shared_ptr_Promise_GeolocationResponse___ = Result<std::shared_ptr<Promise<GeolocationResponse>>>;
-  inline Result_std__shared_ptr_Promise_GeolocationResponse___ create_Result_std__shared_ptr_Promise_GeolocationResponse___(const std::shared_ptr<Promise<GeolocationResponse>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<GeolocationResponse>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<LocationProviderStatus>>>
+  using Result_std__shared_ptr_Promise_LocationProviderStatus___ = Result<std::shared_ptr<Promise<LocationProviderStatus>>>;
+  inline Result_std__shared_ptr_Promise_LocationProviderStatus___ create_Result_std__shared_ptr_Promise_LocationProviderStatus___(const std::shared_ptr<Promise<LocationProviderStatus>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<LocationProviderStatus>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_LocationProviderStatus___ create_Result_std__shared_ptr_Promise_LocationProviderStatus___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<LocationProviderStatus>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<LocationAvailability>>>
+  using Result_std__shared_ptr_Promise_LocationAvailability___ = Result<std::shared_ptr<Promise<LocationAvailability>>>;
+  inline Result_std__shared_ptr_Promise_LocationAvailability___ create_Result_std__shared_ptr_Promise_LocationAvailability___(const std::shared_ptr<Promise<LocationAvailability>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<LocationAvailability>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_LocationAvailability___ create_Result_std__shared_ptr_Promise_LocationAvailability___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<LocationAvailability>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<AccuracyAuthorization>>>
+  using Result_std__shared_ptr_Promise_AccuracyAuthorization___ = Result<std::shared_ptr<Promise<AccuracyAuthorization>>>;
+  inline Result_std__shared_ptr_Promise_AccuracyAuthorization___ create_Result_std__shared_ptr_Promise_AccuracyAuthorization___(const std::shared_ptr<Promise<AccuracyAuthorization>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<AccuracyAuthorization>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_GeolocationResponse___ create_Result_std__shared_ptr_Promise_GeolocationResponse___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<GeolocationResponse>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_AccuracyAuthorization___ create_Result_std__shared_ptr_Promise_AccuracyAuthorization___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<AccuracyAuthorization>>>::withError(error);
   }
   
   // pragma MARK: Result<std::string>
@@ -433,55 +853,77 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::function<void(const GeolocationError& /* error */)>
+  // pragma MARK: std::function<void(const CompatGeolocationError& /* error */)>
   /**
-   * Specialized version of `std::function<void(const GeolocationError&)>`.
+   * Specialized version of `std::function<void(const CompatGeolocationError&)>`.
    */
-  using Func_void_GeolocationError = std::function<void(const GeolocationError& /* error */)>;
+  using Func_void_CompatGeolocationError = std::function<void(const CompatGeolocationError& /* error */)>;
   /**
-   * Wrapper class for a `std::function<void(const GeolocationError& / * error * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const CompatGeolocationError& / * error * /)>`, this can be used from Swift.
    */
-  class Func_void_GeolocationError_Wrapper final {
+  class Func_void_CompatGeolocationError_Wrapper final {
   public:
-    explicit Func_void_GeolocationError_Wrapper(std::function<void(const GeolocationError& /* error */)>&& func): _function(std::make_unique<std::function<void(const GeolocationError& /* error */)>>(std::move(func))) {}
-    inline void call(GeolocationError error) const noexcept {
+    explicit Func_void_CompatGeolocationError_Wrapper(std::function<void(const CompatGeolocationError& /* error */)>&& func): _function(std::make_unique<std::function<void(const CompatGeolocationError& /* error */)>>(std::move(func))) {}
+    inline void call(CompatGeolocationError error) const noexcept {
       _function->operator()(error);
     }
   private:
-    std::unique_ptr<std::function<void(const GeolocationError& /* error */)>> _function;
+    std::unique_ptr<std::function<void(const CompatGeolocationError& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_GeolocationError create_Func_void_GeolocationError(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_GeolocationError_Wrapper wrap_Func_void_GeolocationError(Func_void_GeolocationError value) noexcept {
-    return Func_void_GeolocationError_Wrapper(std::move(value));
+  Func_void_CompatGeolocationError create_Func_void_CompatGeolocationError(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CompatGeolocationError_Wrapper wrap_Func_void_CompatGeolocationError(Func_void_CompatGeolocationError value) noexcept {
+    return Func_void_CompatGeolocationError_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::function<void(const GeolocationError& /* error */)>>
+  // pragma MARK: std::optional<std::function<void(const CompatGeolocationError& /* error */)>>
   /**
-   * Specialized version of `std::optional<std::function<void(const GeolocationError& / * error * /)>>`.
+   * Specialized version of `std::optional<std::function<void(const CompatGeolocationError& / * error * /)>>`.
    */
-  using std__optional_std__function_void_const_GeolocationError_____error______ = std::optional<std::function<void(const GeolocationError& /* error */)>>;
-  inline std::optional<std::function<void(const GeolocationError& /* error */)>> create_std__optional_std__function_void_const_GeolocationError_____error______(const std::function<void(const GeolocationError& /* error */)>& value) noexcept {
-    return std::optional<std::function<void(const GeolocationError& /* error */)>>(value);
+  using std__optional_std__function_void_const_CompatGeolocationError_____error______ = std::optional<std::function<void(const CompatGeolocationError& /* error */)>>;
+  inline std::optional<std::function<void(const CompatGeolocationError& /* error */)>> create_std__optional_std__function_void_const_CompatGeolocationError_____error______(const std::function<void(const CompatGeolocationError& /* error */)>& value) noexcept {
+    return std::optional<std::function<void(const CompatGeolocationError& /* error */)>>(value);
   }
-  inline bool has_value_std__optional_std__function_void_const_GeolocationError_____error______(const std::optional<std::function<void(const GeolocationError& /* error */)>>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_void_const_CompatGeolocationError_____error______(const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<void(const GeolocationError& /* error */)> get_std__optional_std__function_void_const_GeolocationError_____error______(const std::optional<std::function<void(const GeolocationError& /* error */)>>& optional) noexcept {
+  inline std::function<void(const CompatGeolocationError& /* error */)> get_std__optional_std__function_void_const_CompatGeolocationError_____error______(const std::optional<std::function<void(const CompatGeolocationError& /* error */)>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<GeolocationOptions>
+  // pragma MARK: std::function<void(const CompatGeolocationResponse& /* position */)>
+  /**
+   * Specialized version of `std::function<void(const CompatGeolocationResponse&)>`.
+   */
+  using Func_void_CompatGeolocationResponse = std::function<void(const CompatGeolocationResponse& /* position */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CompatGeolocationResponse& / * position * /)>`, this can be used from Swift.
+   */
+  class Func_void_CompatGeolocationResponse_Wrapper final {
+  public:
+    explicit Func_void_CompatGeolocationResponse_Wrapper(std::function<void(const CompatGeolocationResponse& /* position */)>&& func): _function(std::make_unique<std::function<void(const CompatGeolocationResponse& /* position */)>>(std::move(func))) {}
+    inline void call(CompatGeolocationResponse position) const noexcept {
+      _function->operator()(position);
+    }
+  private:
+    std::unique_ptr<std::function<void(const CompatGeolocationResponse& /* position */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CompatGeolocationResponse create_Func_void_CompatGeolocationResponse(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CompatGeolocationResponse_Wrapper wrap_Func_void_CompatGeolocationResponse(Func_void_CompatGeolocationResponse value) noexcept {
+    return Func_void_CompatGeolocationResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<CompatGeolocationOptions>
   /**
-   * Specialized version of `std::optional<GeolocationOptions>`.
+   * Specialized version of `std::optional<CompatGeolocationOptions>`.
    */
-  using std__optional_GeolocationOptions_ = std::optional<GeolocationOptions>;
-  inline std::optional<GeolocationOptions> create_std__optional_GeolocationOptions_(const GeolocationOptions& value) noexcept {
-    return std::optional<GeolocationOptions>(value);
+  using std__optional_CompatGeolocationOptions_ = std::optional<CompatGeolocationOptions>;
+  inline std::optional<CompatGeolocationOptions> create_std__optional_CompatGeolocationOptions_(const CompatGeolocationOptions& value) noexcept {
+    return std::optional<CompatGeolocationOptions>(value);
   }
-  inline bool has_value_std__optional_GeolocationOptions_(const std::optional<GeolocationOptions>& optional) noexcept {
+  inline bool has_value_std__optional_CompatGeolocationOptions_(const std::optional<CompatGeolocationOptions>& optional) noexcept {
     return optional.has_value();
   }
-  inline GeolocationOptions get_std__optional_GeolocationOptions_(const std::optional<GeolocationOptions>& optional) noexcept {
+  inline CompatGeolocationOptions get_std__optional_CompatGeolocationOptions_(const std::optional<CompatGeolocationOptions>& optional) noexcept {
     return optional.value();
   }