react-native-nitro-location-tracking 0.1.5 → 0.1.6

package/nitrogen/generated/ios/swift/HybridNitroLocationTrackingSpec_cxx.swift

@@ -327,6 +327,203 @@ open class HybridNitroLocationTrackingSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func isFakeGpsEnabled() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.isFakeGpsEnabled()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setRejectMockLocations(reject: Bool) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setRejectMockLocations(reject: reject)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addGeofence(region: GeofenceRegion) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addGeofence(region: region)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removeGeofence(regionId: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removeGeofence(regionId: String(regionId))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removeAllGeofences() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removeAllGeofences()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func onGeofenceEvent(callback: bridge.Func_void_GeofenceEvent_std__string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.onGeofenceEvent(callback: { () -> (GeofenceEvent, String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_GeofenceEvent_std__string(callback)
+        return { (__event: GeofenceEvent, __regionId: String) -> Void in
+          __wrappedFunction.call(__event.rawValue, std.string(__regionId))
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func configureSpeedMonitor(config: SpeedConfig) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.configureSpeedMonitor(config: config)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func onSpeedAlert(callback: bridge.Func_void_SpeedAlertType_double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.onSpeedAlert(callback: { () -> (SpeedAlertType, Double) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_SpeedAlertType_double(callback)
+        return { (__alert: SpeedAlertType, __currentSpeedKmh: Double) -> Void in
+          __wrappedFunction.call(__alert.rawValue, __currentSpeedKmh)
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getCurrentSpeed() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getCurrentSpeed()
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func startTripCalculation() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.startTripCalculation()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func stopTripCalculation() -> bridge.Result_TripStats_ {
+    do {
+      let __result = try self.__implementation.stopTripCalculation()
+      let __resultCpp = __result
+      return bridge.create_Result_TripStats_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_TripStats_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getTripStats() -> bridge.Result_TripStats_ {
+    do {
+      let __result = try self.__implementation.getTripStats()
+      let __resultCpp = __result
+      return bridge.create_Result_TripStats_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_TripStats_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func resetTripCalculation() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.resetTripCalculation()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func isLocationServicesEnabled() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.isLocationServicesEnabled()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func onProviderStatusChange(callback: bridge.Func_void_LocationProviderStatus_LocationProviderStatus) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.onProviderStatusChange(callback: { () -> (LocationProviderStatus, LocationProviderStatus) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_LocationProviderStatus_LocationProviderStatus(callback)
+        return { (__gps: LocationProviderStatus, __network: LocationProviderStatus) -> Void in
+          __wrappedFunction.call(__gps.rawValue, __network.rawValue)
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getLocationPermissionStatus() -> bridge.Result_PermissionStatus_ {
+    do {
+      let __result = try self.__implementation.getLocationPermissionStatus()
+      let __resultCpp = __result
+      return bridge.create_Result_PermissionStatus_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_PermissionStatus_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func showLocalNotification(title: std.string, body: std.string) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/LocationData.swift

@@ -18,8 +18,14 @@ public extension LocationData {
   /**
    * Create a new instance of `LocationData`.
    */
-  init(latitude: Double, longitude: Double, altitude: Double, speed: Double, bearing: Double, accuracy: Double, timestamp: Double) {
-    self.init(latitude, longitude, altitude, speed, bearing, accuracy, timestamp)
+  init(latitude: Double, longitude: Double, altitude: Double, speed: Double, bearing: Double, accuracy: Double, timestamp: Double, isMockLocation: Bool?) {
+    self.init(latitude, longitude, altitude, speed, bearing, accuracy, timestamp, { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = isMockLocation {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
   }
 
   @inline(__always)
@@ -56,4 +62,16 @@ public extension LocationData {
   var timestamp: Double {
     return self.__timestamp
   }
+  
+  @inline(__always)
+  var isMockLocation: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__isMockLocation) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__isMockLocation)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
 }

package/nitrogen/generated/ios/swift/LocationProviderStatus.swift

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

package/nitrogen/generated/ios/swift/PermissionStatus.swift

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

package/nitrogen/generated/ios/swift/SpeedAlertType.swift

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

package/nitrogen/generated/ios/swift/SpeedConfig.swift

@@ -0,0 +1,39 @@
+///
+/// SpeedConfig.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `SpeedConfig`, backed by a C++ struct.
+ */
+public typealias SpeedConfig = margelo.nitro.nitrolocationtracking.SpeedConfig
+
+public extension SpeedConfig {
+  private typealias bridge = margelo.nitro.nitrolocationtracking.bridge.swift
+
+  /**
+   * Create a new instance of `SpeedConfig`.
+   */
+  init(maxSpeedKmh: Double, minSpeedKmh: Double, checkIntervalMs: Double) {
+    self.init(maxSpeedKmh, minSpeedKmh, checkIntervalMs)
+  }
+
+  @inline(__always)
+  var maxSpeedKmh: Double {
+    return self.__maxSpeedKmh
+  }
+  
+  @inline(__always)
+  var minSpeedKmh: Double {
+    return self.__minSpeedKmh
+  }
+  
+  @inline(__always)
+  var checkIntervalMs: Double {
+    return self.__checkIntervalMs
+  }
+}

package/nitrogen/generated/ios/swift/TripStats.swift

@@ -0,0 +1,49 @@
+///
+/// TripStats.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `TripStats`, backed by a C++ struct.
+ */
+public typealias TripStats = margelo.nitro.nitrolocationtracking.TripStats
+
+public extension TripStats {
+  private typealias bridge = margelo.nitro.nitrolocationtracking.bridge.swift
+
+  /**
+   * Create a new instance of `TripStats`.
+   */
+  init(distanceMeters: Double, durationMs: Double, averageSpeedKmh: Double, maxSpeedKmh: Double, pointCount: Double) {
+    self.init(distanceMeters, durationMs, averageSpeedKmh, maxSpeedKmh, pointCount)
+  }
+
+  @inline(__always)
+  var distanceMeters: Double {
+    return self.__distanceMeters
+  }
+  
+  @inline(__always)
+  var durationMs: Double {
+    return self.__durationMs
+  }
+  
+  @inline(__always)
+  var averageSpeedKmh: Double {
+    return self.__averageSpeedKmh
+  }
+  
+  @inline(__always)
+  var maxSpeedKmh: Double {
+    return self.__maxSpeedKmh
+  }
+  
+  @inline(__always)
+  var pointCount: Double {
+    return self.__pointCount
+  }
+}

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

@@ -0,0 +1,76 @@
+///
+/// GeofenceEvent.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::nitrolocationtracking {
+
+  /**
+   * An enum which can be represented as a JavaScript union (GeofenceEvent).
+   */
+  enum class GeofenceEvent {
+    ENTER      SWIFT_NAME(enter) = 0,
+    EXIT      SWIFT_NAME(exit) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitrolocationtracking
+
+namespace margelo::nitro {
+
+  // C++ GeofenceEvent <> JS GeofenceEvent (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrolocationtracking::GeofenceEvent> final {
+    static inline margelo::nitro::nitrolocationtracking::GeofenceEvent 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("enter"): return margelo::nitro::nitrolocationtracking::GeofenceEvent::ENTER;
+        case hashString("exit"): return margelo::nitro::nitrolocationtracking::GeofenceEvent::EXIT;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum GeofenceEvent - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitrolocationtracking::GeofenceEvent arg) {
+      switch (arg) {
+        case margelo::nitro::nitrolocationtracking::GeofenceEvent::ENTER: return JSIConverter<std::string>::toJSI(runtime, "enter");
+        case margelo::nitro::nitrolocationtracking::GeofenceEvent::EXIT: return JSIConverter<std::string>::toJSI(runtime, "exit");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert GeofenceEvent 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("enter"):
+        case hashString("exit"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,103 @@
+///
+/// GeofenceRegion.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 <string>
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  /**
+   * A struct which can be represented as a JavaScript object (GeofenceRegion).
+   */
+  struct GeofenceRegion final {
+  public:
+    std::string id     SWIFT_PRIVATE;
+    double latitude     SWIFT_PRIVATE;
+    double longitude     SWIFT_PRIVATE;
+    double radius     SWIFT_PRIVATE;
+    bool notifyOnEntry     SWIFT_PRIVATE;
+    bool notifyOnExit     SWIFT_PRIVATE;
+
+  public:
+    GeofenceRegion() = default;
+    explicit GeofenceRegion(std::string id, double latitude, double longitude, double radius, bool notifyOnEntry, bool notifyOnExit): id(id), latitude(latitude), longitude(longitude), radius(radius), notifyOnEntry(notifyOnEntry), notifyOnExit(notifyOnExit) {}
+
+  public:
+    friend bool operator==(const GeofenceRegion& lhs, const GeofenceRegion& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking
+
+namespace margelo::nitro {
+
+  // C++ GeofenceRegion <> JS GeofenceRegion (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrolocationtracking::GeofenceRegion> final {
+    static inline margelo::nitro::nitrolocationtracking::GeofenceRegion fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrolocationtracking::GeofenceRegion(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "latitude"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "longitude"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "radius"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "notifyOnEntry"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "notifyOnExit")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrolocationtracking::GeofenceRegion& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "id"), JSIConverter<std::string>::toJSI(runtime, arg.id));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "latitude"), JSIConverter<double>::toJSI(runtime, arg.latitude));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "longitude"), JSIConverter<double>::toJSI(runtime, arg.longitude));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "radius"), JSIConverter<double>::toJSI(runtime, arg.radius));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "notifyOnEntry"), JSIConverter<bool>::toJSI(runtime, arg.notifyOnEntry));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "notifyOnExit"), JSIConverter<bool>::toJSI(runtime, arg.notifyOnExit));
+      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::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "latitude")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "longitude")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "radius")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "notifyOnEntry")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "notifyOnExit")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -29,6 +29,22 @@ namespace margelo::nitro::nitrolocationtracking {
       prototype.registerHybridMethod("onConnectionStateChange", &HybridNitroLocationTrackingSpec::onConnectionStateChange);
       prototype.registerHybridMethod("onMessage", &HybridNitroLocationTrackingSpec::onMessage);
       prototype.registerHybridMethod("forceSync", &HybridNitroLocationTrackingSpec::forceSync);
+      prototype.registerHybridMethod("isFakeGpsEnabled", &HybridNitroLocationTrackingSpec::isFakeGpsEnabled);
+      prototype.registerHybridMethod("setRejectMockLocations", &HybridNitroLocationTrackingSpec::setRejectMockLocations);
+      prototype.registerHybridMethod("addGeofence", &HybridNitroLocationTrackingSpec::addGeofence);
+      prototype.registerHybridMethod("removeGeofence", &HybridNitroLocationTrackingSpec::removeGeofence);
+      prototype.registerHybridMethod("removeAllGeofences", &HybridNitroLocationTrackingSpec::removeAllGeofences);
+      prototype.registerHybridMethod("onGeofenceEvent", &HybridNitroLocationTrackingSpec::onGeofenceEvent);
+      prototype.registerHybridMethod("configureSpeedMonitor", &HybridNitroLocationTrackingSpec::configureSpeedMonitor);
+      prototype.registerHybridMethod("onSpeedAlert", &HybridNitroLocationTrackingSpec::onSpeedAlert);
+      prototype.registerHybridMethod("getCurrentSpeed", &HybridNitroLocationTrackingSpec::getCurrentSpeed);
+      prototype.registerHybridMethod("startTripCalculation", &HybridNitroLocationTrackingSpec::startTripCalculation);
+      prototype.registerHybridMethod("stopTripCalculation", &HybridNitroLocationTrackingSpec::stopTripCalculation);
+      prototype.registerHybridMethod("getTripStats", &HybridNitroLocationTrackingSpec::getTripStats);
+      prototype.registerHybridMethod("resetTripCalculation", &HybridNitroLocationTrackingSpec::resetTripCalculation);
+      prototype.registerHybridMethod("isLocationServicesEnabled", &HybridNitroLocationTrackingSpec::isLocationServicesEnabled);
+      prototype.registerHybridMethod("onProviderStatusChange", &HybridNitroLocationTrackingSpec::onProviderStatusChange);
+      prototype.registerHybridMethod("getLocationPermissionStatus", &HybridNitroLocationTrackingSpec::getLocationPermissionStatus);
       prototype.registerHybridMethod("showLocalNotification", &HybridNitroLocationTrackingSpec::showLocalNotification);
       prototype.registerHybridMethod("updateForegroundNotification", &HybridNitroLocationTrackingSpec::updateForegroundNotification);
       prototype.registerHybridMethod("destroy", &HybridNitroLocationTrackingSpec::destroy);