@kingstinct/react-native-healthkit 8.7.2 → 9.0.0

package/src/index.ts

@@ -0,0 +1,444 @@
+import { Platform } from 'react-native'
+
+// Import types for default values and function signatures.
+// These types are expected to be available via the './types' export.
+// You might need to adjust the import path or ensure these types are correctly exported from './types'
+
+// This import is crucial for deriving the type of the default export `HealthkitModule`
+// It assumes that index.ios.ts exports a default object matching the Healthkit native module structure.
+import type * as ReactNativeHealthkit from './index.ios'
+import type { SourceProxy } from './specs/SourceProxy.nitro'
+import type { WorkoutProxy } from './specs/WorkoutProxy.nitro'
+import { AuthorizationRequestStatus, AuthorizationStatus } from './types/Auth'
+import type {
+  CategorySampleTyped,
+  CategorySamplesWithAnchorResponseTyped,
+} from './types/CategoryType'
+import type { CategoryTypeIdentifier } from './types/CategoryTypeIdentifier'
+import {
+  BiologicalSex,
+  BloodType,
+  FitzpatrickSkinType,
+  WheelchairUse,
+} from './types/Characteristics'
+import type { CorrelationSample } from './types/CorrelationType'
+import type {
+  HeartbeatSeriesSample,
+  HeartbeatSeriesSamplesWithAnchorResponse,
+} from './types/HeartbeatSeries'
+import type { QuantitySample } from './types/QuantitySample'
+import type {
+  QuantitySamplesWithAnchorResponse,
+  QueryStatisticsResponse,
+} from './types/QuantityType'
+import type { StateOfMindSample } from './types/StateOfMind'
+import type { IdentifierWithUnit } from './types/Units'
+import type { QueryWorkoutSamplesWithAnchorResponse } from './types/Workouts'
+
+const notAvailableError = `[@kingstinct/react-native-healthkit] Platform "${Platform.OS}" not supported. HealthKit is only available on iOS.`
+
+let hasWarned = false
+
+// @ts-ignore
+// biome-ignore lint/complexity/noBannedTypes: <explanation>
+function UnavailableFnNew<T extends Function>(defaultValue: ReturnType<T>): T {
+  // @ts-ignore
+  return () => {
+    if (Platform.OS !== 'ios' && !hasWarned) {
+      console.warn(notAvailableError)
+      hasWarned = true
+    }
+    return defaultValue
+  }
+}
+
+// @ts-ignore
+function UnavailableFnFromModule<
+  TKey extends keyof typeof ReactNativeHealthkit,
+  // @ts-ignore
+  // biome-ignore lint/complexity/noBannedTypes: <explanation>
+  T extends Function = (typeof ReactNativeHealthkit)[TKey],
+  // @ts-ignore
+>(fn: TKey, defaultValue: ReturnType<T>): T {
+  // @ts-ignore
+  return () => {
+    if (Platform.OS !== 'ios' && !hasWarned) {
+      console.warn(notAvailableError)
+      hasWarned = true
+    }
+    return defaultValue
+  }
+}
+
+// --- Mock Implementations for exported functions ---
+
+// CoreModule functions
+export const authorizationStatusFor = UnavailableFnFromModule(
+  'authorizationStatusFor',
+  AuthorizationStatus.notDetermined,
+)
+export const disableAllBackgroundDelivery = UnavailableFnFromModule(
+  'disableAllBackgroundDelivery',
+  Promise.resolve(false),
+)
+export const disableBackgroundDelivery = UnavailableFnFromModule(
+  'disableBackgroundDelivery',
+  Promise.resolve(false),
+)
+export const enableBackgroundDelivery = UnavailableFnFromModule(
+  'enableBackgroundDelivery',
+  Promise.resolve(false),
+)
+export const getPreferredUnits = UnavailableFnFromModule(
+  'getPreferredUnits',
+  Promise.resolve([]),
+)
+export const getRequestStatusForAuthorization = UnavailableFnFromModule(
+  'getRequestStatusForAuthorization',
+  Promise.resolve(AuthorizationRequestStatus.unknown),
+)
+export const isHealthDataAvailable = UnavailableFnFromModule(
+  'isHealthDataAvailable',
+  false,
+) // Original was synchronous
+export const isHealthDataAvailableAsync = UnavailableFnFromModule(
+  'isHealthDataAvailableAsync',
+  Promise.resolve(false),
+) // Added for consistency if needed
+export const querySources = UnavailableFnFromModule(
+  'querySources',
+  Promise.resolve([]),
+)
+export const requestAuthorization = UnavailableFnFromModule(
+  'requestAuthorization',
+  Promise.resolve(false),
+)
+export const deleteObjects = UnavailableFnFromModule(
+  'deleteObjects',
+  Promise.resolve(0),
+)
+export const subscribeToChanges = UnavailableFnFromModule(
+  'subscribeToChanges',
+  'dummy-query-uuid',
+) // Mocking the observer query UUID
+export const isProtectedDataAvailable = UnavailableFnFromModule(
+  'isProtectedDataAvailable',
+  false,
+)
+export const isObjectTypeAvailable = UnavailableFnFromModule(
+  'isObjectTypeAvailable',
+  false,
+)
+export const isObjectTypeAvailableAsync = UnavailableFnFromModule(
+  'isObjectTypeAvailableAsync',
+  Promise.resolve(false),
+)
+export const areObjectTypesAvailable = UnavailableFnFromModule(
+  'areObjectTypesAvailable',
+  {},
+)
+export const areObjectTypesAvailableAsync = UnavailableFnFromModule(
+  'areObjectTypesAvailableAsync',
+  Promise.resolve({}),
+)
+
+// CharacteristicTypeModule functions
+export const getBiologicalSex = UnavailableFnFromModule(
+  'getBiologicalSex',
+  BiologicalSex.notSet,
+)
+export const getBloodType = UnavailableFnFromModule(
+  'getBloodType',
+  BloodType.notSet,
+)
+export const getDateOfBirth = UnavailableFnFromModule(
+  'getDateOfBirth',
+  new Date(0),
+) // Assuming string for date
+export const getFitzpatrickSkinType = UnavailableFnFromModule(
+  'getFitzpatrickSkinType',
+  FitzpatrickSkinType.notSet,
+)
+export const getWheelchairUse = UnavailableFnFromModule(
+  'getWheelchairUse',
+  WheelchairUse.notSet,
+)
+
+// QuantityTypeModule functions
+export const queryQuantitySamples = UnavailableFnFromModule(
+  'queryQuantitySamples',
+  Promise.resolve([]),
+)
+export const queryQuantitySamplesWithAnchor = UnavailableFnFromModule(
+  'queryQuantitySamplesWithAnchor',
+  Promise.resolve({
+    samples: [],
+    deletedSamples: [],
+    newAnchor: '',
+  }),
+)
+export const queryStatisticsForQuantity = UnavailableFnFromModule(
+  'queryStatisticsForQuantity',
+  Promise.resolve({}),
+)
+export const queryStatisticsCollectionForQuantity = UnavailableFnFromModule(
+  'queryStatisticsCollectionForQuantity',
+  Promise.resolve([]),
+)
+export const saveQuantitySample = UnavailableFnFromModule(
+  'saveQuantitySample',
+  Promise.resolve(false),
+)
+export const isQuantityCompatibleWithUnit = UnavailableFnFromModule(
+  'isQuantityCompatibleWithUnit',
+  false,
+)
+
+// CategoryTypeModule functions
+export function queryCategorySamples<T extends CategoryTypeIdentifier>(
+  categoryTypeIdentifier: T,
+): Promise<CategorySampleTyped<T>[]> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve([])
+}
+
+export function queryCategorySamplesWithAnchor<
+  T extends CategoryTypeIdentifier,
+>(
+  categoryTypeIdentifier: T,
+): Promise<CategorySamplesWithAnchorResponseTyped<T>> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve({
+    samples: [],
+    deletedSamples: [],
+    newAnchor: '',
+  })
+}
+export const saveCategorySample = UnavailableFnFromModule(
+  'saveCategorySample',
+  Promise.resolve(false),
+)
+
+// CorrelationTypeModule functions
+export const queryCorrelationSamples = UnavailableFnFromModule(
+  'queryCorrelationSamples',
+  Promise.resolve([]),
+)
+export const saveCorrelationSample = UnavailableFnFromModule(
+  'saveCorrelationSample',
+  Promise.resolve(false),
+)
+
+// HeartbeatSeriesModule functions
+export const queryHeartbeatSeriesSamples = UnavailableFnFromModule(
+  'queryHeartbeatSeriesSamples',
+  Promise.resolve([]),
+)
+export const queryHeartbeatSeriesSamplesWithAnchor = UnavailableFnFromModule(
+  'queryHeartbeatSeriesSamplesWithAnchor',
+  Promise.resolve({
+    samples: [],
+    deletedSamples: [],
+    newAnchor: '',
+  }),
+)
+
+// WorkoutsModule functions
+export const queryWorkoutSamples = UnavailableFnFromModule(
+  'queryWorkoutSamples',
+  Promise.resolve([]),
+)
+export const queryWorkoutSamplesWithAnchor = UnavailableFnFromModule(
+  'queryWorkoutSamplesWithAnchor',
+  Promise.resolve({
+    workouts: [],
+    deletedSamples: [],
+    newAnchor: '',
+  }),
+)
+export const saveWorkoutSample = UnavailableFnFromModule(
+  'saveWorkoutSample',
+  Promise.resolve(''),
+)
+export const startWatchApp = UnavailableFnFromModule(
+  'startWatchApp',
+  Promise.resolve(false),
+)
+
+// StateOfMindModule functions
+export const queryStateOfMindSamples = UnavailableFnFromModule(
+  'queryStateOfMindSamples',
+  Promise.resolve([]),
+)
+export const saveStateOfMindSample = UnavailableFnFromModule(
+  'saveStateOfMindSample',
+  Promise.resolve(false),
+)
+
+// Utility functions (from original export list)
+export function getMostRecentCategorySample<T extends CategoryTypeIdentifier>(
+  identifier: T,
+): Promise<CategorySampleTyped<T> | undefined> {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return Promise.resolve(undefined)
+}
+
+export const getMostRecentQuantitySample = UnavailableFnFromModule(
+  'getMostRecentQuantitySample',
+  Promise.resolve(undefined),
+)
+export const getMostRecentWorkout = UnavailableFnFromModule(
+  'getMostRecentWorkout',
+  Promise.resolve(undefined),
+)
+export const getPreferredUnit = UnavailableFnFromModule(
+  'getPreferredUnit',
+  Promise.resolve('count'),
+) // Defaulting to 'count'
+
+// Hooks (from original export list)
+export function useMostRecentCategorySample<T extends CategoryTypeIdentifier>(
+  categoryTypeIdentifier: T,
+): CategorySampleTyped<T> | undefined {
+  if (Platform.OS !== 'ios' && !hasWarned) {
+    console.warn(notAvailableError)
+    hasWarned = true
+  }
+  return undefined
+}
+
+export const useMostRecentQuantitySample = UnavailableFnFromModule(
+  'useMostRecentQuantitySample',
+  undefined,
+)
+export const useMostRecentWorkout = UnavailableFnFromModule(
+  'useMostRecentWorkout',
+  undefined,
+)
+export const useSubscribeToChanges = UnavailableFnFromModule(
+  'useSubscribeToChanges',
+  undefined,
+) // Mocking callback structure
+export const useHealthkitAuthorization = UnavailableFnFromModule(
+  'useHealthkitAuthorization',
+  [
+    AuthorizationRequestStatus.unknown,
+    () => Promise.resolve(AuthorizationRequestStatus.unknown),
+  ] as const,
+)
+export const useIsHealthDataAvailable = UnavailableFnFromModule(
+  'useIsHealthDataAvailable',
+  false,
+)
+export const useSources = UnavailableFnFromModule('useSources', null)
+export const useStatisticsForQuantity = UnavailableFnFromModule(
+  'useStatisticsForQuantity',
+  null,
+)
+
+export const getBiologicalSexAsync = UnavailableFnFromModule(
+  'getBiologicalSexAsync',
+  Promise.resolve(BiologicalSex.notSet),
+)
+export const getBloodTypeAsync = UnavailableFnFromModule(
+  'getBloodTypeAsync',
+  Promise.resolve(BloodType.notSet),
+)
+export const getDateOfBirthAsync = UnavailableFnFromModule(
+  'getDateOfBirthAsync',
+  Promise.resolve(new Date(0)),
+) // Assuming string for date
+export const getFitzpatrickSkinTypeAsync = UnavailableFnFromModule(
+  'getFitzpatrickSkinTypeAsync',
+  Promise.resolve(FitzpatrickSkinType.notSet),
+)
+export const getWheelchairUseAsync = UnavailableFnFromModule(
+  'getWheelchairUseAsync',
+  Promise.resolve(WheelchairUse.notSet),
+)
+
+export const unsubscribeQueries = UnavailableFnFromModule(
+  'unsubscribeQueries',
+  0,
+)
+
+// --- Default Export ---
+// This attempts to match the structure of the default export from index.ios.ts
+const HealthkitModule = {
+  // All named exports are also part of the default export object
+  authorizationStatusFor,
+  isObjectTypeAvailable,
+  unsubscribeQueries,
+  isObjectTypeAvailableAsync,
+  areObjectTypesAvailable,
+  areObjectTypesAvailableAsync,
+  isQuantityCompatibleWithUnit,
+  disableAllBackgroundDelivery,
+  disableBackgroundDelivery,
+  enableBackgroundDelivery,
+  getBiologicalSex,
+  getBloodType,
+  getDateOfBirth,
+  getFitzpatrickSkinType,
+  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,
+  startWatchApp,
+  isProtectedDataAvailable,
+  queryStateOfMindSamples,
+  saveStateOfMindSample,
+
+  // Hooks
+  useMostRecentCategorySample,
+  useMostRecentQuantitySample,
+  useMostRecentWorkout,
+  useSubscribeToChanges,
+  useHealthkitAuthorization,
+  useIsHealthDataAvailable,
+  useSources,
+  useStatisticsForQuantity,
+  getBiologicalSexAsync,
+  getBloodTypeAsync,
+  getDateOfBirthAsync,
+  getFitzpatrickSkinTypeAsync,
+  getWheelchairUseAsync,
+} as Omit<typeof ReactNativeHealthkit, 'default'>
+
+export default {
+  ...HealthkitModule,
+  default: HealthkitModule,
+} as typeof ReactNativeHealthkit

