@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

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

@@ -115,6 +115,229 @@ open class HybridWorkoutProxySpec_cxx {
   }
 
   // Properties
+  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 events: bridge.std__optional_std__vector_WorkoutEvent__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__vector_WorkoutEvent__ in
+        if let __unwrappedValue = self.__implementation.events {
+          return bridge.create_std__optional_std__vector_WorkoutEvent__({ () -> bridge.std__vector_WorkoutEvent_ in
+            var __vector = bridge.create_std__vector_WorkoutEvent_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var activities: bridge.std__optional_std__vector_WorkoutActivity__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__vector_WorkoutActivity__ in
+        if let __unwrappedValue = self.__implementation.activities {
+          return bridge.create_std__optional_std__vector_WorkoutActivity__({ () -> bridge.std__vector_WorkoutActivity_ in
+            var __vector = bridge.create_std__vector_WorkoutActivity_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataAverageMETs: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataAverageMETs {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataElevationAscended: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataElevationAscended {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataElevationDescended: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataElevationDescended {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataIndoorWorkout: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.metadataIndoorWorkout {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataAverageSpeed: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataAverageSpeed {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataMaximumSpeed: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataMaximumSpeed {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var sampleType: SampleType {
+    @inline(__always)
+    get {
+      return self.__implementation.sampleType
+    }
+  }
+  
+  public final var startDate: margelo.nitro.chrono_time {
+    @inline(__always)
+    get {
+      return self.__implementation.startDate.toCpp()
+    }
+  }
+  
+  public final var endDate: margelo.nitro.chrono_time {
+    @inline(__always)
+    get {
+      return self.__implementation.endDate.toCpp()
+    }
+  }
+  
+  public final var hasUndeterminedDuration: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.hasUndeterminedDuration
+    }
+  }
+  
+  public final var metadataWeatherCondition: bridge.std__optional_WeatherCondition_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_WeatherCondition_ in
+        if let __unwrappedValue = self.__implementation.metadataWeatherCondition {
+          return bridge.create_std__optional_WeatherCondition_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataWeatherHumidity: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataWeatherHumidity {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataWeatherTemperature: bridge.std__optional_Quantity_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = self.__implementation.metadataWeatherTemperature {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataInsulinDeliveryReason: bridge.std__optional_InsulinDeliveryReason_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_InsulinDeliveryReason_ in
+        if let __unwrappedValue = self.__implementation.metadataInsulinDeliveryReason {
+          return bridge.create_std__optional_InsulinDeliveryReason_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataHeartRateMotionContext: bridge.std__optional_HeartRateMotionContext_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_HeartRateMotionContext_ in
+        if let __unwrappedValue = self.__implementation.metadataHeartRateMotionContext {
+          return bridge.create_std__optional_HeartRateMotionContext_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
   public final var uuid: std.string {
     @inline(__always)
     get {
@@ -122,6 +345,13 @@ open class HybridWorkoutProxySpec_cxx {
     }
   }
   
+  public final var sourceRevision: SourceRevision {
+    @inline(__always)
+    get {
+      return self.__implementation.sourceRevision
+    }
+  }
+  
   public final var device: bridge.std__optional_Device_ {
     @inline(__always)
     get {
@@ -135,40 +365,58 @@ open class HybridWorkoutProxySpec_cxx {
     }
   }
   
-  public final var workoutActivityType: Int32 {
+  public final var metadata: margelo.nitro.SharedAnyMap {
     @inline(__always)
     get {
-      return self.__implementation.workoutActivityType.rawValue
+      return self.__implementation.metadata.cppPart
     }
   }
   
-  public final var duration: Quantity {
+  public final var metadataExternalUUID: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return self.__implementation.duration
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataExternalUUID {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  public final var startDate: margelo.nitro.chrono_time {
+  public final var metadataTimeZone: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return self.__implementation.startDate.toCpp()
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataTimeZone {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  public final var endDate: margelo.nitro.chrono_time {
+  public final var metadataWasUserEntered: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return self.__implementation.endDate.toCpp()
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.metadataWasUserEntered {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  public final var metadata: bridge.std__optional_std__shared_ptr_AnyMap__ {
+  public final var metadataDeviceSerialNumber: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_std__shared_ptr_AnyMap__ in
-        if let __unwrappedValue = self.__implementation.metadata {
-          return bridge.create_std__optional_std__shared_ptr_AnyMap__(__unwrappedValue.cppPart)
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataDeviceSerialNumber {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
         } else {
           return .init()
         }
@@ -176,12 +424,12 @@ open class HybridWorkoutProxySpec_cxx {
     }
   }
   
-  public final var sourceRevision: bridge.std__optional_SourceRevision_ {
+  public final var metadataUdiDeviceIdentifier: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_SourceRevision_ in
-        if let __unwrappedValue = self.__implementation.sourceRevision {
-          return bridge.create_std__optional_SourceRevision_(__unwrappedValue)
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataUdiDeviceIdentifier {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
         } else {
           return .init()
         }
@@ -189,18 +437,12 @@ open class HybridWorkoutProxySpec_cxx {
     }
   }
   
-  public final var events: bridge.std__optional_std__vector_WorkoutEvent__ {
+  public final var metadataUdiProductionIdentifier: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_std__vector_WorkoutEvent__ in
-        if let __unwrappedValue = self.__implementation.events {
-          return bridge.create_std__optional_std__vector_WorkoutEvent__({ () -> bridge.std__vector_WorkoutEvent_ in
-            var __vector = bridge.create_std__vector_WorkoutEvent_(__unwrappedValue.count)
-            for __item in __unwrappedValue {
-              __vector.push_back(__item)
-            }
-            return __vector
-          }())
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataUdiProductionIdentifier {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
         } else {
           return .init()
         }
@@ -208,18 +450,116 @@ open class HybridWorkoutProxySpec_cxx {
     }
   }
   
-  public final var activities: bridge.std__optional_std__vector_WorkoutActivity__ {
+  public final var metadataDigitalSignature: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_std__vector_WorkoutActivity__ in
-        if let __unwrappedValue = self.__implementation.activities {
-          return bridge.create_std__optional_std__vector_WorkoutActivity__({ () -> bridge.std__vector_WorkoutActivity_ in
-            var __vector = bridge.create_std__vector_WorkoutActivity_(__unwrappedValue.count)
-            for __item in __unwrappedValue {
-              __vector.push_back(__item)
-            }
-            return __vector
-          }())
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataDigitalSignature {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataDeviceName: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataDeviceName {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataDeviceManufacturerName: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataDeviceManufacturerName {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataSyncIdentifier: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.metadataSyncIdentifier {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataSyncVersion: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.metadataSyncVersion {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataWasTakenInLab: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.metadataWasTakenInLab {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataReferenceRangeLowerLimit: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.metadataReferenceRangeLowerLimit {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataReferenceRangeUpperLimit: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.metadataReferenceRangeUpperLimit {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  public final var metadataAlgorithmVersion: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.metadataAlgorithmVersion {
+          return bridge.create_std__optional_double_(__unwrappedValue)
         } else {
           return .init()
         }

package/nitrogen/generated/ios/swift/InsulinDeliveryReason.swift

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

package/nitrogen/generated/ios/swift/MedicationConcept.swift

@@ -0,0 +1,80 @@
+///
+/// MedicationConcept.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `MedicationConcept`, backed by a C++ struct.
+ */
+public typealias MedicationConcept = margelo.nitro.healthkit.MedicationConcept
+
+public extension MedicationConcept {
+  private typealias bridge = margelo.nitro.healthkit.bridge.swift
+
+  /**
+   * Create a new instance of `MedicationConcept`.
+   */
+  init(identifier: String, displayText: String, generalForm: GeneralForm, relatedCodings: [RelatedCoding]) {
+    self.init(std.string(identifier), std.string(displayText), generalForm, { () -> bridge.std__vector_RelatedCoding_ in
+      var __vector = bridge.create_std__vector_RelatedCoding_(relatedCodings.count)
+      for __item in relatedCodings {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }())
+  }
+
+  var identifier: String {
+    @inline(__always)
+    get {
+      return String(self.__identifier)
+    }
+    @inline(__always)
+    set {
+      self.__identifier = std.string(newValue)
+    }
+  }
+  
+  var displayText: String {
+    @inline(__always)
+    get {
+      return String(self.__displayText)
+    }
+    @inline(__always)
+    set {
+      self.__displayText = std.string(newValue)
+    }
+  }
+  
+  var generalForm: GeneralForm {
+    @inline(__always)
+    get {
+      return self.__generalForm
+    }
+    @inline(__always)
+    set {
+      self.__generalForm = newValue
+    }
+  }
+  
+  var relatedCodings: [RelatedCoding] {
+    @inline(__always)
+    get {
+      return self.__relatedCodings.map({ __item in __item })
+    }
+    @inline(__always)
+    set {
+      self.__relatedCodings = { () -> bridge.std__vector_RelatedCoding_ in
+        var __vector = bridge.create_std__vector_RelatedCoding_(newValue.count)
+        for __item in newValue {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+    }
+  }
+}