@kingstinct/react-native-healthkit 10.0.0 → 11.0.0

package/nitrogen/generated/ios/swift/HybridSourceProxySpec_cxx.swift

@@ -17,7 +17,7 @@ import NitroModules
  * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
  * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
  */
-public class HybridSourceProxySpec_cxx {
+open class HybridSourceProxySpec_cxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::healthkit::bridge::swift`)
    * from `ReactNativeHealthkit-Swift-Cxx-Bridge.hpp`.
@@ -33,7 +33,7 @@ public class HybridSourceProxySpec_cxx {
   /**
    * Holds a weak pointer to the C++ class that wraps the Swift class.
    */
-  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_
+  private var __cxxPart: bridge.std__weak_ptr_HybridSourceProxySpec_
 
   /**
    * Create a new `HybridSourceProxySpec_cxx` that wraps the given `HybridSourceProxySpec`.
@@ -72,15 +72,15 @@ public class HybridSourceProxySpec_cxx {
 
   /**
    * Gets (or creates) the C++ part of this Hybrid Object.
-   * The C++ part is a `std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>`.
+   * The C++ part is a `std::shared_ptr<HybridSourceProxySpec>`.
    */
-  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_ {
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridSourceProxySpec_ {
     let cachedCxxPart = self.__cxxPart.lock()
     if cachedCxxPart.__convertToBool() {
       return cachedCxxPart
     } else {
-      let newCxxPart = bridge.create_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_(self.toUnsafe())
-      __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_(newCxxPart)
+      let newCxxPart = bridge.create_std__shared_ptr_HybridSourceProxySpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridSourceProxySpec_(newCxxPart)
       return newCxxPart
     }
   }
@@ -96,6 +96,15 @@ public class HybridSourceProxySpec_cxx {
     return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
   }
 
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
   // Properties
   public final var bundleIdentifier: std.string {
     @inline(__always)
@@ -109,7 +118,8 @@ public class HybridSourceProxySpec_cxx {
   public final func toJSON(key: bridge.std__optional_std__string_) -> bridge.Result_Source_ {
     do {
       let __result = try self.__implementation.toJSON(key: { () -> String? in
-        if let __unwrapped = key.value {
+        if bridge.has_value_std__optional_std__string_(key) {
+          let __unwrapped = bridge.get_std__optional_std__string_(key)
           return String(__unwrapped)
         } else {
           return nil

package/nitrogen/generated/ios/swift/HybridStateOfMindModuleSpec.swift

@@ -19,8 +19,9 @@ public protocol HybridStateOfMindModuleSpec_protocol: HybridObject {
 }
 
 /// See ``HybridStateOfMindModuleSpec``
-public class HybridStateOfMindModuleSpec_base {
+open class HybridStateOfMindModuleSpec_base {
   private weak var cxxWrapper: HybridStateOfMindModuleSpec_cxx? = nil
+  public init() { }
   public func getCxxWrapper() -> HybridStateOfMindModuleSpec_cxx {
   #if DEBUG
     guard self is HybridStateOfMindModuleSpec else {

package/nitrogen/generated/ios/swift/HybridStateOfMindModuleSpec_cxx.swift

@@ -17,7 +17,7 @@ import NitroModules
  * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
  * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
  */
-public class HybridStateOfMindModuleSpec_cxx {
+open class HybridStateOfMindModuleSpec_cxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::healthkit::bridge::swift`)
    * from `ReactNativeHealthkit-Swift-Cxx-Bridge.hpp`.
