@kingstinct/react-native-healthkit 13.3.1 → 14.0.0

package/src/healthkit.ios.ts

@@ -21,7 +21,31 @@ import {
   StateOfMind,
   Workouts,
 } from './modules'
+import type {
+  CorrelationSampleTyped,
+  QueryCorrelationSamplesWithAnchorResponseTyped,
+} from './types/CorrelationType'
+import type {
+  ElectrocardiogramSamplesWithAnchorResponseTyped,
+  ElectrocardiogramSampleTyped,
+} from './types/ElectrocardiogramSample'
+import type {
+  HeartbeatSeriesSamplesWithAnchorResponseTyped,
+  HeartbeatSeriesSampleTyped,
+} from './types/HeartbeatSeries'
+import type {
+  MedicationDoseEventsWithAnchorResponseTyped,
+  MedicationDoseEventTyped,
+} from './types/Medication'
 import type { QuantityTypeIdentifier } from './types/QuantityTypeIdentifier'
+import type {
+  StateOfMindSamplesWithAnchorResponseTyped,
+  StateOfMindSampleTyped,
+} from './types/StateOfMind'
+import type {
+  QueryWorkoutSamplesWithAnchorResponseTyped,
+  WorkoutProxyTyped,
+} from './types/Workouts'
 import getMostRecentCategorySample from './utils/getMostRecentCategorySample'
 import getMostRecentQuantitySample from './utils/getMostRecentQuantitySample'
 import getMostRecentWorkout from './utils/getMostRecentWorkout'
@@ -90,6 +114,188 @@ export type AvailableQuantityTypes<
   ? AvailableQuantityTypesIOS17Plus
   : AvailableQuantityTypesBeforeIOS17
 
