@kingstinct/react-native-healthkit 4.4.6 → 5.0.0

package/src/types.ts

@@ -1,34 +1,22 @@
 import type {
-  HealthkitReadAuthorization,
-  HealthkitWriteAuthorization,
-  HKAuthorizationRequestStatus,
-  HKBiologicalSex,
-  HKBloodType,
+  EnergyUnit,
   HKCategorySampleRaw,
   HKCategoryTypeIdentifier,
-  HKCategoryValueForIdentifier,
   HKCorrelationRaw,
   HKCorrelationTypeIdentifier,
-  HKFitzpatrickSkinType,
-  HKQuantitySampleRaw,
+  HKDevice,
   HKQuantityTypeIdentifier,
-  HKSampleTypeIdentifier,
-  HKStatisticsOptions,
+  HKSourceRevision,
   HKUnit,
-  HKUnitSI,
-  HKUnitSIPrefix,
-  HKUpdateFrequency,
-  HKWheelchairUse,
-  HKWorkoutActivityType,
-  HKWorkoutMetadata,
   HKWorkoutRaw,
-  MetadataMapperForCategoryIdentifier,
-  MetadataMapperForCorrelationIdentifier,
+  LengthUnit,
   MetadataMapperForQuantityIdentifier,
   QueryStatisticsResponseRaw,
-  WorkoutRoute,
+  UnitForIdentifier,
 } from './native-types'
 
+export * from './native-types'
+
 export interface QueryWorkoutsOptions<
   TEnergy extends HKUnit,
   TDistance extends HKUnit
@@ -52,8 +40,8 @@ export type GenericQueryOptions = {
 };
 
 export interface HKWorkout<
