react-native-nitro-geolocation 0.1.1 → 0.2.0

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

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // 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 `GeolocationCoordinates` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
 // Forward declaration of `GeolocationError` to properly resolve imports.
@@ -18,29 +20,51 @@ namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
 namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
 // Forward declaration of `GeolocationResponse` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// 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 `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 `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 `PermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridNitroGeolocationCompatSpec_cxx` to properly resolve imports.
+namespace NitroGeolocation { class HybridNitroGeolocationCompatSpec_cxx; }
 // Forward declaration of `HybridNitroGeolocationSpec_cxx` to properly resolve imports.
 namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
 
 // Include C++ defined types
+#include "AuthorizationLevel.hpp"
 #include "AuthorizationLevelInternal.hpp"
 #include "GeolocationCoordinates.hpp"
 #include "GeolocationError.hpp"
 #include "GeolocationOptions.hpp"
 #include "GeolocationResponse.hpp"
+#include "HybridNitroGeolocationCompatSpec.hpp"
 #include "HybridNitroGeolocationSpec.hpp"
+#include "LocationError.hpp"
+#include "LocationProvider.hpp"
 #include "LocationProviderInternal.hpp"
+#include "LocationRequestOptions.hpp"
+#include "PermissionStatus.hpp"
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -48,33 +72,312 @@ namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
  */
 namespace margelo::nitro::nitrogeolocation::bridge::swift {
 
-  // pragma MARK: std::optional<AuthorizationLevelInternal>
+  // pragma MARK: std::optional<bool>
   /**
-   * Specialized version of `std::optional<AuthorizationLevelInternal>`.
+   * Specialized version of `std::optional<bool>`.
    */
-  using std__optional_AuthorizationLevelInternal_ = std::optional<AuthorizationLevelInternal>;
-  inline std::optional<AuthorizationLevelInternal> create_std__optional_AuthorizationLevelInternal_(const AuthorizationLevelInternal& value) noexcept {
-    return std::optional<AuthorizationLevelInternal>(value);
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
   }
-  inline bool has_value_std__optional_AuthorizationLevelInternal_(const std::optional<AuthorizationLevelInternal>& optional) noexcept {
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
     return optional.has_value();
   }
-  inline AuthorizationLevelInternal get_std__optional_AuthorizationLevelInternal_(const std::optional<AuthorizationLevelInternal>& optional) noexcept {
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
     return *optional;
   }
   
-  // pragma MARK: std::optional<bool>
+  // pragma MARK: std::optional<AuthorizationLevel>
   /**
-   * Specialized version of `std::optional<bool>`.
+   * Specialized version of `std::optional<AuthorizationLevel>`.
    */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
-    return std::optional<bool>(value);
+  using std__optional_AuthorizationLevel_ = std::optional<AuthorizationLevel>;
+  inline std::optional<AuthorizationLevel> create_std__optional_AuthorizationLevel_(const AuthorizationLevel& value) noexcept {
+    return std::optional<AuthorizationLevel>(value);
   }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+  inline bool has_value_std__optional_AuthorizationLevel_(const std::optional<AuthorizationLevel>& optional) noexcept {
     return optional.has_value();
   }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+  inline AuthorizationLevel get_std__optional_AuthorizationLevel_(const std::optional<AuthorizationLevel>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<LocationProvider>
+  /**
+   * Specialized version of `std::optional<LocationProvider>`.
+   */
+  using std__optional_LocationProvider_ = std::optional<LocationProvider>;
+  inline std::optional<LocationProvider> create_std__optional_LocationProvider_(const LocationProvider& value) noexcept {
+    return std::optional<LocationProvider>(value);
+  }
+  inline bool has_value_std__optional_LocationProvider_(const std::optional<LocationProvider>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline LocationProvider get_std__optional_LocationProvider_(const std::optional<LocationProvider>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<PermissionStatus>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<PermissionStatus>>`.
+   */
+  using std__shared_ptr_Promise_PermissionStatus__ = std::shared_ptr<Promise<PermissionStatus>>;
+  inline std::shared_ptr<Promise<PermissionStatus>> create_std__shared_ptr_Promise_PermissionStatus__() noexcept {
+    return Promise<PermissionStatus>::create();
+  }
+  inline PromiseHolder<PermissionStatus> wrap_std__shared_ptr_Promise_PermissionStatus__(std::shared_ptr<Promise<PermissionStatus>> promise) noexcept {
+    return PromiseHolder<PermissionStatus>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(PermissionStatus /* result */)>
+  /**
+   * Specialized version of `std::function<void(PermissionStatus)>`.
+   */
+  using Func_void_PermissionStatus = std::function<void(PermissionStatus /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(PermissionStatus / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_PermissionStatus_Wrapper final {
+  public:
+    explicit Func_void_PermissionStatus_Wrapper(std::function<void(PermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(PermissionStatus /* result */)>>(std::move(func))) {}
+    inline void call(int result) const noexcept {
+      _function->operator()(static_cast<PermissionStatus>(result));
+    }
+  private:
+    std::unique_ptr<std::function<void(PermissionStatus /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PermissionStatus create_Func_void_PermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PermissionStatus_Wrapper wrap_Func_void_PermissionStatus(Func_void_PermissionStatus value) noexcept {
+    return Func_void_PermissionStatus_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, double>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, double>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__double_ final {
+    std::variant<nitro::NullType, double> variant;
+    std__variant_nitro__NullType__double_(std::variant<nitro::NullType, double> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, double>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline double get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(double value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
+  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<GeolocationResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<GeolocationResponse>>`.
+   */
+  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();
+  }
+  inline PromiseHolder<GeolocationResponse> wrap_std__shared_ptr_Promise_GeolocationResponse__(std::shared_ptr<Promise<GeolocationResponse>> promise) noexcept {
+    return PromiseHolder<GeolocationResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const GeolocationResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const GeolocationResponse&)>`.
+   */
+  using Func_void_GeolocationResponse = std::function<void(const GeolocationResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const GeolocationResponse& / * result * /)>`, 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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const GeolocationResponse& /* result */)>> _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>
+  /**
+   * 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;
+  }
+  
+  // pragma MARK: std::optional<LocationRequestOptions>
+  /**
+   * Specialized version of `std::optional<LocationRequestOptions>`.
+   */
+  using std__optional_LocationRequestOptions_ = std::optional<LocationRequestOptions>;
+  inline std::optional<LocationRequestOptions> create_std__optional_LocationRequestOptions_(const LocationRequestOptions& value) noexcept {
+    return std::optional<LocationRequestOptions>(value);
+  }
+  inline bool has_value_std__optional_LocationRequestOptions_(const std::optional<LocationRequestOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline LocationRequestOptions get_std__optional_LocationRequestOptions_(const std::optional<LocationRequestOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroGeolocationSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNitroGeolocationSpec>`.
+   */
+  using std__shared_ptr_HybridNitroGeolocationSpec_ = std::shared_ptr<HybridNitroGeolocationSpec>;
+  std::shared_ptr<HybridNitroGeolocationSpec> create_std__shared_ptr_HybridNitroGeolocationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroGeolocationSpec_(std__shared_ptr_HybridNitroGeolocationSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroGeolocationSpec>
+  using std__weak_ptr_HybridNitroGeolocationSpec_ = std::weak_ptr<HybridNitroGeolocationSpec>;
+  inline std__weak_ptr_HybridNitroGeolocationSpec_ weakify_std__shared_ptr_HybridNitroGeolocationSpec_(const std::shared_ptr<HybridNitroGeolocationSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<PermissionStatus>>>
+  using Result_std__shared_ptr_Promise_PermissionStatus___ = Result<std::shared_ptr<Promise<PermissionStatus>>>;
+  inline Result_std__shared_ptr_Promise_PermissionStatus___ create_Result_std__shared_ptr_Promise_PermissionStatus___(const std::shared_ptr<Promise<PermissionStatus>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<PermissionStatus>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_PermissionStatus___ create_Result_std__shared_ptr_Promise_PermissionStatus___(const std::exception_ptr& error) noexcept {
+    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);
+  }
+  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);
+  }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: std::optional<AuthorizationLevelInternal>
+  /**
+   * Specialized version of `std::optional<AuthorizationLevelInternal>`.
+   */
+  using std__optional_AuthorizationLevelInternal_ = std::optional<AuthorizationLevelInternal>;
+  inline std::optional<AuthorizationLevelInternal> create_std__optional_AuthorizationLevelInternal_(const AuthorizationLevelInternal& value) noexcept {
+    return std::optional<AuthorizationLevelInternal>(value);
+  }
+  inline bool has_value_std__optional_AuthorizationLevelInternal_(const std::optional<AuthorizationLevelInternal>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AuthorizationLevelInternal get_std__optional_AuthorizationLevelInternal_(const std::optional<AuthorizationLevelInternal>& optional) noexcept {
     return *optional;
   }
   
@@ -167,43 +470,6 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return *optional;
   }
   
-  // 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;
-  }
-  
-  // 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& /* position */)>;
-  /**
-   * 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& /* 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& /* 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<GeolocationOptions>
   /**
    * Specialized version of `std::optional<GeolocationOptions>`.
@@ -219,26 +485,17 @@ namespace margelo::nitro::nitrogeolocation::bridge::swift {
     return *optional;
   }
   
-  // pragma MARK: std::shared_ptr<HybridNitroGeolocationSpec>
+  // pragma MARK: std::shared_ptr<HybridNitroGeolocationCompatSpec>
   /**
-   * Specialized version of `std::shared_ptr<HybridNitroGeolocationSpec>`.
+   * Specialized version of `std::shared_ptr<HybridNitroGeolocationCompatSpec>`.
    */
-  using std__shared_ptr_HybridNitroGeolocationSpec_ = std::shared_ptr<HybridNitroGeolocationSpec>;
-  std::shared_ptr<HybridNitroGeolocationSpec> create_std__shared_ptr_HybridNitroGeolocationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridNitroGeolocationSpec_(std__shared_ptr_HybridNitroGeolocationSpec_ cppType) noexcept;
+  using std__shared_ptr_HybridNitroGeolocationCompatSpec_ = std::shared_ptr<HybridNitroGeolocationCompatSpec>;
+  std::shared_ptr<HybridNitroGeolocationCompatSpec> create_std__shared_ptr_HybridNitroGeolocationCompatSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroGeolocationCompatSpec_(std__shared_ptr_HybridNitroGeolocationCompatSpec_ cppType);
   
-  // pragma MARK: std::weak_ptr<HybridNitroGeolocationSpec>
-  using std__weak_ptr_HybridNitroGeolocationSpec_ = std::weak_ptr<HybridNitroGeolocationSpec>;
-  inline std__weak_ptr_HybridNitroGeolocationSpec_ weakify_std__shared_ptr_HybridNitroGeolocationSpec_(const std::shared_ptr<HybridNitroGeolocationSpec>& strong) noexcept { return strong; }
-  
-  // pragma MARK: Result<void>
-  using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() noexcept {
-    return Result<void>::withValue();
-  }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
-    return Result<void>::withError(error);
-  }
+  // pragma MARK: std::weak_ptr<HybridNitroGeolocationCompatSpec>
+  using std__weak_ptr_HybridNitroGeolocationCompatSpec_ = std::weak_ptr<HybridNitroGeolocationCompatSpec>;
+  inline std__weak_ptr_HybridNitroGeolocationCompatSpec_ weakify_std__shared_ptr_HybridNitroGeolocationCompatSpec_(const std::shared_ptr<HybridNitroGeolocationCompatSpec>& strong) noexcept { return strong; }
   
   // pragma MARK: Result<double>
   using Result_double_ = Result<double>;

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

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // 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 `GeolocationCoordinates` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
 // Forward declaration of `GeolocationError` to properly resolve imports.
@@ -18,28 +20,50 @@ namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
 namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
 // Forward declaration of `GeolocationResponse` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// 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 `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 `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 `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; }
 
 // Include C++ defined types
+#include "AuthorizationLevel.hpp"
 #include "AuthorizationLevelInternal.hpp"
 #include "GeolocationCoordinates.hpp"
 #include "GeolocationError.hpp"
 #include "GeolocationOptions.hpp"
 #include "GeolocationResponse.hpp"
+#include "HybridNitroGeolocationCompatSpec.hpp"
 #include "HybridNitroGeolocationSpec.hpp"
+#include "LocationError.hpp"
+#include "LocationProvider.hpp"
 #include "LocationProviderInternal.hpp"
+#include "LocationRequestOptions.hpp"
+#include "ModernGeolocationConfiguration.hpp"
+#include "PermissionStatus.hpp"
 #include "RNConfigurationInternal.hpp"
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 
 // C++ helpers for Swift
 #include "NitroGeolocation-Swift-Cxx-Bridge.hpp"
@@ -51,6 +75,8 @@ namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridNitroGeolocationCompatSpec_cxx` to properly resolve imports.
+namespace NitroGeolocation { class HybridNitroGeolocationCompatSpec_cxx; }
 // Forward declaration of `HybridNitroGeolocationSpec_cxx` to properly resolve imports.
 namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
 

package/nitrogen/generated/ios/NitroGeolocationAutolinking.mm

@@ -11,6 +11,7 @@
 #import <type_traits>
 
 #include "HybridNitroGeolocationSpecSwift.hpp"
+#include "HybridNitroGeolocationCompatSpecSwift.hpp"
 
 @interface NitroGeolocationAutolinking : NSObject
 @end
@@ -28,6 +29,13 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroGeolocationCompat",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridNitroGeolocationCompatSpec> hybridObject = NitroGeolocation::NitroGeolocationAutolinking::createNitroGeolocationCompat();
+      return hybridObject;
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/NitroGeolocationAutolinking.swift

@@ -22,4 +22,19 @@ public final class NitroGeolocationAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridNitroGeolocationCompatSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridNitroGeolocationCompatSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `NitroGeolocationCompat`).
+   */
+  public static func createNitroGeolocationCompat() -> bridge.std__shared_ptr_HybridNitroGeolocationCompatSpec_ {
+    let hybridObject = NitroGeolocationCompat()
+    return { () -> bridge.std__shared_ptr_HybridNitroGeolocationCompatSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
 }

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

@@ -0,0 +1,11 @@
+///
+/// HybridNitroGeolocationCompatSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroGeolocationCompatSpecSwift.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+} // namespace margelo::nitro::nitrogeolocation