react-native-nitro-geolocation 1.2.6 → 1.3.1

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

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

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

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

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

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

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

@@ -0,0 +1,47 @@
+///
+/// HybridNitroBackgroundLocationSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBackgroundLocationSpec.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  void HybridNitroBackgroundLocationSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("checkBackgroundPermission", &HybridNitroBackgroundLocationSpec::checkBackgroundPermission);
+      prototype.registerHybridMethod("requestBackgroundPermission", &HybridNitroBackgroundLocationSpec::requestBackgroundPermission);
+      prototype.registerHybridMethod("openAppLocationSettings", &HybridNitroBackgroundLocationSpec::openAppLocationSettings);
+      prototype.registerHybridMethod("configureBackgroundLocation", &HybridNitroBackgroundLocationSpec::configureBackgroundLocation);
+      prototype.registerHybridMethod("getBackgroundConfiguration", &HybridNitroBackgroundLocationSpec::getBackgroundConfiguration);
+      prototype.registerHybridMethod("startBackgroundLocation", &HybridNitroBackgroundLocationSpec::startBackgroundLocation);
+      prototype.registerHybridMethod("stopBackgroundLocation", &HybridNitroBackgroundLocationSpec::stopBackgroundLocation);
+      prototype.registerHybridMethod("resetBackgroundLocation", &HybridNitroBackgroundLocationSpec::resetBackgroundLocation);
+      prototype.registerHybridMethod("getBackgroundLocationStatus", &HybridNitroBackgroundLocationSpec::getBackgroundLocationStatus);
+      prototype.registerHybridMethod("addBackgroundEventListener", &HybridNitroBackgroundLocationSpec::addBackgroundEventListener);
+      prototype.registerHybridMethod("removeBackgroundEventListener", &HybridNitroBackgroundLocationSpec::removeBackgroundEventListener);
+      prototype.registerHybridMethod("addBackgroundLocationListener", &HybridNitroBackgroundLocationSpec::addBackgroundLocationListener);
+      prototype.registerHybridMethod("removeBackgroundLocationListener", &HybridNitroBackgroundLocationSpec::removeBackgroundLocationListener);
+      prototype.registerHybridMethod("addBackgroundErrorListener", &HybridNitroBackgroundLocationSpec::addBackgroundErrorListener);
+      prototype.registerHybridMethod("removeBackgroundErrorListener", &HybridNitroBackgroundLocationSpec::removeBackgroundErrorListener);
+      prototype.registerHybridMethod("getStoredBackgroundLocations", &HybridNitroBackgroundLocationSpec::getStoredBackgroundLocations);
+      prototype.registerHybridMethod("clearStoredBackgroundLocations", &HybridNitroBackgroundLocationSpec::clearStoredBackgroundLocations);
+      prototype.registerHybridMethod("markStoredBackgroundLocationsDelivered", &HybridNitroBackgroundLocationSpec::markStoredBackgroundLocationsDelivered);
+      prototype.registerHybridMethod("getStoredBackgroundEvents", &HybridNitroBackgroundLocationSpec::getStoredBackgroundEvents);
+      prototype.registerHybridMethod("clearStoredBackgroundEvents", &HybridNitroBackgroundLocationSpec::clearStoredBackgroundEvents);
+      prototype.registerHybridMethod("markStoredBackgroundEventsDelivered", &HybridNitroBackgroundLocationSpec::markStoredBackgroundEventsDelivered);
+      prototype.registerHybridMethod("addGeofences", &HybridNitroBackgroundLocationSpec::addGeofences);
+      prototype.registerHybridMethod("removeGeofences", &HybridNitroBackgroundLocationSpec::removeGeofences);
+      prototype.registerHybridMethod("getRegisteredGeofences", &HybridNitroBackgroundLocationSpec::getRegisteredGeofences);
+      prototype.registerHybridMethod("startActivityRecognition", &HybridNitroBackgroundLocationSpec::startActivityRecognition);
+      prototype.registerHybridMethod("stopActivityRecognition", &HybridNitroBackgroundLocationSpec::stopActivityRecognition);
+      prototype.registerHybridMethod("syncStoredLocations", &HybridNitroBackgroundLocationSpec::syncStoredLocations);
+    });
+  }
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,133 @@
+///
+/// HybridNitroBackgroundLocationSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `BackgroundPermissionResult` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundPermissionResult; }
+// Forward declaration of `BackgroundLocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundLocationOptions; }
+// Forward declaration of `BackgroundLocationStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundLocationStatus; }
+// Forward declaration of `BackgroundEventEnvelope` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundEventEnvelope; }
+// Forward declaration of `BackgroundLocation` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundLocation; }
+// Forward declaration of `LocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationError; }
+// Forward declaration of `StoredBackgroundLocation` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct StoredBackgroundLocation; }
+// Forward declaration of `GetStoredBackgroundLocationsOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GetStoredBackgroundLocationsOptions; }
+// Forward declaration of `StoredBackgroundEventEnvelope` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct StoredBackgroundEventEnvelope; }
+// Forward declaration of `GetStoredBackgroundEventsOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GetStoredBackgroundEventsOptions; }
+// Forward declaration of `GeofenceRegion` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeofenceRegion; }
+// Forward declaration of `GeofencingOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeofencingOptions; }
+// Forward declaration of `ActivityRecognitionOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ActivityRecognitionOptions; }
+// Forward declaration of `BackgroundHttpSyncResult` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundHttpSyncResult; }
+
+#include "BackgroundPermissionResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include "BackgroundLocationOptions.hpp"
+#include <optional>
+#include "BackgroundLocationStatus.hpp"
+#include <string>
+#include "BackgroundEventEnvelope.hpp"
+#include <functional>
+#include "BackgroundLocation.hpp"
+#include "LocationError.hpp"
+#include "StoredBackgroundLocation.hpp"
+#include <vector>
+#include "GetStoredBackgroundLocationsOptions.hpp"
+#include "StoredBackgroundEventEnvelope.hpp"
+#include "GetStoredBackgroundEventsOptions.hpp"
+#include "GeofenceRegion.hpp"
+#include "GeofencingOptions.hpp"
+#include "ActivityRecognitionOptions.hpp"
+#include "BackgroundHttpSyncResult.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NitroBackgroundLocation`
+   * Inherit this class to create instances of `HybridNitroBackgroundLocationSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNitroBackgroundLocation: public HybridNitroBackgroundLocationSpec {
+   * public:
+   *   HybridNitroBackgroundLocation(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNitroBackgroundLocationSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNitroBackgroundLocationSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNitroBackgroundLocationSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<BackgroundPermissionResult>> checkBackgroundPermission() = 0;
+      virtual std::shared_ptr<Promise<BackgroundPermissionResult>> requestBackgroundPermission() = 0;
+      virtual std::shared_ptr<Promise<void>> openAppLocationSettings() = 0;
+      virtual std::shared_ptr<Promise<void>> configureBackgroundLocation(const BackgroundLocationOptions& options) = 0;
+      virtual std::shared_ptr<Promise<std::optional<BackgroundLocationOptions>>> getBackgroundConfiguration() = 0;
+      virtual std::shared_ptr<Promise<void>> startBackgroundLocation(const std::optional<BackgroundLocationOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<void>> stopBackgroundLocation() = 0;
+      virtual std::shared_ptr<Promise<void>> resetBackgroundLocation() = 0;
+      virtual std::shared_ptr<Promise<BackgroundLocationStatus>> getBackgroundLocationStatus() = 0;
+      virtual std::string addBackgroundEventListener(const std::function<void(const BackgroundEventEnvelope& /* event */)>& listener) = 0;
+      virtual void removeBackgroundEventListener(const std::string& token) = 0;
+      virtual std::string addBackgroundLocationListener(const std::function<void(const BackgroundLocation& /* location */)>& listener) = 0;
+      virtual void removeBackgroundLocationListener(const std::string& token) = 0;
+      virtual std::string addBackgroundErrorListener(const std::function<void(const LocationError& /* error */)>& listener) = 0;
+      virtual void removeBackgroundErrorListener(const std::string& token) = 0;
+      virtual std::shared_ptr<Promise<std::vector<StoredBackgroundLocation>>> getStoredBackgroundLocations(const std::optional<GetStoredBackgroundLocationsOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<void>> clearStoredBackgroundLocations(const std::optional<std::vector<std::string>>& ids) = 0;
+      virtual std::shared_ptr<Promise<void>> markStoredBackgroundLocationsDelivered(const std::vector<std::string>& ids) = 0;
+      virtual std::shared_ptr<Promise<std::vector<StoredBackgroundEventEnvelope>>> getStoredBackgroundEvents(const std::optional<GetStoredBackgroundEventsOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<void>> clearStoredBackgroundEvents(const std::optional<std::vector<std::string>>& ids) = 0;
+      virtual std::shared_ptr<Promise<void>> markStoredBackgroundEventsDelivered(const std::vector<std::string>& ids) = 0;
+      virtual std::shared_ptr<Promise<void>> addGeofences(const std::vector<GeofenceRegion>& regions, const std::optional<GeofencingOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<void>> removeGeofences(const std::optional<std::vector<std::string>>& identifiers) = 0;
+      virtual std::shared_ptr<Promise<std::vector<GeofenceRegion>>> getRegisteredGeofences() = 0;
+      virtual std::shared_ptr<Promise<void>> startActivityRecognition(const std::optional<ActivityRecognitionOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<void>> stopActivityRecognition() = 0;
+      virtual std::shared_ptr<Promise<BackgroundHttpSyncResult>> syncStoredLocations() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NitroBackgroundLocation";
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

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