+type BoundMethod<
+  TMethod,
+  TReturn = TMethod extends (...args: infer _Args) => infer TResult
+    ? TResult
+    : never,
+> = (
+  ...args: TMethod extends (...args: infer TArgs) => unknown ? TArgs : never
+) => TReturn
+
+function bindRetypedMethod<TModule, TMethod, TReturn>(
+  module: TModule,
+  method: TMethod,
+): BoundMethod<TMethod, TReturn> {
+  return (
+    method as TMethod extends (...args: infer TArgs) => infer TResult
+      ? (...args: TArgs) => TResult
+      : never
+  ).bind(module) as BoundMethod<TMethod, TReturn>
+}
+
+const CorrelationTypeBindings = {
+  queryCorrelationSamples: bindRetypedMethod<
+    typeof CorrelationTypes,
+    typeof CorrelationTypes.queryCorrelationSamples,
+    Promise<readonly CorrelationSampleTyped[]>
+  >(CorrelationTypes, CorrelationTypes.queryCorrelationSamples),
+  queryCorrelationSamplesWithAnchor: bindRetypedMethod<
+    typeof CorrelationTypes,
+    typeof CorrelationTypes.queryCorrelationSamplesWithAnchor,
+    Promise<QueryCorrelationSamplesWithAnchorResponseTyped>
+  >(CorrelationTypes, CorrelationTypes.queryCorrelationSamplesWithAnchor),
+  saveCorrelationSample: bindRetypedMethod<
+    typeof CorrelationTypes,
+    typeof CorrelationTypes.saveCorrelationSample,
+    Promise<CorrelationSampleTyped | undefined>
+  >(CorrelationTypes, CorrelationTypes.saveCorrelationSample),
+} satisfies {
+  queryCorrelationSamples: BoundMethod<
+    typeof CorrelationTypes.queryCorrelationSamples,
+    Promise<readonly CorrelationSampleTyped[]>
+  >
+  queryCorrelationSamplesWithAnchor: BoundMethod<
+    typeof CorrelationTypes.queryCorrelationSamplesWithAnchor,
+    Promise<QueryCorrelationSamplesWithAnchorResponseTyped>
+  >
+  saveCorrelationSample: BoundMethod<
+    typeof CorrelationTypes.saveCorrelationSample,
+    Promise<CorrelationSampleTyped | undefined>
+  >
+}
+
+const HeartbeatSeriesBindings = {
+  queryHeartbeatSeriesSamples: bindRetypedMethod<
+    typeof HeartbeatSeries,
+    typeof HeartbeatSeries.queryHeartbeatSeriesSamples,
+    Promise<readonly HeartbeatSeriesSampleTyped[]>
+  >(HeartbeatSeries, HeartbeatSeries.queryHeartbeatSeriesSamples),
+  queryHeartbeatSeriesSamplesWithAnchor: bindRetypedMethod<
+    typeof HeartbeatSeries,
+    typeof HeartbeatSeries.queryHeartbeatSeriesSamplesWithAnchor,
+    Promise<HeartbeatSeriesSamplesWithAnchorResponseTyped>
+  >(HeartbeatSeries, HeartbeatSeries.queryHeartbeatSeriesSamplesWithAnchor),
+} satisfies {
+  queryHeartbeatSeriesSamples: BoundMethod<
+    typeof HeartbeatSeries.queryHeartbeatSeriesSamples,
+    Promise<readonly HeartbeatSeriesSampleTyped[]>
+  >
+  queryHeartbeatSeriesSamplesWithAnchor: BoundMethod<
+    typeof HeartbeatSeries.queryHeartbeatSeriesSamplesWithAnchor,
+    Promise<HeartbeatSeriesSamplesWithAnchorResponseTyped>
+  >
+}
+
+const ElectrocardiogramBindings = {
+  queryElectrocardiogramSamples: bindRetypedMethod<
+    typeof Electrocardiograms,
+    typeof Electrocardiograms.queryElectrocardiogramSamples,
+    Promise<readonly ElectrocardiogramSampleTyped[]>
+  >(Electrocardiograms, Electrocardiograms.queryElectrocardiogramSamples),
+  queryElectrocardiogramSamplesWithAnchor: bindRetypedMethod<
+    typeof Electrocardiograms,
+    typeof Electrocardiograms.queryElectrocardiogramSamplesWithAnchor,
+    Promise<ElectrocardiogramSamplesWithAnchorResponseTyped>
+  >(
+    Electrocardiograms,
+    Electrocardiograms.queryElectrocardiogramSamplesWithAnchor,
+  ),
+} satisfies {
+  queryElectrocardiogramSamples: BoundMethod<
+    typeof Electrocardiograms.queryElectrocardiogramSamples,
+    Promise<readonly ElectrocardiogramSampleTyped[]>
+  >
+  queryElectrocardiogramSamplesWithAnchor: BoundMethod<
+    typeof Electrocardiograms.queryElectrocardiogramSamplesWithAnchor,
+    Promise<ElectrocardiogramSamplesWithAnchorResponseTyped>
+  >
+}
+
+const WorkoutBindings = {
+  queryWorkoutSamples: bindRetypedMethod<
+    typeof Workouts,
+    typeof Workouts.queryWorkoutSamples,
+    Promise<readonly WorkoutProxyTyped[]>
+  >(Workouts, Workouts.queryWorkoutSamples),
+  queryWorkoutSamplesWithAnchor: bindRetypedMethod<
+    typeof Workouts,
+    typeof Workouts.queryWorkoutSamplesWithAnchor,
+    Promise<QueryWorkoutSamplesWithAnchorResponseTyped>
+  >(Workouts, Workouts.queryWorkoutSamplesWithAnchor),
+  saveWorkoutSample: bindRetypedMethod<
+    typeof Workouts,
+    typeof Workouts.saveWorkoutSample,
+    Promise<WorkoutProxyTyped>
+  >(Workouts, Workouts.saveWorkoutSample),
+} satisfies {
+  queryWorkoutSamples: BoundMethod<
+    typeof Workouts.queryWorkoutSamples,
+    Promise<readonly WorkoutProxyTyped[]>
+  >
+  queryWorkoutSamplesWithAnchor: BoundMethod<
+    typeof Workouts.queryWorkoutSamplesWithAnchor,
+    Promise<QueryWorkoutSamplesWithAnchorResponseTyped>
+  >
+  saveWorkoutSample: BoundMethod<
+    typeof Workouts.saveWorkoutSample,
+    Promise<WorkoutProxyTyped>
+  >
+}
+
+const StateOfMindBindings = {
+  queryStateOfMindSamples: bindRetypedMethod<
+    typeof StateOfMind,
+    typeof StateOfMind.queryStateOfMindSamples,
+    Promise<readonly StateOfMindSampleTyped[]>
+  >(StateOfMind, StateOfMind.queryStateOfMindSamples),
+  queryStateOfMindSamplesWithAnchor: bindRetypedMethod<
+    typeof StateOfMind,
+    typeof StateOfMind.queryStateOfMindSamplesWithAnchor,
+    Promise<StateOfMindSamplesWithAnchorResponseTyped>
+  >(StateOfMind, StateOfMind.queryStateOfMindSamplesWithAnchor),
+  saveStateOfMindSample: bindRetypedMethod<
+    typeof StateOfMind,
+    typeof StateOfMind.saveStateOfMindSample,
+    Promise<StateOfMindSampleTyped | undefined>
+  >(StateOfMind, StateOfMind.saveStateOfMindSample),
+} satisfies {
+  queryStateOfMindSamples: BoundMethod<
+    typeof StateOfMind.queryStateOfMindSamples,
+    Promise<readonly StateOfMindSampleTyped[]>
+  >
+  queryStateOfMindSamplesWithAnchor: BoundMethod<
+    typeof StateOfMind.queryStateOfMindSamplesWithAnchor,
+    Promise<StateOfMindSamplesWithAnchorResponseTyped>
+  >
+  saveStateOfMindSample: BoundMethod<
+    typeof StateOfMind.saveStateOfMindSample,
+    Promise<StateOfMindSampleTyped | undefined>
+  >
+}
+
+const MedicationBindings = {
+  queryMedicationEvents: bindRetypedMethod<
+    typeof Medication,
+    typeof Medication.queryMedicationEvents,
+    Promise<readonly MedicationDoseEventTyped[]>
+  >(Medication, Medication.queryMedicationEvents),
+  queryMedicationEventsWithAnchor: bindRetypedMethod<
+    typeof Medication,
+    typeof Medication.queryMedicationEventsWithAnchor,
+    Promise<MedicationDoseEventsWithAnchorResponseTyped>
+  >(Medication, Medication.queryMedicationEventsWithAnchor),
+} satisfies {
+  queryMedicationEvents: BoundMethod<
+    typeof Medication.queryMedicationEvents,
+    Promise<readonly MedicationDoseEventTyped[]>
+  >
+  queryMedicationEventsWithAnchor: BoundMethod<
+    typeof Medication.queryMedicationEventsWithAnchor,
+    Promise<MedicationDoseEventsWithAnchorResponseTyped>
+  >
+}
+
 // Named exports - all functions bound to their respective modules
 export const authorizationStatusFor = Core.authorizationStatusFor.bind(Core)
 export const requestPerObjectReadAuthorization =