-  TEnergy extends HKUnit = HKUnit,
-  TDistance extends HKUnit = HKUnit
+  TEnergy extends EnergyUnit = EnergyUnit,
+  TDistance extends LengthUnit = LengthUnit
 > extends Omit<HKWorkoutRaw<TEnergy, TDistance>, 'endDate' | 'startDate'> {
   readonly startDate: Date;
   readonly endDate: Date;
@@ -61,25 +49,27 @@ export interface HKWorkout<
 
 export interface HKQuantitySample<
   TIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier,
-  TUnit extends HKUnit = HKUnit
-> extends Omit<
-  HKQuantitySampleRaw<TIdentifier, TUnit>,
-  'endDate' | 'startDate'
-  > {
+  TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>
+> {
+  readonly uuid: string;
+  readonly device?: HKDevice;
+  readonly quantityType: TIdentifier;
+  readonly quantity: number;
+  readonly unit: TUnit;
+  readonly metadata?: MetadataMapperForQuantityIdentifier<TIdentifier>;
+  readonly sourceRevision?: HKSourceRevision;
   readonly startDate: Date;
   readonly endDate: Date;
 }
 
-export interface QueryStatisticsResponse<T extends HKUnit = HKUnit>
+export interface QueryStatisticsResponse<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>>
   extends Omit<
-  QueryStatisticsResponseRaw<T>,
+  QueryStatisticsResponseRaw<TIdentifier, TUnit>,
   'mostRecentQuantityDateInterval'
   > {
   readonly mostRecentQuantityDateInterval?: { readonly from: Date; readonly to: Date };
 }
-
-type UnsubscribeFunction = () => Promise<boolean>;
-
+/*
 export type IsHealthDataAvailableFn = () => Promise<boolean>;
 
 export type GetBloodTypeFn = () => Promise<HKBloodType>;
@@ -89,21 +79,6 @@ export type GetBiologicalSexFn = () => Promise<HKBiologicalSex>;
 export type GetWheelchairUseFn = () => Promise<HKWheelchairUse>;
 export type GetFitzpatrickSkinTypeFn = () => Promise<HKFitzpatrickSkinType>;
 
-export type QueryStatisticsForQuantityFn = <TUnit extends HKUnit>(
-  identifier: HKQuantityTypeIdentifier,
-  options: readonly HKStatisticsOptions[],
-  from: Date,
-  to?: Date,
-  unit?: TUnit
-) => Promise<QueryStatisticsResponse<TUnit>>;
-
-export type QueryWorkoutsFn = <
-  TEnergy extends HKUnit,
-  TDistance extends HKUnit
->(
-  options: QueryWorkoutsOptions<TEnergy, TDistance>
-) => Promise<readonly HKWorkout<TEnergy, TDistance>[]>;
-
 export type AuthorizationStatusForFn = (
   type: HealthkitReadAuthorization
 ) => Promise<boolean>;
@@ -123,30 +98,29 @@ export type RequestAuthorizationFn = (
   write?: readonly HealthkitWriteAuthorization[]
 ) => Promise<boolean>;
 
-export type SaveQuantitySampleFn = <TUnit extends HKQuantityTypeIdentifier>(
-  identifier: TUnit,
-  unit: HKUnit,
+export type SaveQuantitySampleFn = <TType extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TType>>(
+  identifier: TType,
+  unit: TUnit,
   value: number,
   options?: {
     readonly start?: Date;
     readonly end?: Date;
-    readonly metadata?: MetadataMapperForQuantityIdentifier<TUnit>;
+    readonly metadata?: MetadataMapperForQuantityIdentifier<TType>;
   }
 ) => Promise<boolean>;
 
 export type QueryQuantitySamplesFn = <
   TIdentifier extends HKQuantityTypeIdentifier,
-  TUnit extends HKUnit = HKUnit
+  TUnit extends UnitForIdentifier<TIdentifier>
 >(
   identifier: TIdentifier,
   options: GenericQueryOptions & { readonly unit?: TUnit }
-) => Promise<readonly HKQuantitySample<TIdentifier, TUnit>[]>;
+) => Promise<readonly HKQuantitySample<TIdentifier>[]>; */
 
-export type SubscribeToChangesFn = (
-  identifier: HKSampleTypeIdentifier,
-  callback: () => void
-) => Promise<UnsubscribeFunction>;
+export type HKCategorySampleForSaving =Omit<HKCategorySample, 'device' | 'endDate' | 'startDate' | 'uuid'>
 
+export type HKQuantitySampleForSaving =Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>
+/*
 export type SaveCategorySampleFn = <T extends HKCategoryTypeIdentifier>(
   identifier: T,
   value: HKCategoryValueForIdentifier<T>,
@@ -157,12 +131,6 @@ export type SaveCategorySampleFn = <T extends HKCategoryTypeIdentifier>(
   }
 ) => Promise<boolean>;
 
-export type GetMostRecentCategorySampleFn = <
-  T extends HKCategoryTypeIdentifier
->(
-  identifier: T
-) => Promise<HKCategorySample<T> | null>;
-
 export type MostRecentCategorySampleHook = <T extends HKCategoryTypeIdentifier>(
   identifier: T
 ) => HKCategorySample<T> | null;
@@ -173,35 +141,17 @@ export type MostRecentCorrelationSampleHook = <
   identifer: T
 ) => HKCorrelation<T> | null;
 
-export type GetMostRecentQuantitySampleFn = <
-  TIdentifier extends HKQuantityTypeIdentifier,
-  TUnit extends HKUnit
->(
-  identifier: TIdentifier,
-  unit?: TUnit
-) => Promise<HKQuantitySample<TIdentifier, TUnit> | null>;
-
 export type MostRecentQuantitySampleHook = <
   TIdentifier extends HKQuantityTypeIdentifier,
-  TUnit extends HKUnit
+  TUnit extends UnitForIdentifier<TIdentifier>
 >(
   identifier: TIdentifier,
   unit?: TUnit
-) => HKQuantitySample<TIdentifier, TUnit> | null;
-
-export type GetMostRecentWorkoutFn = <
-  TEnergy extends HKUnit,
-  TDistance extends HKUnit
->(
-  options?: Pick<
-  QueryWorkoutsOptions<TEnergy, TDistance>,
-  'distanceUnit' | 'energyUnit'
-  >
-) => Promise<HKWorkout<TEnergy, TDistance> | null>;
+) => HKQuantitySample<TIdentifier> | null;
 
 export type MostRecentWorkoutHook = <
-  TEnergy extends HKUnit,
-  TDistance extends HKUnit
+  TEnergy extends EnergyUnit,
+  TDistance extends LengthUnit
 >(
   options?: Pick<
   QueryWorkoutsOptions<TEnergy, TDistance>,
@@ -223,7 +173,7 @@ export type SaveCorrelationSampleFn = <
   typeIdentifier: TIdentifier,
   samples: readonly (
     | Omit<HKCategorySample, 'device' | 'endDate' | 'startDate' | 'uuid'>
-    | Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>
+    | Omit<HKQuantitySample<HKQuantityTypeIdentifier>, 'device' | 'endDate' | 'startDate' | 'uuid'>
   )[],
   options?: {
     readonly start?: Date;
@@ -232,10 +182,10 @@ export type SaveCorrelationSampleFn = <
   }
 ) => Promise<boolean>;
 
-export type SaveWorkoutSampleFn = (
-  typeIdentifier: HKWorkoutActivityType,
+export type SaveWorkoutSampleFn<TIdentifier extends HKWorkoutActivityType, TQIdentifier extends HKQuantityTypeIdentifier> = (
+  typeIdentifier: TIdentifier,
   quantities: readonly Omit<
-  HKQuantitySample,
+  HKQuantitySample<TQIdentifier>,
   'device' | 'endDate' | 'startDate' | 'uuid'
   >[],
   start: Date,
@@ -244,7 +194,7 @@ export type SaveWorkoutSampleFn = (
     readonly metadata?: HKWorkoutMetadata;
   }
 ) => Promise<boolean>;
-
+*/
 export interface HKCorrelation<TIdentifier extends HKCorrelationTypeIdentifier>
   extends Omit<
   HKCorrelationRaw<TIdentifier>,
@@ -254,14 +204,7 @@ export interface HKCorrelation<TIdentifier extends HKCorrelationTypeIdentifier>
   readonly startDate: Date;
   readonly endDate: Date;
 }
-
-export type QueryCorrelationSamplesFn = <
-  TIdentifier extends HKCorrelationTypeIdentifier
->(
-  typeIdentifier: TIdentifier,
-  options: Omit<GenericQueryOptions, 'ascending' | 'limit'>
-) => Promise<readonly HKCorrelation<TIdentifier>[]>;
-
+/*
 export type SubscribeToChangesHook = <
   TIdentifier extends HKSampleTypeIdentifier
 >(
@@ -273,58 +216,4 @@ export type SubscribeToChangesHook = <
 export type GetWorkoutRoutesFn = (
   workoutUUID: string
 ) => Promise<readonly WorkoutRoute[]>;
-
-export type ReactNativeHealthkit = {
-  readonly authorizationStatusFor: AuthorizationStatusForFn;
-
-  readonly getBiologicalSex: GetBiologicalSexFn;
-  readonly getBloodType: GetBloodTypeFn;
-  readonly getDateOfBirth: GetDateOfBirthFn;
-  readonly getFitzpatrickSkinType: GetFitzpatrickSkinTypeFn;
-  readonly getMostRecentQuantitySample: GetMostRecentQuantitySampleFn;
-  readonly getMostRecentCategorySample: GetMostRecentCategorySampleFn;
-  readonly getMostRecentWorkout: GetMostRecentWorkoutFn;
-  readonly getPreferredUnit: GetPreferredUnitFn;
-  readonly getPreferredUnits: GetPreferredUnitsFn;
-  readonly getRequestStatusForAuthorization: GetRequestStatusForAuthorizationFn;
-  readonly getWheelchairUse: GetWheelchairUseFn;
-  readonly getWorkoutRoutes: GetWorkoutRoutesFn;
-
-  readonly buildUnitWithPrefix: (prefix: HKUnitSIPrefix, unit: HKUnitSI) => HKUnit;
-
-  readonly isHealthDataAvailable: IsHealthDataAvailableFn;
-
-  readonly queryCategorySamples: QueryCategorySamplesFn;
-  readonly queryQuantitySamples: QueryQuantitySamplesFn;
-  readonly queryStatisticsForQuantity: QueryStatisticsForQuantityFn;
-  readonly queryWorkouts: QueryWorkoutsFn;
-  readonly queryCorrelationSamples: QueryCorrelationSamplesFn;
-
-  readonly requestAuthorization: RequestAuthorizationFn;
-
-  readonly saveCategorySample: SaveCategorySampleFn;
-  readonly saveQuantitySample: SaveQuantitySampleFn;
-  readonly saveCorrelationSample: SaveCorrelationSampleFn;
-  readonly saveWorkoutSample: SaveWorkoutSampleFn;
-  readonly enableBackgroundDelivery: (
-    typeIdentifier: HKSampleTypeIdentifier,
-    updateFrequency: HKUpdateFrequency
-  ) => Promise<boolean>;
-  readonly disableBackgroundDelivery: (
-    typeIdentifier: HKSampleTypeIdentifier
-  ) => Promise<boolean>;
-  readonly disableAllBackgroundDelivery: () => Promise<boolean>;
-
-  readonly subscribeToChanges: SubscribeToChangesFn;
-
-  readonly useMostRecentWorkout: MostRecentWorkoutHook;
-  readonly useMostRecentCategorySample: MostRecentCategorySampleHook;
-  readonly useMostRecentQuantitySample: MostRecentQuantitySampleHook;
-
-  readonly useSubscribeToChanges: SubscribeToChangesHook;
-  readonly useIsHealthDataAvailable: () => boolean | null;
-  readonly useHealthkitAuthorization: (
-    read: readonly HealthkitReadAuthorization[],
-    write?: readonly HealthkitWriteAuthorization[],
-  ) => readonly [authorizationStatus: HKAuthorizationRequestStatus | null, request: () => Promise<HKAuthorizationRequestStatus | null>];
-};
+*/

package/src/utils/deserializeCategorySample.ts

@@ -0,0 +1,12 @@
+import type { HKCategorySampleRaw, HKCategoryTypeIdentifier } from '../native-types'
+import type { HKCategorySample } from '../types'
+
+const deserializCategorySample = <T extends HKCategoryTypeIdentifier>(
+  sample: HKCategorySampleRaw<T>,
+): HKCategorySample<T> => ({
+  ...sample,
+  startDate: new Date(sample.startDate),
+  endDate: new Date(sample.endDate),
+})
+
+export default deserializCategorySample

package/src/utils/deserializeCorrelation.ts

@@ -0,0 +1,28 @@
+import deserializCategorySample from './deserializeCategorySample'
+import deserializeSample from './deserializeSample'
+
+import type {
+  HKCategorySampleRaw, HKCorrelationRaw, HKCorrelationTypeIdentifier, HKQuantitySampleRaw, HKQuantityTypeIdentifier,
+} from '../native-types'
+import type { HKCorrelation } from '../types'
+
+function deserializeCorrelation<
+  TIdentifier extends HKCorrelationTypeIdentifier
+>(s: HKCorrelationRaw<TIdentifier>): HKCorrelation<TIdentifier> {
+  return {
+    ...s,
+    objects: s.objects.map((o) => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+      if (o.quantity !== undefined) {
+        return deserializeSample(o as HKQuantitySampleRaw<HKQuantityTypeIdentifier>)
+      }
+
+      return deserializCategorySample(o as HKCategorySampleRaw)
+    }),
+    endDate: new Date(s.endDate),
+    startDate: new Date(s.startDate),
+  }
+}
+
+export default deserializeCorrelation

