@kingstinct/react-native-healthkit 8.7.2 → 9.0.0

package/src/hooks/useHealthkitAuthorization.ts

@@ -1,19 +1,22 @@
-import {
-  useCallback, useEffect, useRef, useState,
-} from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 
-import getRequestStatusForAuthorization from '../utils/getRequestStatusForAuthorization'
-import requestAuthorization from '../utils/requestAuthorization'
-
-import type { HealthkitReadAuthorization, HealthkitWriteAuthorization, HKAuthorizationRequestStatus } from '../native-types'
+import { Core } from '../modules'
+import type { AuthorizationRequestStatus } from '../types/Auth'
+import type {
+  ObjectTypeIdentifier,
+  SampleTypeIdentifierWriteable,
+} from '../types/Shared'
 
 /**
-   * @description Hook to retrieve the current authorization status for the given types, and request authorization if needed.
-   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs - requestAuthorization}
-   * @see {@link https://developer.apple.com/documentation/healthkit/authorizing_access_to_health_data Apple Docs - Authorizing access to health data}
-   */
-const useHealthkitAuthorization = (read: readonly HealthkitReadAuthorization[], write?: readonly HealthkitWriteAuthorization[]) => {
-  const [status, setStatus] = useState<HKAuthorizationRequestStatus | null>(null)
+ * @description Hook to retrieve the current authorization status for the given types, and request authorization if needed.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs - requestAuthorization}
+ * @see {@link https://developer.apple.com/documentation/healthkit/authorizing_access_to_health_data Apple Docs - Authorizing access to health data}
+ */
+export const useHealthkitAuthorization = (
+  read: ObjectTypeIdentifier[],
+  write?: SampleTypeIdentifierWriteable[],
+) => {
+  const [status, setStatus] = useState<AuthorizationRequestStatus | null>(null)
 
   const readMemo = useRef(read)
   const writeMemo = useRef(write)
@@ -24,14 +27,17 @@ const useHealthkitAuthorization = (read: readonly HealthkitReadAuthorization[],
   }, [read, write])
 
   const refreshAuthStatus = useCallback(async () => {
-    const auth = await getRequestStatusForAuthorization(readMemo.current, writeMemo.current)
+    const auth = await Core.getRequestStatusForAuthorization(
+      writeMemo.current ?? [],
+      readMemo.current,
+    )
 
     setStatus(auth)
     return auth
   }, [])
 
   const request = useCallback(async () => {
-    await requestAuthorization(readMemo.current, writeMemo.current)
+    await Core.requestAuthorization(writeMemo.current ?? [], readMemo.current)
     return refreshAuthStatus()
   }, [refreshAuthStatus])
 

package/src/hooks/useIsHealthDataAvailable.test.ts

@@ -1,12 +1,17 @@
+import { describe, expect, jest, test } from 'bun:test'
 import { renderHook } from '@testing-library/react-native'
 
+import { Core } from '../modules'
 import waitForNextUpdate from '../test-utils'
 
 describe('useIsHealthDataAvailable', () => {
   test('should return false', async () => {
-    const useIsHealthDataAvailable = (await import('./useIsHealthDataAvailable')).default
-    const { default: Native } = await import('../native-types')
-    jest.spyOn(Native, 'isHealthDataAvailable').mockReturnValue(Promise.resolve(false))
+    const useIsHealthDataAvailable = (
+      await import('./useIsHealthDataAvailable')
+    ).default
+    jest
+      .spyOn(Core, 'isHealthDataAvailableAsync')
+      .mockReturnValue(Promise.resolve(false))
 
     const { result } = renderHook(useIsHealthDataAvailable)
 
@@ -16,9 +21,12 @@ describe('useIsHealthDataAvailable', () => {
   })
 
   test('should return true', async () => {
-    const useIsHealthDataAvailable = (await import('./useIsHealthDataAvailable')).default
-    const { default: Native } = await import('../native-types')
-    jest.spyOn(Native, 'isHealthDataAvailable').mockReturnValue(Promise.resolve(true))
+    const useIsHealthDataAvailable = (
+      await import('./useIsHealthDataAvailable')
+    ).default
+    jest
+      .spyOn(Core, 'isHealthDataAvailableAsync')
+      .mockReturnValue(Promise.resolve(true))
 
     const { result } = renderHook(useIsHealthDataAvailable)
 
@@ -28,7 +36,9 @@ describe('useIsHealthDataAvailable', () => {
   })
 
   test('should return null before initalizing', async () => {
-    const useIsHealthDataAvailable = (await import('./useIsHealthDataAvailable')).default
+    const useIsHealthDataAvailable = (
+      await import('./useIsHealthDataAvailable')
+    ).default
     const { result } = renderHook(useIsHealthDataAvailable)
 
     expect(result.current).toBe(null)

package/src/hooks/useIsHealthDataAvailable.ts

@@ -1,18 +1,18 @@
 import { useEffect, useState } from 'react'
 
-import Native from '../native-types'
+import { Core } from '../modules'
 
 /**
- * @description By default, HealthKit data is available on iOS and watchOS. HealthKit data is also available on iPadOS 17 or later. However, devices running in an enterprise environment may restrict access to HealthKit data.
-* @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614180-ishealthdataavailable Apple HealthKit isHealthDataAvailable}
-* @returns {boolean | null} true if HealthKit is available; otherwise, false. null while initializing.
-*/
-const useIsHealthDataAvailable = (): boolean | null => {
+ * @description Now there is a Core.isHealthDataAvailable() that can be called synchronously. By default, HealthKit data is available on iOS and watchOS. HealthKit data is also available on iPadOS 17 or later. However, devices running in an enterprise environment may restrict access to HealthKit data.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614180-ishealthdataavailable Apple HealthKit isHealthDataAvailable}
+ * @returns {boolean | null} true if HealthKit is available; otherwise, false. null while initializing.
+ */
+export const useIsHealthDataAvailable = (): boolean | null => {
   const [isAvailable, setIsAvailable] = useState<boolean | null>(null)
 
   useEffect(() => {
     const init = async () => {
-      const res = await Native.isHealthDataAvailable()
+      const res = await Core.isHealthDataAvailableAsync()
       setIsAvailable(res)
     }
     void init()

package/src/hooks/useMostRecentCategorySample.ts

@@ -1,20 +1,18 @@
 import { useCallback, useState } from 'react'
 
-import useSubscribeToChanges from './useSubscribeToChanges'
+import type { CategorySampleTyped } from '../types/CategoryType'
+import type { CategoryTypeIdentifier } from '../types/CategoryTypeIdentifier'
 import getMostRecentCategorySample from '../utils/getMostRecentCategorySample'
-
-import type { HKCategoryTypeIdentifier } from '../native-types'
-import type { HKCategorySample } from '../types'
+import useSubscribeToChanges from './useSubscribeToChanges'
 
 /**
-   * @returns the most recent sample for the given category type.
-   */
-function useMostRecentCategorySample<
-  TCategory extends HKCategoryTypeIdentifier
->(identifier: TCategory) {
-  const [category, setCategory] = useState<HKCategorySample<TCategory> | null>(
-    null,
-  )
+ * @returns the most recent sample for the given category type.
+ */
+export function useMostRecentCategorySample<T extends CategoryTypeIdentifier>(
+  identifier: T,
+) {
+  const [category, setCategory] = useState<CategorySampleTyped<T>>()
+
   const updater = useCallback(() => {
     void getMostRecentCategorySample(identifier).then(setCategory)
   }, [identifier])

package/src/hooks/useMostRecentQuantitySample.ts

@@ -1,44 +1,25 @@
-import { useEffect, useState } from 'react'
-
-import ensureUnit from '../utils/ensureUnit'
+import { useCallback, useState } from 'react'
+import type { QuantitySample } from '../types/QuantitySample'
+import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier'
 import getMostRecentQuantitySample from '../utils/getMostRecentQuantitySample'
-import subscribeToChanges from '../utils/subscribeToChanges'
-
-import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types'
-import type { HKQuantitySample } from '../types'
+import useSubscribeToChanges from './useSubscribeToChanges'
 
 /**
-   * @returns the most recent sample for the given quantity type.
-   */
-function useMostRecentQuantitySample<
-  TIdentifier extends HKQuantityTypeIdentifier,
-  TUnit extends UnitForIdentifier<TIdentifier>
->(identifier: TIdentifier, unit?: TUnit) {
-  const [lastSample, setLastSample] = useState<HKQuantitySample<
-  TIdentifier
-  > | null>(null)
-
-  useEffect(() => {
-    let cancelSubscription: (() => Promise<boolean>) | undefined
-
-    const init = async () => {
-      const actualUnit = await ensureUnit(identifier, unit)
-
-      const value = await getMostRecentQuantitySample(identifier, actualUnit)
-      setLastSample(value)
-
-      cancelSubscription = await subscribeToChanges(identifier, async () => {
-        const value = await getMostRecentQuantitySample(identifier, actualUnit)
-        setLastSample(value)
-      })
-    }
-    void init()
-
-    return () => {
-      void cancelSubscription?.()
-    }
+ * @returns the most recent sample for the given quantity type.
+ */
+export function useMostRecentQuantitySample(
+  identifier: QuantityTypeIdentifier,
+  unit?: string,
+) {
+  const [lastSample, setLastSample] = useState<QuantitySample>()
+
+  const fetchMostRecentSample = useCallback(async () => {
+    const value = await getMostRecentQuantitySample(identifier, unit)
+    setLastSample(value)
   }, [identifier, unit])
 
+  useSubscribeToChanges(identifier, fetchMostRecentSample)
+
   return lastSample
 }
 

package/src/hooks/useMostRecentWorkout.ts

@@ -1,22 +1,16 @@
-import {
-  useEffect, useState, useRef, useCallback,
-} from 'react'
-
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { WorkoutProxy } from '../specs/WorkoutProxy.nitro'
 import getMostRecentWorkout from '../utils/getMostRecentWorkout'
-import getPreferredUnitsTyped from '../utils/getPreferredUnitsTyped'
-import subscribeToChanges from '../utils/subscribeToChanges'
-
-import type { EnergyUnit, LengthUnit } from '../native-types'
-import type { HKWorkout } from '../types'
+import useSubscribeToChanges from './useSubscribeToChanges'
 
 /**
-   * @returns the most recent workout sample.
-   */
-function useMostRecentWorkout<
-  TEnergy extends EnergyUnit,
-  TDistance extends LengthUnit
->(options?: { readonly energyUnit?: TEnergy; readonly distanceUnit?: TDistance }) {
-  const [workout, setWorkout] = useState<HKWorkout<TEnergy, TDistance> | null>(null)
+ * @returns the most recent workout sample.
+ */
+export function useMostRecentWorkout(options?: {
+  readonly energyUnit?: string
+  readonly distanceUnit?: string
+}) {
+  const [workout, setWorkout] = useState<WorkoutProxy>()
 
   const optionsRef = useRef(options)
 
@@ -25,35 +19,19 @@ function useMostRecentWorkout<
   }, [options])
 
   const update = useCallback(async () => {
-    const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(
-      optionsRef.current,
+    setWorkout(
+      await getMostRecentWorkout({
+        energyUnit: optionsRef.current?.energyUnit,
+        distanceUnit: optionsRef.current?.distanceUnit,
+      }),
     )
-
-    setWorkout(await getMostRecentWorkout({
-      energyUnit,
-      distanceUnit,
-    }))
   }, [])
 
   useEffect(() => {
     void update()
   }, [update])
 
-  useEffect(() => {
-    let cancelSubscription: (() => Promise<boolean>) | undefined
-
-    const init = async () => {
-      cancelSubscription = await subscribeToChanges(
-        'HKWorkoutTypeIdentifier',
-        update,
-      )
-    }
-    void init()
-
-    return () => {
-      void cancelSubscription?.()
-    }
-  }, [update])
+  useSubscribeToChanges('HKWorkoutTypeIdentifier', update)
 
   return workout
 }

package/src/hooks/useSources.ts

@@ -1,20 +1,16 @@
 import { useCallback, useEffect, useState } from 'react'
 
-import querySources from '../utils/querySources'
+import { Core } from '../modules'
+import type { SourceProxy } from '../specs/SourceProxy.nitro'
+import type { SampleTypeIdentifier } from '../types/Shared'
 
-import type {
-  HKCategoryTypeIdentifier,
-  HKQuantityTypeIdentifier,
-  HKSource,
-} from '../native-types'
-
-function useSources<
-  TIdentifier extends HKCategoryTypeIdentifier | HKQuantityTypeIdentifier
->(identifier: TIdentifier) {
-  const [result, setResult] = useState<readonly HKSource[] | null>(null)
+export function useSources<TIdentifier extends SampleTypeIdentifier>(
+  identifier: TIdentifier,
+) {
+  const [result, setResult] = useState<readonly SourceProxy[] | null>(null)
 
   const update = useCallback(async () => {
-    const res = await querySources(identifier)
+    const res = await Core.querySources(identifier)
     setResult(res)
   }, [identifier])
 

package/src/hooks/useStatisticsForQuantity.ts

@@ -1,21 +1,24 @@
-import {
-  useState, useEffect, useCallback, useRef,
-} from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 
 import useSubscribeToChanges from './useSubscribeToChanges'
-import queryStatisticsForQuantity from '../utils/queryStatisticsForQuantity'
 
-import type { HKQuantityTypeIdentifier, HKStatisticsOptions, UnitForIdentifier } from '../native-types'
-import type { QueryStatisticsResponse } from '../types'
+import { QuantityTypes } from '../modules'
+import type {
+  QueryStatisticsResponse,
+  StatisticsOptions,
+} from '../types/QuantityType'
+import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier'
 
-function useStatisticsForQuantity<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>>(
+export function useStatisticsForQuantity<
+  TIdentifier extends QuantityTypeIdentifier,
+>(
   identifier: TIdentifier,
-  options: readonly HKStatisticsOptions[],
+  options: readonly StatisticsOptions[],
   from: Date,
   to?: Date,
-  unit?: TUnit,
+  unit?: string,
 ) {
-  const [result, setResult] = useState<QueryStatisticsResponse<TIdentifier, TUnit> | null>(null)
+  const [result, setResult] = useState<QueryStatisticsResponse | null>(null)
 
   const optionsRef = useRef(options)
 
@@ -24,11 +27,13 @@ function useStatisticsForQuantity<TIdentifier extends HKQuantityTypeIdentifier,
   }, [options])
 
   const update = useCallback(async () => {
-    const res = await queryStatisticsForQuantity(identifier, optionsRef.current, from, to, unit)
+    const res = await QuantityTypes.queryStatisticsForQuantity(
+      identifier,
+      optionsRef.current,
+      { filter: { startDate: from, endDate: to }, unit },
+    )
     setResult(res)
-  }, [
-    identifier, from, to, unit,
-  ])
+  }, [identifier, from, to, unit])
 
   useEffect(() => {
     void update()

package/src/hooks/useSubscribeToChanges.ts

@@ -1,12 +1,11 @@
 import { useEffect, useRef } from 'react'
+import type { SampleTypeIdentifier } from '../types/Shared'
+import type { OnChangeCallbackArgs } from '../types/Subscriptons'
+import { subscribeToChanges } from '../utils/subscribeToChanges'
 
-import subscribeToChanges from '../utils/subscribeToChanges'
-
-import type { HKSampleTypeIdentifier } from '..'
-
-function useSubscribeToChanges<TIdentifier extends HKSampleTypeIdentifier>(
+export function useSubscribeToChanges<TIdentifier extends SampleTypeIdentifier>(
   identifier: TIdentifier,
-  onChange: () => void,
+  onChange: (args: OnChangeCallbackArgs) => void,
 ): void {
   const onChangeRef = useRef(onChange)
 
@@ -15,15 +14,12 @@ function useSubscribeToChanges<TIdentifier extends HKSampleTypeIdentifier>(
   }, [onChange])
 
   useEffect(() => {
-    let cancelSubscription: (() => Promise<boolean>) | undefined
-
-    const init = async () => {
-      cancelSubscription = await subscribeToChanges(identifier, onChangeRef.current)
-    }
-    void init()
+    const subscription = subscribeToChanges(identifier, (args) => {
+      onChangeRef.current(args)
+    })
 
     return () => {
-      void cancelSubscription?.()
+      subscription.remove()
     }
   }, [identifier])
 }

package/src/index.ios.ts

@@ -0,0 +1,232 @@
+import { Platform } from 'react-native'
+import useHealthkitAuthorization from './hooks/useHealthkitAuthorization'
+import { useIsHealthDataAvailable } from './hooks/useIsHealthDataAvailable'
+import useMostRecentCategorySample from './hooks/useMostRecentCategorySample'
+import useMostRecentQuantitySample from './hooks/useMostRecentQuantitySample'
+import useMostRecentWorkout from './hooks/useMostRecentWorkout'
+import useSources from './hooks/useSources'
+import useStatisticsForQuantity from './hooks/useStatisticsForQuantity'
+import useSubscribeToChanges from './hooks/useSubscribeToChanges'
+import {
+  CategoryTypes,
+  Characteristics,
+  Core,
+  CorrelationTypes,
+  HeartbeatSeries,
+  QuantityTypes,
+  StateOfMind,
+  Workouts,
+} from './modules'
+import type { QuantityTypeIdentifier } from './types/QuantityTypeIdentifier'
+import getMostRecentCategorySample from './utils/getMostRecentCategorySample'
+import getMostRecentQuantitySample from './utils/getMostRecentQuantitySample'
+import getMostRecentWorkout from './utils/getMostRecentWorkout'
+import getPreferredUnit from './utils/getPreferredUnit'
+
+const currentMajorVersionIOS =
+  Platform.OS === 'ios' ? Number.parseInt(Platform.Version, 10) : 0
+
+/**
+ * Quantity types that are not available before iOS 17
+ */
+type QuantityTypesIOS17Plus =
+  | 'HKQuantityTypeIdentifierCyclingCadence'
+  | 'HKQuantityTypeIdentifierCyclingFunctionalThresholdPower'
+  | 'HKQuantityTypeIdentifierCyclingPower'
+  | 'HKQuantityTypeIdentifierCyclingSpeed'
+  | 'HKQuantityTypeIdentifierPhysicalEffort'
+  | 'HKQuantityTypeIdentifierTimeInDaylight'
+
+/**
+ * Available quantity types for iOS versions before iOS 17
+ */
+export type AvailableQuantityTypesBeforeIOS17 = Exclude<
+  QuantityTypeIdentifier,
+  QuantityTypesIOS17Plus
+>
+
+export {
+  getMostRecentCategorySample,
+  getMostRecentQuantitySample,
+  getMostRecentWorkout,
+  getPreferredUnit,
+  useMostRecentCategorySample,
+  useMostRecentQuantitySample,
+  useMostRecentWorkout,
+  useSubscribeToChanges,
+  useHealthkitAuthorization,
+  useIsHealthDataAvailable,
+  useSources,
+  useStatisticsForQuantity,
+}
+
+/**
+ * Available quantity types for iOS 17 and later (all quantity types)
+ */
+export type AvailableQuantityTypesIOS17Plus = QuantityTypeIdentifier
+
+/**
+ * Get available quantity types based on iOS version
+ * @param majorVersionIOS - iOS major version number (defaults to current iOS version)
+ * @returns Available quantity types for the given iOS version
+ */
+export type AvailableQuantityTypes<
+  T extends number = typeof currentMajorVersionIOS,
+> = T extends 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25
+  ? AvailableQuantityTypesIOS17Plus
+  : AvailableQuantityTypesBeforeIOS17
+
+// Named exports - all functions bound to their respective modules
+export const authorizationStatusFor = Core.authorizationStatusFor.bind(Core)
+export const disableAllBackgroundDelivery =
+  Core.disableAllBackgroundDelivery.bind(Core)
+export const disableBackgroundDelivery =
+  Core.disableBackgroundDelivery.bind(Core)
+export const enableBackgroundDelivery = Core.enableBackgroundDelivery.bind(Core)
+export const getBiologicalSex =
+  Characteristics.getBiologicalSex.bind(Characteristics)
+export const getBloodType = Characteristics.getBloodType.bind(Characteristics)
+export const getDateOfBirth =
+  Characteristics.getDateOfBirth.bind(Characteristics)
+export const getFitzpatrickSkinType =
+  Characteristics.getFitzpatrickSkinType.bind(Characteristics)
+export const getPreferredUnits = Core.getPreferredUnits.bind(Core)
+export const getRequestStatusForAuthorization =
+  Core.getRequestStatusForAuthorization.bind(Core)
+export const getWheelchairUse =
+  Characteristics.getWheelchairUse.bind(Characteristics)
+export const isHealthDataAvailable = Core.isHealthDataAvailable.bind(Core)
+export const isHealthDataAvailableAsync =
+  Core.isHealthDataAvailableAsync.bind(Core)
+export const queryCategorySamples =
+  CategoryTypes.queryCategorySamples.bind(CategoryTypes)
+export const queryCategorySamplesWithAnchor =
+  CategoryTypes.queryCategorySamplesWithAnchor.bind(CategoryTypes)
+export const queryCorrelationSamples =
+  CorrelationTypes.queryCorrelationSamples.bind(CorrelationTypes)
+export const queryHeartbeatSeriesSamples =
+  HeartbeatSeries.queryHeartbeatSeriesSamples.bind(HeartbeatSeries)
+export const queryHeartbeatSeriesSamplesWithAnchor =
+  HeartbeatSeries.queryHeartbeatSeriesSamplesWithAnchor.bind(HeartbeatSeries)
+export const queryQuantitySamples =
+  QuantityTypes.queryQuantitySamples.bind(QuantityTypes)
+export const queryQuantitySamplesWithAnchor =
+  QuantityTypes.queryQuantitySamplesWithAnchor.bind(QuantityTypes)
+export const queryStatisticsForQuantity =
+  QuantityTypes.queryStatisticsForQuantity.bind(QuantityTypes)
+export const queryStatisticsCollectionForQuantity =
+  QuantityTypes.queryStatisticsCollectionForQuantity.bind(QuantityTypes)
+export const queryWorkoutSamples = Workouts.queryWorkoutSamples.bind(Workouts)
+export const queryWorkoutSamplesWithAnchor =
+  Workouts.queryWorkoutSamplesWithAnchor.bind(Workouts)
+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)
+export const saveQuantitySample =
+  QuantityTypes.saveQuantitySample.bind(QuantityTypes)
+export const saveWorkoutSample = Workouts.saveWorkoutSample.bind(Workouts)
+export const subscribeToChanges = Core.subscribeToObserverQuery.bind(Core)
+export const startWatchApp =
+  Workouts.startWatchAppWithWorkoutConfiguration.bind(Workouts)
+export const isProtectedDataAvailable = Core.isProtectedDataAvailable.bind(Core)
+export const queryStateOfMindSamples =
+  StateOfMind.queryStateOfMindSamples.bind(StateOfMind)
+export const saveStateOfMindSample =
+  StateOfMind.saveStateOfMindSample.bind(StateOfMind)
+export const isQuantityCompatibleWithUnit =
+  QuantityTypes.isQuantityCompatibleWithUnit.bind(QuantityTypes)
+export const unsubscribeQueries = Core.unsubscribeQueries.bind(Core)
+
+export const isObjectTypeAvailable = Core.isObjectTypeAvailable.bind(Core)
+export const isObjectTypeAvailableAsync =
+  Core.isObjectTypeAvailableAsync.bind(Core)
+export const areObjectTypesAvailable = Core.areObjectTypesAvailable.bind(Core)
+export const areObjectTypesAvailableAsync =
+  Core.areObjectTypesAvailableAsync.bind(Core)
+
+export const getBiologicalSexAsync =
+  Characteristics.getBiologicalSexAsync.bind(Characteristics)
+export const getBloodTypeAsync =
+  Characteristics.getBloodTypeAsync.bind(Characteristics)
+export const getDateOfBirthAsync =
+  Characteristics.getDateOfBirthAsync.bind(Characteristics)
+export const getFitzpatrickSkinTypeAsync =
+  Characteristics.getFitzpatrickSkinTypeAsync.bind(Characteristics)
+export const getWheelchairUseAsync =
+  Characteristics.getWheelchairUseAsync.bind(Characteristics)
+
+export default {
+  authorizationStatusFor,
+  isObjectTypeAvailable,
+  isObjectTypeAvailableAsync,
+  areObjectTypesAvailable,
+  areObjectTypesAvailableAsync,
+  isQuantityCompatibleWithUnit,
+  disableAllBackgroundDelivery,
+  disableBackgroundDelivery,
+  enableBackgroundDelivery,
+  getBiologicalSex,
+  getBloodType,
+  getDateOfBirth,
+  getFitzpatrickSkinType,
+  getBiologicalSexAsync,
+  getBloodTypeAsync,
+  getDateOfBirthAsync,
+  getFitzpatrickSkinTypeAsync,
+  getWheelchairUseAsync,
+  getMostRecentCategorySample,
+  getMostRecentQuantitySample,
+  getMostRecentWorkout,
+  getPreferredUnits,
+  getPreferredUnit,
+  getRequestStatusForAuthorization,
+  getWheelchairUse,
+  isHealthDataAvailable,
+  isHealthDataAvailableAsync,
+  queryCategorySamples,
+  queryCategorySamplesWithAnchor,
+  queryCorrelationSamples,
+  queryHeartbeatSeriesSamples,
+  queryHeartbeatSeriesSamplesWithAnchor,
+  queryQuantitySamples,
+  queryQuantitySamplesWithAnchor,
+  queryStatisticsForQuantity,
+  queryStatisticsCollectionForQuantity,
+  queryWorkoutSamples,
+  queryWorkoutSamplesWithAnchor,
+  querySources,
+  requestAuthorization,
+  deleteObjects,
+  saveCategorySample,
+  saveCorrelationSample,
+  saveQuantitySample,
+  saveWorkoutSample,
+  subscribeToChanges,
+  unsubscribeQueries,
+  startWatchApp,
+  isProtectedDataAvailable,
+  queryStateOfMindSamples,
+  saveStateOfMindSample,
+  // Modules
+  // Core,
+  // Workouts,
+  // Characteristics,
+  // QuantityTypes,
+  // CategoryTypes,
+  // CorrelationTypes,
+  // HeartbeatSeries,
+  // StateOfMind,
+  // hooks
+  useMostRecentCategorySample,
+  useMostRecentQuantitySample,
+  useMostRecentWorkout,
+  useSubscribeToChanges,
+  useHealthkitAuthorization,
+  useIsHealthDataAvailable,
+  useSources,
+  useStatisticsForQuantity,
+}