@@ -99,6 +305,8 @@ export const disableAllBackgroundDelivery =
 export const disableBackgroundDelivery =
   Core.disableBackgroundDelivery.bind(Core)
 export const enableBackgroundDelivery = Core.enableBackgroundDelivery.bind(Core)
+export const configureBackgroundTypes = Core.configureBackgroundTypes.bind(Core)
+export const clearBackgroundTypes = Core.clearBackgroundTypes.bind(Core)
 export const getBiologicalSex =
   Characteristics.getBiologicalSex.bind(Characteristics)
 export const getBloodType = Characteristics.getBloodType.bind(Characteristics)
@@ -119,19 +327,17 @@ export const queryCategorySamples =
 export const queryCategorySamplesWithAnchor =
   CategoryTypes.queryCategorySamplesWithAnchor.bind(CategoryTypes)
 export const queryCorrelationSamples =
-  CorrelationTypes.queryCorrelationSamples.bind(CorrelationTypes)
+  CorrelationTypeBindings.queryCorrelationSamples
 export const queryCorrelationSamplesWithAnchor =
-  CorrelationTypes.queryCorrelationSamplesWithAnchor.bind(CorrelationTypes)
+  CorrelationTypeBindings.queryCorrelationSamplesWithAnchor
 export const queryHeartbeatSeriesSamples =
-  HeartbeatSeries.queryHeartbeatSeriesSamples.bind(HeartbeatSeries)
+  HeartbeatSeriesBindings.queryHeartbeatSeriesSamples
 export const queryHeartbeatSeriesSamplesWithAnchor =
-  HeartbeatSeries.queryHeartbeatSeriesSamplesWithAnchor.bind(HeartbeatSeries)
+  HeartbeatSeriesBindings.queryHeartbeatSeriesSamplesWithAnchor
 export const queryElectrocardiogramSamples =