package/src/utils/deserializeSample.ts

@@ -0,0 +1,17 @@
+import type { HKQuantitySampleRaw, HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types'
+import type { HKQuantitySample } from '../types'
+
+function deserializeSample<
+  TIdentifier extends HKQuantityTypeIdentifier,
+  TUnit extends UnitForIdentifier<TIdentifier>
+>(
+  sample: HKQuantitySampleRaw<TIdentifier, TUnit>,
+): HKQuantitySample<TIdentifier, TUnit> {
+  return {
+    ...sample,
+    startDate: new Date(sample.startDate),
+    endDate: new Date(sample.endDate),
+  }
+}
+
+export default deserializeSample

package/src/utils/deserializeWorkout.ts

@@ -0,0 +1,14 @@
+import type { EnergyUnit, HKWorkoutRaw, LengthUnit } from '../native-types'
+import type { HKWorkout } from '../types'
+
+function deserializeWorkout<TEnergy extends EnergyUnit, TDistance extends LengthUnit>(
+  sample: HKWorkoutRaw<TEnergy, TDistance>,
+): HKWorkout<TEnergy, TDistance> {
+  return {
+    ...sample,
+    startDate: new Date(sample.startDate),
+    endDate: new Date(sample.endDate),
+  }
+}
+
+export default deserializeWorkout

package/src/utils/ensureMetadata.ts

@@ -0,0 +1,5 @@
+function ensureMetadata<TMetadata>(metadata?: TMetadata) {
+  return metadata || ({} as TMetadata)
+}
+
+export default ensureMetadata

package/src/utils/ensureUnit.ts

@@ -0,0 +1,19 @@
+import Native from '../native-types'
+
+import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types'
+
+const ensureUnit = async <
+  TIdentifier extends HKQuantityTypeIdentifier,
+  TUnit extends UnitForIdentifier<TIdentifier>
+>(
+  type: TIdentifier,
+  providedUnit?: TUnit,
+) => {
+  if (providedUnit) {
+    return providedUnit
+  }
+  const unit = await Native.getPreferredUnits([type])
+  return unit[type] as TUnit
+}
+
+export default ensureUnit

package/src/utils/getDateOfBirth.ts

@@ -0,0 +1,8 @@
+import Native from '../native-types'
+
+const getDateOfBirth = async () => {
+  const dateOfBirth = await Native.getDateOfBirth()
+  return new Date(dateOfBirth)
+}
+
+export default getDateOfBirth

package/src/utils/getMostRecentCategorySample.ts

@@ -0,0 +1,18 @@
+import queryCategorySamples from './queryCategorySamples'
+
+import type { HKCategoryTypeIdentifier } from '../native-types'
+
+async function getMostRecentCategorySample<
+  T extends HKCategoryTypeIdentifier
+>(
+  identifier: T,
+) {
+  const samples = await queryCategorySamples(identifier, {
+    limit: 1,
+    ascending: false,
+  })
+
+  return samples[0] || null
+}
+
+export default getMostRecentCategorySample

package/src/utils/getMostRecentQuantitySample.ts

@@ -0,0 +1,19 @@
+import queryQuantitySamples from './queryQuantitySamples'
+
+import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types'
+
+async function getMostRecentQuantitySample<
+  TIdentifier extends HKQuantityTypeIdentifier,
+  TUnit extends UnitForIdentifier<TIdentifier>
+>(
+  identifier: TIdentifier,
+  unit: TUnit,
+) {
+  const samples = await queryQuantitySamples(identifier, {
+    limit: 1,
+    unit,
+  })
+  return samples[0] || null
+}
+
+export default getMostRecentQuantitySample

package/src/utils/getMostRecentWorkout.ts

@@ -0,0 +1,27 @@
+import queryWorkouts from './queryWorkouts'
+
+import type { EnergyUnit, LengthUnit } from '../native-types'
+import type { HKWorkout, QueryWorkoutsOptions } from '../types'
+
+export type GetMostRecentWorkoutFn = <
+  TEnergy extends EnergyUnit,
+  TDistance extends LengthUnit
+>(
+  options?: Pick<
+  QueryWorkoutsOptions<TEnergy, TDistance>,
+  'distanceUnit' | 'energyUnit'
+  >
+) => Promise<HKWorkout<TEnergy, TDistance> | null>;
+
+const getMostRecentWorkout: GetMostRecentWorkoutFn = async (options) => {
+  const workouts = await queryWorkouts({
+    limit: 1,
+    ascending: false,
+    energyUnit: options?.energyUnit,
+    distanceUnit: options?.distanceUnit,
+  })
+
+  return workouts[0] || null
+}
+
+export default getMostRecentWorkout

package/src/utils/getPreferredUnit.ts

@@ -0,0 +1,14 @@
+import getPreferredUnits from './getPreferredUnits'
+
+import type { HKQuantityTypeIdentifier, HKUnit } from '../native-types'
+
+export type GetPreferredUnitFn = (
+  identifier: HKQuantityTypeIdentifier
+) => Promise<HKUnit>;
+
+const getPreferredUnit: GetPreferredUnitFn = async (type) => {
+  const [unit] = await getPreferredUnits([type])
+  return unit!
+}
+
+export default getPreferredUnit

package/src/utils/getPreferredUnits.ts

@@ -0,0 +1,14 @@
+import Native from '../native-types'
+
+import type { HKQuantityTypeIdentifier, HKUnit } from '../native-types'
+
+export type GetPreferredUnitsFn = (
+  identifiers: readonly HKQuantityTypeIdentifier[]
+) => Promise<readonly HKUnit[]>;
+
+const getPreferredUnits: GetPreferredUnitsFn = async (identifiers) => {
+  const units = await Native.getPreferredUnits(identifiers)
+  return identifiers.map((i) => units[i])
+}
+
+export default getPreferredUnits

package/src/utils/getPreferredUnitsTyped.ts

@@ -0,0 +1,38 @@
+import Native, { HKQuantityTypeIdentifier, UnitOfEnergy, UnitOfLength } from '../native-types'
+
+import type { HKUnit } from '../native-types'
+
+async function getPreferredUnitsTyped<
+  TEnergy extends HKUnit,
+  TDistance extends HKUnit
+>(options?: { readonly energyUnit?: TEnergy; readonly distanceUnit?: TDistance }) {
+  let energyUnit = options?.energyUnit
+  let distanceUnit = options?.distanceUnit
+
+  if (!energyUnit || !distanceUnit) {
+    const units = await Native.getPreferredUnits([
+      HKQuantityTypeIdentifier.distanceWalkingRunning,
+      HKQuantityTypeIdentifier.activeEnergyBurned,
+    ])
+    if (!energyUnit) {
+      energyUnit = units[HKQuantityTypeIdentifier.activeEnergyBurned] as
+      | TEnergy
+      | undefined
+    }
+    if (!distanceUnit) {
+      distanceUnit = units[HKQuantityTypeIdentifier.distanceWalkingRunning] as
+      | TDistance
+      | undefined
+    }
+  }
+
+  if (!energyUnit) {
+    energyUnit = UnitOfEnergy.Kilocalories as TEnergy
+  }
+  if (!distanceUnit) {
+    distanceUnit = UnitOfLength.Meter as TDistance
+  }
+  return { energyUnit, distanceUnit }
+}
+
+export default getPreferredUnitsTyped

package/src/utils/getRequestStatusForAuthorization.ts

@@ -0,0 +1,21 @@
+import Native from '../native-types'
+
+import type {
+  HealthkitReadAuthorization, HealthkitWriteAuthorization, ReadPermissions, WritePermissions,
+} from '../native-types'
+
+const getRequestStatusForAuthorization = async (
+  read: readonly HealthkitReadAuthorization[],
+  write: readonly HealthkitWriteAuthorization[] = [],
+) => {
+  const readPermissions = read.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as ReadPermissions)
+
+  const writePermissions = write.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as WritePermissions)
+
+  return Native.getRequestStatusForAuthorization(
+    writePermissions,
+    readPermissions,
+  )
+}
+
+export default getRequestStatusForAuthorization