package/src/modules.ts

@@ -0,0 +1,43 @@
+import { NitroModules } from 'react-native-nitro-modules'
+import type {
+  CategoryTypeModule,
+  CategoryTypeModuleTyped,
+} from './specs/CategoryTypeModule.nitro'
+import type { CharacteristicTypeModule } from './specs/CharacteristicTypeModule.nitro'
+import type { CoreModule } from './specs/CoreModule.nitro'
+import type { CorrelationTypeModule } from './specs/CorrelationTypeModule.nitro'
+import type { HeartbeatSeriesModule } from './specs/HeartbeatSeriesModule.nitro'
+import type { QuantityTypeModule } from './specs/QuantityTypeModule.nitro'
+import type { StateOfMindModule } from './specs/StateOfMindModule.nitro'
+import type { WorkoutsModule } from './specs/WorkoutsModule.nitro'
+
+export const Core = NitroModules.createHybridObject<CoreModule>('CoreModule')
+
+export const Workouts =
+  NitroModules.createHybridObject<WorkoutsModule>('WorkoutsModule')
+
+export const Characteristics =
+  NitroModules.createHybridObject<CharacteristicTypeModule>(
+    'CharacteristicTypeModule',
+  )
+
+export const QuantityTypes =
+  NitroModules.createHybridObject<QuantityTypeModule>('QuantityTypeModule')
+
+export const CategoryTypes =
+  NitroModules.createHybridObject<CategoryTypeModule>(
+    'CategoryTypeModule',
+  ) as CategoryTypeModuleTyped
+
+export const CorrelationTypes =
+  NitroModules.createHybridObject<CorrelationTypeModule>(
+    'CorrelationTypeModule',
+  )
+
+export const HeartbeatSeries =
+  NitroModules.createHybridObject<HeartbeatSeriesModule>(
+    'HeartbeatSeriesModule',
+  )
+
+export const StateOfMind =
+  NitroModules.createHybridObject<StateOfMindModule>('StateOfMindModule')

