react-native-nitro-geolocation 1.2.6 → 1.3.1

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

@@ -0,0 +1,416 @@
+///
+/// HybridNitroBackgroundLocationSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroBackgroundLocationSpec.hpp"
+
+// Forward declaration of `HybridNitroBackgroundLocationSpec_cxx` to properly resolve imports.
+namespace NitroGeolocation { class HybridNitroBackgroundLocationSpec_cxx; }
+
+// Forward declaration of `BackgroundPermissionResult` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundPermissionResult; }
+// Forward declaration of `PermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
+// Forward declaration of `BackgroundPermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class BackgroundPermissionStatus; }
+// Forward declaration of `AccuracyAuthorization` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AccuracyAuthorization; }
+// Forward declaration of `BackgroundLocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundLocationOptions; }
+// Forward declaration of `BackgroundTrackingMode` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class BackgroundTrackingMode; }
+// Forward declaration of `LocationAccuracyOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAccuracyOptions; }
+// Forward declaration of `AndroidAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidAccuracyPreset; }
+// Forward declaration of `IOSAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSAccuracyPreset; }
+// Forward declaration of `AndroidGranularity` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidGranularity; }
+// Forward declaration of `AndroidBackgroundLocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct AndroidBackgroundLocationOptions; }
+// Forward declaration of `AndroidBackgroundProvider` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidBackgroundProvider; }
+// Forward declaration of `AndroidForegroundServiceOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct AndroidForegroundServiceOptions; }
+// Forward declaration of `IOSBackgroundLocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct IOSBackgroundLocationOptions; }
+// Forward declaration of `IOSBackgroundActivityType` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSBackgroundActivityType; }
+// Forward declaration of `GeofencingOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeofencingOptions; }
+// Forward declaration of `GeofenceTransition` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class GeofenceTransition; }
+// Forward declaration of `ActivityRecognitionOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ActivityRecognitionOptions; }
+// Forward declaration of `BackgroundHttpSyncOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundHttpSyncOptions; }
+// Forward declaration of `BackgroundHttpMethod` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class BackgroundHttpMethod; }
+// Forward declaration of `BackgroundLocationStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundLocationStatus; }
+// Forward declaration of `BackgroundLocationState` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class BackgroundLocationState; }
+// Forward declaration of `LocationProviderStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationProviderStatus; }
+// Forward declaration of `AndroidBackgroundLocationStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct AndroidBackgroundLocationStatus; }
+// Forward declaration of `IOSBackgroundLocationStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct IOSBackgroundLocationStatus; }
+// Forward declaration of `LocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationError; }
+// 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 `BackgroundLocationSource` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class BackgroundLocationSource; }
+// Forward declaration of `LocationProviderUsed` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderUsed; }
+// Forward declaration of `DetectedActivity` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct DetectedActivity; }
+// Forward declaration of `DetectedActivityType` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class DetectedActivityType; }
+// Forward declaration of `BatterySnapshot` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BatterySnapshot; }
+// Forward declaration of `GeolocationCoordinates` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
+// Forward declaration of `GeofenceEvent` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeofenceEvent; }
+// Forward declaration of `GeofenceRegion` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeofenceRegion; }
+// Forward declaration of `BackgroundHttpSyncResult` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct BackgroundHttpSyncResult; }
+// Forward declaration of `BackgroundEventType` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class BackgroundEventType; }
+// 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; }
+
+#include "BackgroundPermissionResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include "PermissionStatus.hpp"
+#include "BackgroundPermissionStatus.hpp"
+#include "AccuracyAuthorization.hpp"
+#include <optional>
+#include "BackgroundLocationOptions.hpp"
+#include "BackgroundTrackingMode.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "AndroidGranularity.hpp"
+#include "AndroidBackgroundLocationOptions.hpp"
+#include "AndroidBackgroundProvider.hpp"
+#include "AndroidForegroundServiceOptions.hpp"
+#include <string>
+#include "IOSBackgroundLocationOptions.hpp"
+#include "IOSBackgroundActivityType.hpp"
+#include "GeofencingOptions.hpp"
+#include "GeofenceTransition.hpp"
+#include <vector>
+#include "ActivityRecognitionOptions.hpp"
+#include "BackgroundHttpSyncOptions.hpp"
+#include "BackgroundHttpMethod.hpp"
+#include <unordered_map>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "BackgroundLocationStatus.hpp"
+#include "BackgroundLocationState.hpp"
+#include "LocationProviderStatus.hpp"
+#include "AndroidBackgroundLocationStatus.hpp"
+#include "IOSBackgroundLocationStatus.hpp"
+#include "LocationError.hpp"
+#include "BackgroundEventEnvelope.hpp"
+#include <functional>
+#include "BackgroundLocation.hpp"
+#include "BackgroundLocationSource.hpp"
+#include "LocationProviderUsed.hpp"
+#include "DetectedActivity.hpp"
+#include "DetectedActivityType.hpp"
+#include "BatterySnapshot.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "GeofenceEvent.hpp"
+#include "GeofenceRegion.hpp"
+#include "BackgroundHttpSyncResult.hpp"
+#include "BackgroundEventType.hpp"
+#include "StoredBackgroundLocation.hpp"
+#include "GetStoredBackgroundLocationsOptions.hpp"
+#include "StoredBackgroundEventEnvelope.hpp"
+#include "GetStoredBackgroundEventsOptions.hpp"
+
+#include "NitroGeolocation-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * The C++ part of HybridNitroBackgroundLocationSpec_cxx.swift.
+   *
+   * HybridNitroBackgroundLocationSpecSwift (C++) accesses HybridNitroBackgroundLocationSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNitroBackgroundLocationSpec_cxx can directly inherit from the C++ class HybridNitroBackgroundLocationSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroBackgroundLocationSpecSwift: public virtual HybridNitroBackgroundLocationSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroBackgroundLocationSpecSwift(const NitroGeolocation::HybridNitroBackgroundLocationSpec_cxx& swiftPart):
+      HybridObject(HybridNitroBackgroundLocationSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroGeolocation::HybridNitroBackgroundLocationSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNitroBackgroundLocationSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<BackgroundPermissionResult>> checkBackgroundPermission() override {
+      auto __result = _swiftPart.checkBackgroundPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BackgroundPermissionResult>> requestBackgroundPermission() override {
+      auto __result = _swiftPart.requestBackgroundPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> openAppLocationSettings() override {
+      auto __result = _swiftPart.openAppLocationSettings();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> configureBackgroundLocation(const BackgroundLocationOptions& options) override {
+      auto __result = _swiftPart.configureBackgroundLocation(std::forward<decltype(options)>(options));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::optional<BackgroundLocationOptions>>> getBackgroundConfiguration() override {
+      auto __result = _swiftPart.getBackgroundConfiguration();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> startBackgroundLocation(const std::optional<BackgroundLocationOptions>& options) override {
+      auto __result = _swiftPart.startBackgroundLocation(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> stopBackgroundLocation() override {
+      auto __result = _swiftPart.stopBackgroundLocation();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> resetBackgroundLocation() override {
+      auto __result = _swiftPart.resetBackgroundLocation();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BackgroundLocationStatus>> getBackgroundLocationStatus() override {
+      auto __result = _swiftPart.getBackgroundLocationStatus();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::string addBackgroundEventListener(const std::function<void(const BackgroundEventEnvelope& /* event */)>& listener) override {
+      auto __result = _swiftPart.addBackgroundEventListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void removeBackgroundEventListener(const std::string& token) override {
+      auto __result = _swiftPart.removeBackgroundEventListener(token);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::string addBackgroundLocationListener(const std::function<void(const BackgroundLocation& /* location */)>& listener) override {
+      auto __result = _swiftPart.addBackgroundLocationListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void removeBackgroundLocationListener(const std::string& token) override {
+      auto __result = _swiftPart.removeBackgroundLocationListener(token);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::string addBackgroundErrorListener(const std::function<void(const LocationError& /* error */)>& listener) override {
+      auto __result = _swiftPart.addBackgroundErrorListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void removeBackgroundErrorListener(const std::string& token) override {
+      auto __result = _swiftPart.removeBackgroundErrorListener(token);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<std::vector<StoredBackgroundLocation>>> getStoredBackgroundLocations(const std::optional<GetStoredBackgroundLocationsOptions>& options) override {
+      auto __result = _swiftPart.getStoredBackgroundLocations(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearStoredBackgroundLocations(const std::optional<std::vector<std::string>>& ids) override {
+      auto __result = _swiftPart.clearStoredBackgroundLocations(ids);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> markStoredBackgroundLocationsDelivered(const std::vector<std::string>& ids) override {
+      auto __result = _swiftPart.markStoredBackgroundLocationsDelivered(ids);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<StoredBackgroundEventEnvelope>>> getStoredBackgroundEvents(const std::optional<GetStoredBackgroundEventsOptions>& options) override {
+      auto __result = _swiftPart.getStoredBackgroundEvents(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearStoredBackgroundEvents(const std::optional<std::vector<std::string>>& ids) override {
+      auto __result = _swiftPart.clearStoredBackgroundEvents(ids);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> markStoredBackgroundEventsDelivered(const std::vector<std::string>& ids) override {
+      auto __result = _swiftPart.markStoredBackgroundEventsDelivered(ids);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> addGeofences(const std::vector<GeofenceRegion>& regions, const std::optional<GeofencingOptions>& options) override {
+      auto __result = _swiftPart.addGeofences(regions, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> removeGeofences(const std::optional<std::vector<std::string>>& identifiers) override {
+      auto __result = _swiftPart.removeGeofences(identifiers);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<GeofenceRegion>>> getRegisteredGeofences() override {
+      auto __result = _swiftPart.getRegisteredGeofences();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> startActivityRecognition(const std::optional<ActivityRecognitionOptions>& options) override {
+      auto __result = _swiftPart.startActivityRecognition(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> stopActivityRecognition() override {
+      auto __result = _swiftPart.stopActivityRecognition();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BackgroundHttpSyncResult>> syncStoredLocations() override {
+      auto __result = _swiftPart.syncStoredLocations();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroGeolocation::HybridNitroBackgroundLocationSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/ios/swift/ActivityRecognitionOptions.swift

@@ -0,0 +1,96 @@
+///
+/// ActivityRecognitionOptions.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 `ActivityRecognitionOptions`, backed by a C++ struct.
+ */
+public typealias ActivityRecognitionOptions = margelo.nitro.nitrogeolocation.ActivityRecognitionOptions
+
+public extension ActivityRecognitionOptions {
+  private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  /**
+   * Create a new instance of `ActivityRecognitionOptions`.
+   */
+  init(enabled: Bool?, interval: Double?, stopOnStill: Bool?, minimumConfidence: Double?) {
+    self.init({ () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = enabled {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = interval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = stopOnStill {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = minimumConfidence {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var enabled: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__enabled) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__enabled)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var interval: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__interval) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__interval)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var stopOnStill: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__stopOnStill) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__stopOnStill)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var minimumConfidence: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__minimumConfidence) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__minimumConfidence)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/AndroidBackgroundLocationOptions.swift

@@ -0,0 +1,76 @@
+///
+/// AndroidBackgroundLocationOptions.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 `AndroidBackgroundLocationOptions`, backed by a C++ struct.
+ */
+public typealias AndroidBackgroundLocationOptions = margelo.nitro.nitrogeolocation.AndroidBackgroundLocationOptions
+
+public extension AndroidBackgroundLocationOptions {
+  private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  /**
+   * Create a new instance of `AndroidBackgroundLocationOptions`.
+   */
+  init(locationProvider: AndroidBackgroundProvider?, foregroundService: AndroidForegroundServiceOptions, requestNotificationPermission: Bool?, requestIgnoreBatteryOptimizations: Bool?) {
+    self.init({ () -> bridge.std__optional_AndroidBackgroundProvider_ in
+      if let __unwrappedValue = locationProvider {
+        return bridge.create_std__optional_AndroidBackgroundProvider_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), foregroundService, { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = requestNotificationPermission {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = requestIgnoreBatteryOptimizations {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var locationProvider: AndroidBackgroundProvider? {
+    return self.__locationProvider.value
+  }
+  
+  @inline(__always)
+  var foregroundService: AndroidForegroundServiceOptions {
+    return self.__foregroundService
+  }
+  
+  @inline(__always)
+  var requestNotificationPermission: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__requestNotificationPermission) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__requestNotificationPermission)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var requestIgnoreBatteryOptimizations: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__requestIgnoreBatteryOptimizations) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__requestIgnoreBatteryOptimizations)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/AndroidBackgroundLocationStatus.swift

@@ -0,0 +1,58 @@
+///
+/// AndroidBackgroundLocationStatus.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 `AndroidBackgroundLocationStatus`, backed by a C++ struct.
+ */
+public typealias AndroidBackgroundLocationStatus = margelo.nitro.nitrogeolocation.AndroidBackgroundLocationStatus
+
+public extension AndroidBackgroundLocationStatus {
+  private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  /**
+   * Create a new instance of `AndroidBackgroundLocationStatus`.
+   */
+  init(isForegroundServiceRunning: Bool, isIgnoringBatteryOptimizations: Bool?, notificationPermission: PermissionStatus?) {
+    self.init(isForegroundServiceRunning, { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = isIgnoringBatteryOptimizations {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_PermissionStatus_ in
+      if let __unwrappedValue = notificationPermission {
+        return bridge.create_std__optional_PermissionStatus_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var isForegroundServiceRunning: Bool {
+    return self.__isForegroundServiceRunning
+  }
+  
+  @inline(__always)
+  var isIgnoringBatteryOptimizations: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__isIgnoringBatteryOptimizations) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__isIgnoringBatteryOptimizations)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var notificationPermission: PermissionStatus? {
+    return self.__notificationPermission.value
+  }
+}