react-native-nitro-geolocation 1.1.3 → 1.2.0

package/nitrogen/generated/ios/swift/HybridNitroGeolocationSpec_cxx.swift

@@ -125,7 +125,7 @@ open class HybridNitroGeolocationSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func setConfiguration(config: ModernGeolocationConfiguration) -> bridge.Result_void_ {
+  public final func setConfiguration(config: GeolocationConfiguration) -> bridge.Result_void_ {
     do {
       try self.__implementation.setConfiguration(config: config)
       return bridge.create_Result_void_()
@@ -155,40 +155,343 @@ open class HybridNitroGeolocationSpec_cxx {
   }
   
   @inline(__always)
-  public final func requestPermission() -> bridge.Result_std__shared_ptr_Promise_PermissionStatus___ {
+  public final func requestPermission(success: bridge.Func_void_PermissionStatus, error: bridge.std__optional_std__function_void_const_LocationError_____error______) -> bridge.Result_void_ {
     do {
-      let __result = try self.__implementation.requestPermission()
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_PermissionStatus__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_PermissionStatus__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_PermissionStatus__(__promise)
+      try self.__implementation.requestPermission(success: { () -> (PermissionStatus) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PermissionStatus(success)
+        return { (__status: PermissionStatus) -> Void in
+          __wrappedFunction.call(__status.rawValue)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func hasServicesEnabled() -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.hasServicesEnabled()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
         __result
           .then({ __result in __promiseHolder.resolve(__result) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_PermissionStatus___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_PermissionStatus___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getProviderStatus() -> bridge.Result_std__shared_ptr_Promise_LocationProviderStatus___ {
+    do {
+      let __result = try self.__implementation.getProviderStatus()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_LocationProviderStatus__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_LocationProviderStatus__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_LocationProviderStatus__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_LocationProviderStatus___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_LocationProviderStatus___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getLocationAvailability() -> bridge.Result_std__shared_ptr_Promise_LocationAvailability___ {
+    do {
+      let __result = try self.__implementation.getLocationAvailability()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_LocationAvailability__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_LocationAvailability__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_LocationAvailability__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_LocationAvailability___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_LocationAvailability___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func requestLocationSettings(success: bridge.Func_void_LocationProviderStatus, error: bridge.std__optional_std__function_void_const_LocationError_____error______, options: bridge.std__optional_LocationSettingsOptions_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.requestLocationSettings(success: { () -> (LocationProviderStatus) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_LocationProviderStatus(success)
+        return { (__status: LocationProviderStatus) -> Void in
+          __wrappedFunction.call(__status)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }(), options: options.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getCurrentPosition(options: bridge.std__optional_LocationRequestOptions_) -> bridge.Result_std__shared_ptr_Promise_GeolocationResponse___ {
+  public final func getAccuracyAuthorization() -> bridge.Result_std__shared_ptr_Promise_AccuracyAuthorization___ {
     do {
-      let __result = try self.__implementation.getCurrentPosition(options: options.value)
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_GeolocationResponse__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_GeolocationResponse__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_GeolocationResponse__(__promise)
+      let __result = try self.__implementation.getAccuracyAuthorization()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_AccuracyAuthorization__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_AccuracyAuthorization__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_AccuracyAuthorization__(__promise)
         __result
           .then({ __result in __promiseHolder.resolve(__result) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_GeolocationResponse___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_AccuracyAuthorization___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_AccuracyAuthorization___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func requestTemporaryFullAccuracy(purposeKey: std.string, success: bridge.Func_void_AccuracyAuthorization, error: bridge.std__optional_std__function_void_const_LocationError_____error______) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.requestTemporaryFullAccuracy(purposeKey: String(purposeKey), success: { () -> (AccuracyAuthorization) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_AccuracyAuthorization(success)
+        return { (__authorization: AccuracyAuthorization) -> Void in
+          __wrappedFunction.call(__authorization.rawValue)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getCurrentPosition(success: bridge.Func_void_GeolocationResponse, error: bridge.std__optional_std__function_void_const_LocationError_____error______, options: bridge.std__optional_LocationRequestOptions_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.getCurrentPosition(success: { () -> (GeolocationResponse) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_GeolocationResponse(success)
+        return { (__position: GeolocationResponse) -> Void in
+          __wrappedFunction.call(__position)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }(), options: options.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getLastKnownPosition(success: bridge.Func_void_GeolocationResponse, error: bridge.std__optional_std__function_void_const_LocationError_____error______, options: bridge.std__optional_LocationRequestOptions_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.getLastKnownPosition(success: { () -> (GeolocationResponse) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_GeolocationResponse(success)
+        return { (__position: GeolocationResponse) -> Void in
+          __wrappedFunction.call(__position)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }(), options: options.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func geocode(address: std.string, success: bridge.Func_void_std__vector_GeocodedLocation_, error: bridge.std__optional_std__function_void_const_LocationError_____error______) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.geocode(address: String(address), success: { () -> ([GeocodedLocation]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_GeocodedLocation_(success)
+        return { (__locations: [GeocodedLocation]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_GeocodedLocation_ in
+            var __vector = bridge.create_std__vector_GeocodedLocation_(__locations.count)
+            for __item in __locations {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func reverseGeocode(coords: GeocodingCoordinates, success: bridge.Func_void_std__vector_ReverseGeocodedAddress_, error: bridge.std__optional_std__function_void_const_LocationError_____error______) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.reverseGeocode(coords: coords, success: { () -> ([ReverseGeocodedAddress]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_ReverseGeocodedAddress_(success)
+        return { (__addresses: [ReverseGeocodedAddress]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_ReverseGeocodedAddress_ in
+            var __vector = bridge.create_std__vector_ReverseGeocodedAddress_(__addresses.count)
+            for __item in __addresses {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getHeading(success: bridge.Func_void_Heading, error: bridge.std__optional_std__function_void_const_LocationError_____error______) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.getHeading(success: { () -> (Heading) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_Heading(success)
+        return { (__heading: Heading) -> Void in
+          __wrappedFunction.call(__heading)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func watchHeading(success: bridge.Func_void_Heading, error: bridge.std__optional_std__function_void_const_LocationError_____error______, options: bridge.std__optional_HeadingOptions_) -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.watchHeading(success: { () -> (Heading) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_Heading(success)
+        return { (__heading: Heading) -> Void in
+          __wrappedFunction.call(__heading)
+        }
+      }(), error: { () -> ((_ error: LocationError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_LocationError_____error______(error) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_LocationError_____error______(error)
+          return { () -> (LocationError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_LocationError(__unwrapped)
+            return { (__error: LocationError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }(), options: options.value)
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_GeolocationResponse___(__exceptionPtr)
+      return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/IOSAccuracyPreset.swift

@@ -0,0 +1,60 @@
+///
+/// IOSAccuracyPreset.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 `IOSAccuracyPreset`, backed by a C++ enum.
+ */
+public typealias IOSAccuracyPreset = margelo.nitro.nitrogeolocation.IOSAccuracyPreset
+
+public extension IOSAccuracyPreset {
+  /**
+   * Get a IOSAccuracyPreset for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "bestForNavigation":
+        self = .bestfornavigation
+      case "best":
+        self = .best
+      case "nearestTenMeters":
+        self = .nearesttenmeters
+      case "hundredMeters":
+        self = .hundredmeters
+      case "kilometer":
+        self = .kilometer
+      case "threeKilometers":
+        self = .threekilometers
+      case "reduced":
+        self = .reduced
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this IOSAccuracyPreset represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .bestfornavigation:
+        return "bestForNavigation"
+      case .best:
+        return "best"
+      case .nearesttenmeters:
+        return "nearestTenMeters"
+      case .hundredmeters:
+        return "hundredMeters"
+      case .kilometer:
+        return "kilometer"
+      case .threekilometers:
+        return "threeKilometers"
+      case .reduced:
+        return "reduced"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/IOSActivityType.swift

@@ -0,0 +1,52 @@
+///
+/// IOSActivityType.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 `IOSActivityType`, backed by a C++ enum.
+ */
+public typealias IOSActivityType = margelo.nitro.nitrogeolocation.IOSActivityType
+
+public extension IOSActivityType {
+  /**
+   * Get a IOSActivityType for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "other":
+        self = .other
+      case "automotiveNavigation":
+        self = .automotivenavigation
+      case "fitness":
+        self = .fitness
+      case "otherNavigation":
+        self = .othernavigation
+      case "airborne":
+        self = .airborne
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this IOSActivityType represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .other:
+        return "other"
+      case .automotivenavigation:
+        return "automotiveNavigation"
+      case .fitness:
+        return "fitness"
+      case .othernavigation:
+        return "otherNavigation"
+      case .airborne:
+        return "airborne"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/LocationAccuracyOptions.swift

@@ -0,0 +1,46 @@
+///
+/// LocationAccuracyOptions.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 `LocationAccuracyOptions`, backed by a C++ struct.
+ */
+public typealias LocationAccuracyOptions = margelo.nitro.nitrogeolocation.LocationAccuracyOptions
+
+public extension LocationAccuracyOptions {
+  private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  /**
+   * Create a new instance of `LocationAccuracyOptions`.
+   */
+  init(android: AndroidAccuracyPreset?, ios: IOSAccuracyPreset?) {
+    self.init({ () -> bridge.std__optional_AndroidAccuracyPreset_ in
+      if let __unwrappedValue = android {
+        return bridge.create_std__optional_AndroidAccuracyPreset_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_IOSAccuracyPreset_ in
+      if let __unwrappedValue = ios {
+        return bridge.create_std__optional_IOSAccuracyPreset_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var android: AndroidAccuracyPreset? {
+    return self.__android.value
+  }
+  
+  @inline(__always)
+  var ios: IOSAccuracyPreset? {
+    return self.__ios.value
+  }
+}

package/nitrogen/generated/ios/swift/LocationAvailability.swift

@@ -0,0 +1,47 @@
+///
+/// LocationAvailability.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 `LocationAvailability`, backed by a C++ struct.
+ */
+public typealias LocationAvailability = margelo.nitro.nitrogeolocation.LocationAvailability
+
+public extension LocationAvailability {
+  private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  /**
+   * Create a new instance of `LocationAvailability`.
+   */
+  init(available: Bool, reason: String?) {
+    self.init(available, { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = reason {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var available: Bool {
+    return self.__available
+  }
+  
+  @inline(__always)
+  var reason: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__reason) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__reason)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+}

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

@@ -0,0 +1,106 @@
+///
+/// LocationProviderStatus.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 `LocationProviderStatus`, backed by a C++ struct.
+ */
+public typealias LocationProviderStatus = margelo.nitro.nitrogeolocation.LocationProviderStatus
+
+public extension LocationProviderStatus {
+  private typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  /**
+   * Create a new instance of `LocationProviderStatus`.
+   */
+  init(locationServicesEnabled: Bool, backgroundModeEnabled: Bool, gpsAvailable: Bool?, networkAvailable: Bool?, passiveAvailable: Bool?, googleLocationAccuracyEnabled: Bool?) {
+    self.init(locationServicesEnabled, backgroundModeEnabled, { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = gpsAvailable {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = networkAvailable {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = passiveAvailable {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = googleLocationAccuracyEnabled {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var locationServicesEnabled: Bool {
+    return self.__locationServicesEnabled
+  }
+  
+  @inline(__always)
+  var backgroundModeEnabled: Bool {
+    return self.__backgroundModeEnabled
+  }
+  
+  @inline(__always)
+  var gpsAvailable: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__gpsAvailable) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__gpsAvailable)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var networkAvailable: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__networkAvailable) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__networkAvailable)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var passiveAvailable: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__passiveAvailable) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__passiveAvailable)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var googleLocationAccuracyEnabled: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__googleLocationAccuracyEnabled) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__googleLocationAccuracyEnabled)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}