package/src/specs/CategoryTypeModule.nitro.ts

@@ -0,0 +1,64 @@
+import type { AnyMap, HybridObject } from 'react-native-nitro-modules'
+
+import type {
+  CategorySample,
+  CategorySampleTyped,
+  CategorySamplesWithAnchorResponse,
+  CategorySamplesWithAnchorResponseTyped,
+  CategoryValueForIdentifier,
+  MetadataForCategoryIdentifier,
+} from '../types/CategoryType'
+import type { CategoryTypeIdentifier } from '../types/CategoryTypeIdentifier'
+import type { InterfaceAssertion } from '../types/InterfaceVerification'
+import type {
+  QueryOptionsWithAnchor,
+  QueryOptionsWithSortOrder,
+} from '../types/QueryOptions'
+
+export interface CategoryTypeModule extends HybridObject<{ ios: 'swift' }> {
+  saveCategorySample(
+    identifier: CategoryTypeIdentifier,
+    value: CategoryValueForIdentifier,
+    startDate: Date,
+    endDate: Date,
+    metadata: AnyMap,
+  ): Promise<boolean>
+
+  queryCategorySamples(
+    identifier: CategoryTypeIdentifier,
+    options?: QueryOptionsWithSortOrder,
+  ): Promise<readonly CategorySample[]>
+
+  queryCategorySamplesWithAnchor(
+    identifier: CategoryTypeIdentifier,
+    options: QueryOptionsWithAnchor,
+  ): Promise<CategorySamplesWithAnchorResponse>
+}
+
+// Interface verification to ensure CategoryTypeModule and CategoryTypeModuleTyped stay in sync
+// This will cause a TypeScript compilation error if the interfaces have different method names or parameter counts
+const _interfaceVerification: InterfaceAssertion<
+  CategoryTypeModule,
+  CategoryTypeModuleTyped,
+  keyof HybridObject
+> = true
+
+export interface CategoryTypeModuleTyped {
+  saveCategorySample<T extends CategoryTypeIdentifier>(
+    identifier: T,
+    value: CategoryValueForIdentifier,
+    startDate: Date,
+    endDate: Date,
+    metadata: MetadataForCategoryIdentifier<T>,
+  ): Promise<boolean>
+
+  queryCategorySamples<T extends CategoryTypeIdentifier>(
+    identifier: T,
+    options?: QueryOptionsWithSortOrder,
+  ): Promise<readonly CategorySampleTyped<T>[]>
+
+  queryCategorySamplesWithAnchor<T extends CategoryTypeIdentifier>(
+    identifier: T,
+    options: QueryOptionsWithAnchor,
+  ): Promise<CategorySamplesWithAnchorResponseTyped<T>>
+}