-  Electrocardiograms.queryElectrocardiogramSamples.bind(Electrocardiograms)
+  ElectrocardiogramBindings.queryElectrocardiogramSamples
 export const queryElectrocardiogramSamplesWithAnchor =
-  Electrocardiograms.queryElectrocardiogramSamplesWithAnchor.bind(
-    Electrocardiograms,
-  )
+  ElectrocardiogramBindings.queryElectrocardiogramSamplesWithAnchor
 export const queryQuantitySamples =
   QuantityTypes.queryQuantitySamples.bind(QuantityTypes)
 export const queryQuantitySamplesWithAnchor =
@@ -146,28 +352,27 @@ export const queryStatisticsCollectionForQuantitySeparateBySource =
   QuantityTypes.queryStatisticsCollectionForQuantitySeparateBySource.bind(
     QuantityTypes,
   )
-export const queryWorkoutSamples = Workouts.queryWorkoutSamples.bind(Workouts)
+export const queryWorkoutSamples = WorkoutBindings.queryWorkoutSamples
 export const queryWorkoutSamplesWithAnchor =
-  Workouts.queryWorkoutSamplesWithAnchor.bind(Workouts)
+  WorkoutBindings.queryWorkoutSamplesWithAnchor
 export const querySources = Core.querySources.bind(Core)
 export const requestAuthorization = Core.requestAuthorization.bind(Core)
 export const deleteObjects = Core.deleteObjects.bind(Core)
 export const saveCategorySample =
   CategoryTypes.saveCategorySample.bind(CategoryTypes)
 export const saveCorrelationSample =
-  CorrelationTypes.saveCorrelationSample.bind(CorrelationTypes)
+  CorrelationTypeBindings.saveCorrelationSample
 export const saveQuantitySample =
   QuantityTypes.saveQuantitySample.bind(QuantityTypes)
-export const saveWorkoutSample = Workouts.saveWorkoutSample.bind(Workouts)
+export const saveWorkoutSample = WorkoutBindings.saveWorkoutSample
 export const startWatchApp =
   Workouts.startWatchAppWithWorkoutConfiguration.bind(Workouts)
 export const isProtectedDataAvailable = Core.isProtectedDataAvailable.bind(Core)
 export const queryStateOfMindSamples =
-  StateOfMind.queryStateOfMindSamples.bind(StateOfMind)
+  StateOfMindBindings.queryStateOfMindSamples
 export const queryStateOfMindSamplesWithAnchor =
-  StateOfMind.queryStateOfMindSamplesWithAnchor.bind(StateOfMind)
-export const saveStateOfMindSample =
-  StateOfMind.saveStateOfMindSample.bind(StateOfMind)
+  StateOfMindBindings.queryStateOfMindSamplesWithAnchor
+export const saveStateOfMindSample = StateOfMindBindings.saveStateOfMindSample
 export const isQuantityCompatibleWithUnit =
   QuantityTypes.isQuantityCompatibleWithUnit.bind(QuantityTypes)
 
@@ -181,10 +386,9 @@ export const requestMedicationsAuthorization =
   Medication.requestMedicationsAuthorization.bind(Medication)
 
 export const queryMedications = Medication.queryMedications.bind(Medication)
-export const queryMedicationEvents =
-  Medication.queryMedicationEvents.bind(Medication)
+export const queryMedicationEvents = MedicationBindings.queryMedicationEvents
 export const queryMedicationEventsWithAnchor =
-  Medication.queryMedicationEventsWithAnchor.bind(Medication)
+  MedicationBindings.queryMedicationEventsWithAnchor
 
 export const currentAppSource = Core.currentAppSource.bind(Core)
 
