@kingstinct/react-native-healthkit 10.0.0 → 10.1.0

package/ios/CorrelationTypeModule.swift

@@ -134,6 +134,7 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
                             }
 
                             return CorrelationSample(
+                                uuid: correlation.uuid.uuidString,
                                 correlationType: CorrelationTypeIdentifier(fromString: correlation.correlationType.identifier)!,
                                 objects: objects,
                                 metadata: serializeMetadata(correlation.metadata),

package/ios/Helpers.swift

@@ -39,7 +39,7 @@ func createPredicateForWorkout(filter: PredicateForWorkouts) throws -> NSPredica
         case .second(let uuidsWrapper):
             return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
         case .third(let metadataKey):
-            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            return try createMetadataPredicate(metadataKey: metadataKey)
         case .fourth(let dateFilter):
             return createDatePredicate(dateFilter: dateFilter)
         case .fifth(let w):
@@ -69,7 +69,7 @@ func createPredicateForWorkout(filter: Variant_PredicateWithUUID_PredicateWithUU
         case .second(let uuidsWrapper):
             return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
         case .third(let metadataKey):
-            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            return try createMetadataPredicate(metadataKey: metadataKey)
         case .fourth(let dateFilter):
             return createDatePredicate(dateFilter: dateFilter)
         case .fifth(let w):
@@ -136,6 +136,50 @@ func createUUIDsPredicate(uuidsWrapper: PredicateWithUUIDs) -> NSPredicate {
     return HKQuery.predicateForObjects(with: Set(uuids))
 }
 
+func createMetadataPredicate(metadataKey: PredicateWithMetadataKey) throws -> NSPredicate {
+    guard let valueVariant = metadataKey.value else {
+        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+    }
+
+    let actualValue: Any
+
+    switch valueVariant {
+      case .first(let stringValue):
+          actualValue = stringValue
+      case .second(let doubleValue):
+          actualValue = NSNumber(value: doubleValue)
+      case .third(let boolValue):
+          actualValue = NSNumber(value: boolValue ? 1 : 0)
+      case .fourth(let dateValue):
+          actualValue = dateValue
+    }
+
+    let operatorType: NSComparisonPredicate.Operator
+
+    if let operatorTypeValue = metadataKey.operatorType {
+        switch operatorTypeValue {
+          case PredicateWithMetadataOperator.equalto:
+              operatorType = .equalTo
+          case PredicateWithMetadataOperator.notequalto:
+              operatorType = .notEqualTo
+          case PredicateWithMetadataOperator.greaterthan:
+              operatorType = .greaterThan
+          case PredicateWithMetadataOperator.lessthan:
+              operatorType = .lessThan
+          default:
+              throw RuntimeError.error(withMessage: "Unsupported operator: \(operatorTypeValue)")
+        }
+    } else {
+        operatorType = .equalTo
+    }
+
+    return HKQuery.predicateForObjects(
+        withMetadataKey: metadataKey.withMetadataKey,
+        operatorType: operatorType,
+        value: actualValue
+    )
+}
+
 func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr?) throws -> NSPredicate? {
     if let filter = filter {
         switch filter {
@@ -144,7 +188,7 @@ func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_Predic
             case .second(let uuidsWrapper):
                 return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
             case .third(let metadataKey):
-                return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+                return try createMetadataPredicate(metadataKey: metadataKey)
             case .fourth(let dateFilter):
                 return createDatePredicate(dateFilter: dateFilter)
             case .fifth(let w):
@@ -173,7 +217,7 @@ func createPredicateForSamples(filter: PredicateForSamples) throws -> NSPredicat
         case .second(let uuidsWrapper):
             return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
         case .third(let metadataKey):
-            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            return try createMetadataPredicate(metadataKey: metadataKey)
         case .fourth(let dateFilter):
             return createDatePredicate(dateFilter: dateFilter)
         case .fifth(let w):
@@ -191,7 +235,7 @@ func createPredicateForSamples(filter: FilterForSamples) throws -> NSPredicate {
     case .second(let uuidsWrapper):
         return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
     case .third(let metadataKey):
-        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        return try createMetadataPredicate(metadataKey: metadataKey)
     case .fourth(let dateFilter):
         return createDatePredicate(dateFilter: dateFilter)
     case .fifth(let w):
@@ -218,7 +262,7 @@ func createPredicateForSamples(filter: Variant_PredicateWithUUID_PredicateWithUU
     case .second(let uuidsWrapper):
         return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
     case .third(let metadataKey):
-        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        return try createMetadataPredicate(metadataKey: metadataKey)
     case .fourth(let dateFilter):
         return createDatePredicate(dateFilter: dateFilter)
     case .fifth(let w):

package/ios/QuantityTypeModule.swift

@@ -178,71 +178,76 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     quantitySamplePredicate: predicate,
                     options: buildStatisticsOptions(statistics: statistics)
                 ) { (_, stats: HKStatistics?, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                        return
-                    }
+                    DispatchQueue.main.async {
+                        if let error = error {
+                            continuation.resume(throwing: error)
+                            return
+                        }
 
-                    guard let gottenStats = stats else {
-                        let emptyResponse = QueryStatisticsResponse()
-                        continuation.resume(returning: emptyResponse)
-                        return
-                    }
+                        guard let gottenStats = stats else {
+                            let emptyResponse = QueryStatisticsResponse()
+                            continuation.resume(returning: emptyResponse)
+                            return
+                        }
 
-                    var response = QueryStatisticsResponse()
+                        var response = QueryStatisticsResponse()
 
-                    if let averageQuantity = gottenStats.averageQuantity() {
-                        response.averageQuantity = Quantity(
-                            unit: unit.unitString,
-                            quantity: averageQuantity.doubleValue(for: unit)
-                        )
-                    }
-                    if let maximumQuantity = gottenStats.maximumQuantity() {
-                        response.maximumQuantity = Quantity(
-                            unit: unit.unitString,
-                            quantity: maximumQuantity.doubleValue(for: unit)
-                        )
-                    }
-                    if let minimumQuantity = gottenStats.minimumQuantity() {
-                        response.minimumQuantity = Quantity(
-                            unit: unit.unitString,
-                            quantity: minimumQuantity.doubleValue(for: unit)
-                        )
-                    }
-                    if let sumQuantity = gottenStats.sumQuantity() {
-                        response.sumQuantity = Quantity(
-                            unit: unit.unitString,
-                            quantity: sumQuantity.doubleValue(for: unit)
-                        )
-                    }
+                        response.startDate = gottenStats.startDate
+                        response.endDate = gottenStats.endDate
 
-                    if #available(iOS 12, *) {
-                        if let mostRecent = gottenStats.mostRecentQuantity() {
-                            response.mostRecentQuantity = Quantity(
+                        if let averageQuantity = gottenStats.averageQuantity() {
+                            response.averageQuantity = Quantity(
                                 unit: unit.unitString,
-                                quantity: mostRecent.doubleValue(for: unit)
+                                quantity: averageQuantity.doubleValue(for: unit)
                             )
                         }
-
-                        if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
-                            response.mostRecentQuantityDateInterval = QuantityDateInterval(
-                                from: mostRecentDateInterval.start,
-                                to: mostRecentDateInterval.end
+                        if let maximumQuantity = gottenStats.maximumQuantity() {
+                            response.maximumQuantity = Quantity(
+                                unit: unit.unitString,
+                                quantity: maximumQuantity.doubleValue(for: unit)
                             )
                         }
-                    }
-
-                    if #available(iOS 13, *) {
-                        if let duration = gottenStats.duration() {
-                            let durationUnit = HKUnit.second()
-                            response.duration = Quantity(
-                                unit: durationUnit.unitString,
-                                quantity: duration.doubleValue(for: durationUnit)
+                        if let minimumQuantity = gottenStats.minimumQuantity() {
+                            response.minimumQuantity = Quantity(
+                                unit: unit.unitString,
+                                quantity: minimumQuantity.doubleValue(for: unit)
+                            )
+                        }
+                        if let sumQuantity = gottenStats.sumQuantity() {
+                            response.sumQuantity = Quantity(
+                                unit: unit.unitString,
+                                quantity: sumQuantity.doubleValue(for: unit)
                             )
                         }
-                    }
 
-                    continuation.resume(returning: response)
+                        if #available(iOS 12, *) {
+                            if let mostRecent = gottenStats.mostRecentQuantity() {
+                                response.mostRecentQuantity = Quantity(
+                                    unit: unit.unitString,
+                                    quantity: mostRecent.doubleValue(for: unit)
+                                )
+                            }
+
+                            if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
+                                response.mostRecentQuantityDateInterval = QuantityDateInterval(
+                                    from: mostRecentDateInterval.start,
+                                    to: mostRecentDateInterval.end
+                                )
+                            }
+                        }
+
+                        if #available(iOS 13, *) {
+                            if let duration = gottenStats.duration() {
+                                let durationUnit = HKUnit.second()
+                                response.duration = Quantity(
+                                    unit: durationUnit.unitString,
+                                    quantity: duration.doubleValue(for: durationUnit)
+                                )
+                            }
+                        }
+
+                        continuation.resume(returning: response)
+                    }
                 }
 
                 store.execute(query)
@@ -323,6 +328,9 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     statistics.enumerateStatistics(from: enumerateFrom, to: enumerateTo) { stats, _ in
                         var response = QueryStatisticsResponse()
 
+                        response.startDate = stats.startDate
+                        response.endDate = stats.endDate
+
                         if let averageQuantity = stats.averageQuantity() {
                             response.averageQuantity = Quantity(
                                 unit: unit.unitString,

package/lib/commonjs/healthkit.js

@@ -74,7 +74,7 @@ exports.queryStatisticsCollectionForQuantity = UnavailableFnFromModule('querySta
 exports.saveQuantitySample = UnavailableFnFromModule('saveQuantitySample', Promise.resolve(false));
 exports.isQuantityCompatibleWithUnit = UnavailableFnFromModule('isQuantityCompatibleWithUnit', false);
 // CategoryTypeModule functions
-function queryCategorySamples(_categoryTypeIdentifier) {
+function queryCategorySamples(_categoryTypeIdentifier, _options) {
     if (react_native_1.Platform.OS !== 'ios' && !hasWarned) {
         console.warn(notAvailableError);
         hasWarned = true;

package/lib/module/healthkit.js

@@ -52,7 +52,7 @@ export const queryStatisticsCollectionForQuantity = UnavailableFnFromModule('que
 export const saveQuantitySample = UnavailableFnFromModule('saveQuantitySample', Promise.resolve(false));
 export const isQuantityCompatibleWithUnit = UnavailableFnFromModule('isQuantityCompatibleWithUnit', false);
 // CategoryTypeModule functions
-export function queryCategorySamples(_categoryTypeIdentifier) {
+export function queryCategorySamples(_categoryTypeIdentifier, _options) {
     if (Platform.OS !== 'ios' && !hasWarned) {
         console.warn(notAvailableError);
         hasWarned = true;

package/lib/typescript/healthkit.d.ts

@@ -5,7 +5,7 @@ import type { CategorySamplesWithAnchorResponseTyped, CategorySampleTyped } from
 import type { CategoryTypeIdentifier } from './types/CategoryTypeIdentifier';
 import { BiologicalSex, BloodType, FitzpatrickSkinType, WheelchairUse } from './types/Characteristics';
 import type { QuantitySample } from './types/QuantitySample';
-import type { QueryOptionsWithAnchor } from './types/QueryOptions';
+import type { QueryOptionsWithAnchor, QueryOptionsWithSortOrder } from './types/QueryOptions';
 export * from './types';
 export declare const authorizationStatusFor: (type: import("./types").ObjectTypeIdentifier) => AuthorizationStatus;
 export declare const disableAllBackgroundDelivery: () => Promise<boolean>;
@@ -35,18 +35,18 @@ export declare const queryStatisticsForQuantity: (identifier: import("./types").
 export declare const queryStatisticsCollectionForQuantity: (identifier: import("./types").QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
 export declare const saveQuantitySample: (identifier: import("./types").QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
 export declare const isQuantityCompatibleWithUnit: (identifier: import("./types").QuantityTypeIdentifier, unit: string) => boolean;
-export declare function queryCategorySamples<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T): Promise<CategorySampleTyped<T>[]>;
+export declare function queryCategorySamples<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T, _options?: QueryOptionsWithSortOrder): Promise<CategorySampleTyped<T>[]>;
 export declare function queryCategorySamplesWithAnchor<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T, _options: QueryOptionsWithAnchor): Promise<CategorySamplesWithAnchorResponseTyped<T>>;
 export declare const saveCategorySample: <T extends CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
 export declare const queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly import("./types").CorrelationSample[]>;
 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 queryHeartbeatSeriesSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
+export declare const queryHeartbeatSeriesSamples: (options?: QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
 export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
 export declare const queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<WorkoutProxy[]>;
 export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
 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<WorkoutProxy>;
 export declare const startWatchApp: (workoutConfiguration: import("./types").WorkoutConfiguration) => Promise<boolean>;
-export declare const queryStateOfMindSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
+export declare const queryStateOfMindSamples: (options?: QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
 export declare const saveStateOfMindSample: (date: Date, kind: import("./types").StateOfMindKind, valence: number, labels: readonly import("./types").StateOfMindLabel[], associations: readonly import("./types").StateOfMindAssociation[], metadata?: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
 export declare function getMostRecentCategorySample<T extends CategoryTypeIdentifier>(_identifier: T): Promise<CategorySampleTyped<T> | undefined>;
 export declare const getMostRecentQuantitySample: typeof import("./healthkit.ios").getMostRecentQuantitySample;

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

@@ -8,6 +8,7 @@ import type { GenericMetadata } from './Shared';
 export type CorrelationTypeIdentifier = 'HKCorrelationTypeIdentifierBloodPressure' | 'HKCorrelationTypeIdentifierFood';
 type CorrelationObject = CategorySample | QuantitySample;
 export interface CorrelationSample {
+    readonly uuid: string;
     readonly correlationType: CorrelationTypeIdentifier;
     readonly objects: readonly CorrelationObject[];
     readonly metadata: AnyMap;

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

@@ -15,6 +15,8 @@ export interface QueryStatisticsResponse {
     readonly mostRecentQuantity?: Quantity;
     readonly mostRecentQuantityDateInterval?: QuantityDateInterval;
     readonly duration?: Quantity;
+    readonly startDate?: Date;
+    readonly endDate?: Date;
 }
 export interface QuantitySamplesWithAnchorResponse {
     readonly samples: readonly QuantitySample[];

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

@@ -11,8 +11,12 @@ type PredicateWithStartAndEnd = {
     readonly strictEndDate?: boolean;
     readonly strictStartDate?: boolean;
 };
+type PredicateWithMetadataOperator = 'equalTo' | 'notEqualTo' | 'greaterThan' | 'lessThan';
+type PredicateWithMetadataValue = string | number | Date | boolean;
 type PredicateWithMetadataKey = {
     readonly withMetadataKey: string;
+    readonly operatorType?: PredicateWithMetadataOperator;
+    readonly value?: PredicateWithMetadataValue;
 };
 export type FilterForSamplesAnd = {
     readonly AND: PredicateForSamples[];

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

@@ -84,6 +84,8 @@ namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
 namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 // Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `PredicateWithStartAndEnd` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
 // Forward declaration of `PredicateWithUUID` to properly resolve imports.
@@ -217,6 +219,7 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "PredicateForWorkoutsOr.hpp"
 #include "PredicateFromWorkout.hpp"
 #include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "PredicateWithStartAndEnd.hpp"
 #include "PredicateWithUUID.hpp"
 #include "PredicateWithUUIDs.hpp"
@@ -442,6 +445,65 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return vector;
   }
   
+  // pragma MARK: std::optional<PredicateWithMetadataOperator>
+  /**
+   * Specialized version of `std::optional<PredicateWithMetadataOperator>`.
+   */
+  using std__optional_PredicateWithMetadataOperator_ = std::optional<PredicateWithMetadataOperator>;
+  inline std::optional<PredicateWithMetadataOperator> create_std__optional_PredicateWithMetadataOperator_(const PredicateWithMetadataOperator& value) {
+    return std::optional<PredicateWithMetadataOperator>(value);
+  }
+  
+  // pragma MARK: std::variant<std::string, double, bool, std::chrono::system_clock::time_point>
+  /**
+   * Wrapper struct for `std::variant<std::string, double, bool, std::chrono::system_clock::time_point>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ {
+    std::variant<std::string, double, bool, std::chrono::system_clock::time_point> variant;
+    std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std::variant<std::string, double, bool, std::chrono::system_clock::time_point> variant): variant(variant) { }
+    operator std::variant<std::string, double, bool, std::chrono::system_clock::time_point>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline std::string get_0() const {
+      return std::get<0>(variant);
+    }
+    inline double get_1() const {
+      return std::get<1>(variant);
+    }
+    inline bool get_2() const {
+      return std::get<2>(variant);
+    }
+    inline std::chrono::system_clock::time_point get_3() const {
+      return std::get<3>(variant);
+    }
+  };
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(const std::string& value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(double value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(bool value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std::chrono::system_clock::time_point value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>
+  /**
+   * Specialized version of `std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>`.
+   */
+  using std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__ = std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>;
+  inline std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>> create_std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__(const std::variant<std::string, double, bool, std::chrono::system_clock::time_point>& value) {
+    return std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>(value);
+  }
+  
   // pragma MARK: std::optional<std::chrono::system_clock::time_point>
   /**
    * Specialized version of `std::optional<std::chrono::system_clock::time_point>`.

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

@@ -86,6 +86,8 @@ namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
 namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 // Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `PredicateWithStartAndEnd` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
 // Forward declaration of `PredicateWithUUID` to properly resolve imports.
@@ -212,6 +214,7 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "PredicateForWorkoutsOr.hpp"
 #include "PredicateFromWorkout.hpp"
 #include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "PredicateWithStartAndEnd.hpp"
 #include "PredicateWithUUID.hpp"
 #include "PredicateWithUUIDs.hpp"

package/nitrogen/generated/ios/c++/HybridCategoryTypeModuleSpecSwift.hpp

@@ -40,6 +40,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `CategorySamplesWithAnchorResponse` to properly resolve imports.
@@ -70,6 +72,7 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 #include "CategorySamplesWithAnchorResponse.hpp"
 #include "DeletedSample.hpp"

package/nitrogen/generated/ios/c++/HybridCoreModuleSpecSwift.hpp

@@ -46,6 +46,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 
@@ -73,6 +75,7 @@ namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include <chrono>
 #include "HybridWorkoutProxySpec.hpp"
 #include <unordered_map>

package/nitrogen/generated/ios/c++/HybridHeartbeatSeriesModuleSpecSwift.hpp

@@ -40,6 +40,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `HeartbeatSeriesSamplesWithAnchorResponse` to properly resolve imports.
@@ -70,6 +72,7 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 #include "HeartbeatSeriesSamplesWithAnchorResponse.hpp"
 #include "DeletedSample.hpp"

package/nitrogen/generated/ios/c++/HybridQuantityTypeModuleSpecSwift.hpp

@@ -30,6 +30,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `QuantitySample` to properly resolve imports.
@@ -76,6 +78,7 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndUnit; }
 #include "FilterForSamplesOr.hpp"
 #include <vector>
 #include <optional>
+#include "PredicateWithMetadataOperator.hpp"
 #include <memory>
 #include "HybridWorkoutProxySpec.hpp"
 #include "QuantitySample.hpp"

package/nitrogen/generated/ios/c++/HybridStateOfMindModuleSpecSwift.hpp

@@ -46,6 +46,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 
@@ -73,6 +75,7 @@ namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 
 #include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"

package/nitrogen/generated/ios/c++/HybridWorkoutsModuleSpecSwift.hpp

@@ -52,6 +52,8 @@ namespace margelo::nitro::healthkit { struct WorkoutDurationPredicate; }
 namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
 // Forward declaration of `PredicateForWorkoutsAnd` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateForWorkoutsAnd; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `ComparisonPredicateOperator` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class ComparisonPredicateOperator; }
 // Forward declaration of `WorkoutQueryOptions` to properly resolve imports.
@@ -88,6 +90,7 @@ namespace margelo::nitro::healthkit { enum class WorkoutSessionLocationType; }
 #include "WorkoutDurationPredicate.hpp"
 #include "PredicateForWorkoutsOr.hpp"
 #include "PredicateForWorkoutsAnd.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "ComparisonPredicateOperator.hpp"
 #include "WorkoutQueryOptions.hpp"
 #include "WorkoutConfiguration.hpp"

package/nitrogen/generated/ios/swift/CorrelationSample.swift

@@ -18,8 +18,8 @@ public extension CorrelationSample {
   /**
    * Create a new instance of `CorrelationSample`.
    */
-  init(correlationType: CorrelationTypeIdentifier, objects: [CorrelationObject], metadata: AnyMap, startDate: Date, endDate: Date) {
-    self.init(correlationType, { () -> bridge.std__vector_std__variant_CategorySample__QuantitySample__ in
+  init(uuid: String, correlationType: CorrelationTypeIdentifier, objects: [CorrelationObject], metadata: AnyMap, startDate: Date, endDate: Date) {
+    self.init(std.string(uuid), correlationType, { () -> bridge.std__vector_std__variant_CategorySample__QuantitySample__ in
       var __vector = bridge.create_std__vector_std__variant_CategorySample__QuantitySample__(objects.count)
       for __item in objects {
         __vector.push_back({ () -> bridge.std__variant_CategorySample__QuantitySample_ in
@@ -35,6 +35,17 @@ public extension CorrelationSample {
     }(), metadata.cppPart, startDate.toCpp(), endDate.toCpp())
   }
 
+  var uuid: String {
+    @inline(__always)
+    get {
+      return String(self.__uuid)
+    }
+    @inline(__always)
+    set {
+      self.__uuid = std.string(newValue)
+    }
+  }
+  
   var correlationType: CorrelationTypeIdentifier {
     @inline(__always)
     get {

package/nitrogen/generated/ios/swift/PredicateWithMetadataKey.swift

@@ -18,8 +18,31 @@ public extension PredicateWithMetadataKey {
   /**
    * Create a new instance of `PredicateWithMetadataKey`.
    */
-  init(withMetadataKey: String) {
-    self.init(std.string(withMetadataKey))
+  init(withMetadataKey: String, operatorType: PredicateWithMetadataOperator?, value: Variant_String_Double_Bool_Date?) {
+    self.init(std.string(withMetadataKey), { () -> bridge.std__optional_PredicateWithMetadataOperator_ in
+      if let __unwrappedValue = operatorType {
+        return bridge.create_std__optional_PredicateWithMetadataOperator_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__ in
+      if let __unwrappedValue = value {
+        return bridge.create_std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__({ () -> bridge.std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std.string(__value))
+            case .second(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+            case .third(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+            case .fourth(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value.toCpp())
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }())
   }
 
   var withMetadataKey: String {
@@ -32,4 +55,73 @@ public extension PredicateWithMetadataKey {
       self.__withMetadataKey = std.string(newValue)
     }
   }
+  
+  var operatorType: PredicateWithMetadataOperator? {
+    @inline(__always)
+    get {
+      return self.__operatorType.value
+    }
+    @inline(__always)
+    set {
+      self.__operatorType = { () -> bridge.std__optional_PredicateWithMetadataOperator_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_PredicateWithMetadataOperator_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var value: Variant_String_Double_Bool_Date? {
+    @inline(__always)
+    get {
+      return { () -> Variant_String_Double_Bool_Date? in
+        if let __unwrapped = self.__value.value {
+          return { () -> Variant_String_Double_Bool_Date in
+            let __variant = bridge.std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__unwrapped)
+            switch __variant.index() {
+              case 0:
+                let __actual = __variant.get_0()
+                return .first(String(__actual))
+              case 1:
+                let __actual = __variant.get_1()
+                return .second(__actual)
+              case 2:
+                let __actual = __variant.get_2()
+                return .third(__actual)
+              case 3:
+                let __actual = __variant.get_3()
+                return .fourth(Date(fromChrono: __actual))
+              default:
+                fatalError("Variant can never have index \(__variant.index())!")
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__value = { () -> bridge.std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__({ () -> bridge.std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std.string(__value))
+              case .second(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+              case .third(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+              case .fourth(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value.toCpp())
+            }
+          }().variant)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

package/nitrogen/generated/ios/swift/PredicateWithMetadataOperator.swift

@@ -0,0 +1,48 @@
+///
+/// PredicateWithMetadataOperator.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 union `PredicateWithMetadataOperator`, backed by a C++ enum.
+ */
+public typealias PredicateWithMetadataOperator = margelo.nitro.healthkit.PredicateWithMetadataOperator
+
+public extension PredicateWithMetadataOperator {
+  /**
+   * Get a PredicateWithMetadataOperator for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "equalTo":
+        self = .equalto
+      case "notEqualTo":
+        self = .notequalto
+      case "greaterThan":
+        self = .greaterthan
+      case "lessThan":
+        self = .lessthan
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this PredicateWithMetadataOperator represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .equalto:
+        return "equalTo"
+      case .notequalto:
+        return "notEqualTo"
+      case .greaterthan:
+        return "greaterThan"
+      case .lessthan:
+        return "lessThan"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/QueryStatisticsResponse.swift

@@ -18,7 +18,7 @@ public extension QueryStatisticsResponse {
   /**
    * Create a new instance of `QueryStatisticsResponse`.
    */
-  init(averageQuantity: Quantity?, maximumQuantity: Quantity?, minimumQuantity: Quantity?, sumQuantity: Quantity?, mostRecentQuantity: Quantity?, mostRecentQuantityDateInterval: QuantityDateInterval?, duration: Quantity?) {
+  init(averageQuantity: Quantity?, maximumQuantity: Quantity?, minimumQuantity: Quantity?, sumQuantity: Quantity?, mostRecentQuantity: Quantity?, mostRecentQuantityDateInterval: QuantityDateInterval?, duration: Quantity?, startDate: Date?, endDate: Date?) {
     self.init({ () -> bridge.std__optional_Quantity_ in
       if let __unwrappedValue = averageQuantity {
         return bridge.create_std__optional_Quantity_(__unwrappedValue)
@@ -61,6 +61,18 @@ public extension QueryStatisticsResponse {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_std__chrono__system_clock__time_point_ in
+      if let __unwrappedValue = startDate {
+        return bridge.create_std__optional_std__chrono__system_clock__time_point_(__unwrappedValue.toCpp())
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__chrono__system_clock__time_point_ in
+      if let __unwrappedValue = endDate {
+        return bridge.create_std__optional_std__chrono__system_clock__time_point_(__unwrappedValue.toCpp())
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -224,4 +236,50 @@ public extension QueryStatisticsResponse {
       }()
     }
   }
+  
+  var startDate: Date? {
+    @inline(__always)
+    get {
+      return { () -> Date? in
+        if let __unwrapped = self.__startDate.value {
+          return Date(fromChrono: __unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__startDate = { () -> bridge.std__optional_std__chrono__system_clock__time_point_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__chrono__system_clock__time_point_(__unwrappedValue.toCpp())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var endDate: Date? {
+    @inline(__always)
+    get {
+      return { () -> Date? in
+        if let __unwrapped = self.__endDate.value {
+          return Date(fromChrono: __unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__endDate = { () -> bridge.std__optional_std__chrono__system_clock__time_point_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__chrono__system_clock__time_point_(__unwrappedValue.toCpp())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

package/nitrogen/generated/ios/swift/Variant_String_Double_Bool_Date.swift

@@ -0,0 +1,18 @@
+///
+/// Variant_String_Double_Bool_Date.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: `string | number | boolean | date`
+ */
+@frozen
+public indirect enum Variant_String_Double_Bool_Date {
+  case first(String)
+  case second(Double)
+  case third(Bool)
+  case fourth(Date)
+}

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

@@ -27,6 +27,7 @@ namespace margelo::nitro::healthkit { struct QuantitySample; }
 // Forward declaration of `AnyMap` to properly resolve imports.
 namespace NitroModules { class AnyMap; }
 
+#include <string>
 #include "CorrelationTypeIdentifier.hpp"
 #include <vector>
 #include <variant>
@@ -42,6 +43,7 @@ namespace margelo::nitro::healthkit {
    */
   struct CorrelationSample {
   public:
+    std::string uuid     SWIFT_PRIVATE;
     CorrelationTypeIdentifier correlationType     SWIFT_PRIVATE;
     std::vector<std::variant<CategorySample, QuantitySample>> objects     SWIFT_PRIVATE;
     std::shared_ptr<AnyMap> metadata     SWIFT_PRIVATE;
@@ -50,7 +52,7 @@ namespace margelo::nitro::healthkit {
 
   public:
     CorrelationSample() = default;
-    explicit CorrelationSample(CorrelationTypeIdentifier correlationType, std::vector<std::variant<CategorySample, QuantitySample>> objects, std::shared_ptr<AnyMap> metadata, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate): correlationType(correlationType), objects(objects), metadata(metadata), startDate(startDate), endDate(endDate) {}
+    explicit CorrelationSample(std::string uuid, CorrelationTypeIdentifier correlationType, std::vector<std::variant<CategorySample, QuantitySample>> objects, std::shared_ptr<AnyMap> metadata, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate): uuid(uuid), correlationType(correlationType), objects(objects), metadata(metadata), startDate(startDate), endDate(endDate) {}
   };
 
 } // namespace margelo::nitro::healthkit
@@ -65,6 +67,7 @@ namespace margelo::nitro {
     static inline CorrelationSample fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return CorrelationSample(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "uuid")),
         JSIConverter<CorrelationTypeIdentifier>::fromJSI(runtime, obj.getProperty(runtime, "correlationType")),
         JSIConverter<std::vector<std::variant<CategorySample, QuantitySample>>>::fromJSI(runtime, obj.getProperty(runtime, "objects")),
         JSIConverter<std::shared_ptr<AnyMap>>::fromJSI(runtime, obj.getProperty(runtime, "metadata")),
@@ -74,6 +77,7 @@ namespace margelo::nitro {
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const CorrelationSample& arg) {
       jsi::Object obj(runtime);
+      obj.setProperty(runtime, "uuid", JSIConverter<std::string>::toJSI(runtime, arg.uuid));
       obj.setProperty(runtime, "correlationType", JSIConverter<CorrelationTypeIdentifier>::toJSI(runtime, arg.correlationType));
       obj.setProperty(runtime, "objects", JSIConverter<std::vector<std::variant<CategorySample, QuantitySample>>>::toJSI(runtime, arg.objects));
       obj.setProperty(runtime, "metadata", JSIConverter<std::shared_ptr<AnyMap>>::toJSI(runtime, arg.metadata));
@@ -86,6 +90,7 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "uuid"))) return false;
       if (!JSIConverter<CorrelationTypeIdentifier>::canConvert(runtime, obj.getProperty(runtime, "correlationType"))) return false;
       if (!JSIConverter<std::vector<std::variant<CategorySample, QuantitySample>>>::canConvert(runtime, obj.getProperty(runtime, "objects"))) return false;
       if (!JSIConverter<std::shared_ptr<AnyMap>>::canConvert(runtime, obj.getProperty(runtime, "metadata"))) return false;

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

@@ -18,9 +18,14 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 
 #include <string>
+#include <optional>
+#include "PredicateWithMetadataOperator.hpp"
+#include <variant>
+#include <chrono>
 
 namespace margelo::nitro::healthkit {
 
@@ -30,10 +35,12 @@ namespace margelo::nitro::healthkit {
   struct PredicateWithMetadataKey {
   public:
     std::string withMetadataKey     SWIFT_PRIVATE;
+    std::optional<PredicateWithMetadataOperator> operatorType     SWIFT_PRIVATE;
+    std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>> value     SWIFT_PRIVATE;
 
   public:
     PredicateWithMetadataKey() = default;
-    explicit PredicateWithMetadataKey(std::string withMetadataKey): withMetadataKey(withMetadataKey) {}
+    explicit PredicateWithMetadataKey(std::string withMetadataKey, std::optional<PredicateWithMetadataOperator> operatorType, std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>> value): withMetadataKey(withMetadataKey), operatorType(operatorType), value(value) {}
   };
 
 } // namespace margelo::nitro::healthkit
@@ -48,12 +55,16 @@ namespace margelo::nitro {
     static inline PredicateWithMetadataKey fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return PredicateWithMetadataKey(
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "withMetadataKey"))
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "withMetadataKey")),
+        JSIConverter<std::optional<PredicateWithMetadataOperator>>::fromJSI(runtime, obj.getProperty(runtime, "operatorType")),
+        JSIConverter<std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>>::fromJSI(runtime, obj.getProperty(runtime, "value"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const PredicateWithMetadataKey& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "withMetadataKey", JSIConverter<std::string>::toJSI(runtime, arg.withMetadataKey));
+      obj.setProperty(runtime, "operatorType", JSIConverter<std::optional<PredicateWithMetadataOperator>>::toJSI(runtime, arg.operatorType));
+      obj.setProperty(runtime, "value", JSIConverter<std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>>::toJSI(runtime, arg.value));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -62,6 +73,8 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "withMetadataKey"))) return false;
+      if (!JSIConverter<std::optional<PredicateWithMetadataOperator>>::canConvert(runtime, obj.getProperty(runtime, "operatorType"))) return false;
+      if (!JSIConverter<std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>>::canConvert(runtime, obj.getProperty(runtime, "value"))) return false;
       return true;
     }
   };

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

@@ -0,0 +1,86 @@
+///
+/// PredicateWithMetadataOperator.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * An enum which can be represented as a JavaScript union (PredicateWithMetadataOperator).
+   */
+  enum class PredicateWithMetadataOperator {
+    EQUALTO      SWIFT_NAME(equalto) = 0,
+    NOTEQUALTO      SWIFT_NAME(notequalto) = 1,
+    GREATERTHAN      SWIFT_NAME(greaterthan) = 2,
+    LESSTHAN      SWIFT_NAME(lessthan) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::healthkit
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::healthkit;
+
+  // C++ PredicateWithMetadataOperator <> JS PredicateWithMetadataOperator (union)
+  template <>
+  struct JSIConverter<PredicateWithMetadataOperator> final {
+    static inline PredicateWithMetadataOperator fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("equalTo"): return PredicateWithMetadataOperator::EQUALTO;
+        case hashString("notEqualTo"): return PredicateWithMetadataOperator::NOTEQUALTO;
+        case hashString("greaterThan"): return PredicateWithMetadataOperator::GREATERTHAN;
+        case hashString("lessThan"): return PredicateWithMetadataOperator::LESSTHAN;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum PredicateWithMetadataOperator - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, PredicateWithMetadataOperator arg) {
+      switch (arg) {
+        case PredicateWithMetadataOperator::EQUALTO: return JSIConverter<std::string>::toJSI(runtime, "equalTo");
+        case PredicateWithMetadataOperator::NOTEQUALTO: return JSIConverter<std::string>::toJSI(runtime, "notEqualTo");
+        case PredicateWithMetadataOperator::GREATERTHAN: return JSIConverter<std::string>::toJSI(runtime, "greaterThan");
+        case PredicateWithMetadataOperator::LESSTHAN: return JSIConverter<std::string>::toJSI(runtime, "lessThan");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert PredicateWithMetadataOperator to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("equalTo"):
+        case hashString("notEqualTo"):
+        case hashString("greaterThan"):
+        case hashString("lessThan"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -26,6 +26,7 @@ namespace margelo::nitro::healthkit { struct QuantityDateInterval; }
 #include <optional>
 #include "Quantity.hpp"
 #include "QuantityDateInterval.hpp"
+#include <chrono>
 
 namespace margelo::nitro::healthkit {
 
@@ -41,10 +42,12 @@ namespace margelo::nitro::healthkit {
     std::optional<Quantity> mostRecentQuantity     SWIFT_PRIVATE;
     std::optional<QuantityDateInterval> mostRecentQuantityDateInterval     SWIFT_PRIVATE;
     std::optional<Quantity> duration     SWIFT_PRIVATE;
+    std::optional<std::chrono::system_clock::time_point> startDate     SWIFT_PRIVATE;
+    std::optional<std::chrono::system_clock::time_point> endDate     SWIFT_PRIVATE;
 
   public:
     QueryStatisticsResponse() = default;
-    explicit QueryStatisticsResponse(std::optional<Quantity> averageQuantity, std::optional<Quantity> maximumQuantity, std::optional<Quantity> minimumQuantity, std::optional<Quantity> sumQuantity, std::optional<Quantity> mostRecentQuantity, std::optional<QuantityDateInterval> mostRecentQuantityDateInterval, std::optional<Quantity> duration): averageQuantity(averageQuantity), maximumQuantity(maximumQuantity), minimumQuantity(minimumQuantity), sumQuantity(sumQuantity), mostRecentQuantity(mostRecentQuantity), mostRecentQuantityDateInterval(mostRecentQuantityDateInterval), duration(duration) {}
+    explicit QueryStatisticsResponse(std::optional<Quantity> averageQuantity, std::optional<Quantity> maximumQuantity, std::optional<Quantity> minimumQuantity, std::optional<Quantity> sumQuantity, std::optional<Quantity> mostRecentQuantity, std::optional<QuantityDateInterval> mostRecentQuantityDateInterval, std::optional<Quantity> duration, std::optional<std::chrono::system_clock::time_point> startDate, std::optional<std::chrono::system_clock::time_point> endDate): averageQuantity(averageQuantity), maximumQuantity(maximumQuantity), minimumQuantity(minimumQuantity), sumQuantity(sumQuantity), mostRecentQuantity(mostRecentQuantity), mostRecentQuantityDateInterval(mostRecentQuantityDateInterval), duration(duration), startDate(startDate), endDate(endDate) {}
   };
 
 } // namespace margelo::nitro::healthkit
@@ -65,7 +68,9 @@ namespace margelo::nitro {
         JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "sumQuantity")),
         JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "mostRecentQuantity")),
         JSIConverter<std::optional<QuantityDateInterval>>::fromJSI(runtime, obj.getProperty(runtime, "mostRecentQuantityDateInterval")),
-        JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "duration"))
+        JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "duration")),
+        JSIConverter<std::optional<std::chrono::system_clock::time_point>>::fromJSI(runtime, obj.getProperty(runtime, "startDate")),
+        JSIConverter<std::optional<std::chrono::system_clock::time_point>>::fromJSI(runtime, obj.getProperty(runtime, "endDate"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const QueryStatisticsResponse& arg) {
@@ -77,6 +82,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "mostRecentQuantity", JSIConverter<std::optional<Quantity>>::toJSI(runtime, arg.mostRecentQuantity));
       obj.setProperty(runtime, "mostRecentQuantityDateInterval", JSIConverter<std::optional<QuantityDateInterval>>::toJSI(runtime, arg.mostRecentQuantityDateInterval));
       obj.setProperty(runtime, "duration", JSIConverter<std::optional<Quantity>>::toJSI(runtime, arg.duration));
+      obj.setProperty(runtime, "startDate", JSIConverter<std::optional<std::chrono::system_clock::time_point>>::toJSI(runtime, arg.startDate));
+      obj.setProperty(runtime, "endDate", JSIConverter<std::optional<std::chrono::system_clock::time_point>>::toJSI(runtime, arg.endDate));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -91,6 +98,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<Quantity>>::canConvert(runtime, obj.getProperty(runtime, "mostRecentQuantity"))) return false;
       if (!JSIConverter<std::optional<QuantityDateInterval>>::canConvert(runtime, obj.getProperty(runtime, "mostRecentQuantityDateInterval"))) return false;
       if (!JSIConverter<std::optional<Quantity>>::canConvert(runtime, obj.getProperty(runtime, "duration"))) return false;
+      if (!JSIConverter<std::optional<std::chrono::system_clock::time_point>>::canConvert(runtime, obj.getProperty(runtime, "startDate"))) return false;
+      if (!JSIConverter<std::optional<std::chrono::system_clock::time_point>>::canConvert(runtime, obj.getProperty(runtime, "endDate"))) return false;
       return true;
     }
   };

package/package.json

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

package/src/healthkit.ts

@@ -21,7 +21,10 @@ import {
   WheelchairUse,
 } from './types/Characteristics'
 import type { QuantitySample } from './types/QuantitySample'
-import type { QueryOptionsWithAnchor } from './types/QueryOptions'
+import type {
+  QueryOptionsWithAnchor,
+  QueryOptionsWithSortOrder,
+} from './types/QueryOptions'
 
 export * from './types'
 
@@ -174,6 +177,7 @@ export const isQuantityCompatibleWithUnit = UnavailableFnFromModule(
 // CategoryTypeModule functions
 export function queryCategorySamples<T extends CategoryTypeIdentifier>(
   _categoryTypeIdentifier: T,
+  _options?: QueryOptionsWithSortOrder,
 ): Promise<CategorySampleTyped<T>[]> {
   if (Platform.OS !== 'ios' && !hasWarned) {
     console.warn(notAvailableError)

package/src/hooks/queryStatisticsForQuantity.test.ts

@@ -0,0 +1,32 @@
+/**
+ * Test case to verify that queryStatisticsForQuantity resolves when no data is present
+ */
+
+import { describe, expect, test } from 'bun:test'
+import type { QueryStatisticsResponse } from '../types/QuantityType'
+
+describe('queryStatisticsForQuantity', () => {
+  test('should resolve with empty response when no data is present', async () => {
+    // This test would normally require running on iOS simulator or device
+    // For now, we're just testing the TypeScript interface
+
+    const mockEmptyResponse: QueryStatisticsResponse = {}
+
+    // Verify that empty response is properly typed
+    expect(mockEmptyResponse.averageQuantity).toBeUndefined()
+    expect(mockEmptyResponse.sumQuantity).toBeUndefined()
+    expect(mockEmptyResponse.startDate).toBeUndefined()
+    expect(mockEmptyResponse.endDate).toBeUndefined()
+  })
+
+  test('should handle date range with no data', async () => {
+    // This is more of a documentation of the expected behavior
+    // The query should resolve with an empty response object
+    // when there's no data in the specified timeframe
+    const expectedResult: QueryStatisticsResponse = {
+      // All properties should be undefined for empty result
+    }
+
+    expect(expectedResult).toBeDefined()
+  })
+})

package/src/types/CorrelationType.ts

@@ -13,6 +13,7 @@ export type CorrelationTypeIdentifier =
 type CorrelationObject = CategorySample | QuantitySample
 
 export interface CorrelationSample {
+  readonly uuid: string
   readonly correlationType: CorrelationTypeIdentifier
   readonly objects: readonly CorrelationObject[]
   readonly metadata: AnyMap

package/src/types/QuantityType.ts

@@ -28,6 +28,8 @@ export interface QueryStatisticsResponse {
   readonly mostRecentQuantity?: Quantity
   readonly mostRecentQuantityDateInterval?: QuantityDateInterval
   readonly duration?: Quantity
+  readonly startDate?: Date
+  readonly endDate?: Date
 }
 
 export interface QuantitySamplesWithAnchorResponse {

package/src/types/QueryOptions.ts

@@ -15,8 +15,18 @@ type PredicateWithStartAndEnd = {
   readonly strictStartDate?: boolean
 }
 
+type PredicateWithMetadataOperator =
+  | 'equalTo'
+  | 'notEqualTo'
+  | 'greaterThan'
+  | 'lessThan'
+
+type PredicateWithMetadataValue = string | number | Date | boolean
+
 type PredicateWithMetadataKey = {
   readonly withMetadataKey: string
+  readonly operatorType?: PredicateWithMetadataOperator
+  readonly value?: PredicateWithMetadataValue
 }
 
 export type FilterForSamplesAnd = {