@@ -33,7 +33,7 @@ public class HybridStateOfMindModuleSpec_cxx {
   /**
    * Holds a weak pointer to the C++ class that wraps the Swift class.
    */
-  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_
+  private var __cxxPart: bridge.std__weak_ptr_HybridStateOfMindModuleSpec_
 
   /**
    * Create a new `HybridStateOfMindModuleSpec_cxx` that wraps the given `HybridStateOfMindModuleSpec`.
@@ -72,15 +72,15 @@ public class HybridStateOfMindModuleSpec_cxx {
 
   /**
    * Gets (or creates) the C++ part of this Hybrid Object.
-   * The C++ part is a `std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>`.
+   * The C++ part is a `std::shared_ptr<HybridStateOfMindModuleSpec>`.
    */
-  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_ {
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridStateOfMindModuleSpec_ {
     let cachedCxxPart = self.__cxxPart.lock()
     if cachedCxxPart.__convertToBool() {
       return cachedCxxPart
     } else {
-      let newCxxPart = bridge.create_std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(self.toUnsafe())
-      __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(newCxxPart)
+      let newCxxPart = bridge.create_std__shared_ptr_HybridStateOfMindModuleSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridStateOfMindModuleSpec_(newCxxPart)
       return newCxxPart
     }
   }
@@ -96,6 +96,15 @@ public class HybridStateOfMindModuleSpec_cxx {
     return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
   }
 
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
   // Properties
   
 
@@ -104,7 +113,8 @@ public class HybridStateOfMindModuleSpec_cxx {
   public final func queryStateOfMindSamples(options: bridge.std__optional_QueryOptionsWithSortOrder_) -> bridge.Result_std__shared_ptr_Promise_std__vector_StateOfMindSample____ {
     do {
       let __result = try self.__implementation.queryStateOfMindSamples(options: { () -> QueryOptionsWithSortOrder? in
-        if let __unwrapped = options.value {
+        if bridge.has_value_std__optional_QueryOptionsWithSortOrder_(options) {
+          let __unwrapped = bridge.get_std__optional_QueryOptionsWithSortOrder_(options)
           return __unwrapped
         } else {
           return nil
@@ -135,7 +145,8 @@ public class HybridStateOfMindModuleSpec_cxx {
   public final func saveStateOfMindSample(date: margelo.nitro.chrono_time, kind: Int32, valence: Double, labels: bridge.std__vector_StateOfMindLabel_, associations: bridge.std__vector_StateOfMindAssociation_, metadata: bridge.std__optional_std__shared_ptr_AnyMap__) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
       let __result = try self.__implementation.saveStateOfMindSample(date: Date(fromChrono: date), kind: margelo.nitro.healthkit.StateOfMindKind(rawValue: kind)!, valence: valence, labels: labels.map({ __item in __item }), associations: associations.map({ __item in __item }), metadata: { () -> AnyMap? in
-        if let __unwrapped = metadata.value {
+        if bridge.has_value_std__optional_std__shared_ptr_AnyMap__(metadata) {
+          let __unwrapped = bridge.get_std__optional_std__shared_ptr_AnyMap__(metadata)
           return AnyMap(withCppPart: __unwrapped)
         } else {
           return nil

package/nitrogen/generated/ios/swift/HybridWorkoutProxySpec.swift

@@ -11,14 +11,14 @@ import NitroModules
 /// See ``HybridWorkoutProxySpec``
 public protocol HybridWorkoutProxySpec_protocol: HybridObject {
   // Properties
-  var uuid: String { get }
-  var device: Device? { get }
-  var workoutActivityType: WorkoutActivityType { get }
-  var duration: Quantity { get }
   var totalDistance: Quantity? { get }
   var totalEnergyBurned: Quantity? { get }
   var totalSwimmingStrokeCount: Quantity? { get }
   var totalFlightsClimbed: Quantity? { get }
+  var uuid: String { get }
+  var device: Device? { get }
+  var workoutActivityType: WorkoutActivityType { get }
+  var duration: Quantity { get }
   var startDate: Date { get }
   var endDate: Date { get }
   var metadata: AnyMap? { get }
@@ -31,11 +31,14 @@ public protocol HybridWorkoutProxySpec_protocol: HybridObject {
   func saveWorkoutRoute(locations: [LocationForSaving]) throws -> Promise<Bool>
   func getWorkoutPlan() throws -> Promise<WorkoutPlan?>
   func getWorkoutRoutes() throws -> Promise<[WorkoutRoute]>
+  func getStatistic(quantityType: QuantityTypeIdentifier, unitOverride: String?) throws -> Promise<QueryStatisticsResponse?>
+  func getAllStatistics() throws -> Promise<Dictionary<String, QueryStatisticsResponse>>
 }
 
 /// See ``HybridWorkoutProxySpec``
-public class HybridWorkoutProxySpec_base {
+open class HybridWorkoutProxySpec_base {
   private weak var cxxWrapper: HybridWorkoutProxySpec_cxx? = nil
+  public init() { }
   public func getCxxWrapper() -> HybridWorkoutProxySpec_cxx {
   #if DEBUG
     guard self is HybridWorkoutProxySpec else {

package/nitrogen/generated/ios/swift/HybridWorkoutProxySpec_cxx.swift

@@ -17,7 +17,7 @@ import NitroModules
  * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
  * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
  */
-public class HybridWorkoutProxySpec_cxx {
+open class HybridWorkoutProxySpec_cxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::healthkit::bridge::swift`)
    * from `ReactNativeHealthkit-Swift-Cxx-Bridge.hpp`.
@@ -33,7 +33,7 @@ public class HybridWorkoutProxySpec_cxx {
   /**
    * Holds a weak pointer to the C++ class that wraps the Swift class.
    */
-  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_
+  private var __cxxPart: bridge.std__weak_ptr_HybridWorkoutProxySpec_
 
   /**
    * Create a new `HybridWorkoutProxySpec_cxx` that wraps the given `HybridWorkoutProxySpec`.
@@ -72,15 +72,15 @@ public class HybridWorkoutProxySpec_cxx {
 
   /**
    * Gets (or creates) the C++ part of this Hybrid Object.
-   * The C++ part is a `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>`.
+   * The C++ part is a `std::shared_ptr<HybridWorkoutProxySpec>`.
    */
-  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ {
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridWorkoutProxySpec_ {
     let cachedCxxPart = self.__cxxPart.lock()
     if cachedCxxPart.__convertToBool() {
       return cachedCxxPart
     } else {
-      let newCxxPart = bridge.create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(self.toUnsafe())
-      __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(newCxxPart)
+      let newCxxPart = bridge.create_std__shared_ptr_HybridWorkoutProxySpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridWorkoutProxySpec_(newCxxPart)
       return newCxxPart
     }
   }
@@ -96,41 +96,16 @@ public class HybridWorkoutProxySpec_cxx {
     return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
   }
 
-  // Properties
-  public final var uuid: std.string {
-    @inline(__always)
-    get {
-      return std.string(self.__implementation.uuid)
-    }
-  }
-  
-  public final var device: bridge.std__optional_Device_ {
-    @inline(__always)
-    get {
-      return { () -> bridge.std__optional_Device_ in
-        if let __unwrappedValue = self.__implementation.device {
-          return bridge.create_std__optional_Device_(__unwrappedValue)
-        } else {
-          return .init()
-        }
-      }()
-    }
-  }
-  
-  public final var workoutActivityType: Int32 {
-    @inline(__always)
-    get {
-      return self.__implementation.workoutActivityType.rawValue
-    }
-  }
-  
-  public final var duration: Quantity {
-    @inline(__always)
-    get {
-      return self.__implementation.duration
-    }
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
   }
-  
+
+  // Properties
   public final var totalDistance: bridge.std__optional_Quantity_ {
     @inline(__always)
     get {
@@ -183,6 +158,40 @@ public class HybridWorkoutProxySpec_cxx {
     }
   }
   
+  public final var uuid: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.uuid)
+    }
+  }
+  
+  public final var device: bridge.std__optional_Device_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Device_ in
+        if let __unwrappedValue = self.__implementation.device {
+          return bridge.create_std__optional_Device_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var workoutActivityType: Int32 {
+    @inline(__always)
+    get {
+      return self.__implementation.workoutActivityType.rawValue
+    }
+  }
+  
+  public final var duration: Quantity {
+    @inline(__always)
+    get {
+      return self.__implementation.duration
+    }
+  }
+  
   public final var startDate: margelo.nitro.chrono_time {
     @inline(__always)
     get {
@@ -266,7 +275,8 @@ public class HybridWorkoutProxySpec_cxx {
   public final func toJSON(key: bridge.std__optional_std__string_) -> bridge.Result_WorkoutSample_ {
     do {
       let __result = try self.__implementation.toJSON(key: { () -> String? in
-        if let __unwrapped = key.value {
+        if bridge.has_value_std__optional_std__string_(key) {
+          let __unwrapped = bridge.get_std__optional_std__string_(key)
           return String(__unwrapped)
         } else {
           return nil
@@ -348,4 +358,61 @@ public class HybridWorkoutProxySpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_std__vector_WorkoutRoute____(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getStatistic(quantityType: Int32, unitOverride: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_Promise_std__optional_QueryStatisticsResponse____ {
+    do {
+      let __result = try self.__implementation.getStatistic(quantityType: margelo.nitro.healthkit.QuantityTypeIdentifier(rawValue: quantityType)!, unitOverride: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(unitOverride) {
+          let __unwrapped = bridge.get_std__optional_std__string_(unitOverride)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__optional_QueryStatisticsResponse___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__optional_QueryStatisticsResponse___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__optional_QueryStatisticsResponse___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__optional_QueryStatisticsResponse_ in
+              if let __unwrappedValue = __result {
+                return bridge.create_std__optional_QueryStatisticsResponse_(__unwrappedValue)
+              } else {
+                return .init()
+              }
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_QueryStatisticsResponse____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_QueryStatisticsResponse____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getAllStatistics() -> bridge.Result_std__shared_ptr_Promise_std__unordered_map_std__string__QueryStatisticsResponse____ {
+    do {
+      let __result = try self.__implementation.getAllStatistics()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__unordered_map_std__string__QueryStatisticsResponse___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__unordered_map_std__string__QueryStatisticsResponse___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__unordered_map_std__string__QueryStatisticsResponse___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__unordered_map_std__string__QueryStatisticsResponse_ in
+              var __map = bridge.create_std__unordered_map_std__string__QueryStatisticsResponse_(__result.count)
+              for (__k, __v) in __result {
+                bridge.emplace_std__unordered_map_std__string__QueryStatisticsResponse_(&__map, std.string(__k), __v)
+              }
+              return __map
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__unordered_map_std__string__QueryStatisticsResponse____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__unordered_map_std__string__QueryStatisticsResponse____(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/HybridWorkoutsModuleSpec.swift

@@ -21,8 +21,9 @@ public protocol HybridWorkoutsModuleSpec_protocol: HybridObject {
 }
 
 /// See ``HybridWorkoutsModuleSpec``
-public class HybridWorkoutsModuleSpec_base {
+open class HybridWorkoutsModuleSpec_base {
   private weak var cxxWrapper: HybridWorkoutsModuleSpec_cxx? = nil
+  public init() { }
   public func getCxxWrapper() -> HybridWorkoutsModuleSpec_cxx {
   #if DEBUG
     guard self is HybridWorkoutsModuleSpec else {

package/nitrogen/generated/ios/swift/HybridWorkoutsModuleSpec_cxx.swift

@@ -17,7 +17,7 @@ import NitroModules
  * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
  * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
  */
-public class HybridWorkoutsModuleSpec_cxx {
+open class HybridWorkoutsModuleSpec_cxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::healthkit::bridge::swift`)
    * from `ReactNativeHealthkit-Swift-Cxx-Bridge.hpp`.
@@ -33,7 +33,7 @@ public class HybridWorkoutsModuleSpec_cxx {
   /**
    * Holds a weak pointer to the C++ class that wraps the Swift class.
    */
-  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_
+  private var __cxxPart: bridge.std__weak_ptr_HybridWorkoutsModuleSpec_
 
   /**
    * Create a new `HybridWorkoutsModuleSpec_cxx` that wraps the given `HybridWorkoutsModuleSpec`.
@@ -72,15 +72,15 @@ public class HybridWorkoutsModuleSpec_cxx {
 
   /**
    * Gets (or creates) the C++ part of this Hybrid Object.
-   * The C++ part is a `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>`.
+   * The C++ part is a `std::shared_ptr<HybridWorkoutsModuleSpec>`.
    */
-  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ {
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridWorkoutsModuleSpec_ {
     let cachedCxxPart = self.__cxxPart.lock()
     if cachedCxxPart.__convertToBool() {
       return cachedCxxPart
     } else {
-      let newCxxPart = bridge.create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(self.toUnsafe())
-      __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(newCxxPart)
+      let newCxxPart = bridge.create_std__shared_ptr_HybridWorkoutsModuleSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridWorkoutsModuleSpec_(newCxxPart)
       return newCxxPart
     }
   }
@@ -96,29 +96,38 @@ public class HybridWorkoutsModuleSpec_cxx {
     return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
   }
 
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
   // Properties
   
 
   // Methods
   @inline(__always)
-  public final func saveWorkoutSample(workoutActivityType: Int32, quantities: bridge.std__vector_QuantitySampleForSaving_, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, totals: WorkoutTotals, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ {
+  public final func saveWorkoutSample(workoutActivityType: Int32, quantities: bridge.std__vector_QuantitySampleForSaving_, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, totals: WorkoutTotals, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_HybridWorkoutProxySpec____ {
     do {
       let __result = try self.__implementation.saveWorkoutSample(workoutActivityType: margelo.nitro.healthkit.WorkoutActivityType(rawValue: workoutActivityType)!, quantities: quantities.map({ __item in __item }), startDate: Date(fromChrono: startDate), endDate: Date(fromChrono: endDate), totals: totals, metadata: AnyMap(withCppPart: metadata))
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_HybridWorkoutProxySpec___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_HybridWorkoutProxySpec___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_HybridWorkoutProxySpec___(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ in
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__shared_ptr_HybridWorkoutProxySpec_ in
               let __cxxWrapped = __result.getCxxWrapper()
               return __cxxWrapped.getCxxPart()
             }()) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridWorkoutProxySpec____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridWorkoutProxySpec____(__exceptionPtr)
     }
   }
   
@@ -142,17 +151,17 @@ public class HybridWorkoutsModuleSpec_cxx {
   }
   
   @inline(__always)
-  public final func queryWorkoutSamples(options: WorkoutQueryOptions) -> bridge.Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____ {
+  public final func queryWorkoutSamples(options: WorkoutQueryOptions) -> bridge.Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_HybridWorkoutProxySpec_____ {
     do {
       let __result = try self.__implementation.queryWorkoutSamples(options: options)
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_std__shared_ptr_HybridWorkoutProxySpec____ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_std__shared_ptr_HybridWorkoutProxySpec____()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_std__shared_ptr_HybridWorkoutProxySpec____(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ in
-              var __vector = bridge.create_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__(__result.count)
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_std__shared_ptr_HybridWorkoutProxySpec__ in
+              var __vector = bridge.create_std__vector_std__shared_ptr_HybridWorkoutProxySpec__(__result.count)
               for __item in __result {
-                __vector.push_back({ () -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ in
+                __vector.push_back({ () -> bridge.std__shared_ptr_HybridWorkoutProxySpec_ in
                   let __cxxWrapped = __item.getCxxWrapper()
                   return __cxxWrapped.getCxxPart()
                 }())
@@ -162,10 +171,10 @@ public class HybridWorkoutsModuleSpec_cxx {
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_HybridWorkoutProxySpec_____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_HybridWorkoutProxySpec_____(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/OnChangeCallbackArgs.swift

@@ -43,7 +43,8 @@ public extension OnChangeCallbackArgs {
     @inline(__always)
     get {
       return { () -> String? in
-        if let __unwrapped = self.__errorMessage.value {
+        if bridge.has_value_std__optional_std__string_(self.__errorMessage) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__errorMessage)
           return String(__unwrapped)
         } else {
           return nil

package/nitrogen/generated/ios/swift/PredicateForSamples.swift

@@ -5,6 +5,8 @@
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
+
+
 /**
  * An Swift enum with associated values representing a Variant/Union type.
  * JS type: `struct | struct | struct | struct | struct`

package/nitrogen/generated/ios/swift/PredicateForWorkouts.swift

@@ -5,6 +5,8 @@
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
+
+
 /**
  * An Swift enum with associated values representing a Variant/Union type.
  * JS type: `struct | struct | struct | struct | struct | struct | struct`

package/nitrogen/generated/ios/swift/PredicateFromWorkout.swift

@@ -19,7 +19,7 @@ public extension PredicateFromWorkout {
    * Create a new instance of `PredicateFromWorkout`.
    */
   init(workout: (any HybridWorkoutProxySpec)) {
-    self.init({ () -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ in
+    self.init({ () -> bridge.std__shared_ptr_HybridWorkoutProxySpec_ in
       let __cxxWrapped = workout.getCxxWrapper()
       return __cxxWrapped.getCxxPart()
     }())
@@ -29,14 +29,14 @@ public extension PredicateFromWorkout {
     @inline(__always)
     get {
       return { () -> HybridWorkoutProxySpec in
-        let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(self.__workout)
+        let __unsafePointer = bridge.get_std__shared_ptr_HybridWorkoutProxySpec_(self.__workout)
         let __instance = HybridWorkoutProxySpec_cxx.fromUnsafe(__unsafePointer)
         return __instance.getHybridWorkoutProxySpec()
       }()
     }
     @inline(__always)
     set {
-      self.__workout = { () -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ in
+      self.__workout = { () -> bridge.std__shared_ptr_HybridWorkoutProxySpec_ in
         let __cxxWrapped = newValue.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()