@kingstinct/react-native-healthkit 4.4.6 → 5.0.0

package/lib/typescript/src/index.ios.d.ts

@@ -1,5 +1,50 @@
-import type { ReactNativeHealthkit } from './types';
-declare const Healthkit: ReactNativeHealthkit;
-export * from './native-types';
+import useMostRecentCategorySample from './hooks/useMostRecentCategorySample';
+import useMostRecentQuantitySample from './hooks/useMostRecentQuantitySample';
+import useMostRecentWorkout from './hooks/useMostRecentWorkout';
+import useSubscribeToChanges from './hooks/useSubscribeToChanges';
+import getMostRecentCategorySample from './utils/getMostRecentCategorySample';
+import getMostRecentQuantitySample from './utils/getMostRecentQuantitySample';
+import queryStatisticsForQuantity from './utils/queryStatisticsForQuantity';
+import queryWorkouts from './utils/queryWorkouts';
+import saveCategorySample from './utils/saveCategorySample';
+import saveCorrelationSample from './utils/saveCorrelationSample';
+import saveQuantitySample from './utils/saveQuantitySample';
+import saveWorkoutSample from './utils/saveWorkoutSample';
+declare const Healthkit: {
+    authorizationStatusFor: (type: import("./native-types").HealthkitReadAuthorization) => Promise<boolean>;
+    isHealthDataAvailable: () => Promise<boolean>;
+    disableAllBackgroundDelivery: () => Promise<boolean>;
+    disableBackgroundDelivery: (typeIdentifier: import("./native-types").HKSampleTypeIdentifier) => Promise<boolean>;
+    enableBackgroundDelivery: (typeIdentifier: import("./native-types").HKSampleTypeIdentifier, updateFrequency: import("./native-types").HKUpdateFrequency) => Promise<boolean>;
+    getBiologicalSex: () => Promise<import("./native-types").HKBiologicalSex>;
+    getFitzpatrickSkinType: () => Promise<import("./native-types").HKFitzpatrickSkinType>;
+    getWheelchairUse: () => Promise<import("./native-types").HKWheelchairUse>;
+    getBloodType: () => Promise<import("./native-types").HKBloodType>;
+    getWorkoutRoutes: (workoutUUID: string) => Promise<readonly import("./native-types").WorkoutRoute[]>;
+    getDateOfBirth: () => Promise<Date>;
+    getMostRecentQuantitySample: typeof getMostRecentQuantitySample;
+    getMostRecentCategorySample: typeof getMostRecentCategorySample;
+    getMostRecentWorkout: import("./utils/getMostRecentWorkout").GetMostRecentWorkoutFn;
+    getPreferredUnit: import("./utils/getPreferredUnit").GetPreferredUnitFn;
+    getPreferredUnits: import("./utils/getPreferredUnits").GetPreferredUnitsFn;
+    getRequestStatusForAuthorization: (read: readonly import("./native-types").HealthkitReadAuthorization[], write?: readonly import("./native-types").HKSampleTypeIdentifier[]) => Promise<import("./native-types").HKAuthorizationRequestStatus>;
+    queryCategorySamples: import("./utils/queryCategorySamples").QueryCategorySamplesFn;
+    queryCorrelationSamples: import("./utils/queryCorrelationSamples").QueryCorrelationSamplesFn;
+    queryQuantitySamples: import("./utils/queryQuantitySamples").QueryQuantitySamplesFn;
+    queryStatisticsForQuantity: typeof queryStatisticsForQuantity;
+    queryWorkouts: typeof queryWorkouts;
+    requestAuthorization: (read: readonly import("./native-types").HealthkitReadAuthorization[], write?: readonly import("./native-types").HKSampleTypeIdentifier[]) => Promise<boolean>;
+    saveCategorySample: typeof saveCategorySample;
+    saveCorrelationSample: typeof saveCorrelationSample;
+    saveQuantitySample: typeof saveQuantitySample;
+    saveWorkoutSample: typeof saveWorkoutSample;
+    subscribeToChanges: (identifier: import("./native-types").HKSampleTypeIdentifier, callback: () => void) => Promise<() => Promise<boolean>>;
+    useMostRecentCategorySample: typeof useMostRecentCategorySample;
+    useMostRecentQuantitySample: typeof useMostRecentQuantitySample;
+    useMostRecentWorkout: typeof useMostRecentWorkout;
+    useSubscribeToChanges: typeof useSubscribeToChanges;
+    useIsHealthDataAvailable: () => boolean | null;
+    useHealthkitAuthorization: (read: readonly import("./native-types").HealthkitReadAuthorization[], write?: readonly import("./native-types").HKSampleTypeIdentifier[] | undefined) => readonly [import("./native-types").HKAuthorizationRequestStatus | null, () => Promise<import("./native-types").HKAuthorizationRequestStatus>];
+};
 export * from './types';
 export default Healthkit;

package/lib/typescript/src/native-types.d.ts