package/src/utils/prepareOptions.ts

@@ -0,0 +1,15 @@
+import serializeDate from './serializeDate'
+
+import type { GenericQueryOptions } from '../types'
+
+const prepareOptions = (options: GenericQueryOptions) => {
+  const limit = !options.limit || options.limit === Infinity ? 0 : options.limit
+  const ascending = options.ascending ?? limit === 0
+  const from = serializeDate(options.from)
+  const to = serializeDate(options.to)
+  return {
+    limit, ascending, from, to,
+  }
+}
+
+export default prepareOptions

package/src/utils/queryCategorySamples.ts

@@ -0,0 +1,29 @@
+import Native from '../native-types'
+import deserializCategorySample from './deserializeCategorySample'
+import prepareOptions from './prepareOptions'
+
+import type { HKCategoryTypeIdentifier } from '../native-types'
+import type { GenericQueryOptions, HKCategorySample } from '../types'
+
+export type QueryCategorySamplesFn = <T extends HKCategoryTypeIdentifier>(
+  identifier: T,
+  options: GenericQueryOptions
+) => Promise<readonly HKCategorySample<T>[]>;
+
+const queryCategorySamples: QueryCategorySamplesFn = async (
+  identifier,
+  options,
+) => {
+  const opts = prepareOptions(options)
+  const results = await Native.queryCategorySamples(
+    identifier,
+    opts.from,
+    opts.to,
+    opts.limit,
+    opts.ascending,
+  )
+
+  return results.map(deserializCategorySample)
+}
+
+export default queryCategorySamples

package/src/utils/queryCorrelationSamples.ts

@@ -0,0 +1,29 @@
+import Native from '../native-types'
+import deserializeCorrelation from './deserializeCorrelation'
+import prepareOptions from './prepareOptions'
+
+import type { HKCorrelationTypeIdentifier } from '../native-types'
+import type { GenericQueryOptions, HKCorrelation } from '../types'
+
+export type QueryCorrelationSamplesFn = <
+  TIdentifier extends HKCorrelationTypeIdentifier
+>(
+  typeIdentifier: TIdentifier,
+  options: Omit<GenericQueryOptions, 'ascending' | 'limit'>
+) => Promise<readonly HKCorrelation<TIdentifier>[]>;
+
+const queryCorrelationSamples: QueryCorrelationSamplesFn = async (
+  typeIdentifier,
+  options,
+) => {
+  const opts = prepareOptions(options)
+  const correlations = await Native.queryCorrelationSamples(
+    typeIdentifier,
+    opts.from,
+    opts.to,
+  )
+
+  return correlations.map(deserializeCorrelation)
+}
+
+export default queryCorrelationSamples