@@ -206,6 +410,8 @@ export default {
   areObjectTypesAvailable,
   areObjectTypesAvailableAsync,
   isQuantityCompatibleWithUnit,
+  configureBackgroundTypes,
+  clearBackgroundTypes,
   disableAllBackgroundDelivery,
   disableBackgroundDelivery,
   enableBackgroundDelivery,

package/src/healthkit.ts

@@ -13,18 +13,41 @@ import { AuthorizationRequestStatus, AuthorizationStatus } from './types/Auth'
 import type {
   CategorySamplesWithAnchorResponseTyped,
   CategorySampleTyped,
+  CategoryValueForIdentifier,
+  MetadataForCategoryIdentifier,
 } from './types/CategoryType'
-import type { CategoryTypeIdentifier } from './types/CategoryTypeIdentifier'
+import type {
+  CategoryTypeIdentifier,
+  CategoryTypeIdentifierWriteable,
+} from './types/CategoryTypeIdentifier'
 import {
   BiologicalSex,
   BloodType,
   FitzpatrickSkinType,
   WheelchairUse,
 } from './types/Characteristics'
-import type { QuantitySample } from './types/QuantitySample'
+import type {
+  MetadataForQuantityIdentifier,
+  QuantitySampleTyped,
+} from './types/QuantitySample'
+import type {
+  IntervalComponents,
+  QuantitySamplesWithAnchorResponseTyped,
+  QueryStatisticsResponse,
+  QueryStatisticsResponseFromSingleSource,
+  StatisticsOptions,
+  StatisticsQueryOptions,
+  UnitForIdentifier,
+} from './types/QuantityType'
+import type {
+  QuantityTypeIdentifier,
+  QuantityTypeIdentifierWriteable,
+} from './types/QuantityTypeIdentifier'
 import type {
   QueryOptionsWithAnchor,
+  QueryOptionsWithAnchorAndUnit,
   QueryOptionsWithSortOrder,
+  QueryOptionsWithSortOrderAndUnit,
 } from './types/QueryOptions'
 
 export * from './types'
@@ -68,6 +91,14 @@ export const enableBackgroundDelivery = UnavailableFnFromModule(
   'enableBackgroundDelivery',
   Promise.resolve(false),
 )
+export const configureBackgroundTypes = UnavailableFnFromModule(
+  'configureBackgroundTypes',
+  Promise.resolve(false),
+)
+export const clearBackgroundTypes = UnavailableFnFromModule(
+  'clearBackgroundTypes',
+  Promise.resolve(false),
+)
 export const getPreferredUnits = UnavailableFnFromModule(
   'getPreferredUnits',
   Promise.resolve([]),
@@ -146,47 +177,114 @@ export const getWheelchairUse = UnavailableFnFromModule(
 )
 
 // QuantityTypeModule functions
-export const queryQuantitySamples = UnavailableFnFromModule(
-  'queryQuantitySamples',
-  Promise.resolve([]),
-)
-export const queryQuantitySamplesWithAnchor = UnavailableFnFromModule(
-  'queryQuantitySamplesWithAnchor',
-  Promise.resolve({
+export function queryQuantitySamples<T extends QuantityTypeIdentifier>(
+  _identifier: T,
+  _options: QueryOptionsWithSortOrderAndUnit<UnitForIdentifier<T>>,
+): Promise<readonly QuantitySampleTyped<T>[]> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve([])
+}
+
+export function queryQuantitySamplesWithAnchor<
+  T extends QuantityTypeIdentifier,
+>(
+  _identifier: T,
+  _options: QueryOptionsWithAnchorAndUnit<UnitForIdentifier<T>>,
+): Promise<QuantitySamplesWithAnchorResponseTyped<T>> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve({
     samples: [],
     deletedSamples: [],
     newAnchor: '',
-  }),
-)
-export const queryStatisticsForQuantity = UnavailableFnFromModule(
-  'queryStatisticsForQuantity',
-  Promise.resolve({
+  })
+}
+export function queryStatisticsForQuantity<T extends QuantityTypeIdentifier>(
+  _identifier: T,
+  _statistics: readonly StatisticsOptions[],
+  _options?: StatisticsQueryOptions<UnitForIdentifier<T>>,
+): Promise<QueryStatisticsResponse> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve({
     sources: [],
-  }),
-)
-export const queryStatisticsCollectionForQuantity = UnavailableFnFromModule(
-  'queryStatisticsCollectionForQuantity',
-  Promise.resolve([]),
-)
+  })
+}
+export function queryStatisticsCollectionForQuantity<
+  T extends QuantityTypeIdentifier,
+>(
+  _identifier: T,
+  _statistics: readonly StatisticsOptions[],
+  _anchorDate: Date,
+  _intervalComponents: IntervalComponents,
+  _options?: StatisticsQueryOptions<UnitForIdentifier<T>>,
+): Promise<readonly QueryStatisticsResponse[]> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve([])
+}
 
