@kingstinct/react-native-healthkit 10.0.0 → 11.0.0

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

@@ -50,14 +50,12 @@ namespace margelo::nitro::healthkit {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::healthkit;
-
   // C++ WorkoutRouteLocation <> JS WorkoutRouteLocation (object)
   template <>
-  struct JSIConverter<WorkoutRouteLocation> final {
-    static inline WorkoutRouteLocation fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::healthkit::WorkoutRouteLocation> final {
+    static inline margelo::nitro::healthkit::WorkoutRouteLocation fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return WorkoutRouteLocation(
+      return margelo::nitro::healthkit::WorkoutRouteLocation(
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "altitude")),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "course")),
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, "date")),
@@ -70,7 +68,7 @@ namespace margelo::nitro {
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "verticalAccuracy"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const WorkoutRouteLocation& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::healthkit::WorkoutRouteLocation& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "altitude", JSIConverter<double>::toJSI(runtime, arg.altitude));
       obj.setProperty(runtime, "course", JSIConverter<double>::toJSI(runtime, arg.course));

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

@@ -34,15 +34,15 @@ namespace margelo::nitro::healthkit { struct WorkoutEvent; }
 namespace margelo::nitro::healthkit { struct WorkoutActivity; }
 
 #include <string>
-#include <optional>
 #include "Device.hpp"
+#include <optional>
 #include "WorkoutActivityType.hpp"
 #include "Quantity.hpp"
 #include <chrono>
 #include <NitroModules/AnyMap.hpp>
 #include "SourceRevision.hpp"
-#include <vector>
 #include "WorkoutEvent.hpp"
+#include <vector>
 #include "WorkoutActivity.hpp"
 
 namespace margelo::nitro::healthkit {
@@ -56,10 +56,6 @@ namespace margelo::nitro::healthkit {
     std::optional<Device> device     SWIFT_PRIVATE;
     WorkoutActivityType workoutActivityType     SWIFT_PRIVATE;
     Quantity duration     SWIFT_PRIVATE;
-    std::optional<Quantity> totalDistance     SWIFT_PRIVATE;
-    std::optional<Quantity> totalEnergyBurned     SWIFT_PRIVATE;
-    std::optional<Quantity> totalSwimmingStrokeCount     SWIFT_PRIVATE;
-    std::optional<Quantity> totalFlightsClimbed     SWIFT_PRIVATE;
     std::chrono::system_clock::time_point startDate     SWIFT_PRIVATE;
     std::chrono::system_clock::time_point endDate     SWIFT_PRIVATE;
     std::optional<std::shared_ptr<AnyMap>> metadata     SWIFT_PRIVATE;
@@ -69,53 +65,43 @@ namespace margelo::nitro::healthkit {
 
   public:
     WorkoutSample() = default;
-    explicit WorkoutSample(std::string uuid, std::optional<Device> device, WorkoutActivityType workoutActivityType, Quantity duration, std::optional<Quantity> totalDistance, std::optional<Quantity> totalEnergyBurned, std::optional<Quantity> totalSwimmingStrokeCount, std::optional<Quantity> totalFlightsClimbed, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, std::optional<std::shared_ptr<AnyMap>> metadata, std::optional<SourceRevision> sourceRevision, std::optional<std::vector<WorkoutEvent>> events, std::optional<std::vector<WorkoutActivity>> activities): uuid(uuid), device(device), workoutActivityType(workoutActivityType), duration(duration), totalDistance(totalDistance), totalEnergyBurned(totalEnergyBurned), totalSwimmingStrokeCount(totalSwimmingStrokeCount), totalFlightsClimbed(totalFlightsClimbed), startDate(startDate), endDate(endDate), metadata(metadata), sourceRevision(sourceRevision), events(events), activities(activities) {}
+    explicit WorkoutSample(std::string uuid, std::optional<Device> device, WorkoutActivityType workoutActivityType, Quantity duration, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, std::optional<std::shared_ptr<AnyMap>> metadata, std::optional<SourceRevision> sourceRevision, std::optional<std::vector<WorkoutEvent>> events, std::optional<std::vector<WorkoutActivity>> activities): uuid(uuid), device(device), workoutActivityType(workoutActivityType), duration(duration), startDate(startDate), endDate(endDate), metadata(metadata), sourceRevision(sourceRevision), events(events), activities(activities) {}
   };
 
 } // namespace margelo::nitro::healthkit
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::healthkit;
-
   // C++ WorkoutSample <> JS WorkoutSample (object)
   template <>
-  struct JSIConverter<WorkoutSample> final {
-    static inline WorkoutSample fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::healthkit::WorkoutSample> final {
+    static inline margelo::nitro::healthkit::WorkoutSample fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return WorkoutSample(
+      return margelo::nitro::healthkit::WorkoutSample(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "uuid")),
-        JSIConverter<std::optional<Device>>::fromJSI(runtime, obj.getProperty(runtime, "device")),
-        JSIConverter<WorkoutActivityType>::fromJSI(runtime, obj.getProperty(runtime, "workoutActivityType")),
-        JSIConverter<Quantity>::fromJSI(runtime, obj.getProperty(runtime, "duration")),
-        JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "totalDistance")),
-        JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "totalEnergyBurned")),
-        JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "totalSwimmingStrokeCount")),
-        JSIConverter<std::optional<Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "totalFlightsClimbed")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::fromJSI(runtime, obj.getProperty(runtime, "device")),
+        JSIConverter<margelo::nitro::healthkit::WorkoutActivityType>::fromJSI(runtime, obj.getProperty(runtime, "workoutActivityType")),
+        JSIConverter<margelo::nitro::healthkit::Quantity>::fromJSI(runtime, obj.getProperty(runtime, "duration")),
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, "startDate")),
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, "endDate")),
         JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::fromJSI(runtime, obj.getProperty(runtime, "metadata")),