package/src/specs/CharacteristicTypeModule.nitro.ts

@@ -0,0 +1,22 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+import type {
+  BiologicalSex,
+  BloodType,
+  FitzpatrickSkinType,
+  WheelchairUse,
+} from '../types/Characteristics'
+
+export interface CharacteristicTypeModule
+  extends HybridObject<{ ios: 'swift' }> {
+  getBloodType(): BloodType
+  getDateOfBirth(): Date
+  getBiologicalSex(): BiologicalSex
+  getFitzpatrickSkinType(): FitzpatrickSkinType
+  getWheelchairUse(): WheelchairUse
+
+  getBloodTypeAsync(): Promise<BloodType>
+  getDateOfBirthAsync(): Promise<Date>
+  getBiologicalSexAsync(): Promise<BiologicalSex>
+  getFitzpatrickSkinTypeAsync(): Promise<FitzpatrickSkinType>
+  getWheelchairUseAsync(): Promise<WheelchairUse>
+}

package/src/specs/CoreModule.nitro.ts

@@ -0,0 +1,107 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+import type {
+  AuthorizationRequestStatus,
+  AuthorizationStatus,
+} from '../types/Auth'
+import type { UpdateFrequency } from '../types/Background'
+import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier'
+import type { FilterForSamples } from '../types/QueryOptions'
+import type {
+  ObjectTypeIdentifier,
+  SampleTypeIdentifier,
+  SampleTypeIdentifierWriteable,
+} from '../types/Shared'
+import type { OnChangeCallbackArgs } from '../types/Subscriptons'
+import type { IdentifierWithUnit } from '../types/Units'
+import type { SourceProxy } from './SourceProxy.nitro'
+
+export interface CoreModule extends HybridObject<{ ios: 'swift' }> {
+  /**
+   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614175-enablebackgrounddelivery Apple Docs }
+   */
+  enableBackgroundDelivery(
+    typeIdentifier: ObjectTypeIdentifier,
+    updateFrequency: UpdateFrequency,
+  ): Promise<boolean>
+  /**
+   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614177-disablebackgrounddelivery Apple Docs }
+   */
+  disableBackgroundDelivery(
+    typeIdentifier: ObjectTypeIdentifier,
+  ): Promise<boolean>
+  /**
+   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614158-disableallbackgrounddelivery Apple Docs }
+   */
+  disableAllBackgroundDelivery(): Promise<boolean>
+
+  /**
+   *  @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614180-ishealthdataavailable Apple Docs }
+   */
+  isHealthDataAvailable(): boolean
+  isHealthDataAvailableAsync(): Promise<boolean>
+
+  isProtectedDataAvailable(): boolean
+  isProtectedDataAvailableAsync(): Promise<boolean>
+
+  getPreferredUnits(
+    identifiers: readonly QuantityTypeIdentifier[],
+    forceUpdate?: boolean,
+  ): Promise<IdentifierWithUnit[]>
+
+  querySources(
+    identifier: SampleTypeIdentifier,
+  ): Promise<readonly SourceProxy[]>
+
+  /** @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614180-requestauthorizationtoaccess Apple Docs }
+   * @param {SampleTypeIdentifier} typeIdentifier - The type identifier of the sample to request authorization for.
+   * @param {(args: OnChangeCallbackArgs) => void} callback - An array of type identifiers that the app wants to write.
+   * @returns A promise that resolves to a boolean indicating whether the authorization was successful.*/
+  subscribeToObserverQuery(
+    typeIdentifier: SampleTypeIdentifier,
+    callback: (args: OnChangeCallbackArgs) => void,
+  ): string
+
+  unsubscribeQuery(queryId: string): boolean
+  unsubscribeQueryAsync(queryId: string): Promise<boolean>
+
+  unsubscribeQueries(queryIds: string[]): number
+  unsubscribeQueriesAsync(queryIds: string[]): Promise<number>
+
+  /**
+   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614154-authorizationstatus Apple Docs }
+   */
+  authorizationStatusFor(type: ObjectTypeIdentifier): AuthorizationStatus
+  /**
+   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/2994346-getrequeststatusforauthorization Apple Docs }
+   */
+  getRequestStatusForAuthorization(
+    toShare: SampleTypeIdentifierWriteable[],
+    toRead: ObjectTypeIdentifier[],
+  ): Promise<AuthorizationRequestStatus>
+  /**
+   * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs }
+   */
+  requestAuthorization(
+    toShare: SampleTypeIdentifierWriteable[],
+    toRead: ObjectTypeIdentifier[],
+  ): Promise<boolean>
+
+  deleteObjects(
+    objectTypeIdentifier: ObjectTypeIdentifier,
+    filter: FilterForSamples,
+  ): Promise<number>
+
+  isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier): boolean
+
+  areObjectTypesAvailable(
+    objectTypeIdentifiers: ObjectTypeIdentifier[],
+  ): Record<string, boolean>
+
+  areObjectTypesAvailableAsync(
+    objectTypeIdentifiers: ObjectTypeIdentifier[],
+  ): Promise<Record<string, boolean>>
+
+  isObjectTypeAvailableAsync(
+    objectTypeIdentifier: ObjectTypeIdentifier,
+  ): Promise<boolean>
+}

package/src/specs/CorrelationTypeModule.nitro.ts

@@ -0,0 +1,23 @@
+import type { AnyMap, HybridObject } from 'react-native-nitro-modules'
+
+import type {
+  CorrelationSample,
+  CorrelationTypeIdentifier,
+  SampleForSaving,
+} from '../types/CorrelationType'
+
+export interface CorrelationTypeModule extends HybridObject<{ ios: 'swift' }> {
+  saveCorrelationSample(
+    typeIdentifier: CorrelationTypeIdentifier,
+    samples: SampleForSaving[],
+    start: Date,
+    end: Date,
+    metadata: AnyMap,
+  ): Promise<boolean>
+
+  queryCorrelationSamples(
+    typeIdentifier: CorrelationTypeIdentifier,
+    from: Date,
+    to: Date,
+  ): Promise<readonly CorrelationSample[]>
+}