@kingstinct/react-native-healthkit 9.0.5 → 9.0.6

package/ios/CoreModule.swift

@@ -9,102 +9,99 @@ import NitroModules
 
 var store = HKHealthStore.init()
 
-var quantityTypeUnitCache = Dictionary<HKQuantityType, HKUnit>()
+var quantityTypeUnitCache = [HKQuantityType: HKUnit]()
 
 func getUnitToUse(unitOverride: String?, quantityType: HKQuantityType) async throws -> HKUnit {
     if let unitOverride = unitOverride {
         let unit = HKUnit(from: unitOverride)
-        
-        if(!quantityType.is(compatibleWith: unit)){
+
+        if !quantityType.is(compatibleWith: unit) {
             throw RuntimeError.error(withMessage: "[react-native-healthkit] Unit \(unitOverride) is incompatible with \(quantityType.identifier)")
         }
-        
+
         return unit
     }
-    
+
     if let preferredUnit = try await getPreferredUnitsInternal(quantityTypes: [quantityType]).first?.value {
         return preferredUnit
     }
-    
+
     throw RuntimeError.error(withMessage: "[react-native-healthkit] Must specify a unit for \(quantityType.identifier)")
 }
 
 func getPreferredUnitsInternal(quantityTypes: [HKQuantityType], forceUpdate: Bool? = false) async throws -> [HKQuantityType: HKUnit] {
-    
-    if(forceUpdate != true){
-        let itemsInCache = quantityTypeUnitCache.filter { (quantityType: HKQuantityType, unit: HKUnit) in
+
+    if forceUpdate != true {
+        let itemsInCache = quantityTypeUnitCache.filter { (quantityType: HKQuantityType, _: HKUnit) in
             return quantityTypes.contains(where: { $0 == quantityType })
         }
-        if(itemsInCache.count == quantityTypes.count){
+        if itemsInCache.count == quantityTypes.count {
             return itemsInCache
         }
     }
-    
-    
+
     return try await withCheckedThrowingContinuation { continuation in
         store.preferredUnits(for: Set(quantityTypes)) {
             (typePerUnits: [HKQuantityType: HKUnit], error: Error?) in
             if let error = error {
                 return continuation.resume(throwing: error)
             }
-            
+
             typePerUnits.forEach { (type: HKQuantityType, unit: HKUnit) in
                 quantityTypeUnitCache.updateValue(unit, forKey: type)
             }
-            
+
             return continuation.resume(returning: typePerUnits)
         }
     }
 }
 
-class CoreModule : HybridCoreModuleSpec {
-    func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Dictionary<String, Bool> {
-        var dict = Dictionary<String, Bool>()
-        
+class CoreModule: HybridCoreModuleSpec {
+    func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> [String: Bool] {
+        var dict = [String: Bool]()
+
         for objectTypeIdentifier in objectTypeIdentifiers {
             dict[objectTypeIdentifier.stringValue] = isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier)
         }
-        
+
         return dict
     }
-    
-    func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Promise<Dictionary<String, Bool>> {
-        return Promise.resolved(withResult:  areObjectTypesAvailable(objectTypeIdentifiers: objectTypeIdentifiers))
+
+    func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Promise<[String: Bool]> {
+        return Promise.resolved(withResult: areObjectTypesAvailable(objectTypeIdentifiers: objectTypeIdentifiers))
     }
-    
-    
-    
+
     func isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier) -> Bool {
         do {
-            let _ = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
+            _ = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
             return true
         } catch {
             return false
         }
     }
-    
+
     func isObjectTypeAvailableAsync(objectTypeIdentifier: ObjectTypeIdentifier) -> Promise<Bool> {
         return Promise.resolved(withResult: isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier))
     }
-    
+
     func authorizationStatusFor(
         type: ObjectTypeIdentifier
     ) throws -> AuthorizationStatus {
         let objectType = try objectTypeFrom(objectTypeIdentifier: type)
-        
+
         let authStatus = store.authorizationStatus(for: objectType)
-        
-        if let authStatus = AuthorizationStatus(rawValue: Int32(authStatus.rawValue)){
+
+        if let authStatus = AuthorizationStatus(rawValue: Int32(authStatus.rawValue)) {
             return authStatus
         }
-        
+
         throw RuntimeError.error(withMessage: "[react-native-healthkit] got unrecognized AuthorizationStatus with value \(authStatus.rawValue)")
     }
-    
+
     func getRequestStatusForAuthorization(toShare: [SampleTypeIdentifierWriteable], toRead: [ObjectTypeIdentifier]) throws -> Promise<AuthorizationRequestStatus> {
         let toShare = sampleTypesFromArray(typeIdentifiersWriteable: toShare)
         let toRead = objectTypesFromArray(typeIdentifiers: toRead)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 store.getRequestStatusForAuthorization(toShare: toShare, read: toRead) { status, error in
@@ -116,17 +113,17 @@ class CoreModule : HybridCoreModuleSpec {
                         } else {
                             continuation.resume(throwing: RuntimeError.error(withMessage: "Unrecognized authStatus returned: \(status.rawValue)"))
                         }
-                        
+
                     }
                 }
             }
         }
     }
-    
+
     func requestAuthorization(toShare: [SampleTypeIdentifierWriteable], toRead: [ObjectTypeIdentifier]) throws -> Promise<Bool> {
         let share = sampleTypesFromArray(typeIdentifiersWriteable: toShare)
         let toRead = objectTypesFromArray(typeIdentifiers: toRead)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 store.requestAuthorization(toShare: share, read: toRead) { status, error in
@@ -139,10 +136,10 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func querySources(identifier: SampleTypeIdentifier) throws -> Promise<[HybridSourceProxySpec]> {
         let sampleType = try sampleTypeFrom(sampleTypeIdentifier: identifier)
-      
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKSourceQuery(
@@ -153,26 +150,26 @@ class CoreModule : HybridCoreModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let sources = sources else {
                       return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response for sample type \(identifier.stringValue)"))
                     }
-                    
+
                     let serializedSources = sources.map { source -> SourceProxy in
-                      
+
                         return SourceProxy(
                             source: source
                         )
                     }
-                    
+
                     continuation.resume(returning: serializedSources)
                 }
-                
+
                 store.execute(query)
             }
         }
     }
-    
+
     func enableBackgroundDelivery(typeIdentifier: ObjectTypeIdentifier, updateFrequency: UpdateFrequency) throws -> Promise<Bool> {
         if let frequency = HKUpdateFrequency(rawValue: Int(updateFrequency.rawValue)) {
             let type = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
@@ -193,7 +190,7 @@ class CoreModule : HybridCoreModuleSpec {
             throw RuntimeError.error(withMessage: "Invalid update frequency value: \(updateFrequency)")
         }
     }
-    
+
     func disableBackgroundDelivery(
         typeIdentifier: ObjectTypeIdentifier
     ) throws -> Promise<Bool> {
@@ -211,7 +208,7 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func disableAllBackgroundDelivery() throws -> Promise<Bool> {
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
@@ -224,64 +221,65 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func unsubscribeQueryAsync(queryId: String) throws -> Promise<Bool> {
         let result = try self.unsubscribeQuery(queryId: queryId)
-        
+
         return Promise.resolved(withResult: result)
     }
-    
+
     func isHealthDataAvailableAsync() -> Promise<Bool> {
         return Promise.resolved(withResult: HKHealthStore.isHealthDataAvailable())
     }
-    
+
     func isProtectedDataAvailableAsync() -> Promise<Bool> {
         return Promise.resolved(withResult: UIApplication.shared.isProtectedDataAvailable)
     }
-    
+
     func isHealthDataAvailable() throws -> Bool {
         return HKHealthStore.isHealthDataAvailable()
     }
-    
+
     func isProtectedDataAvailable() throws -> Bool {
         return UIApplication.shared.isProtectedDataAvailable
     }
-    
+
     func getPreferredUnits(identifiers: [QuantityTypeIdentifier], forceUpdate: Bool?) throws -> Promise<[IdentifierWithUnit]> {
         return Promise.async {
-            
+
             let quantityTypes = identifiers.compactMap { identifier in
                 do {
                     let quantityType = try initializeQuantityType(identifier.stringValue)
+
                     return quantityType
                 } catch {
                     print(error.localizedDescription)
                     return nil
                 }
             }
-            
+
             let typePerUnits = try await getPreferredUnitsInternal(quantityTypes: quantityTypes, forceUpdate: forceUpdate)
-            
+
             let dic = typePerUnits.map { typePerUnit in
                 return IdentifierWithUnit(
                     typeIdentifier: typePerUnit.key.identifier,
                     unit: typePerUnit.value.unitString
                 )
             }
-            
+
             return dic
         }
     }
-    
+
     var _runningQueries: [String: HKQuery] = [:]
-    
+
     func deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples) throws -> Promise<Double> {
         let predicate = try createPredicateForSamples(filter: filter)
         let of = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
-        
+
         return Promise.async {
             return try await withCheckedThrowingContinuation { continuation in
-                store.deleteObjects(of: of, predicate: predicate) { (success, count, error) in
+                store.deleteObjects(of: of, predicate: predicate) { (_, count, error) in
                     if let error = error {
                         continuation.resume(throwing: error)
                     } else {
@@ -291,21 +289,21 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func subscribeToObserverQuery(
         typeIdentifier: SampleTypeIdentifier,
         callback: @escaping (OnChangeCallbackArgs) -> Void
     ) throws -> String {
         let sampleType = try sampleTypeFrom(sampleTypeIdentifier: typeIdentifier)
-        
+
         let predicate = HKQuery.predicateForSamples(
             withStart: Date.init(),
             end: nil,
             options: HKQueryOptions.strictStartDate
         )
-        
+
         let queryId = UUID().uuidString
-        
+
         func responder(
             query: HKObserverQuery,
             handler: @escaping HKObserverQueryCompletionHandler,
@@ -316,42 +314,42 @@ class CoreModule : HybridCoreModuleSpec {
                 handler()
             }
         }
-        
+
         let query = HKObserverQuery(
             sampleType: sampleType,
             predicate: predicate
         ) {
             (query: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
             in
-            
+
             return responder(query: query, handler: handler, error: error)
-            
+
         }
-        
+
         store.execute(query)
-        
+
         self._runningQueries.updateValue(query, forKey: queryId)
-        
-        //resolve(queryId)
-        
+
+        // resolve(queryId)
+
         return queryId
     }
-    
+
     func unsubscribeQuery(queryId: String) throws -> Bool {
         guard let query = self._runningQueries[queryId] else {
             throw RuntimeError.error(withMessage: "Query with id \(queryId) not found")
         }
-        
+
         store.stop(query)
-        
+
         self._runningQueries.removeValue(forKey: queryId)
-        
+
         return true
     }
-    
+
     func unsubscribeQueriesAsync(queryIds: [String]) throws -> Promise<Double> {
         let successCount = self.unsubscribeQueries(queryIds: queryIds)
-        
+
         return Promise.resolved(withResult: successCount)
     }
 
@@ -359,17 +357,17 @@ class CoreModule : HybridCoreModuleSpec {
         let successCounts = queryIds.map { queryId in
             if let query = self._runningQueries[queryId] {
                 store.stop(query)
-                
+
                 self._runningQueries.removeValue(forKey: queryId)
-                
+
                 return true
             }
-            
+
             print("Query with id \(queryId) not found, skipping unsubscribe")
-            
+
             return false
         }
-        
+
         return Double(successCounts.filter { $0 }.count)
     }
 

package/ios/Helpers.swift

@@ -136,27 +136,6 @@ func createUUIDsPredicate(uuidsWrapper: PredicateWithUUIDs) -> NSPredicate {
     return HKQuery.predicateForObjects(with: Set(uuids))
 }
 
-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 w.workoutPredicate
-              }
-              throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
-        }
-    }
-    return nil
-}
-
 func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr?) throws -> NSPredicate? {
     if let filter = filter {
         switch filter {

package/lib/commonjs/types/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Auth"), exports);
 __exportStar(require("./Background"), exports);
 __exportStar(require("./CategoryType"), exports);
+__exportStar(require("./CategoryTypeIdentifier"), exports);
 __exportStar(require("./Characteristics"), exports);
 __exportStar(require("./Constants"), exports);
 __exportStar(require("./CorrelationType"), exports);

package/lib/module/types/index.js

@@ -1,6 +1,7 @@
 export * from './Auth';
 export * from './Background';
 export * from './CategoryType';
+export * from './CategoryTypeIdentifier';
 export * from './Characteristics';
 export * from './Constants';
 export * from './CorrelationType';

package/lib/typescript/index.ios.d.ts

@@ -45,8 +45,8 @@ export declare const getRequestStatusForAuthorization: (toShare: import("./types
 export declare const getWheelchairUse: () => import("./types").WheelchairUse;
 export declare const isHealthDataAvailable: () => boolean;
 export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
-export declare const queryCategorySamples: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CategorySampleTyped<T>[]>;
-export declare const queryCategorySamplesWithAnchor: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").CategorySamplesWithAnchorResponseTyped<T>>;
+export declare const queryCategorySamples: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CategorySampleTyped<T>[]>;
+export declare const queryCategorySamplesWithAnchor: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").CategorySamplesWithAnchorResponseTyped<T>>;
 export declare const queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly import("./types").CorrelationSample[]>;
 export declare const queryHeartbeatSeriesSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
 export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
@@ -59,7 +59,7 @@ export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").
 export declare const querySources: (identifier: import("./types").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
 export declare const requestAuthorization: (toShare: import("./types").SampleTypeIdentifierWriteable[], toRead: import("./types").ObjectTypeIdentifier[]) => Promise<boolean>;
 export declare const deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
-export declare const saveCategorySample: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
+export declare const saveCategorySample: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
 export declare const saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
 export declare const saveQuantitySample: (identifier: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
 export declare const saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<string>;
@@ -107,8 +107,8 @@ declare const _default: {
     getWheelchairUse: () => import("./types").WheelchairUse;
     isHealthDataAvailable: () => boolean;
     isHealthDataAvailableAsync: () => Promise<boolean>;
-    queryCategorySamples: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CategorySampleTyped<T>[]>;
-    queryCategorySamplesWithAnchor: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").CategorySamplesWithAnchorResponseTyped<T>>;
+    queryCategorySamples: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CategorySampleTyped<T>[]>;
+    queryCategorySamplesWithAnchor: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").CategorySamplesWithAnchorResponseTyped<T>>;
     queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly import("./types").CorrelationSample[]>;
     queryHeartbeatSeriesSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
     queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
@@ -121,7 +121,7 @@ declare const _default: {
     querySources: (identifier: import("./types").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
     requestAuthorization: (toShare: import("./types").SampleTypeIdentifierWriteable[], toRead: import("./types").ObjectTypeIdentifier[]) => Promise<boolean>;
     deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
-    saveCategorySample: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
+    saveCategorySample: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
     saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
     saveQuantitySample: (identifier: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
     saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<string>;

package/lib/typescript/types/QuantityType.d.ts

@@ -1,6 +1,6 @@
 import type { QuantitySample } from './QuantitySample';
 import type { QuantityTypeIdentifier } from './QuantityTypeIdentifier';
-import type { PredicateForSamples } from './QueryOptions';
+import type { FilterForSamples } from './QueryOptions';
 import type { DeletedSample, GenericMetadata } from './Shared';
 import type { BloodGlucoseUnit, CountPerTime, EnergyUnit, LengthUnit, MassUnit, SpeedUnit, TemperatureUnit, TimeUnit, Unit, VolumeUnit } from './Units';
 interface QuantityDateInterval {
@@ -45,7 +45,7 @@ export interface IntervalComponents {
     readonly year?: number;
 }
 export interface StatisticsQueryOptions {
-    filter?: PredicateForSamples;
+    filter?: FilterForSamples;
     unit?: string;
 }
 /**

package/lib/typescript/types/QueryOptions.d.ts

@@ -15,14 +15,22 @@ type PredicateWithMetadataKey = {
     readonly withMetadataKey: string;
 };
 export type FilterForSamplesAnd = {
-    AND: PredicateForSamples[];
+    readonly AND: PredicateForSamples[];
 };
 export type FilterForSamplesOr = {
-    OR: PredicateForSamples[];
+    readonly OR: PredicateForSamples[];
 };
 export type PredicateFromWorkout = {
-    workout: WorkoutProxy;
+    readonly workout: WorkoutProxy;
 };
+type ComputeRaw<A> = A extends Function ? A : {
+    [K in keyof A]: A[K];
+} & {};
+type AllKeys<U> = U extends any ? keyof U : never;
+type _Strict<U, UAll extends U = U> = U extends any ? ComputeRaw<U & {
+    [K in Exclude<AllKeys<UAll>, keyof U>]?: never;
+}> : never;
+export type StrictUnion<U extends object> = _Strict<U>;
 export type FilterForSamples = PredicateForSamples | FilterForSamplesAnd | FilterForSamplesOr;
 export type PredicateForSamples = PredicateWithUUID | PredicateWithUUIDs | PredicateWithMetadataKey | PredicateWithStartAndEnd | PredicateFromWorkout;
 /**

package/lib/typescript/types/index.d.ts

@@ -1,6 +1,7 @@
 export * from './Auth';
 export * from './Background';
 export * from './CategoryType';
+export * from './CategoryTypeIdentifier';
 export * from './Characteristics';
 export * from './Constants';
 export * from './CorrelationType';

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.hpp

@@ -1737,15 +1737,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>
-  /**
-   * Specialized version of `std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>`.
-   */
-  using std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__ = std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>;
-  inline std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__(const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>& value) {
-    return std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>(value);
-  }
-  
   // pragma MARK: std::optional<StatisticsQueryOptions>
   /**
    * Specialized version of `std::optional<StatisticsQueryOptions>`.

package/nitrogen/generated/ios/swift/StatisticsQueryOptions.swift

@@ -18,21 +18,25 @@ public extension StatisticsQueryOptions {
   /**
    * Create a new instance of `StatisticsQueryOptions`.
    */
-  init(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout?, unit: String?) {
-    self.init({ () -> bridge.std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__ in
+  init(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr?, unit: String?) {
+    self.init({ () -> bridge.std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__ in
       if let __unwrappedValue = filter {
-        return bridge.create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__({ () -> bridge.std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ in
+        return bridge.create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__({ () -> bridge.std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ in
           switch __unwrappedValue {
             case .first(let __value):
-              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
             case .second(let __value):
-              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
             case .third(let __value):
-              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
             case .fourth(let __value):
-              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
             case .fifth(let __value):
-              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
+            case .sixth(let __value):
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
+            case .seventh(let __value):
+              return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
           }
         }().variant)
       } else {
@@ -47,13 +51,13 @@ public extension StatisticsQueryOptions {
     }())
   }
 
-  var filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout? {
+  var filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr? {
     @inline(__always)
     get {
-      return { () -> Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout? in
+      return { () -> Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr? in
         if let __unwrapped = self.__filter.value {
-          return { () -> Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout in
-            let __variant = bridge.std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__unwrapped)
+          return { () -> Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr in
+            let __variant = bridge.std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__unwrapped)
             switch __variant.index() {
               case 0:
                 let __actual = __variant.get_0()
@@ -70,6 +74,12 @@ public extension StatisticsQueryOptions {
               case 4:
                 let __actual = __variant.get_4()
                 return .fifth(__actual)
+              case 5:
+                let __actual = __variant.get_5()
+                return .sixth(__actual)
+              case 6:
+                let __actual = __variant.get_6()
+                return .seventh(__actual)
               default:
                 fatalError("Variant can never have index \(__variant.index())!")
             }
@@ -81,20 +91,24 @@ public extension StatisticsQueryOptions {
     }
     @inline(__always)
     set {
-      self.__filter = { () -> bridge.std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__ in
+      self.__filter = { () -> bridge.std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__ in
         if let __unwrappedValue = newValue {
-          return bridge.create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__({ () -> bridge.std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ in
+          return bridge.create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__({ () -> bridge.std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ in
             switch __unwrappedValue {
               case .first(let __value):
-                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
               case .second(let __value):
-                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
               case .third(let __value):
-                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
               case .fourth(let __value):
-                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
               case .fifth(let __value):
-                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(__value)
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
+              case .sixth(let __value):
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
+              case .seventh(let __value):
+                return bridge.create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(__value)
             }
           }().variant)
         } else {

package/nitrogen/generated/shared/c++/StatisticsQueryOptions.hpp

@@ -28,6 +28,10 @@ namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
 namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
 // Forward declaration of `PredicateFromWorkout` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
+// Forward declaration of `FilterForSamplesAnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
+// Forward declaration of `FilterForSamplesOr` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
 
 #include <optional>
 #include <variant>
@@ -36,6 +40,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 #include "PredicateWithMetadataKey.hpp"
 #include "PredicateWithStartAndEnd.hpp"
 #include "PredicateFromWorkout.hpp"
+#include "FilterForSamplesAnd.hpp"
+#include "FilterForSamplesOr.hpp"
 #include <string>
 
 namespace margelo::nitro::healthkit {
@@ -45,12 +51,12 @@ namespace margelo::nitro::healthkit {
    */
   struct StatisticsQueryOptions {
   public:
-    std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> filter     SWIFT_PRIVATE;
+    std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>> filter     SWIFT_PRIVATE;
     std::optional<std::string> unit     SWIFT_PRIVATE;
 
   public:
     StatisticsQueryOptions() = default;
-    explicit StatisticsQueryOptions(std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> filter, std::optional<std::string> unit): filter(filter), unit(unit) {}
+    explicit StatisticsQueryOptions(std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>> filter, std::optional<std::string> unit): filter(filter), unit(unit) {}
   };
 
 } // namespace margelo::nitro::healthkit
@@ -65,13 +71,13 @@ namespace margelo::nitro {
     static inline StatisticsQueryOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return StatisticsQueryOptions(
-        JSIConverter<std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>>::fromJSI(runtime, obj.getProperty(runtime, "filter")),
+        JSIConverter<std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>>::fromJSI(runtime, obj.getProperty(runtime, "filter")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "unit"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const StatisticsQueryOptions& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "filter", JSIConverter<std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>>::toJSI(runtime, arg.filter));
+      obj.setProperty(runtime, "filter", JSIConverter<std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>>::toJSI(runtime, arg.filter));
       obj.setProperty(runtime, "unit", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.unit));
       return obj;
     }
@@ -80,7 +86,7 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
-      if (!JSIConverter<std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>>::canConvert(runtime, obj.getProperty(runtime, "filter"))) return false;
+      if (!JSIConverter<std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>>::canConvert(runtime, obj.getProperty(runtime, "filter"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "unit"))) return false;
       return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingstinct/react-native-healthkit",
-  "version": "9.0.5",
+  "version": "9.0.6",
   "description": "React Native bindings for HealthKit",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/src/types/QuantityType.ts

@@ -1,6 +1,6 @@
 import type { QuantitySample } from './QuantitySample'
 import type { QuantityTypeIdentifier } from './QuantityTypeIdentifier'
-import type { PredicateForSamples } from './QueryOptions'
+import type { FilterForSamples } from './QueryOptions'
 import type { DeletedSample, GenericMetadata } from './Shared'
 import type {
   BloodGlucoseUnit,
@@ -64,7 +64,7 @@ export interface IntervalComponents {
 }
 
 export interface StatisticsQueryOptions {
-  filter?: PredicateForSamples
+  filter?: FilterForSamples
   unit?: string
 }
 

package/src/types/QueryOptions.ts

@@ -20,17 +20,39 @@ type PredicateWithMetadataKey = {
 }
 
 export type FilterForSamplesAnd = {
-  AND: PredicateForSamples[]
+  readonly AND: PredicateForSamples[]
 }
 
 export type FilterForSamplesOr = {
-  OR: PredicateForSamples[]
+  readonly OR: PredicateForSamples[]
 }
 
 export type PredicateFromWorkout = {
-  workout: WorkoutProxy
+  readonly workout: WorkoutProxy
 }
 
+// Computes and flattens object types
+// biome-ignore lint/complexity/noBannedTypes: <explanation>
+type ComputeRaw<A> = A extends Function ? A : { [K in keyof A]: A[K] } & {}
+
+// Gets all keys from a union of objects
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+type AllKeys<U> = U extends any ? keyof U : never
+
+// The core: for each member U in the union,
+// add `?: never` for any key that exists in other union members.
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+type _Strict<U, UAll extends U = U> = U extends any
+  ? ComputeRaw<
+      U & {
+        [K in Exclude<AllKeys<UAll>, keyof U>]?: never
+      }
+    >
+  : never
+
+// The exported type you can copy into your codebase
+export type StrictUnion<U extends object> = _Strict<U>
+
 export type FilterForSamples =
   | PredicateForSamples
   | FilterForSamplesAnd
@@ -42,7 +64,6 @@ export type PredicateForSamples =
   | PredicateWithMetadataKey
   | PredicateWithStartAndEnd
   | PredicateFromWorkout
-
 /**
  * Generic options for querying.
  */

package/src/types/index.ts

@@ -1,6 +1,7 @@
 export * from './Auth'
 export * from './Background'
 export * from './CategoryType'
+export * from './CategoryTypeIdentifier'
 export * from './Characteristics'
 export * from './Constants'
 export * from './CorrelationType'

package/nitrogen/generated/ios/swift/Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout.swift

@@ -1,19 +0,0 @@
-///
-/// Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-/**
- * An Swift enum with associated values representing a Variant/Union type.
- * JS type: `struct | struct | struct | struct | struct`
- */
-@frozen
-public indirect enum Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout {
-  case first(PredicateWithUUID)
-  case second(PredicateWithUUIDs)
-  case third(PredicateWithMetadataKey)
-  case fourth(PredicateWithStartAndEnd)
-  case fifth(PredicateFromWorkout)
-}