-        JSIConverter<std::optional<SourceRevision>>::fromJSI(runtime, obj.getProperty(runtime, "sourceRevision")),
-        JSIConverter<std::optional<std::vector<WorkoutEvent>>>::fromJSI(runtime, obj.getProperty(runtime, "events")),
-        JSIConverter<std::optional<std::vector<WorkoutActivity>>>::fromJSI(runtime, obj.getProperty(runtime, "activities"))
+        JSIConverter<std::optional<margelo::nitro::healthkit::SourceRevision>>::fromJSI(runtime, obj.getProperty(runtime, "sourceRevision")),
+        JSIConverter<std::optional<std::vector<margelo::nitro::healthkit::WorkoutEvent>>>::fromJSI(runtime, obj.getProperty(runtime, "events")),
+        JSIConverter<std::optional<std::vector<margelo::nitro::healthkit::WorkoutActivity>>>::fromJSI(runtime, obj.getProperty(runtime, "activities"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const WorkoutSample& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::healthkit::WorkoutSample& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "uuid", JSIConverter<std::string>::toJSI(runtime, arg.uuid));
-      obj.setProperty(runtime, "device", JSIConverter<std::optional<Device>>::toJSI(runtime, arg.device));
-      obj.setProperty(runtime, "workoutActivityType", JSIConverter<WorkoutActivityType>::toJSI(runtime, arg.workoutActivityType));
-      obj.setProperty(runtime, "duration", JSIConverter<Quantity>::toJSI(runtime, arg.duration));
-      obj.setProperty(runtime, "totalDistance", JSIConverter<std::optional<Quantity>>::toJSI(runtime, arg.totalDistance));
-      obj.setProperty(runtime, "totalEnergyBurned", JSIConverter<std::optional<Quantity>>::toJSI(runtime, arg.totalEnergyBurned));
-      obj.setProperty(runtime, "totalSwimmingStrokeCount", JSIConverter<std::optional<Quantity>>::toJSI(runtime, arg.totalSwimmingStrokeCount));
-      obj.setProperty(runtime, "totalFlightsClimbed", JSIConverter<std::optional<Quantity>>::toJSI(runtime, arg.totalFlightsClimbed));
+      obj.setProperty(runtime, "device", JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::toJSI(runtime, arg.device));
+      obj.setProperty(runtime, "workoutActivityType", JSIConverter<margelo::nitro::healthkit::WorkoutActivityType>::toJSI(runtime, arg.workoutActivityType));
+      obj.setProperty(runtime, "duration", JSIConverter<margelo::nitro::healthkit::Quantity>::toJSI(runtime, arg.duration));
       obj.setProperty(runtime, "startDate", JSIConverter<std::chrono::system_clock::time_point>::toJSI(runtime, arg.startDate));
       obj.setProperty(runtime, "endDate", JSIConverter<std::chrono::system_clock::time_point>::toJSI(runtime, arg.endDate));
       obj.setProperty(runtime, "metadata", JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::toJSI(runtime, arg.metadata));
-      obj.setProperty(runtime, "sourceRevision", JSIConverter<std::optional<SourceRevision>>::toJSI(runtime, arg.sourceRevision));
-      obj.setProperty(runtime, "events", JSIConverter<std::optional<std::vector<WorkoutEvent>>>::toJSI(runtime, arg.events));
-      obj.setProperty(runtime, "activities", JSIConverter<std::optional<std::vector<WorkoutActivity>>>::toJSI(runtime, arg.activities));
+      obj.setProperty(runtime, "sourceRevision", JSIConverter<std::optional<margelo::nitro::healthkit::SourceRevision>>::toJSI(runtime, arg.sourceRevision));
+      obj.setProperty(runtime, "events", JSIConverter<std::optional<std::vector<margelo::nitro::healthkit::WorkoutEvent>>>::toJSI(runtime, arg.events));
+      obj.setProperty(runtime, "activities", JSIConverter<std::optional<std::vector<margelo::nitro::healthkit::WorkoutActivity>>>::toJSI(runtime, arg.activities));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -124,19 +110,15 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "uuid"))) return false;
-      if (!JSIConverter<std::optional<Device>>::canConvert(runtime, obj.getProperty(runtime, "device"))) return false;
-      if (!JSIConverter<WorkoutActivityType>::canConvert(runtime, obj.getProperty(runtime, "workoutActivityType"))) return false;
-      if (!JSIConverter<Quantity>::canConvert(runtime, obj.getProperty(runtime, "duration"))) return false;
-      if (!JSIConverter<std::optional<Quantity>>::canConvert(runtime, obj.getProperty(runtime, "totalDistance"))) return false;
-      if (!JSIConverter<std::optional<Quantity>>::canConvert(runtime, obj.getProperty(runtime, "totalEnergyBurned"))) return false;
-      if (!JSIConverter<std::optional<Quantity>>::canConvert(runtime, obj.getProperty(runtime, "totalSwimmingStrokeCount"))) return false;
-      if (!JSIConverter<std::optional<Quantity>>::canConvert(runtime, obj.getProperty(runtime, "totalFlightsClimbed"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::canConvert(runtime, obj.getProperty(runtime, "device"))) return false;
+      if (!JSIConverter<margelo::nitro::healthkit::WorkoutActivityType>::canConvert(runtime, obj.getProperty(runtime, "workoutActivityType"))) return false;
+      if (!JSIConverter<margelo::nitro::healthkit::Quantity>::canConvert(runtime, obj.getProperty(runtime, "duration"))) return false;
       if (!JSIConverter<std::chrono::system_clock::time_point>::canConvert(runtime, obj.getProperty(runtime, "startDate"))) return false;
       if (!JSIConverter<std::chrono::system_clock::time_point>::canConvert(runtime, obj.getProperty(runtime, "endDate"))) return false;
       if (!JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::canConvert(runtime, obj.getProperty(runtime, "metadata"))) return false;
-      if (!JSIConverter<std::optional<SourceRevision>>::canConvert(runtime, obj.getProperty(runtime, "sourceRevision"))) return false;
-      if (!JSIConverter<std::optional<std::vector<WorkoutEvent>>>::canConvert(runtime, obj.getProperty(runtime, "events"))) return false;
-      if (!JSIConverter<std::optional<std::vector<WorkoutActivity>>>::canConvert(runtime, obj.getProperty(runtime, "activities"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::SourceRevision>>::canConvert(runtime, obj.getProperty(runtime, "sourceRevision"))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::healthkit::WorkoutEvent>>>::canConvert(runtime, obj.getProperty(runtime, "events"))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::healthkit::WorkoutActivity>>>::canConvert(runtime, obj.getProperty(runtime, "activities"))) return false;
       return true;
     }
   };

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -34,16 +33,14 @@ namespace margelo::nitro::healthkit {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::healthkit;
-
   // C++ WorkoutSessionLocationType <> JS WorkoutSessionLocationType (enum)
   template <>
-  struct JSIConverter<WorkoutSessionLocationType> final {
-    static inline WorkoutSessionLocationType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::healthkit::WorkoutSessionLocationType> final {
+    static inline margelo::nitro::healthkit::WorkoutSessionLocationType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
-      return static_cast<WorkoutSessionLocationType>(enumValue);
+      return static_cast<margelo::nitro::healthkit::WorkoutSessionLocationType>(enumValue);
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, WorkoutSessionLocationType arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::healthkit::WorkoutSessionLocationType arg) {
       int enumValue = static_cast<int>(arg);
       return JSIConverter<int>::toJSI(runtime, enumValue);
     }
@@ -51,14 +48,15 @@ namespace margelo::nitro {
       if (!value.isNumber()) {
         return false;
       }
-      double integer;
-      double fraction = modf(value.getNumber(), &integer);
-      if (fraction != 0.0) {
-        // It is some kind of floating point number - our enums are ints.
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
         return false;
       }
       // Check if we are within the bounds of the enum.
-      return integer >= 0 && integer <= 2;
+      return integer >= 1 && integer <= 3;
     }
   };
 

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

@@ -41,19 +41,17 @@ namespace margelo::nitro::healthkit {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::healthkit;
-
   // C++ WorkoutTotals <> JS WorkoutTotals (object)
   template <>
-  struct JSIConverter<WorkoutTotals> final {
-    static inline WorkoutTotals fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::healthkit::WorkoutTotals> final {
+    static inline margelo::nitro::healthkit::WorkoutTotals fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return WorkoutTotals(
+      return margelo::nitro::healthkit::WorkoutTotals(
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "distance")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "energyBurned"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const WorkoutTotals& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::healthkit::WorkoutTotals& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "distance", JSIConverter<std::optional<double>>::toJSI(runtime, arg.distance));
       obj.setProperty(runtime, "energyBurned", JSIConverter<std::optional<double>>::toJSI(runtime, arg.energyBurned));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingstinct/react-native-healthkit",
-  "version": "10.0.0",
+  "version": "11.0.0",
   "description": "React Native bindings for HealthKit",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -58,7 +58,7 @@
     "build": "bun run clean && bun run build:cjs && bun run build:esm && bun run build:types",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "lint": "bunx @biomejs/biome format --write",
-    "codegen": "bun run build && nitro-codegen --logLevel=\"debug\"",
+    "codegen": "bun run build && nitrogen --logLevel=\"debug\"",
     "test": "bun test",
     "prepublishOnly": "bun run build && bun run codegen"
   },
@@ -88,17 +88,17 @@
     "access": "public"
   },
   "devDependencies": {
-    "@testing-library/react-native": "^13.2.0",
+    "@testing-library/react-native": "^13.3.3",
     "@types/react": "~19.0.14",
-    "nitro-codegen": "^0.26.4",
-    "react": "19.0.0",
-    "react-native": "*",
-    "react-native-nitro-modules": "^0.26.4",
-    "typescript": "~5.8.3"
+    "nitrogen": "^0.29.4",
+    "react": "19.1.0",
+    "react-native": "0.81.4",
+    "react-native-nitro-modules": "^0.29.6",
+    "typescript": "~5.9.2"
   },
   "peerDependencies": {
-    "react": "*",
-    "react-native": "*",
-    "react-native-nitro-modules": "*"
+    "react": "19.1.0",
+    "react-native": "0.81.4",
+    "react-native-nitro-modules": "0.29.6"
   }
 }

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/hooks/useMostRecentWorkout.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 import type { WorkoutProxy } from '../specs/WorkoutProxy.nitro'
 import getMostRecentWorkout from '../utils/getMostRecentWorkout'
 import useSubscribeToChanges from './useSubscribeToChanges'
@@ -6,25 +6,11 @@ import useSubscribeToChanges from './useSubscribeToChanges'
 /**
  * @returns the most recent workout sample.
  */
-export function useMostRecentWorkout(options?: {
-  readonly energyUnit?: string
-  readonly distanceUnit?: string
-}) {
+export function useMostRecentWorkout() {
   const [workout, setWorkout] = useState<WorkoutProxy>()
 
-  const optionsRef = useRef(options)
-
-  useEffect(() => {
-    optionsRef.current = options
-  }, [options])
-
   const update = useCallback(async () => {
-    setWorkout(
-      await getMostRecentWorkout({
-        energyUnit: optionsRef.current?.energyUnit,
-        distanceUnit: optionsRef.current?.distanceUnit,
-      }),
-    )
+    setWorkout(await getMostRecentWorkout())
   }, [])
 
   useEffect(() => {

package/src/hooks/useWorkoutById.ts

@@ -27,10 +27,7 @@ export function useWorkoutById(
     setIsLoading(true)
     setError(null)
     try {
-      const fetchedWorkout = await getWorkoutById(uuid, {
-        energyUnit: optionsRef.current?.energyUnit,
-        distanceUnit: optionsRef.current?.distanceUnit,
-      })
+      const fetchedWorkout = await getWorkoutById(uuid)
       setWorkout(fetchedWorkout)
     } catch (err) {
       setError(

package/src/specs/WorkoutProxy.nitro.ts

@@ -1,4 +1,9 @@
 import type { HybridObject } from 'react-native-nitro-modules'
+import type {
+  Quantity,
+  QuantityTypeIdentifier,
+  QueryStatisticsResponse,
+} from '../types'
 import type {
   LocationForSaving,
   WorkoutPlan,
@@ -13,6 +18,18 @@ export interface WorkoutProxy
   saveWorkoutRoute(locations: readonly LocationForSaving[]): Promise<boolean>
   getWorkoutPlan(): Promise<WorkoutPlan | null>
   getWorkoutRoutes(): Promise<readonly WorkoutRoute[]>
+  getStatistic(
+    quantityType: QuantityTypeIdentifier,
+    unitOverride?: string,
+  ): Promise<QueryStatisticsResponse | null>
+  getAllStatistics(): Promise<Record<string, QueryStatisticsResponse>>
 
-  // nice to have here: getAllStatistics and getStatisticsForQuantityType
+  /** @deprecated Use allStatistics or statistic() method instead */
+  readonly totalDistance?: Quantity
+  /** @deprecated Use allStatistics or statistic() method instead */
+  readonly totalEnergyBurned?: Quantity
+  /** @deprecated Use allStatistics or statistic() method instead */
+  readonly totalSwimmingStrokeCount?: Quantity
+  /** @deprecated Use allStatistics or statistic() method instead */
+  readonly totalFlightsClimbed?: Quantity
 }

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/src/types/Workouts.ts

@@ -215,16 +215,12 @@ export type FilterForWorkouts =
   | PredicateForWorkoutsAnd
 
 export interface WorkoutQueryOptionsWithAnchor {
-  energyUnit?: string
-  distanceUnit?: string
   filter?: FilterForWorkouts
   limit?: number
   anchor?: string
 }
 
 export interface WorkoutQueryOptions {
-  energyUnit?: string
-  distanceUnit?: string
   filter?: FilterForWorkouts
   limit?: number
   ascending?: boolean
@@ -269,10 +265,6 @@ export interface WorkoutSample {
   readonly device?: Device
   readonly workoutActivityType: WorkoutActivityType
   readonly duration: Quantity
-  readonly totalDistance?: Quantity
-  readonly totalEnergyBurned?: Quantity
-  readonly totalSwimmingStrokeCount?: Quantity
-  readonly totalFlightsClimbed?: Quantity
   readonly startDate: Date
   readonly endDate: Date
   readonly metadata?: AnyMap

package/src/utils/getMostRecentWorkout.ts

@@ -1,14 +1,9 @@
 import { Workouts } from '../modules'
-import type { WorkoutQueryOptions } from '../types/Workouts'
 
-const getMostRecentWorkout = async (
-  options: Pick<WorkoutQueryOptions, 'distanceUnit' | 'energyUnit'>,
-) => {
+const getMostRecentWorkout = async () => {
   const workouts = await Workouts.queryWorkoutSamples({
     limit: 1,
     ascending: false,
-    energyUnit: options?.energyUnit,
-    distanceUnit: options?.distanceUnit,
   })
 
   return workouts[0]

package/src/utils/getWorkoutById.ts

@@ -1,17 +1,12 @@
 import { Workouts } from '../modules'
 import type { WorkoutQueryOptions } from '../types/Workouts'
 
-const getWorkoutById = async (
-  uuid: string,
-  options: Pick<WorkoutQueryOptions, 'distanceUnit' | 'energyUnit'>,
-) => {
+const getWorkoutById = async (uuid: string) => {
   const workouts = await Workouts.queryWorkoutSamples({
     limit: 1,
     filter: {
       uuid: uuid,
     },
-    energyUnit: options?.energyUnit,
-    distanceUnit: options?.distanceUnit,
   })
 
   return workouts[0]