-export const queryStatisticsForQuantitySeparateBySource =
-  UnavailableFnFromModule(
-    'queryStatisticsForQuantitySeparateBySource',
-    Promise.resolve([]),
-  )
-export const queryStatisticsCollectionForQuantitySeparateBySource =
-  UnavailableFnFromModule(
-    'queryStatisticsCollectionForQuantitySeparateBySource',
-    Promise.resolve([]),
-  )
-export const saveQuantitySample = UnavailableFnFromModule(
-  'saveQuantitySample',
-  Promise.resolve(undefined),
-)
-export const isQuantityCompatibleWithUnit = UnavailableFnFromModule(
-  'isQuantityCompatibleWithUnit',
-  false,
-)
+export function queryStatisticsForQuantitySeparateBySource<
+  T extends QuantityTypeIdentifier,
+>(
+  _identifier: T,
+  _statistics: readonly StatisticsOptions[],
+  _options?: StatisticsQueryOptions<UnitForIdentifier<T>>,
+): Promise<QueryStatisticsResponseFromSingleSource[]> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve([])
+}
+export function queryStatisticsCollectionForQuantitySeparateBySource<
+  T extends QuantityTypeIdentifier,
+>(
+  _identifier: T,
+  _statistics: readonly StatisticsOptions[],
+  _anchorDate: Date,
+  _intervalComponents: IntervalComponents,
+  _options?: StatisticsQueryOptions<UnitForIdentifier<T>>,
+): Promise<readonly QueryStatisticsResponseFromSingleSource[]> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve([])
+}
+export function saveQuantitySample<T extends QuantityTypeIdentifierWriteable>(
+  _identifier: T,
+  _unit: UnitForIdentifier<T>,
+  _value: number,
+  _start: Date,
+  _end: Date,
+  _metadata?: MetadataForQuantityIdentifier<T>,
+): Promise<QuantitySampleTyped<T> | undefined> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve(undefined)
+}
+export function isQuantityCompatibleWithUnit<T extends QuantityTypeIdentifier>(
+  _identifier: T,
+  _unit: UnitForIdentifier<T>,
+): boolean {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return false
+}
 
 // CategoryTypeModule functions
 export function queryCategorySamples<T extends CategoryTypeIdentifier>(
@@ -216,10 +314,20 @@ export function queryCategorySamplesWithAnchor<
     newAnchor: '',
   })
 }
-export const saveCategorySample = UnavailableFnFromModule(
-  'saveCategorySample',
-  Promise.resolve(undefined),
-)
+
+export function saveCategorySample<T extends CategoryTypeIdentifierWriteable>(
+  _identifier: T,
+  _value: CategoryValueForIdentifier<T>,
+  _startDate: Date,
+  _endDate: Date,
+  _metadata?: MetadataForCategoryIdentifier<T>,
+): Promise<CategorySampleTyped<T> | undefined> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve(undefined)
+}
 
 // CorrelationTypeModule functions
 export const queryCorrelationSamples = UnavailableFnFromModule(
@@ -321,20 +429,30 @@ export function getMostRecentCategorySample<T extends CategoryTypeIdentifier>(
   return Promise.resolve(undefined)
 }
 
-export const getMostRecentQuantitySample = UnavailableFnFromModule(
-  'getMostRecentQuantitySample',
-  // biome-ignore lint/suspicious/noExplicitAny: it works
-  Promise.resolve(undefined as any as QuantitySample),
-)
+export function getMostRecentQuantitySample<T extends QuantityTypeIdentifier>(
+  _identifier: T,
+  _unit?: UnitForIdentifier<T>,
+): Promise<QuantitySampleTyped<T> | undefined> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve(undefined)
+}
 export const getMostRecentWorkout = UnavailableFnFromModule(
   'getMostRecentWorkout',
   // biome-ignore lint/suspicious/noExplicitAny: it works
   Promise.resolve(undefined as any as WorkoutProxy),
 )