@@ -317,9 +317,9 @@ declare enum HKIndoorWorkout {
 }
 export interface HKWorkoutMetadata extends HKGenericMetadata {
     readonly HKWeatherCondition?: HKWeatherCondition;
-    readonly HKWeatherHumidity?: HKQuantity<HKUnit.Percent>;
-    readonly HKAverageMETs?: HKQuantity<HKUnit>;
-    readonly HKElevationAscended?: HKQuantity<HKUnit.Meters>;
+    readonly HKWeatherHumidity?: HKQuantity<HKQuantityTypeIdentifier, HKUnits.Percent>;
+    readonly HKAverageMETs?: HKQuantity<HKQuantityTypeIdentifier, HKUnit>;
+    readonly HKElevationAscended?: HKQuantity<HKQuantityTypeIdentifier, LengthUnit>;
     readonly HKIndoorWorkout?: HKIndoorWorkout;
 }
 export declare enum HKAuthorizationRequestStatus {
@@ -332,8 +332,8 @@ export declare enum HKAuthorizationStatus {
     sharingDenied = 1,
     sharingAuthorized = 2
 }
-export declare type HKQuantity<T extends HKUnit = HKUnit> = {
-    readonly unit: T;
+export declare type HKQuantity<TIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>> = {
+    readonly unit: TUnit;
     readonly quantity: number;
 };
 export declare enum HKBloodType {
@@ -372,17 +372,17 @@ export declare enum HKStatisticsOptions {
     mostRecent = "mostRecent",
     separateBySource = "separateBySource"
 }
-export declare type QueryStatisticsResponseRaw<TUnit extends HKUnit = HKUnit> = {
-    readonly averageQuantity?: HKQuantity<TUnit>;
-    readonly maximumQuantity?: HKQuantity<TUnit>;
-    readonly minimumQuantity?: HKQuantity<TUnit>;
-    readonly sumQuantity?: HKQuantity<TUnit>;
-    readonly mostRecentQuantity?: HKQuantity<TUnit>;
+export declare type QueryStatisticsResponseRaw<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>> = {
+    readonly averageQuantity?: HKQuantity<TIdentifier, TUnit>;
+    readonly maximumQuantity?: HKQuantity<TIdentifier, TUnit>;
+    readonly minimumQuantity?: HKQuantity<TIdentifier, TUnit>;
+    readonly sumQuantity?: HKQuantity<TIdentifier, TUnit>;
+    readonly mostRecentQuantity?: HKQuantity<TIdentifier, TUnit>;
     readonly mostRecentQuantityDateInterval?: {
         readonly from: string;
         readonly to: string;
     };
-    readonly duration?: HKQuantity<HKUnit.Seconds>;
+    readonly duration?: HKQuantity<HKQuantityTypeIdentifier, TimeUnit>;
 };
 export declare enum HKCategoryValueCervicalMucusQuality {
     dry = 1,
@@ -444,6 +444,7 @@ export declare type MetadataMapperForQuantityIdentifier<TQuantityTypeIdentifier
 export declare type MetadataMapperForCorrelationIdentifier<TCorrelationTypeIdentifier = HKCorrelationTypeIdentifier> = TCorrelationTypeIdentifier extends HKCorrelationTypeIdentifier.food ? HKGenericMetadata & {
     readonly HKFoodType?: string;
 } : HKGenericMetadata;
+export declare type UnitForIdentifier<T extends HKQuantityTypeIdentifier> = T extends HKQuantityTypeIdentifier.bloodGlucose ? BloodGlucoseUnit : T extends HKQuantityTypeIdentifier.appleExerciseTime | HKQuantityTypeIdentifier.appleMoveTime | HKQuantityTypeIdentifier.appleStandTime ? TimeUnit : T extends HKQuantityTypeIdentifier.activeEnergyBurned | HKQuantityTypeIdentifier.basalEnergyBurned | HKQuantityTypeIdentifier.dietaryEnergyConsumed ? EnergyUnit : T extends HKQuantityTypeIdentifier.distanceCycling | HKQuantityTypeIdentifier.distanceDownhillSnowSports | HKQuantityTypeIdentifier.distanceSwimming | HKQuantityTypeIdentifier.distanceWalkingRunning | HKQuantityTypeIdentifier.distanceWheelchair | HKQuantityTypeIdentifier.sixMinuteWalkTestDistance | HKQuantityTypeIdentifier.waistCircumference ? LengthUnit : T extends HKQuantityTypeIdentifier.bodyFatPercentage | HKQuantityTypeIdentifier.oxygenSaturation | HKQuantityTypeIdentifier.walkingAsymmetryPercentage | HKQuantityTypeIdentifier.walkingDoubleSupportPercentage ? HKUnits.Percent : T extends HKQuantityTypeIdentifier.basalBodyTemperature | HKQuantityTypeIdentifier.basalBodyTemperature ? TemperatureUnit : T extends HKQuantityTypeIdentifier.stairAscentSpeed | HKQuantityTypeIdentifier.stairDescentSpeed | HKQuantityTypeIdentifier.walkingSpeed | HKQuantityTypeIdentifier.walkingSpeed ? SpeedUnit<LengthUnit, TimeUnit> : T extends HKQuantityTypeIdentifier.flightsClimbed | HKQuantityTypeIdentifier.numberOfAlcoholicBeverages | HKQuantityTypeIdentifier.numberOfTimesFallen | HKQuantityTypeIdentifier.pushCount | HKQuantityTypeIdentifier.stepCount | HKQuantityTypeIdentifier.swimmingStrokeCount ? HKUnits.Count : T extends HKQuantityTypeIdentifier.dietaryBiotin | HKQuantityTypeIdentifier.dietaryCaffeine | HKQuantityTypeIdentifier.dietaryCalcium | HKQuantityTypeIdentifier.dietaryCarbohydrates | HKQuantityTypeIdentifier.dietaryChloride | HKQuantityTypeIdentifier.dietaryCholesterol | HKQuantityTypeIdentifier.dietaryChromium | HKQuantityTypeIdentifier.dietaryCopper | HKQuantityTypeIdentifier.dietaryFatMonounsaturated | HKQuantityTypeIdentifier.dietaryFatPolyunsaturated | HKQuantityTypeIdentifier.dietaryFatSaturated | HKQuantityTypeIdentifier.dietaryFatTotal | HKQuantityTypeIdentifier.dietaryFiber | HKQuantityTypeIdentifier.dietaryFolate | HKQuantityTypeIdentifier.dietaryIodine | HKQuantityTypeIdentifier.dietaryIodine | HKQuantityTypeIdentifier.dietaryIron | HKQuantityTypeIdentifier.dietaryMagnesium | HKQuantityTypeIdentifier.dietaryManganese | HKQuantityTypeIdentifier.dietaryMolybdenum | HKQuantityTypeIdentifier.dietaryNiacin | HKQuantityTypeIdentifier.dietaryPantothenicAcid | HKQuantityTypeIdentifier.dietaryPhosphorus | HKQuantityTypeIdentifier.dietaryPotassium | HKQuantityTypeIdentifier.dietaryProtein | HKQuantityTypeIdentifier.dietaryRiboflavin | HKQuantityTypeIdentifier.dietarySelenium | HKQuantityTypeIdentifier.dietarySodium | HKQuantityTypeIdentifier.dietarySugar | HKQuantityTypeIdentifier.dietaryThiamin | HKQuantityTypeIdentifier.dietaryVitaminA | HKQuantityTypeIdentifier.dietaryVitaminB6 | HKQuantityTypeIdentifier.dietaryVitaminB12 | HKQuantityTypeIdentifier.dietaryVitaminC | HKQuantityTypeIdentifier.dietaryVitaminD | HKQuantityTypeIdentifier.dietaryVitaminE | HKQuantityTypeIdentifier.dietaryVitaminK | HKQuantityTypeIdentifier.dietaryZinc ? MassUnit : T extends HKQuantityTypeIdentifier.dietaryWater ? VolumeUnit : T extends HKQuantityTypeIdentifier.insulinDelivery ? HKUnits.InternationalUnit | `${HKUnits.InternationalUnit}` : T extends HKQuantityTypeIdentifier.heartRate | HKQuantityTypeIdentifier.restingHeartRate | HKQuantityTypeIdentifier.walkingHeartRateAverage ? CountPerTime<TimeUnit> : HKUnit;
 export declare type HKCategoryValueForIdentifier<T extends HKCategoryTypeIdentifier> = T extends HKCategoryTypeIdentifier.cervicalMucusQuality ? HKCategoryValueCervicalMucusQuality : T extends HKCategoryTypeIdentifier.menstrualFlow ? HKCategoryValueMenstrualFlow : T extends HKCategoryTypeIdentifier.ovulationTestResult ? HKCategoryValueOvulationTestResult : T extends HKCategoryTypeIdentifier.sleepAnalysis ? HKCategoryValueSleepAnalysis : T extends (HKCategoryTypeIdentifier.highHeartRateEvent | HKCategoryTypeIdentifier.intermenstrualBleeding | HKCategoryTypeIdentifier.mindfulSession | HKCategoryTypeIdentifier.sexualActivity) ? HKCategoryValueNotApplicable : T extends (HKCategoryTypeIdentifier.abdominalCramps | HKCategoryTypeIdentifier.abdominalCramps | HKCategoryTypeIdentifier.acne | HKCategoryTypeIdentifier.bladderIncontinence | HKCategoryTypeIdentifier.bloating | HKCategoryTypeIdentifier.breastPain | HKCategoryTypeIdentifier.chestTightnessOrPain | HKCategoryTypeIdentifier.chills | HKCategoryTypeIdentifier.constipation | HKCategoryTypeIdentifier.coughing | HKCategoryTypeIdentifier.diarrhea | HKCategoryTypeIdentifier.dizziness | HKCategoryTypeIdentifier.drySkin | HKCategoryTypeIdentifier.fainting | HKCategoryTypeIdentifier.fatigue | HKCategoryTypeIdentifier.fever | HKCategoryTypeIdentifier.generalizedBodyAche | HKCategoryTypeIdentifier.hairLoss | HKCategoryTypeIdentifier.headache | HKCategoryTypeIdentifier.heartburn | HKCategoryTypeIdentifier.hotFlashes | HKCategoryTypeIdentifier.lossOfSmell | HKCategoryTypeIdentifier.lossOfTaste | HKCategoryTypeIdentifier.lowerBackPain | HKCategoryTypeIdentifier.memoryLapse | HKCategoryTypeIdentifier.moodChanges | HKCategoryTypeIdentifier.nausea | HKCategoryTypeIdentifier.nightSweats | HKCategoryTypeIdentifier.pelvicPain | HKCategoryTypeIdentifier.rapidPoundingOrFlutteringHeartbeat | HKCategoryTypeIdentifier.runnyNose | HKCategoryTypeIdentifier.shortnessOfBreath | HKCategoryTypeIdentifier.sinusCongestion | HKCategoryTypeIdentifier.skippedHeartbeat | HKCategoryTypeIdentifier.soreThroat | HKCategoryTypeIdentifier.vaginalDryness | HKCategoryTypeIdentifier.vomiting | HKCategoryTypeIdentifier.wheezing) ? HKCategoryValueSeverity : T extends (HKCategoryTypeIdentifier.appetiteChanges | HKCategoryTypeIdentifier.sleepChanges) ? HKCategoryValuePresence : T extends HKCategoryTypeIdentifier.lowCardioFitnessEvent ? HKCategoryValueLowCardioFitnessEvent : T extends HKCategoryTypeIdentifier.pregnancyTestResult ? HKCategoryValuePregnancyTestResult : T extends HKCategoryTypeIdentifier.pregnancyTestResult ? HKCategoryValuePregnancyTestResult : T extends HKCategoryTypeIdentifier.appleStandHour ? HKCategoryValueAppleStandHour : number;
 declare enum HKCategoryValuePregnancyTestResult {
     positive = 2,
@@ -460,7 +461,8 @@ export declare enum HKWheelchairUse {
     no = 1,
     yes = 2
 }
-export declare enum HKUnitSIPrefix {
+export declare enum HKMetricPrefix {
+    None = "",
     Pico = "p",
     Nano = "n",
     Micro = "mc",
@@ -472,60 +474,160 @@ export declare enum HKUnitSIPrefix {
     Kilo = "k",
     Mega = "M",
     Giga = "G",
-    Tera = "T"
+    Tera = "T",
+    Femto = "f"
 }
-export declare enum HKUnitSI {
-    Grams = "g",
-    Joules = "J",
-    Kelvin = "K",
-    Liters = "l",
-    Meters = "m",
-    Pascals = "Pa",
-    Seconds = "s",
-    Siemens = "S"
-}
-export declare enum HKUnit {
-    Grams = "g",
-    Joules = "J",
+export declare enum HKUnitMetric {
+    Gram = "g",
+    Joule = "J",
     Kelvin = "K",
-    Liters = "l",
-    Meters = "m",
-    Pascals = "Pa",
-    Seconds = "s",
-    Siemens = "S",
-    Atmospheres = "atm",
-    CentimetersOfWater = "cmAq",
-    Count = "count",
-    Days = "d",
+    Liter = "l",
+    Meter = "m",
+    Pascal = "Pa",
+    Second = "s",
+    Siemen = "S",
+    Hertz = "Hz",
+    Volt = "V"
+}
+export declare enum HKUnits {
     DecibelHearingLevel = "dBHL",
     DecibelSoundPressureLevel = "dBASPL",
-    DegreesCelsius = "degC",
-    DegreesFahrenheit = "degF",
+    Percent = "%",
+    Count = "count",
+    InternationalUnit = "IU"
+}
+export declare type MeterUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Meter}`;
+export declare type LiterUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Liter}`;
+export declare type GramUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Gram}`;
+export declare type PascalUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Pascal}`;
+export declare type SecondUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Second}`;
+export declare type JouleUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Joule}`;
+export declare type HertzUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Hertz}`;
+export declare type VoltUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Volt}`;
+export declare type SiemenUnit<Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}${HKUnitMetric.Siemen}`;
+export declare type MoleUnit<MolarMass extends number> = `mol<${MolarMass}>`;
+export declare type MoleUnitWith<MolarMass extends number, Prefix extends HKMetricPrefix = HKMetricPrefix.None> = `${Prefix}mol<${MolarMass}>`;
+export declare type FrequencyUnit = HertzUnit<HKMetricPrefix>;
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'cm', 'km'
+  */
+export declare enum UnitOfLength {
     Feet = "ft",
-    Hertz = "Hz",
-    Hours = "hr",
+    /**
+    * More SI prefixes also available as literals, just type the string
+    * @example 'cm', 'km'
+    */
+    Meter = "m",
+    Inches = "in",
+    Yards = "yd",
+    Miles = "mi"
+}
+export declare type LengthUnit = MeterUnit<HKMetricPrefix> | UnitOfLength;
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'ml', 'cl'
+  */
+export declare enum UnitOfVolume {
     ImperialCup = "cup_imp",
     ImperialFluidOunces = "fl_oz_imp",
     ImperialPint = "pt_imp",
-    Inches = "in",
-    InternationalUnit = "IU",
-    Kilocalories = "kcal",
-    LargeCalories = "Cal",
-    Miles = "mi",
-    MillimetersOfMercury = "mmHg",
-    Minutes = "min",
-    Ounces = "oz",
-    Percent = "%",
-    Pounds = "lb",
-    SmallCalories = "cal",
-    Stones = "st",
     USCup = "cup_us",
     USFluidOunces = "fl_oz_us",
     USPint = "pt_us",
-    Yard = "yd",
+    /**
+    * More SI prefixes also available as literals, just type the string
+    * @example 'ml', 'cl'
+    */
+    Liter = "l"
+}
+export declare type VolumeUnit = LiterUnit<HKMetricPrefix> | UnitOfVolume;
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'mg', 'kg'
+  */
+export declare enum UnitOfMass {
+    Ounces = "oz",
+    Stones = "st",
+    Pounds = "lb",
+    /**
+    * More SI prefixes also available as literals, just type the string
+    * @example 'mg', 'kg'
+    */
+    Gram = "g"
+}
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'mg', 'kg'
+  */
+export declare type MassUnit = GramUnit<HKMetricPrefix> | UnitOfMass;
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'kPa', 'hPa'
+  */
+export declare enum UnitOfPressure {
+    Atmospheres = "atm",
+    CentimetersOfWater = "cmAq",
+    MillimetersOfMercury = "mmHg",
+    InchesOfMercury = "inHg",
+    DecibelAWeightedSoundPressureLevel = "dBASPL",
+    /**
+    * More SI prefixes also available as literals, just type the string
+    * @example 'kPa', 'hPa'
+    */
+    Pascals = "Pa"
+}
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'kPa', 'hPa'
+  */
+export declare type PressureUnit = PascalUnit<HKMetricPrefix> | UnitOfPressure;
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'ms'
+  */
+export declare enum UnitOfTime {
+    Days = "d",
+    Minutes = "min",
+    Hours = "hr",
+    /**
+    * More SI prefixes also available as literals, just type the string
+    * @example 'ms'
+    */
+    Seconds = "s"
+}
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'ms'
+  */
+export declare type TimeUnit = SecondUnit<HKMetricPrefix> | UnitOfTime;
+export declare enum TemperatureUnit {
+    DegreesCelsius = "degC",
+    DegreesFahrenheit = "degF",
+    Kelvin = "K"
+}
+/**
+  * More SI prefixes also available as literals, just type the string
+  * @example 'kJ'
+  */
+export declare enum UnitOfEnergy {
+    Kilocalories = "kcal",
+    LargeCalories = "Cal",
+    SmallCalories = "cal",
+    /**
+    * More SI prefixes also available as literals, just type the string
+    * @example 'kJ'
+    */
+    Joules = "J"
+}
+export declare type EnergyUnit = JouleUnit<HKMetricPrefix> | UnitOfEnergy;
+export declare enum BloodGlucoseUnit {
     GlucoseMmolPerL = "mmol<180.15588000005408>/l",
     GlucoseMgPerDl = "mg/dL"
 }
+export declare type SpeedUnit<TLength extends LengthUnit, TTime extends TimeUnit> = `${TLength}/${TTime}`;
+export declare type CountPerTime<TTime extends TimeUnit> = `count/${TTime}`;
+export declare type HKUnit = BloodGlucoseUnit | CountPerTime<TimeUnit> | EnergyUnit | FrequencyUnit | HKUnits | LengthUnit | MassUnit | PressureUnit | SpeedUnit<LengthUnit, TimeUnit> | TemperatureUnit | TimeUnit | VolumeUnit | `${BloodGlucoseUnit}` | `${EnergyUnit}` | `${FrequencyUnit}` | `${HKUnits}` | `${LengthUnit}` | `${MassUnit}` | `${PressureUnit}` | `${TemperatureUnit}` | `${TimeUnit}` | `${VolumeUnit}`;
 export declare type HKDevice = {
     readonly name: string;
     readonly firmwareVersion: string | null;
@@ -545,7 +647,7 @@ export declare type HKSourceRevision = {
     readonly operatingSystemVersion?: string;
     readonly productType?: string;
 };
-export declare type HKQuantitySampleRaw<TQuantityIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit> = {
+export declare type HKQuantitySampleRaw<TQuantityIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TQuantityIdentifier> = UnitForIdentifier<TQuantityIdentifier>> = {
     readonly uuid: string;
     readonly device?: HKDevice;
     readonly quantityType: TQuantityIdentifier;
@@ -556,15 +658,17 @@ export declare type HKQuantitySampleRaw<TQuantityIdentifier extends HKQuantityTy
     readonly metadata: MetadataMapperForQuantityIdentifier<TQuantityIdentifier>;
     readonly sourceRevision?: HKSourceRevision;
 };
-export declare type HKWorkoutRaw<TEnergy extends HKUnit, TDistance extends HKUnit> = {
+export declare type HKQuantitySampleRawForSaving<TQuantityIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TQuantityIdentifier> = UnitForIdentifier<TQuantityIdentifier>> = Omit<HKQuantitySampleRaw<TQuantityIdentifier, TUnit>, 'device' | 'endDate' | 'startDate' | 'uuid'>;
+export declare type HKCategorySampleRawForSaving<TCategory extends HKCategoryTypeIdentifier = HKCategoryTypeIdentifier> = Omit<HKCategorySampleRaw<TCategory>, 'device' | 'endDate' | 'startDate' | 'uuid'>;
+export declare type HKWorkoutRaw<TEnergy extends EnergyUnit, TDistance extends LengthUnit> = {
     readonly uuid: string;
     readonly device?: HKDevice;
     readonly workoutActivityType: HKWorkoutActivityType;
     readonly duration: number;
-    readonly totalDistance?: HKQuantity<TDistance>;
-    readonly totalEnergyBurned?: HKQuantity<TEnergy>;
-    readonly totalSwimmingStrokeCount?: HKQuantity<HKUnit.Count>;
-    readonly totalFlightsClimbed?: HKQuantity<HKUnit.Count>;
+    readonly totalDistance?: HKQuantity<HKQuantityTypeIdentifier, TDistance>;
+    readonly totalEnergyBurned?: HKQuantity<HKQuantityTypeIdentifier, TEnergy>;
+    readonly totalSwimmingStrokeCount?: HKQuantity<HKQuantityTypeIdentifier, HKUnits.Count>;
+    readonly totalFlightsClimbed?: HKQuantity<HKQuantityTypeIdentifier, HKUnits.Count>;
     readonly startDate: string;
     readonly endDate: string;
     readonly metadata?: HKWorkoutMetadata;
@@ -633,20 +737,20 @@ declare type ReactNativeHealthkitTypeNative = {
     readonly enableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier, updateFrequency: HKUpdateFrequency) => Promise<boolean>;
     readonly disableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier) => Promise<boolean>;
     readonly disableAllBackgroundDelivery: () => Promise<boolean>;
-    readonly saveCorrelationSample: <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, samples: readonly Omit<HKCategorySampleRaw | HKQuantitySampleRaw, 'device' | 'endDate' | 'startDate' | 'uuid'>[], start: string, end: string, metadata: MetadataMapperForCorrelationIdentifier<TIdentifier>) => Promise<boolean>;
-    readonly saveWorkoutSample: (typeIdentifier: HKWorkoutActivityType, quantities: readonly Omit<HKQuantitySampleRaw, 'device' | 'endDate' | 'startDate' | 'uuid'>[], start: string, end: string, metadata: HKWorkoutMetadata) => Promise<boolean>;
+    readonly saveCorrelationSample: <TIdentifier extends HKCorrelationTypeIdentifier, TSamples extends readonly (HKCategorySampleRawForSaving | HKQuantitySampleRawForSaving)[]>(typeIdentifier: TIdentifier, samples: TSamples, start: string, end: string, metadata: MetadataMapperForCorrelationIdentifier<TIdentifier>) => Promise<boolean>;
+    readonly saveWorkoutSample: (typeIdentifier: HKWorkoutActivityType, quantities: readonly HKQuantitySampleRawForSaving[], start: string, end: string, metadata: HKWorkoutMetadata) => Promise<boolean>;
     readonly queryCorrelationSamples: <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, from: string, to: string) => Promise<readonly HKCorrelationRaw<TIdentifier>[]>;
     subscribeToObserverQuery(identifier: HKSampleTypeIdentifier): Promise<QueryId>;
     unsubscribeQuery(queryId: QueryId): Promise<boolean>;
     authorizationStatusFor(type: HealthkitReadAuthorization): Promise<boolean>;
     getRequestStatusForAuthorization(write: WritePermissions, read: ReadPermissions): Promise<HKAuthorizationRequestStatus>;
     requestAuthorization(write: WritePermissions, read: ReadPermissions): Promise<boolean>;
-    readonly saveQuantitySample: (identifier: HKQuantityTypeIdentifier, unit: HKUnit, value: number, start: string, end: string, metadata: unknown) => Promise<boolean>;
-    readonly queryWorkoutSamples: <TEnergy extends HKUnit, TDistance extends HKUnit>(energyUnit: TEnergy, distanceUnit: TDistance, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKWorkoutRaw<TEnergy, TDistance>[]>;
+    readonly saveQuantitySample: <TType extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TType> = UnitForIdentifier<TType>>(identifier: TType, unit: TUnit, value: number, start: string, end: string, metadata: unknown) => Promise<boolean>;
+    readonly queryWorkoutSamples: <TEnergy extends EnergyUnit, TDistance extends LengthUnit>(energyUnit: TEnergy, distanceUnit: TDistance, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKWorkoutRaw<TEnergy, TDistance>[]>;
     readonly queryCategorySamples: <T extends HKCategoryTypeIdentifier>(identifier: T, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKCategorySampleRaw<T>[]>;
-    readonly queryQuantitySamples: <TUnit extends HKUnit, TIdentifier extends HKQuantityTypeIdentifier>(identifier: TIdentifier, unit: TUnit, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKQuantitySampleRaw<TIdentifier, TUnit>[]>;
+    readonly queryQuantitySamples: <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>>(identifier: TIdentifier, unit: TUnit, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKQuantitySampleRaw<TIdentifier, TUnit>[]>;
     readonly saveCategorySample: <T extends HKCategoryTypeIdentifier>(identifier: T, value: HKCategoryValueForIdentifier<T>, start: string, end: string, metadata: unknown) => Promise<boolean>;
-    readonly queryStatisticsForQuantity: <TUnit extends HKUnit>(identifier: HKQuantityTypeIdentifier, unit: TUnit, from: string, to: string, options: readonly HKStatisticsOptions[]) => Promise<QueryStatisticsResponseRaw<TUnit>>;
+    readonly queryStatisticsForQuantity: <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>>(identifier: HKQuantityTypeIdentifier, unit: TUnit, from: string, to: string, options: readonly HKStatisticsOptions[]) => Promise<QueryStatisticsResponseRaw<TIdentifier, TUnit>>;
     readonly getPreferredUnits: (identifiers: readonly HKQuantityTypeIdentifier[]) => Promise<TypeToUnitMapping>;
     readonly getWorkoutRoutes: (workoutUUID: string) => Promise<readonly WorkoutRoute[]>;
 };

package/lib/typescript/src/types.d.ts

@@ -1,4 +1,5 @@
-import type { HealthkitReadAuthorization, HealthkitWriteAuthorization, HKAuthorizationRequestStatus, HKBiologicalSex, HKBloodType, HKCategorySampleRaw, HKCategoryTypeIdentifier, HKCategoryValueForIdentifier, HKCorrelationRaw, HKCorrelationTypeIdentifier, HKFitzpatrickSkinType, HKQuantitySampleRaw, HKQuantityTypeIdentifier, HKSampleTypeIdentifier, HKStatisticsOptions, HKUnit, HKUnitSI, HKUnitSIPrefix, HKUpdateFrequency, HKWheelchairUse, HKWorkoutActivityType, HKWorkoutMetadata, HKWorkoutRaw, MetadataMapperForCategoryIdentifier, MetadataMapperForCorrelationIdentifier, MetadataMapperForQuantityIdentifier, QueryStatisticsResponseRaw, WorkoutRoute } from './native-types';
+import type { EnergyUnit, HKCategorySampleRaw, HKCategoryTypeIdentifier, HKCorrelationRaw, HKCorrelationTypeIdentifier, HKDevice, HKQuantityTypeIdentifier, HKSourceRevision, HKUnit, HKWorkoutRaw, LengthUnit, MetadataMapperForQuantityIdentifier, QueryStatisticsResponseRaw, UnitForIdentifier } from './native-types';
+export * from './native-types';
 export interface QueryWorkoutsOptions<TEnergy extends HKUnit, TDistance extends HKUnit> extends GenericQueryOptions {
     readonly energyUnit?: TEnergy;
     readonly distanceUnit?: TDistance;
@@ -13,108 +14,31 @@ export declare type GenericQueryOptions = {
     readonly limit?: number;
     readonly ascending?: boolean;
 };
-export interface HKWorkout<TEnergy extends HKUnit = HKUnit, TDistance extends HKUnit = HKUnit> extends Omit<HKWorkoutRaw<TEnergy, TDistance>, 'endDate' | 'startDate'> {
+export interface HKWorkout<TEnergy extends EnergyUnit = EnergyUnit, TDistance extends LengthUnit = LengthUnit> extends Omit<HKWorkoutRaw<TEnergy, TDistance>, 'endDate' | 'startDate'> {
     readonly startDate: Date;
     readonly endDate: Date;
 }
-export interface HKQuantitySample<TIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit> extends Omit<HKQuantitySampleRaw<TIdentifier, TUnit>, 'endDate' | 'startDate'> {
+export interface HKQuantitySample<TIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, 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> extends Omit<QueryStatisticsResponseRaw<T>, 'mostRecentQuantityDateInterval'> {
+export interface QueryStatisticsResponse<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>> extends Omit<QueryStatisticsResponseRaw<TIdentifier, TUnit>, 'mostRecentQuantityDateInterval'> {
     readonly mostRecentQuantityDateInterval?: {
         readonly from: Date;
         readonly to: Date;
     };
 }
-declare type UnsubscribeFunction = () => Promise<boolean>;
-export declare type IsHealthDataAvailableFn = () => Promise<boolean>;
-export declare type GetBloodTypeFn = () => Promise<HKBloodType>;
-export declare type GetDateOfBirthFn = () => Promise<Date>;
-export declare type GetBiologicalSexFn = () => Promise<HKBiologicalSex>;
-export declare type GetWheelchairUseFn = () => Promise<HKWheelchairUse>;
-export declare type GetFitzpatrickSkinTypeFn = () => Promise<HKFitzpatrickSkinType>;
-export declare type QueryStatisticsForQuantityFn = <TUnit extends HKUnit>(identifier: HKQuantityTypeIdentifier, options: readonly HKStatisticsOptions[], from: Date, to?: Date, unit?: TUnit) => Promise<QueryStatisticsResponse<TUnit>>;
-export declare type QueryWorkoutsFn = <TEnergy extends HKUnit, TDistance extends HKUnit>(options: QueryWorkoutsOptions<TEnergy, TDistance>) => Promise<readonly HKWorkout<TEnergy, TDistance>[]>;
-export declare type AuthorizationStatusForFn = (type: HealthkitReadAuthorization) => Promise<boolean>;
-export declare type QueryCategorySamplesFn = <T extends HKCategoryTypeIdentifier>(identifier: T, options: GenericQueryOptions) => Promise<readonly HKCategorySample<T>[]>;
-export declare type GetRequestStatusForAuthorizationFn = (read: readonly HealthkitReadAuthorization[], write?: readonly HealthkitWriteAuthorization[]) => Promise<HKAuthorizationRequestStatus>;
-export declare type RequestAuthorizationFn = (read: readonly HealthkitReadAuthorization[], write?: readonly HealthkitWriteAuthorization[]) => Promise<boolean>;
-export declare type SaveQuantitySampleFn = <TUnit extends HKQuantityTypeIdentifier>(identifier: TUnit, unit: HKUnit, value: number, options?: {
-    readonly start?: Date;
-    readonly end?: Date;
-    readonly metadata?: MetadataMapperForQuantityIdentifier<TUnit>;
-}) => Promise<boolean>;
-export declare type QueryQuantitySamplesFn = <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit>(identifier: TIdentifier, options: GenericQueryOptions & {
-    readonly unit?: TUnit;
-}) => Promise<readonly HKQuantitySample<TIdentifier, TUnit>[]>;
-export declare type SubscribeToChangesFn = (identifier: HKSampleTypeIdentifier, callback: () => void) => Promise<UnsubscribeFunction>;
-export declare type SaveCategorySampleFn = <T extends HKCategoryTypeIdentifier>(identifier: T, value: HKCategoryValueForIdentifier<T>, options?: {
-    readonly start?: Date;
-    readonly end?: Date;
-    readonly metadata?: MetadataMapperForCategoryIdentifier<T>;
-}) => Promise<boolean>;
-export declare type GetMostRecentCategorySampleFn = <T extends HKCategoryTypeIdentifier>(identifier: T) => Promise<HKCategorySample<T> | null>;
-export declare type MostRecentCategorySampleHook = <T extends HKCategoryTypeIdentifier>(identifier: T) => HKCategorySample<T> | null;
-export declare type MostRecentCorrelationSampleHook = <T extends HKCorrelationTypeIdentifier>(identifer: T) => HKCorrelation<T> | null;
-export declare type GetMostRecentQuantitySampleFn = <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends HKUnit>(identifier: TIdentifier, unit?: TUnit) => Promise<HKQuantitySample<TIdentifier, TUnit> | null>;
-export declare type MostRecentQuantitySampleHook = <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends HKUnit>(identifier: TIdentifier, unit?: TUnit) => HKQuantitySample<TIdentifier, TUnit> | null;
-export declare type GetMostRecentWorkoutFn = <TEnergy extends HKUnit, TDistance extends HKUnit>(options?: Pick<QueryWorkoutsOptions<TEnergy, TDistance>, 'distanceUnit' | 'energyUnit'>) => Promise<HKWorkout<TEnergy, TDistance> | null>;
-export declare type MostRecentWorkoutHook = <TEnergy extends HKUnit, TDistance extends HKUnit>(options?: Pick<QueryWorkoutsOptions<TEnergy, TDistance>, 'distanceUnit' | 'energyUnit'>) => HKWorkout<TEnergy, TDistance> | null;
-export declare type GetPreferredUnitsFn = (identifiers: readonly HKQuantityTypeIdentifier[]) => Promise<readonly HKUnit[]>;
-export declare type GetPreferredUnitFn = (identifier: HKQuantityTypeIdentifier) => Promise<HKUnit>;
-export declare type SaveCorrelationSampleFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, samples: readonly (Omit<HKCategorySample, 'device' | 'endDate' | 'startDate' | 'uuid'> | Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>)[], options?: {
-    readonly start?: Date;
-    readonly end?: Date;
-    readonly metadata?: MetadataMapperForCorrelationIdentifier<TIdentifier>;
-}) => Promise<boolean>;
-export declare type SaveWorkoutSampleFn = (typeIdentifier: HKWorkoutActivityType, quantities: readonly Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>[], start: Date, options?: {
-    readonly end?: Date;
-    readonly metadata?: HKWorkoutMetadata;
-}) => Promise<boolean>;
+export declare type HKCategorySampleForSaving = Omit<HKCategorySample, 'device' | 'endDate' | 'startDate' | 'uuid'>;
+export declare type HKQuantitySampleForSaving = Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>;
 export interface HKCorrelation<TIdentifier extends HKCorrelationTypeIdentifier> extends Omit<HKCorrelationRaw<TIdentifier>, 'endDate' | 'objects' | 'startDate'> {
     readonly objects: readonly (HKCategorySample | HKQuantitySample)[];
     readonly startDate: Date;
     readonly endDate: Date;
 }
-export declare type QueryCorrelationSamplesFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, options: Omit<GenericQueryOptions, 'ascending' | 'limit'>) => Promise<readonly HKCorrelation<TIdentifier>[]>;
-export declare type SubscribeToChangesHook = <TIdentifier extends HKSampleTypeIdentifier>(identifier: TIdentifier, onChange: () => void, runInitialUpdate?: boolean) => void;
-export declare type GetWorkoutRoutesFn = (workoutUUID: string) => Promise<readonly WorkoutRoute[]>;
-export declare 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>];
-};
-export {};

package/lib/typescript/src/utils/deserializeCategorySample.d.ts

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

package/lib/typescript/src/utils/deserializeCorrelation.d.ts

@@ -0,0 +1,4 @@
+import type { HKCorrelationRaw, HKCorrelationTypeIdentifier } from '../native-types';
+import type { HKCorrelation } from '../types';
+declare function deserializeCorrelation<TIdentifier extends HKCorrelationTypeIdentifier>(s: HKCorrelationRaw<TIdentifier>): HKCorrelation<TIdentifier>;
+export default deserializeCorrelation;

package/lib/typescript/src/utils/deserializeSample.d.ts

@@ -0,0 +1,4 @@
+import type { HKQuantitySampleRaw, HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types';
+import type { HKQuantitySample } from '../types';
+declare function deserializeSample<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>>(sample: HKQuantitySampleRaw<TIdentifier, TUnit>): HKQuantitySample<TIdentifier, TUnit>;
+export default deserializeSample;

package/lib/typescript/src/utils/deserializeWorkout.d.ts

@@ -0,0 +1,4 @@
+import type { EnergyUnit, HKWorkoutRaw, LengthUnit } from '../native-types';
+import type { HKWorkout } from '../types';
+declare function deserializeWorkout<TEnergy extends EnergyUnit, TDistance extends LengthUnit>(sample: HKWorkoutRaw<TEnergy, TDistance>): HKWorkout<TEnergy, TDistance>;
+export default deserializeWorkout;

package/lib/typescript/src/utils/ensureMetadata.d.ts

@@ -0,0 +1,2 @@
+declare function ensureMetadata<TMetadata>(metadata?: TMetadata): TMetadata;
+export default ensureMetadata;

package/lib/typescript/src/utils/ensureUnit.d.ts

@@ -0,0 +1,3 @@
+import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types';
+declare const ensureUnit: <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>>(type: TIdentifier, providedUnit?: TUnit | undefined) => Promise<TUnit>;
+export default ensureUnit;

package/lib/typescript/src/utils/getDateOfBirth.d.ts

@@ -0,0 +1,2 @@
+declare const getDateOfBirth: () => Promise<Date>;
+export default getDateOfBirth;

package/lib/typescript/src/utils/getMostRecentCategorySample.d.ts

@@ -0,0 +1,3 @@
+import type { HKCategoryTypeIdentifier } from '../native-types';
+declare function getMostRecentCategorySample<T extends HKCategoryTypeIdentifier>(identifier: T): Promise<import("..").HKCategorySample<T> | null>;
+export default getMostRecentCategorySample;

package/lib/typescript/src/utils/getMostRecentQuantitySample.d.ts

@@ -0,0 +1,3 @@
+import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types';
+declare function getMostRecentQuantitySample<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>>(identifier: TIdentifier, unit: TUnit): Promise<import("..").HKQuantitySample<TIdentifier, UnitForIdentifier<TIdentifier>> | null>;
+export default getMostRecentQuantitySample;

package/lib/typescript/src/utils/getMostRecentWorkout.d.ts

@@ -0,0 +1,5 @@
+import type { EnergyUnit, LengthUnit } from '../native-types';
+import type { HKWorkout, QueryWorkoutsOptions } from '../types';
+export declare type GetMostRecentWorkoutFn = <TEnergy extends EnergyUnit, TDistance extends LengthUnit>(options?: Pick<QueryWorkoutsOptions<TEnergy, TDistance>, 'distanceUnit' | 'energyUnit'>) => Promise<HKWorkout<TEnergy, TDistance> | null>;
+declare const getMostRecentWorkout: GetMostRecentWorkoutFn;
+export default getMostRecentWorkout;

package/lib/typescript/src/utils/getPreferredUnit.d.ts

@@ -0,0 +1,4 @@
+import type { HKQuantityTypeIdentifier, HKUnit } from '../native-types';
+export declare type GetPreferredUnitFn = (identifier: HKQuantityTypeIdentifier) => Promise<HKUnit>;
+declare const getPreferredUnit: GetPreferredUnitFn;
+export default getPreferredUnit;

package/lib/typescript/src/utils/getPreferredUnits.d.ts

@@ -0,0 +1,4 @@
+import type { HKQuantityTypeIdentifier, HKUnit } from '../native-types';
+export declare type GetPreferredUnitsFn = (identifiers: readonly HKQuantityTypeIdentifier[]) => Promise<readonly HKUnit[]>;
+declare const getPreferredUnits: GetPreferredUnitsFn;
+export default getPreferredUnits;

package/lib/typescript/src/utils/getPreferredUnitsTyped.d.ts

@@ -0,0 +1,9 @@
+import type { HKUnit } from '../native-types';
+declare function getPreferredUnitsTyped<TEnergy extends HKUnit, TDistance extends HKUnit>(options?: {
+    readonly energyUnit?: TEnergy;
+    readonly distanceUnit?: TDistance;
+}): Promise<{
+    energyUnit: TEnergy;
+    distanceUnit: TDistance;
+}>;
+export default getPreferredUnitsTyped;

package/lib/typescript/src/utils/getRequestStatusForAuthorization.d.ts

@@ -0,0 +1,3 @@
+import type { HealthkitReadAuthorization, HealthkitWriteAuthorization } from '../native-types';
+declare const getRequestStatusForAuthorization: (read: readonly HealthkitReadAuthorization[], write?: readonly HealthkitWriteAuthorization[]) => Promise<import("../native-types").HKAuthorizationRequestStatus>;
+export default getRequestStatusForAuthorization;

package/lib/typescript/src/utils/prepareOptions.d.ts

@@ -0,0 +1,8 @@
+import type { GenericQueryOptions } from '../types';
+declare const prepareOptions: (options: GenericQueryOptions) => {
+    limit: number;
+    ascending: boolean;
+    from: string;
+    to: string;
+};
+export default prepareOptions;

package/lib/typescript/src/utils/queryCategorySamples.d.ts

@@ -0,0 +1,5 @@
+import type { HKCategoryTypeIdentifier } from '../native-types';
+import type { GenericQueryOptions, HKCategorySample } from '../types';
+export declare type QueryCategorySamplesFn = <T extends HKCategoryTypeIdentifier>(identifier: T, options: GenericQueryOptions) => Promise<readonly HKCategorySample<T>[]>;
+declare const queryCategorySamples: QueryCategorySamplesFn;
+export default queryCategorySamples;