@kingstinct/react-native-healthkit 8.7.2 → 9.0.0

package/ios/Helpers.swift

@@ -7,142 +7,392 @@
 
 import Foundation
 import HealthKit
+import NitroModules
 
-func dateOrNilIfZero(date: Date) -> Date? {
-    return date.timeIntervalSince1970 > 0 ? date : nil
+func dateOrNilIfZero(_ timestamp: Double?) -> Date? {
+    if let timestamp = timestamp {
+        if(timestamp == 0){
+           return nil
+        }
+        return Date.init(timeIntervalSince1970: timestamp)
+    }
+    return nil
+    
+    
 }
 
-func limitOrNilIfZero(limit: Int) -> Int {
-    return limit == 0 ? HKObjectQueryNoLimit : limit
+func getQueryLimit(_ limit: Double?) -> Int {
+    if let limit = limit {
+        if(limit == .infinity || limit <= 0){
+            return HKObjectQueryNoLimit
+        }
+        
+        return Int(limit)
+    }
+    
+    return DEFAULT_QUERY_LIMIT
 }
 
-func createPredicate(from: Date?, to: Date?) -> NSPredicate? {
-    if from != nil || to != nil {
-        return HKQuery.predicateForSamples(
-            withStart: from, end: to, options: [.strictEndDate, .strictStartDate])
-    } else {
-        return nil
+func createPredicateForWorkout(filter: PredicateForWorkouts) throws -> NSPredicate {
+    switch filter {
+        case .first(let uuidWrapper):
+            return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+        case .second(let uuidsWrapper):
+            return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+        case .third(let metadataKey):
+            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        case .fourth(let dateFilter):
+            return createDatePredicate(dateFilter: dateFilter)
+        case .fifth(let w):
+          if let w = w.workout as? WorkoutProxy {
+            return HKQuery.predicateForObjects(from: w.workout)
+          }
+          throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
+        case .sixth(let activityType):
+            if let activityType = HKWorkoutActivityType.init(rawValue: UInt(activityType.workoutActivityType.rawValue)) {
+                return HKQuery.predicateForWorkouts(with: activityType)
+            } else {
+                throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized workoutActivityType with identifier \(activityType.workoutActivityType.rawValue)")
+            }
+        case .seventh(let durationPredicate):
+            if let op = NSComparisonPredicate.Operator(rawValue: UInt(durationPredicate.predicateOperator.rawValue)){
+                return HKQuery.predicateForWorkouts(with: op, duration: durationPredicate.durationInSeconds)
+            }
+            throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized workout duration predicate operator \(durationPredicate.predicateOperator.rawValue)")
+    }
+}
+
+func createPredicateForWorkout(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_WorkoutActivityTypePredicate_WorkoutDurationPredicate_PredicateForWorkoutsOr_PredicateForWorkoutsAnd?) throws -> NSPredicate? {
+    if let filter = filter {
+        switch filter {
+        case .first(let uuidWrapper):
+            return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+        case .second(let uuidsWrapper):
+            return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+        case .third(let metadataKey):
+            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        case .fourth(let dateFilter):
+            return createDatePredicate(dateFilter: dateFilter)
+        case .fifth(let w):
+          if let w = w.workout as? WorkoutProxy {
+            return HKQuery.predicateForObjects(from: w.workout)
+          }
+          throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
+        case .sixth(let activityType):
+            if let activityType = HKWorkoutActivityType.init(rawValue: UInt(activityType.workoutActivityType.rawValue)) {
+                return HKQuery.predicateForWorkouts(with: activityType)
+            } else {
+                throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized workoutActivityType with identifier \(activityType.workoutActivityType.rawValue)")
+            }
+        case .seventh(let durationPredicate):
+            if let op = NSComparisonPredicate.Operator(rawValue: UInt(durationPredicate.predicateOperator.rawValue)){
+                return HKQuery.predicateForWorkouts(with: op, duration: durationPredicate.durationInSeconds)
+            }
+            throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized workout duration predicate operator \(durationPredicate.predicateOperator.rawValue)")
+            
+        case .eigth(let or):
+            return NSCompoundPredicate.init(andPredicateWithSubpredicates: try or.OR.map { predicate in
+                return try createPredicateForWorkout(filter: predicate)
+            })
+        case .ninth(let and):
+            return NSCompoundPredicate.init(orPredicateWithSubpredicates: try and.AND
+                .map { predicate in
+                    return try createPredicateForWorkout(filter: predicate)
+                })
+        }
     }
+    
+    return nil
 }
 
-func getSortDescriptors(ascending: Bool) -> [NSSortDescriptor] {
-    return [NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: ascending)]
+func createDatePredicate(dateFilter: PredicateWithStartAndEnd) -> NSPredicate {
+    let strictStartDate = dateFilter.strictStartDate ?? false
+    let strictEndDate = dateFilter.strictEndDate ?? false
+    
+    let options: HKQueryOptions = strictStartDate && strictEndDate
+        ? [.strictStartDate, .strictEndDate]
+        : strictEndDate
+            ? .strictEndDate
+            : strictStartDate
+                ? .strictStartDate
+                : []
+    
+    return HKQuery.predicateForSamples(
+        withStart: dateFilter.startDate,
+        end: dateFilter.endDate,
+        options: options
+    )
 }
 
-func base64StringToHKQueryAnchor(base64String: String) -> HKQueryAnchor? {
-    // Step 1: Decode the base64 string to a Data object
-    guard let data = Data(base64Encoded: base64String) else {
-        print("Error: Invalid base64 string")
-        return nil
+func createUUIDsPredicate(uuidsWrapper: PredicateWithUUIDs) -> NSPredicate {
+    let uuids = uuidsWrapper.uuids.compactMap { uuidStr -> UUID? in
+        do {
+            let uuid = try initializeUUID(uuidStr)
+            return uuid
+        }
+        catch {
+            print(error.localizedDescription)
+            return nil
+        }
     }
+    return HKQuery.predicateForObjects(with: Set(uuids))
+}
 
-    // Step 2: Use NSKeyedUnarchiver to unarchive the data and create an HKQueryAnchor object
-    do {
-        let unarchiver = try NSKeyedUnarchiver(forReadingFrom: data)
-        unarchiver.requiresSecureCoding = true
-        let anchor = try? NSKeyedUnarchiver.unarchiveTopLevelObjectWithData(data)
+func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout?) throws -> NSPredicate? {
+    if let filter = filter {
+        switch filter {
+            case .first(let uuidWrapper):
+                return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+            case .second(let uuidsWrapper):
+                return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+            case .third(let metadataKey):
+                return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            case .fourth(let dateFilter):
+                return createDatePredicate(dateFilter: dateFilter)
+            case .fifth(let w):
+              if let w = w.workout as? WorkoutProxy {
+                return HKQuery.predicateForObjects(from: w.workout)
+              }
+              throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
+        }
+    }
+    return nil
+}
 
-        return anchor as? HKQueryAnchor
-    } catch {
-        print("Error: Unable to unarchive HKQueryAnchor object: \(error)")
-        return nil
+func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr?) throws -> NSPredicate? {
+    if let filter = filter {
+        switch filter {
+            case .first(let uuidWrapper):
+                return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+            case .second(let uuidsWrapper):
+                return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+            case .third(let metadataKey):
+                return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            case .fourth(let dateFilter):
+                return createDatePredicate(dateFilter: dateFilter)
+            case .fifth(let w):
+              if let w = w.workout as? WorkoutProxy {
+                return HKQuery.predicateForObjects(from: w.workout)
+              }
+              throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
+            case .sixth(let and):
+                return NSCompoundPredicate.init(andPredicateWithSubpredicates: try and.AND.map { predicate in
+                    return try createPredicateForSamples(filter: predicate)
+                })
+            case .seventh(let or):
+                return NSCompoundPredicate.init(orPredicateWithSubpredicates: try or.OR
+                    .map { predicate in
+                    return try createPredicateForSamples(filter: predicate)
+                })
+        }
     }
+    return nil
 }
 
-func sampleTypeFromString(typeIdentifier: String) -> HKSampleType? {
-    if typeIdentifier.starts(with: HKQuantityTypeIdentifier_PREFIX) {
-        let identifier = HKQuantityTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKSampleType.quantityType(forIdentifier: identifier) as HKSampleType?
+func createPredicateForSamples(filter: PredicateForSamples) throws -> NSPredicate {
+    switch filter {
+        case .first(let uuidWrapper):
+            return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+        case .second(let uuidsWrapper):
+            return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+        case .third(let metadataKey):
+            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        case .fourth(let dateFilter):
+            return createDatePredicate(dateFilter: dateFilter)
+        case .fifth(let w):
+          if let w = w.workout as? WorkoutProxy {
+            return HKQuery.predicateForObjects(from: w.workout)
+          }
+          throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
     }
+}
 
-    if typeIdentifier.starts(with: HKCategoryTypeIdentifier_PREFIX) {
-        let identifier = HKCategoryTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKSampleType.categoryType(forIdentifier: identifier) as HKSampleType?
+func createPredicateForSamples(filter: FilterForSamples) throws -> NSPredicate {
+    switch filter {
+    case .first(let uuidWrapper):
+        return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+    case .second(let uuidsWrapper):
+        return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+    case .third(let metadataKey):
+        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+    case .fourth(let dateFilter):
+        return createDatePredicate(dateFilter: dateFilter)
+    case .fifth(let w):
+      if let w = w.workout as? WorkoutProxy {
+        return HKQuery.predicateForObjects(from: w.workout)
+      }
+      throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
+    case .sixth(let and):
+        return NSCompoundPredicate.init(andPredicateWithSubpredicates: try and.AND.map { predicate in
+            return try createPredicateForSamples(filter: predicate)
+        })
+    case .seventh(let or):
+        return NSCompoundPredicate.init(orPredicateWithSubpredicates: try or.OR
+            .map { predicate in
+            return try createPredicateForSamples(filter: predicate)
+        })
     }
+}
 
-    if typeIdentifier.starts(with: HKCorrelationTypeIdentifier_PREFIX) {
-        let identifier = HKCorrelationTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKSampleType.correlationType(forIdentifier: identifier) as HKSampleType?
+func createPredicateForSamples(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr) throws -> NSPredicate {
+    switch filter {
+    case .first(let uuidWrapper):
+        return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
+    case .second(let uuidsWrapper):
+        return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
+    case .third(let metadataKey):
+        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+    case .fourth(let dateFilter):
+        return createDatePredicate(dateFilter: dateFilter)
+    case .fifth(let w):
+      if let w = w.workout as? WorkoutProxy {
+        return HKQuery.predicateForObjects(from: w.workout)
+      }
+      throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
+    case .sixth(let and):
+        return NSCompoundPredicate.init(andPredicateWithSubpredicates: try and.AND.map { predicate in
+            return try createPredicateForSamples(filter: predicate)
+        })
+    case .seventh(let or):
+        return NSCompoundPredicate.init(orPredicateWithSubpredicates: try or.OR
+            .map { predicate in
+            return try createPredicateForSamples(filter: predicate)
+        })
     }
+}
 
-    if #available(iOS 13, *) {
-        if typeIdentifier == HKAudiogramTypeIdentifier {
-            return HKSampleType.audiogramSampleType()
+func getSortDescriptors(ascending: Bool?) -> [NSSortDescriptor] {
+    return [NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: ascending ?? false)]
+}
+
+func getSortDescsdsdriptors(ascending: Bool?) -> [NSSortDescriptor] {
+    return [NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: ascending ?? false)]
+}
+
+func deserializeHKQueryAnchor(base64String: String?) throws -> HKQueryAnchor? {
+    if let base64String = base64String {
+        if base64String.isEmpty {
+            return nil
+        }
+        
+        // Step 1: Decode the base64 string to a Data object
+        guard let data = Data(base64Encoded: base64String) else {
+            throw RuntimeError.error(withMessage: "[react-native-healthkit] Invalid base64 string: \(base64String)")
         }
-    }
 
-    #if compiler(>=6)
-        if #available(iOS 18, *) {
-            if typeIdentifier == HKStateOfMindTypeIdentifier {
-                return HKObjectType.stateOfMindType()
-            }
+        // Step 2: Use NSKeyedUnarchiver to unarchive the data and create an HKQueryAnchor object
+        do {
+            let unarchiver = try NSKeyedUnarchiver(forReadingFrom: data)
+            unarchiver.requiresSecureCoding = true
+            let anchor = try? NSKeyedUnarchiver.unarchiveTopLevelObjectWithData(data)
+
+            return anchor as? HKQueryAnchor
+        } catch {
+            throw RuntimeError.error(withMessage: "[react-native-healthkit] Error recreating HKQueryAnchor object: \(error.localizedDescription)")
         }
-    #endif
+    }
+    return nil
+}
 
-    if typeIdentifier == HKWorkoutTypeIdentifier {
-        return HKSampleType.workoutType()
+
+func initializeCategoryType(_ identifier: String) throws -> HKCategoryType {
+    let identifier = HKCategoryTypeIdentifier(rawValue: identifier)
+    if let sampleType = HKSampleType.categoryType(forIdentifier: identifier) {
+        return sampleType
     }
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized categoryType with identifier \(identifier)")
+}
 
-    if #available(iOS 11.0, *) {
-        if typeIdentifier == HKWorkoutRouteTypeIdentifier {
-            return HKObjectType.seriesType(forIdentifier: typeIdentifier)
-        }
+func initializeWorkoutActivityType(_ typeIdentifier: UInt) throws -> HKWorkoutActivityType {
+    if let type = HKWorkoutActivityType.init(rawValue: typeIdentifier) {
+        return type
     }
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized quantityType with identifier \(typeIdentifier)")
+}
 
-    return nil
+func initializeQuantityType(_ identifier: String) throws -> HKQuantityType {
+    let identifier = HKQuantityTypeIdentifier(rawValue: identifier)
+
+    if let sampleType = HKSampleType.quantityType(forIdentifier: identifier) {
+        return sampleType
+    }
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized quantityType with identifier \(identifier)")
 }
 
-func objectTypesFromDictionary(typeIdentifiers: NSDictionary) -> Set<HKObjectType> {
-    var share = Set<HKObjectType>()
-    for item in typeIdentifiers {
-        if item.value as! Bool {
-            let objectType = objectTypeFromString(typeIdentifier: item.key as! String)
-            if objectType != nil {
-                share.insert(objectType!)
-            }
-        }
+func initializeCorrelationType(_ identifier: String) throws -> HKCorrelationType {
+    let identifier = HKCorrelationTypeIdentifier(rawValue: identifier)
+    
+    if let sampleType = HKSampleType.correlationType(forIdentifier: identifier) {
+        return sampleType
     }
-    return share
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized correlationType with identifier \(identifier)")
 }
 
-func sampleTypesFromDictionary(typeIdentifiers: NSDictionary) -> Set<HKSampleType> {
-    var share = Set<HKSampleType>()
-    for item in typeIdentifiers {
-        if item.value as! Bool {
-            let sampleType = sampleTypeFromString(typeIdentifier: item.key as! String)
-            if sampleType != nil {
-                share.insert(sampleType!)
-            }
-        }
+func initializeSeriesType(_ identifier: String) throws -> HKSeriesType {
+    if let seriesType = HKObjectType.seriesType(forIdentifier: identifier) {
+        return seriesType
     }
-    return share
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized seriesType with identifier \(identifier)")
 }
 
-func objectTypeFromString(typeIdentifier: String) -> HKObjectType? {
-    if typeIdentifier.starts(with: HKCharacteristicTypeIdentifier_PREFIX) {
-        let identifier = HKCharacteristicTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKObjectType.characteristicType(forIdentifier: identifier) as HKObjectType?
+func sampleTypeFrom(sampleTypeIdentifier: SampleTypeIdentifier) throws -> HKSampleType {
+    if let sampleType = try sampleTypeFromStringNullable(typeIdentifier: sampleTypeIdentifier.stringValue) {
+        return sampleType
     }
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized sampleType with identifier \(sampleTypeIdentifier.stringValue)")
+}
+
+func sampleTypeFrom(sampleTypeIdentifierWriteable: SampleTypeIdentifierWriteable) throws -> HKSampleType {
+    if let sampleType = try sampleTypeFromStringNullable(typeIdentifier: sampleTypeIdentifierWriteable.stringValue) {
+        return sampleType
+    }
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize unrecognized sampleType with identifier \(sampleTypeIdentifierWriteable.stringValue)")
+}
 
+private func sampleTypeFromStringNullable(typeIdentifier: String) throws -> HKSampleType? {
     if typeIdentifier.starts(with: HKQuantityTypeIdentifier_PREFIX) {
-        let identifier = HKQuantityTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKObjectType.quantityType(forIdentifier: identifier) as HKObjectType?
+        return try initializeQuantityType(typeIdentifier)
     }
 
     if typeIdentifier.starts(with: HKCategoryTypeIdentifier_PREFIX) {
-        let identifier = HKCategoryTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKObjectType.categoryType(forIdentifier: identifier) as HKObjectType?
+        return try initializeCategoryType(typeIdentifier)
     }
 
     if typeIdentifier.starts(with: HKCorrelationTypeIdentifier_PREFIX) {
-        let identifier = HKCorrelationTypeIdentifier.init(rawValue: typeIdentifier)
-        return HKObjectType.correlationType(forIdentifier: identifier) as HKObjectType?
+        return try initializeCorrelationType(typeIdentifier)
+    }
+   
+    if typeIdentifier == HKWorkoutTypeIdentifier {
+        return HKSampleType.workoutType()
     }
 
-    if typeIdentifier == HKActivitySummaryTypeIdentifier {
-        return HKObjectType.activitySummaryType()
+    if #available(iOS 11.0, *) {
+        if typeIdentifier == HKWorkoutRouteTypeIdentifier {
+            return try initializeSeriesType(typeIdentifier)
+        }
     }
 
+    if #available(iOS 13, *) {
+        if typeIdentifier == HKAudiogramTypeIdentifier {
+            return HKObjectType.audiogramSampleType()
+        }
+
+        if typeIdentifier == HKDataTypeIdentifierHeartbeatSeries {
+            return try initializeSeriesType(typeIdentifier)
+        }
+        
+        if typeIdentifier == HKAudiogramTypeIdentifier {
+            return HKSampleType.audiogramSampleType()
+        }
+    }
+    
     #if compiler(>=6)
         if #available(iOS 18, *) {
             if typeIdentifier == HKStateOfMindTypeIdentifier {
@@ -151,27 +401,74 @@ func objectTypeFromString(typeIdentifier: String) -> HKObjectType? {
         }
     #endif
 
-    if #available(iOS 13, *) {
-        if typeIdentifier == HKAudiogramTypeIdentifier {
-            return HKObjectType.audiogramSampleType()
-        }
+    return nil
+}
 
-        if typeIdentifier == HKDataTypeIdentifierHeartbeatSeries {
-            return HKObjectType.seriesType(forIdentifier: typeIdentifier)
+func objectTypesFromArray(typeIdentifiers: [ObjectTypeIdentifier]) -> Set<HKObjectType> {
+    var share = Set<HKObjectType>()
+    for typeIdentifier in typeIdentifiers {
+        do {
+            let objectType = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
+            share.insert(objectType)
+        } catch {
+            print(error.localizedDescription)
         }
     }
+    return share
+}
 
-    if typeIdentifier == HKWorkoutTypeIdentifier {
-        return HKObjectType.workoutType()
+func initializeUUID(_ uuidString: String) throws -> UUID {
+    if let uuid = UUID(uuidString: uuidString) {
+       return uuid
     }
+    
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Got invalid UUID: \(uuidString)")
+}
 
-    if #available(iOS 11.0, *) {
-        if typeIdentifier == HKWorkoutRouteTypeIdentifier {
-            return HKObjectType.seriesType(forIdentifier: typeIdentifier)
+func sampleTypesFromArray(typeIdentifiers: [SampleTypeIdentifier]) -> Set<HKSampleType> {
+    return Set(typeIdentifiers.compactMap { typeIdentifier in
+        do {
+            let sampleType = try sampleTypeFrom(sampleTypeIdentifier: typeIdentifier)
+            return sampleType
+        } catch {
+            print(error.localizedDescription)
+        }
+        return nil
+    })
+}
+
+func sampleTypesFromArray(typeIdentifiersWriteable: [SampleTypeIdentifierWriteable]) -> Set<HKSampleType> {
+    return Set(typeIdentifiersWriteable.compactMap { typeIdentifier in
+        do {
+            let sampleType = try sampleTypeFrom(sampleTypeIdentifierWriteable: typeIdentifier)
+            return sampleType
+        } catch {
+            print(error.localizedDescription)
+        }
+        return nil
+    })
+}
+
+
+// objectType is wider than sampleType, so it uses it under the hood
+func objectTypeFrom(objectTypeIdentifier: ObjectTypeIdentifier) throws -> HKObjectType {
+    let typeIdentifier = objectTypeIdentifier.stringValue
+    if let sampleType = try sampleTypeFromStringNullable(typeIdentifier: typeIdentifier) {
+        return sampleType
+    }
+    
+    if typeIdentifier.starts(with: HKCharacteristicTypeIdentifier_PREFIX) {
+        let identifier = HKCharacteristicTypeIdentifier.init(rawValue: typeIdentifier)
+        if let type = HKObjectType.characteristicType(forIdentifier: identifier) as HKObjectType? {
+            return type
         }
     }
 
-    return nil
+    if typeIdentifier == HKActivitySummaryTypeIdentifier {
+        return HKObjectType.activitySummaryType()
+    }
+
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed initializing unrecognized objectType identifier " + typeIdentifier)
 }
 
 func hkStatisticsOptionsFromOptions(_ options: NSArray) -> HKStatisticsOptions {
@@ -189,10 +486,6 @@ func hkStatisticsOptionsFromOptions(_ options: NSArray) -> HKStatisticsOptions {
             opts.insert(.discreteMax)
         case "discreteMin":
             opts.insert(.discreteMin)
-        case "discreteMostRecent":
-            if #available(iOS 12, *) {
-                opts.insert(.discreteMostRecent)
-            }
         case "duration":
             if #available(iOS 13, *) {
                 opts.insert(.duration)
@@ -229,166 +522,151 @@ func componentsFromInterval(_ interval: NSDictionary) -> DateComponents {
     return intervalComponents
 }
 
-func serializeQuantityIfExists(unit: HKUnit, quantity: HKQuantity?) -> [String: Any]? {
-    guard let quantity = quantity else { return nil }
-    return serializeQuantity(unit: unit, quantity: quantity)
-}
-
-func serializeStatisticIfExists(unit: HKUnit, quantity: HKQuantity?, stats: HKStatistics)
-    -> [String: Any]? {
-    guard let quantity = quantity else { return nil }
-    return serializeStatistic(unit: unit, quantity: quantity, stats: stats)
-}
-
-func parseWorkoutConfiguration(_ dict: NSDictionary) -> HKWorkoutConfiguration {
+func parseWorkoutConfiguration(_ config: WorkoutConfiguration) -> HKWorkoutConfiguration {
     let configuration = HKWorkoutConfiguration()
 
-    if let activityTypeRaw = dict[HKWorkoutActivityTypePropertyName] as? UInt,
-        let activityType = HKWorkoutActivityType(rawValue: activityTypeRaw) {
-        configuration.activityType = activityType
+    if let activityType = HKWorkoutActivityType(rawValue: UInt(config.activityType.rawValue)) {
+      configuration.activityType = activityType
     }
 
-    if let locationTypeRaw = dict[HKWorkoutSessionLocationTypePropertyName] as? Int,
-        let locationType = HKWorkoutSessionLocationType(rawValue: locationTypeRaw) {
+    if let locationTypeRaw = config.locationType,
+       let locationType = HKWorkoutSessionLocationType(rawValue: Int(locationTypeRaw.rawValue)) {
         configuration.locationType = locationType
     }
 
     return configuration
 }
 
-#if compiler(>=6)
-@available(iOS 18.0, *)
-extension HKStateOfMind.Kind: @retroactive CaseIterable, @retroactive CustomStringConvertible {
-  public var description: String {
-    switch self {
-      case .dailyMood: "Daily mood"
-      case .momentaryEmotion: "Momentary Emotion"
-      @unknown default: "Unknown"
-    }
-  }
-
-  public static var allCases: [HKStateOfMind.Kind] {
-    [.dailyMood, .momentaryEmotion]
-  }
-
-  static func convertToStateOfMindKind(int: Int) -> HKStateOfMind.Kind {
-    // default to .dailyMood if we receive an int out of bounds
-    return HKStateOfMind.Kind(rawValue: int) ?? .dailyMood
-  }
-}
-#endif
-
-#if compiler(>=6)
-@available(iOS 18.0, *)
-extension HKStateOfMind.Label: @retroactive CaseIterable, @retroactive CustomStringConvertible {
-  public var description: String {
-    switch self {
-      case .amazed: "Amazed"
-      case .amused: "Amused"
-      case .angry: "Angry"
-      case .anxious: "Anxious"
-      case .ashamed: "Ashamed"
-      case .brave: "Brave"
-      case .calm: "Calm"
-      case .content: "Content"
-      case .disappointed: "Disappointed"
-      case .discouraged: "Discouraged"
-      case .disgusted: "Disgusted"
-      case .embarrassed: "Embarrassed"
-      case .excited: "Excited"
-      case .frustrated: "Frustrated"
-      case .grateful: "Grateful"
-      case .guilty: "Guilty"
-      case .happy: "Happy"
-      case .hopeless: "Hopeless"
-      case .irritated: "Irritated"
-      case .jealous: "Jealous"
-      case .joyful: "Joyful"
-      case .lonely: "Lonely"
-      case .passionate: "Passionate"
-      case .peaceful: "Peaceful"
-      case .proud: "Proud"
-      case .relieved: "Relieved"
-      case .sad: "Sad"
-      case .scared: "Scared"
-      case .stressed: "Stressed"
-      case .surprised: "Surprised"
-      case .worried: "Worried"
-      case .annoyed: "Annoyed"
-      case .confident: "Confident"
-      case .drained: "Drained"
-      case .hopeful: "Hopeful"
-      case .indifferent: "Indifferent"
-      case .overwhelmed: "Overwhelmed"
-      case .satisfied: "Satisfied"
-      @unknown default: "Unknown"
-    }
-  }
-
-  public static var allCases: [HKStateOfMind.Label] {
-    [
-      .amazed, .amused, .angry, .anxious, .ashamed,
-      .brave, .calm, .content, .disappointed, .discouraged,
-      .disgusted, .embarrassed, .excited, .frustrated, .grateful,
-      .guilty, .happy, .hopeless, .irritated, .jealous,
-      .joyful, .lonely, .passionate, .peaceful, .proud,
-      .relieved, .sad, .scared, .stressed, .surprised,
-      .worried, .annoyed, .confident, .drained, .hopeful,
-      .indifferent, .overwhelmed, .satisfied
+// Returns all available HKQuantityTypeIdentifier raw values as an array of String
+func allQuantityTypeIdentifiers() -> [String] {
+    let allIdentifiers: [HKQuantityTypeIdentifier] = [
+        .bodyMassIndex,
+        .bodyFatPercentage,
+        .height,
+        .bodyMass,
+        .leanBodyMass,
+        .waistCircumference,
+        .stepCount,
+        .distanceWalkingRunning,
+        .distanceCycling,
+        .distanceWheelchair,
+        .basalEnergyBurned,
+        .activeEnergyBurned,
+        .flightsClimbed,
+        .nikeFuel,
+        .appleExerciseTime,
+        .pushCount,
+        .distanceSwimming,
+        .swimmingStrokeCount,
+        .vo2Max,
+        .distanceDownhillSnowSports,
+        .appleStandTime,
+        .walkingSpeed,
+        .walkingDoubleSupportPercentage,
+        .walkingAsymmetryPercentage,
+        .walkingStepLength,
+        .sixMinuteWalkTestDistance,
+        .stairAscentSpeed,
+        .stairDescentSpeed,
+        .heartRate,
+        .bodyTemperature,
+        .basalBodyTemperature,
+        .bloodPressureSystolic,
+        .bloodPressureDiastolic,
+        .respiratoryRate,
+        .restingHeartRate,
+        .walkingHeartRateAverage,
+        .heartRateVariabilitySDNN,
+        .oxygenSaturation,
+        .peripheralPerfusionIndex,
+        .bloodGlucose,
+        .numberOfTimesFallen,
+        .electrodermalActivity,
+        .inhalerUsage,
+        .insulinDelivery,
+        .bloodAlcoholContent,
+        .forcedVitalCapacity,
+        .forcedExpiratoryVolume1,
+        .peakExpiratoryFlowRate,
+        .environmentalAudioExposure,
+        .headphoneAudioExposure,
+        .dietaryFatTotal,
+        .dietaryFatPolyunsaturated,
+        .dietaryFatMonounsaturated,
+        .dietaryFatSaturated,
+        .dietaryCholesterol,
+        .dietarySodium,
+        .dietaryCarbohydrates,
+        .dietaryFiber,
+        .dietarySugar,
+        .dietaryEnergyConsumed,
+        .dietaryProtein,
+        .dietaryVitaminA,
+        .dietaryVitaminB6,
+        .dietaryVitaminB12,
+        .dietaryVitaminC,
+        .dietaryVitaminD,
+        .dietaryVitaminE,
+        .dietaryVitaminK,
+        .dietaryCalcium,
+        .dietaryIron,
+        .dietaryThiamin,
+        .dietaryRiboflavin,
+        .dietaryNiacin,
+        .dietaryFolate,
+        .dietaryBiotin,
+        .dietaryPantothenicAcid,
+        .dietaryPhosphorus,
+        .dietaryIodine,
+        .dietaryMagnesium,
+        .dietaryZinc,
+        .dietarySelenium,
+        .dietaryCopper,
+        .dietaryManganese,
+        .dietaryChromium,
+        .dietaryMolybdenum,
+        .dietaryChloride,
+        .dietaryPotassium,
+        .dietaryCaffeine,
+        .dietaryWater,
+        .uvExposure
+        // Add more identifiers as needed for your iOS version
     ]
-  }
-
-  static func convertToStateOfMindLabels(intArray: [Int]) -> [HKStateOfMind.Label] {
-      return intArray.compactMap { index in
-        // if any int are out of bounds return nil instead of crashing
-        guard index >= 0 && index < HKStateOfMind.Label.allCases.count else { return nil }
-        return HKStateOfMind.Label(rawValue: index)
-      }
-  }
-}
-#endif
-
-#if compiler(>=6)
-@available(iOS 18.0, *)
-extension HKStateOfMind.Association: @retroactive CaseIterable, @retroactive CustomStringConvertible {
-  public var description: String {
-    switch self {
-      case .community: "Community"
-      case .currentEvents: "Current Events"
-      case .dating: "Dating"
-      case .education: "Education"
-      case .family: "Family"
-      case .fitness: "Fitness"
-      case .friends: "Friends"
-      case .health: "Health"
-      case .hobbies: "Hobbies"
-      case .identity: "Identity"
-      case .money: "Money"
-      case .partner: "Partner"
-      case .selfCare: "Self Care"
-      case .spirituality: "Spirituality"
-      case .tasks: "Tasks"
-      case .travel: "Travel"
-      case .work: "Work"
-      case .weather: "Weather"
-      @unknown default: "Unknown"
-    }
-  }
-
-  public static var allCases: [HKStateOfMind.Association] {
-    [
-      .community, .currentEvents, .dating, .education, .family,
-      .fitness, .friends, .health, .hobbies, .identity,
-      .money, .partner, .selfCare, .spirituality, .tasks,
-      .travel, .work, .weather
+    let supported = allIdentifiers.compactMap { identifier in
+        HKObjectType.quantityType(forIdentifier: identifier) != nil ? identifier.rawValue : nil
+    }
+    let missing = allIdentifiers.filter { HKObjectType.quantityType(forIdentifier: $0) == nil }
+    if !missing.isEmpty {
+        print("[react-native-healthkit] Warning: The following HKQuantityTypeIdentifiers are not available on this iOS version: \(missing.map { $0.rawValue })")
+    }
+    // --- New logic: Warn if any available identifier is not in the hardcoded list ---
+    // Try common HealthKit identifier strings (brute-force, as Apple does not provide a list)
+    let knownPrefixes = [
+        "HKQuantityTypeIdentifier",
+        "HKQuantityTypeIdentifierDietary",
+        "HKQuantityTypeIdentifierEnvironmental",
+        "HKQuantityTypeIdentifierBlood",
+        "HKQuantityTypeIdentifierBody",
+        "HKQuantityTypeIdentifierDistance",
+        "HKQuantityTypeIdentifierHeart",
+        "HKQuantityTypeIdentifierRespiratory",
+        "HKQuantityTypeIdentifierWalking",
+        "HKQuantityTypeIdentifierSwimming",
+        "HKQuantityTypeIdentifierApple"
     ]
-  }
-
-  static func convertToStateOfMindAssociations(intArray: [Int]) -> [HKStateOfMind.Association] {
-      return intArray.compactMap { index in
-        guard index >= 0 && index < HKStateOfMind.Association.allCases.count else { return nil }
-        return HKStateOfMind.Association(rawValue: index)
-      }
-  }
+    var foundButNotListed: [String] = []
+    // Try all possible identifier strings (brute-force for demonstration, not exhaustive)
+    for codePoint in 0..<300 {
+        for prefix in knownPrefixes {
+            let candidate = prefix + String(codePoint)
+            if let type = HKObjectType.quantityType(forIdentifier: HKQuantityTypeIdentifier(rawValue: candidate)),
+               !allIdentifiers.contains(where: { $0.rawValue == candidate }) {
+                foundButNotListed.append(candidate)
+            }
+        }
+    }
+    if !foundButNotListed.isEmpty {
+        print("[react-native-healthkit] Warning: The following HKQuantityTypeIdentifiers are available on this iOS version but NOT included in the hardcoded list: \(foundButNotListed)")
+    }
+    return supported
 }
-#endif