-export const getPreferredUnit = UnavailableFnFromModule(
-  'getPreferredUnit',
-  Promise.resolve('count'),
-) // Defaulting to 'count'
+export function getPreferredUnit<T extends QuantityTypeIdentifier>(
+  _quantityType: T,
+): Promise<UnitForIdentifier<T>> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve('count' as UnitForIdentifier<T>)
+}
 
 // Hooks (from original export list)
 export function useMostRecentCategorySample<T extends CategoryTypeIdentifier>(
@@ -347,10 +465,16 @@ export function useMostRecentCategorySample<T extends CategoryTypeIdentifier>(
   return undefined
 }
 
-export const useMostRecentQuantitySample = UnavailableFnFromModule(
-  'useMostRecentQuantitySample',
-  undefined,
-)
+export function useMostRecentQuantitySample<T extends QuantityTypeIdentifier>(
+  _identifier: T,
+  _unit?: UnitForIdentifier<T>,
+): QuantitySampleTyped<T> | undefined {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return undefined
+}
 export const useMostRecentWorkout = UnavailableFnFromModule(
   'useMostRecentWorkout',
   undefined,
@@ -463,6 +587,8 @@ const HealthkitModule = {
   areObjectTypesAvailable,
   areObjectTypesAvailableAsync,
   isQuantityCompatibleWithUnit,
+  configureBackgroundTypes,
+  clearBackgroundTypes,
   disableAllBackgroundDelivery,
   disableBackgroundDelivery,
   enableBackgroundDelivery,

package/src/hooks/useMostRecentQuantitySample.ts

@@ -1,5 +1,6 @@
 import { useCallback, useState } from 'react'
-import type { QuantitySample } from '../types/QuantitySample'
+import type { QuantitySampleTyped } from '../types/QuantitySample'
+import type { UnitForIdentifier } from '../types/QuantityType'
 import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier'
 import getMostRecentQuantitySample from '../utils/getMostRecentQuantitySample'
 import useSubscribeToChanges from './useSubscribeToChanges'
@@ -7,11 +8,11 @@ import useSubscribeToChanges from './useSubscribeToChanges'
 /**
  * @returns the most recent sample for the given quantity type.
  */
-export function useMostRecentQuantitySample(
-  identifier: QuantityTypeIdentifier,
-  unit?: string,
+export function useMostRecentQuantitySample<T extends QuantityTypeIdentifier>(
+  identifier: T,
+  unit?: UnitForIdentifier<T>,
 ) {
-  const [lastSample, setLastSample] = useState<QuantitySample>()
+  const [lastSample, setLastSample] = useState<QuantitySampleTyped<T>>()
 
   const fetchMostRecentSample = useCallback(async () => {
     const value = await getMostRecentQuantitySample(identifier, unit)

package/src/hooks/useMostRecentWorkout.ts

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useState } from 'react'
-import type { WorkoutProxy } from '../specs/WorkoutProxy.nitro'
+import type { WorkoutProxyTyped } from '../types/Workouts'
 import getMostRecentWorkout from '../utils/getMostRecentWorkout'
 import useSubscribeToChanges from './useSubscribeToChanges'
 
@@ -7,7 +7,7 @@ import useSubscribeToChanges from './useSubscribeToChanges'
  * @returns the most recent workout sample.
  */
 export function useMostRecentWorkout() {
-  const [workout, setWorkout] = useState<WorkoutProxy>()
+  const [workout, setWorkout] = useState<WorkoutProxyTyped>()
 
   const update = useCallback(async () => {
     setWorkout(await getMostRecentWorkout())

package/src/hooks/useQuantitySampleById.ts

@@ -1,5 +1,6 @@
 import { useCallback, useState } from 'react'
-import type { QuantitySample } from '../types/QuantitySample'
+import type { QuantitySampleTyped } from '../types/QuantitySample'
+import type { UnitForIdentifier } from '../types/QuantityType'
 import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier'
 import getQuantitySampleById from '../utils/getQuantitySampleById'
 import useSubscribeToChanges from './useSubscribeToChanges'
@@ -7,15 +8,15 @@ import useSubscribeToChanges from './useSubscribeToChanges'
 /**
  * @returns the most recent sample for the given quantity type.
  */
-export function useQuantitySampleById(
-  identifier: QuantityTypeIdentifier,
+export function useQuantitySampleById<T extends QuantityTypeIdentifier>(
+  identifier: T,
   uuid: string,
   options: {
     /** The unit to use for the sample. */
-    unit?: string
+    unit?: UnitForIdentifier<T>
   } = {},
 ) {
-  const [sample, setSample] = useState<QuantitySample>()
+  const [sample, setSample] = useState<QuantitySampleTyped<T>>()
   const [isLoading, setIsLoading] = useState(true)
   const [error, setError] = useState<Error | null>(null)