@kingstinct/react-native-healthkit 9.0.11 → 10.1.0

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++/HybridWorkoutsModuleSpec.hpp

@@ -13,6 +13,8 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `WorkoutActivityType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WorkoutActivityType; }
 // Forward declaration of `QuantitySampleForSaving` to properly resolve imports.
@@ -25,15 +27,14 @@ namespace NitroModules { class AnyMap; }
 namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
 // Forward declaration of `WorkoutQueryOptionsWithAnchor` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct WorkoutQueryOptionsWithAnchor; }
-// Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
-namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `WorkoutQueryOptions` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct WorkoutQueryOptions; }
 // Forward declaration of `WorkoutConfiguration` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct WorkoutConfiguration; }
 
 #include <NitroModules/Promise.hpp>
-#include <string>
+#include <memory>
+#include "HybridWorkoutProxySpec.hpp"
 #include "WorkoutActivityType.hpp"
 #include <vector>
 #include "QuantitySampleForSaving.hpp"
@@ -42,8 +43,6 @@ namespace margelo::nitro::healthkit { struct WorkoutConfiguration; }
 #include <NitroModules/AnyMap.hpp>
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
 #include "WorkoutQueryOptionsWithAnchor.hpp"
-#include <memory>
-#include "HybridWorkoutProxySpec.hpp"
 #include "WorkoutQueryOptions.hpp"
 #include "WorkoutConfiguration.hpp"
 
@@ -78,7 +77,7 @@ namespace margelo::nitro::healthkit {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<std::string>> saveWorkoutSample(WorkoutActivityType workoutActivityType, const std::vector<QuantitySampleForSaving>& quantities, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const WorkoutTotals& totals, const std::shared_ptr<AnyMap>& metadata) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>> saveWorkoutSample(WorkoutActivityType workoutActivityType, const std::vector<QuantitySampleForSaving>& quantities, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const WorkoutTotals& totals, const std::shared_ptr<AnyMap>& metadata) = 0;
       virtual std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>> queryWorkoutSamplesWithAnchor(const WorkoutQueryOptionsWithAnchor& options) = 0;
       virtual std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>> queryWorkoutSamples(const WorkoutQueryOptions& options) = 0;
       virtual std::shared_ptr<Promise<bool>> startWatchAppWithWorkoutConfiguration(const WorkoutConfiguration& workoutConfiguration) = 0;

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": "9.0.11",
+  "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)
@@ -242,7 +246,8 @@ export const queryWorkoutSamplesWithAnchor = UnavailableFnFromModule(
 )
 export const saveWorkoutSample = UnavailableFnFromModule(
   'saveWorkoutSample',
-  Promise.resolve(''),
+  // biome-ignore lint/suspicious/noExplicitAny: it works
+  Promise.resolve(undefined as any as WorkoutProxy),
 )
 export const startWatchApp = UnavailableFnFromModule(
   'startWatchApp',

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/specs/WorkoutsModule.nitro.ts

@@ -18,7 +18,7 @@ export interface WorkoutsModule extends HybridObject<{ ios: 'swift' }> {
     endDate: Date,
     totals: WorkoutTotals,
     metadata: AnyMap,
-  ): Promise<string>
+  ): Promise<WorkoutProxy>
 
   queryWorkoutSamplesWithAnchor(
     options: WorkoutQueryOptionsWithAnchor,

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 = {

package/nitrogen/generated/ios/swift/Func_void_std__string.swift

@@ -1,46 +0,0 @@
-///
-/// Func_void_std__string.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-import NitroModules
-
-/**
- * Wraps a Swift `(_ value: String) -> Void` as a class.
- * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
- */
-public final class Func_void_std__string {
-  public typealias bridge = margelo.nitro.healthkit.bridge.swift
-
-  private let closure: (_ value: String) -> Void
-
-  public init(_ closure: @escaping (_ value: String) -> Void) {
-    self.closure = closure
-  }
-
-  @inline(__always)
-  public func call(value: std.string) -> Void {
-    self.closure(String(value))
-  }
-
-  /**
-   * Casts this instance to a retained unsafe raw pointer.
-   * This acquires one additional strong reference on the object!
-   */
-  @inline(__always)
-  public func toUnsafe() -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(self).toOpaque()
-  }
-
-  /**
-   * Casts an unsafe pointer to a `Func_void_std__string`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__string>`.
-   * This removes one strong reference from the object!
-   */
-  @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string {
-    return Unmanaged<Func_void_std__string>.fromOpaque(pointer).takeRetainedValue()
-  }
-}