@kingstinct/react-native-healthkit 9.0.1 → 9.0.2

package/lib/typescript/index.d.ts

@@ -0,0 +1,74 @@
+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 { QueryWorkoutSamplesWithAnchorResponse } from './types/Workouts';
+export declare const authorizationStatusFor: (type: import("./types/Shared").ObjectTypeIdentifier) => AuthorizationStatus;
+export declare const disableAllBackgroundDelivery: () => Promise<boolean>;
+export declare const disableBackgroundDelivery: (typeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => Promise<boolean>;
+export declare const enableBackgroundDelivery: (typeIdentifier: import("./types/Shared").ObjectTypeIdentifier, updateFrequency: import("./types/Background").UpdateFrequency) => Promise<boolean>;
+export declare const getPreferredUnits: (identifiers: readonly import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types/Units").IdentifierWithUnit[]>;
+export declare const getRequestStatusForAuthorization: (toShare: import("./types/Shared").SampleTypeIdentifierWriteable[], toRead: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<AuthorizationRequestStatus>;
+export declare const isHealthDataAvailable: () => boolean;
+export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
+export declare const querySources: (identifier: import("./types/Shared").SampleTypeIdentifier) => Promise<readonly SourceProxy[]>;
+export declare const requestAuthorization: (toShare: import("./types/Shared").SampleTypeIdentifierWriteable[], toRead: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<boolean>;
+export declare const deleteObjects: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier, filter: import("./types/QueryOptions").FilterForSamples) => Promise<number>;
+export declare const subscribeToChanges: (typeIdentifier: import("./types/Shared").SampleTypeIdentifier, callback: (args: import("./types/Subscriptons").OnChangeCallbackArgs) => void) => string;
+export declare const isProtectedDataAvailable: () => boolean;
+export declare const isObjectTypeAvailable: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => boolean;
+export declare const isObjectTypeAvailableAsync: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => Promise<boolean>;
+export declare const areObjectTypesAvailable: (objectTypeIdentifiers: import("./types/Shared").ObjectTypeIdentifier[]) => Record<string, boolean>;
+export declare const areObjectTypesAvailableAsync: (objectTypeIdentifiers: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<Record<string, boolean>>;
+export declare const getBiologicalSex: () => BiologicalSex;
+export declare const getBloodType: () => BloodType;
+export declare const getDateOfBirth: () => Date;
+export declare const getFitzpatrickSkinType: () => FitzpatrickSkinType;
+export declare const getWheelchairUse: () => WheelchairUse;
+export declare const queryQuantitySamples: (identifier: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier, options?: import("./types/QueryOptions").QueryOptionsWithSortOrderAndUnit) => Promise<readonly QuantitySample[]>;
+export declare const queryQuantitySamplesWithAnchor: (identifier: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier, options: import("./types/QueryOptions").QueryOptionsWithAnchorAndUnit) => Promise<QuantitySamplesWithAnchorResponse>;
+export declare const queryStatisticsForQuantity: (identifier: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier, statistics: readonly import("./types/QuantityType").StatisticsOptions[], options?: import("./types/QuantityType").StatisticsQueryOptions) => Promise<QueryStatisticsResponse>;
+export declare const queryStatisticsCollectionForQuantity: (identifier: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier, statistics: readonly import("./types/QuantityType").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types/QuantityType").IntervalComponents, options?: import("./types/QuantityType").StatisticsQueryOptions) => Promise<readonly QueryStatisticsResponse[]>;
+export declare const saveQuantitySample: (identifier: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+export declare const isQuantityCompatibleWithUnit: (identifier: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier, unit: string) => boolean;
+export declare function queryCategorySamples<T extends CategoryTypeIdentifier>(categoryTypeIdentifier: T): Promise<CategorySampleTyped<T>[]>;
+export declare function queryCategorySamplesWithAnchor<T extends CategoryTypeIdentifier>(categoryTypeIdentifier: T): Promise<CategorySamplesWithAnchorResponseTyped<T>>;
+export declare const saveCategorySample: <T extends CategoryTypeIdentifier>(identifier: T, value: import("./types/CategoryType").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types/CategoryType").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
+export declare const queryCorrelationSamples: (typeIdentifier: import("./types/CorrelationType").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly CorrelationSample[]>;
+export declare const saveCorrelationSample: (typeIdentifier: import("./types/CorrelationType").CorrelationTypeIdentifier, samples: import("./types/CorrelationType").SampleForSaving[], start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+export declare const queryHeartbeatSeriesSamples: (options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly HeartbeatSeriesSample[]>;
+export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types/QueryOptions").QueryOptionsWithAnchor) => Promise<HeartbeatSeriesSamplesWithAnchorResponse>;
+export declare const queryWorkoutSamples: (options: import("./types/Workouts").WorkoutQueryOptions) => Promise<WorkoutProxy[]>;
+export declare const queryWorkoutSamplesWithAnchor: (options: import("./types/Workouts").WorkoutQueryOptionsWithAnchor) => Promise<QueryWorkoutSamplesWithAnchorResponse>;
+export declare const saveWorkoutSample: (workoutActivityType: import("./types/Workouts").WorkoutActivityType, quantities: readonly import("./types/QuantitySample").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types/Workouts").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<string>;
+export declare const startWatchApp: (workoutConfiguration: import("./types/WorkoutKit").WorkoutConfiguration) => Promise<boolean>;
+export declare const queryStateOfMindSamples: (options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly StateOfMindSample[]>;
+export declare const saveStateOfMindSample: (date: Date, kind: import("./types/StateOfMind").StateOfMindKind, valence: number, labels: readonly import("./types/StateOfMind").StateOfMindLabel[], associations: readonly import("./types/StateOfMind").StateOfMindAssociation[], metadata?: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+export declare function getMostRecentCategorySample<T extends CategoryTypeIdentifier>(identifier: T): Promise<CategorySampleTyped<T> | undefined>;
+export declare const getMostRecentQuantitySample: typeof ReactNativeHealthkit.getMostRecentQuantitySample;
+export declare const getMostRecentWorkout: (options: Pick<import("./types/Workouts").WorkoutQueryOptions, "distanceUnit" | "energyUnit">) => Promise<WorkoutProxy | undefined>;
+export declare const getPreferredUnit: (quantityType: import("./types/QuantityTypeIdentifier").QuantityTypeIdentifier) => Promise<string>;
+export declare function useMostRecentCategorySample<T extends CategoryTypeIdentifier>(categoryTypeIdentifier: T): CategorySampleTyped<T> | undefined;
+export declare const useMostRecentQuantitySample: typeof ReactNativeHealthkit.useMostRecentQuantitySample;
+export declare const useMostRecentWorkout: typeof ReactNativeHealthkit.useMostRecentWorkout;
+export declare const useSubscribeToChanges: typeof ReactNativeHealthkit.useSubscribeToChanges;
+export declare const useHealthkitAuthorization: (read: import("./types/Shared").ObjectTypeIdentifier[], write?: import("./types/Shared").SampleTypeIdentifierWriteable[]) => readonly [AuthorizationRequestStatus | null, () => Promise<AuthorizationRequestStatus>];
+export declare const useIsHealthDataAvailable: () => boolean | null;
+export declare const useSources: typeof ReactNativeHealthkit.useSources;
+export declare const useStatisticsForQuantity: typeof ReactNativeHealthkit.useStatisticsForQuantity;
+export declare const getBiologicalSexAsync: () => Promise<BiologicalSex>;
+export declare const getBloodTypeAsync: () => Promise<BloodType>;
+export declare const getDateOfBirthAsync: () => Promise<Date>;
+export declare const getFitzpatrickSkinTypeAsync: () => Promise<FitzpatrickSkinType>;
+export declare const getWheelchairUseAsync: () => Promise<WheelchairUse>;
+export declare const unsubscribeQueries: (queryIds: string[]) => number;
+declare const _default: typeof ReactNativeHealthkit;
+export default _default;

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

@@ -0,0 +1,142 @@
+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 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';
+declare const currentMajorVersionIOS: number;
+/**
+ * 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;
+export declare const authorizationStatusFor: (type: import("./types/Shared").ObjectTypeIdentifier) => import("./types/Auth").AuthorizationStatus;
+export declare const disableAllBackgroundDelivery: () => Promise<boolean>;
+export declare const disableBackgroundDelivery: (typeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => Promise<boolean>;
+export declare const enableBackgroundDelivery: (typeIdentifier: import("./types/Shared").ObjectTypeIdentifier, updateFrequency: import("./types/Background").UpdateFrequency) => Promise<boolean>;
+export declare const getBiologicalSex: () => import("./types/Characteristics").BiologicalSex;
+export declare const getBloodType: () => import("./types/Characteristics").BloodType;
+export declare const getDateOfBirth: () => Date;
+export declare const getFitzpatrickSkinType: () => import("./types/Characteristics").FitzpatrickSkinType;
+export declare const getPreferredUnits: (identifiers: readonly QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types/Units").IdentifierWithUnit[]>;
+export declare const getRequestStatusForAuthorization: (toShare: import("./types/Shared").SampleTypeIdentifierWriteable[], toRead: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<import("./types/Auth").AuthorizationRequestStatus>;
+export declare const getWheelchairUse: () => import("./types/Characteristics").WheelchairUse;
+export declare const isHealthDataAvailable: () => boolean;
+export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
+export declare const queryCategorySamples: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly import("./types/CategoryType").CategorySampleTyped<T>[]>;
+export declare const queryCategorySamplesWithAnchor: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options: import("./types/QueryOptions").QueryOptionsWithAnchor) => Promise<import("./types/CategoryType").CategorySamplesWithAnchorResponseTyped<T>>;
+export declare const queryCorrelationSamples: (typeIdentifier: import("./types/CorrelationType").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly import("./types/CorrelationType").CorrelationSample[]>;
+export declare const queryHeartbeatSeriesSamples: (options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly import("./types/HeartbeatSeries").HeartbeatSeriesSample[]>;
+export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types/QueryOptions").QueryOptionsWithAnchor) => Promise<import("./types/HeartbeatSeries").HeartbeatSeriesSamplesWithAnchorResponse>;
+export declare const queryQuantitySamples: (identifier: QuantityTypeIdentifier, options?: import("./types/QueryOptions").QueryOptionsWithSortOrderAndUnit) => Promise<readonly import("./types/QuantitySample").QuantitySample[]>;
+export declare const queryQuantitySamplesWithAnchor: (identifier: QuantityTypeIdentifier, options: import("./types/QueryOptions").QueryOptionsWithAnchorAndUnit) => Promise<import("./types/QuantityType").QuantitySamplesWithAnchorResponse>;
+export declare const queryStatisticsForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types/QuantityType").StatisticsOptions[], options?: import("./types/QuantityType").StatisticsQueryOptions) => Promise<import("./types/QuantityType").QueryStatisticsResponse>;
+export declare const queryStatisticsCollectionForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types/QuantityType").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types/QuantityType").IntervalComponents, options?: import("./types/QuantityType").StatisticsQueryOptions) => Promise<readonly import("./types/QuantityType").QueryStatisticsResponse[]>;
+export declare const queryWorkoutSamples: (options: import("./types/Workouts").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>;
+export declare const queryWorkoutSamplesWithAnchor: (options: import("./types/Workouts").WorkoutQueryOptionsWithAnchor) => Promise<import("./types/Workouts").QueryWorkoutSamplesWithAnchorResponse>;
+export declare const querySources: (identifier: import("./types/Shared").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
+export declare const requestAuthorization: (toShare: import("./types/Shared").SampleTypeIdentifierWriteable[], toRead: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<boolean>;
+export declare const deleteObjects: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier, filter: import("./types/QueryOptions").FilterForSamples) => Promise<number>;
+export declare const saveCategorySample: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, value: import("./types/CategoryType").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types/CategoryType").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
+export declare const saveCorrelationSample: (typeIdentifier: import("./types/CorrelationType").CorrelationTypeIdentifier, samples: import("./types/CorrelationType").SampleForSaving[], start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+export declare const saveQuantitySample: (identifier: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+export declare const saveWorkoutSample: (workoutActivityType: import("./types/Workouts").WorkoutActivityType, quantities: readonly import("./types/QuantitySample").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types/Workouts").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<string>;
+export declare const subscribeToChanges: (typeIdentifier: import("./types/Shared").SampleTypeIdentifier, callback: (args: import("./types/Subscriptons").OnChangeCallbackArgs) => void) => string;
+export declare const startWatchApp: (workoutConfiguration: import("./types/WorkoutKit").WorkoutConfiguration) => Promise<boolean>;
+export declare const isProtectedDataAvailable: () => boolean;
+export declare const queryStateOfMindSamples: (options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly import("./types/StateOfMind").StateOfMindSample[]>;
+export declare const saveStateOfMindSample: (date: Date, kind: import("./types/StateOfMind").StateOfMindKind, valence: number, labels: readonly import("./types/StateOfMind").StateOfMindLabel[], associations: readonly import("./types/StateOfMind").StateOfMindAssociation[], metadata?: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+export declare const isQuantityCompatibleWithUnit: (identifier: QuantityTypeIdentifier, unit: string) => boolean;
+export declare const unsubscribeQueries: (queryIds: string[]) => number;
+export declare const isObjectTypeAvailable: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => boolean;
+export declare const isObjectTypeAvailableAsync: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => Promise<boolean>;
+export declare const areObjectTypesAvailable: (objectTypeIdentifiers: import("./types/Shared").ObjectTypeIdentifier[]) => Record<string, boolean>;
+export declare const areObjectTypesAvailableAsync: (objectTypeIdentifiers: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<Record<string, boolean>>;
+export declare const getBiologicalSexAsync: () => Promise<import("./types/Characteristics").BiologicalSex>;
+export declare const getBloodTypeAsync: () => Promise<import("./types/Characteristics").BloodType>;
+export declare const getDateOfBirthAsync: () => Promise<Date>;
+export declare const getFitzpatrickSkinTypeAsync: () => Promise<import("./types/Characteristics").FitzpatrickSkinType>;
+export declare const getWheelchairUseAsync: () => Promise<import("./types/Characteristics").WheelchairUse>;
+declare const _default: {
+    authorizationStatusFor: (type: import("./types/Shared").ObjectTypeIdentifier) => import("./types/Auth").AuthorizationStatus;
+    isObjectTypeAvailable: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => boolean;
+    isObjectTypeAvailableAsync: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => Promise<boolean>;
+    areObjectTypesAvailable: (objectTypeIdentifiers: import("./types/Shared").ObjectTypeIdentifier[]) => Record<string, boolean>;
+    areObjectTypesAvailableAsync: (objectTypeIdentifiers: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<Record<string, boolean>>;
+    isQuantityCompatibleWithUnit: (identifier: QuantityTypeIdentifier, unit: string) => boolean;
+    disableAllBackgroundDelivery: () => Promise<boolean>;
+    disableBackgroundDelivery: (typeIdentifier: import("./types/Shared").ObjectTypeIdentifier) => Promise<boolean>;
+    enableBackgroundDelivery: (typeIdentifier: import("./types/Shared").ObjectTypeIdentifier, updateFrequency: import("./types/Background").UpdateFrequency) => Promise<boolean>;
+    getBiologicalSex: () => import("./types/Characteristics").BiologicalSex;
+    getBloodType: () => import("./types/Characteristics").BloodType;
+    getDateOfBirth: () => Date;
+    getFitzpatrickSkinType: () => import("./types/Characteristics").FitzpatrickSkinType;
+    getBiologicalSexAsync: () => Promise<import("./types/Characteristics").BiologicalSex>;
+    getBloodTypeAsync: () => Promise<import("./types/Characteristics").BloodType>;
+    getDateOfBirthAsync: () => Promise<Date>;
+    getFitzpatrickSkinTypeAsync: () => Promise<import("./types/Characteristics").FitzpatrickSkinType>;
+    getWheelchairUseAsync: () => Promise<import("./types/Characteristics").WheelchairUse>;
+    getMostRecentCategorySample: typeof getMostRecentCategorySample;
+    getMostRecentQuantitySample: typeof getMostRecentQuantitySample;
+    getMostRecentWorkout: (options: Pick<import("./types/Workouts").WorkoutQueryOptions, "distanceUnit" | "energyUnit">) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy | undefined>;
+    getPreferredUnits: (identifiers: readonly QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types/Units").IdentifierWithUnit[]>;
+    getPreferredUnit: (quantityType: QuantityTypeIdentifier) => Promise<string>;
+    getRequestStatusForAuthorization: (toShare: import("./types/Shared").SampleTypeIdentifierWriteable[], toRead: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<import("./types/Auth").AuthorizationRequestStatus>;
+    getWheelchairUse: () => import("./types/Characteristics").WheelchairUse;
+    isHealthDataAvailable: () => boolean;
+    isHealthDataAvailableAsync: () => Promise<boolean>;
+    queryCategorySamples: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly import("./types/CategoryType").CategorySampleTyped<T>[]>;
+    queryCategorySamplesWithAnchor: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, options: import("./types/QueryOptions").QueryOptionsWithAnchor) => Promise<import("./types/CategoryType").CategorySamplesWithAnchorResponseTyped<T>>;
+    queryCorrelationSamples: (typeIdentifier: import("./types/CorrelationType").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly import("./types/CorrelationType").CorrelationSample[]>;
+    queryHeartbeatSeriesSamples: (options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly import("./types/HeartbeatSeries").HeartbeatSeriesSample[]>;
+    queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types/QueryOptions").QueryOptionsWithAnchor) => Promise<import("./types/HeartbeatSeries").HeartbeatSeriesSamplesWithAnchorResponse>;
+    queryQuantitySamples: (identifier: QuantityTypeIdentifier, options?: import("./types/QueryOptions").QueryOptionsWithSortOrderAndUnit) => Promise<readonly import("./types/QuantitySample").QuantitySample[]>;
+    queryQuantitySamplesWithAnchor: (identifier: QuantityTypeIdentifier, options: import("./types/QueryOptions").QueryOptionsWithAnchorAndUnit) => Promise<import("./types/QuantityType").QuantitySamplesWithAnchorResponse>;
+    queryStatisticsForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types/QuantityType").StatisticsOptions[], options?: import("./types/QuantityType").StatisticsQueryOptions) => Promise<import("./types/QuantityType").QueryStatisticsResponse>;
+    queryStatisticsCollectionForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types/QuantityType").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types/QuantityType").IntervalComponents, options?: import("./types/QuantityType").StatisticsQueryOptions) => Promise<readonly import("./types/QuantityType").QueryStatisticsResponse[]>;
+    queryWorkoutSamples: (options: import("./types/Workouts").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>;
+    queryWorkoutSamplesWithAnchor: (options: import("./types/Workouts").WorkoutQueryOptionsWithAnchor) => Promise<import("./types/Workouts").QueryWorkoutSamplesWithAnchorResponse>;
+    querySources: (identifier: import("./types/Shared").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
+    requestAuthorization: (toShare: import("./types/Shared").SampleTypeIdentifierWriteable[], toRead: import("./types/Shared").ObjectTypeIdentifier[]) => Promise<boolean>;
+    deleteObjects: (objectTypeIdentifier: import("./types/Shared").ObjectTypeIdentifier, filter: import("./types/QueryOptions").FilterForSamples) => Promise<number>;
+    saveCategorySample: <T extends import("./types/CategoryTypeIdentifier").CategoryTypeIdentifier>(identifier: T, value: import("./types/CategoryType").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types/CategoryType").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
+    saveCorrelationSample: (typeIdentifier: import("./types/CorrelationType").CorrelationTypeIdentifier, samples: import("./types/CorrelationType").SampleForSaving[], start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+    saveQuantitySample: (identifier: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+    saveWorkoutSample: (workoutActivityType: import("./types/Workouts").WorkoutActivityType, quantities: readonly import("./types/QuantitySample").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types/Workouts").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<string>;
+    subscribeToChanges: (typeIdentifier: import("./types/Shared").SampleTypeIdentifier, callback: (args: import("./types/Subscriptons").OnChangeCallbackArgs) => void) => string;
+    unsubscribeQueries: (queryIds: string[]) => number;
+    startWatchApp: (workoutConfiguration: import("./types/WorkoutKit").WorkoutConfiguration) => Promise<boolean>;
+    isProtectedDataAvailable: () => boolean;
+    queryStateOfMindSamples: (options?: import("./types/QueryOptions").QueryOptionsWithSortOrder) => Promise<readonly import("./types/StateOfMind").StateOfMindSample[]>;
+    saveStateOfMindSample: (date: Date, kind: import("./types/StateOfMind").StateOfMindKind, valence: number, labels: readonly import("./types/StateOfMind").StateOfMindLabel[], associations: readonly import("./types/StateOfMind").StateOfMindAssociation[], metadata?: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
+    useMostRecentCategorySample: typeof useMostRecentCategorySample;
+    useMostRecentQuantitySample: typeof useMostRecentQuantitySample;
+    useMostRecentWorkout: typeof useMostRecentWorkout;
+    useSubscribeToChanges: typeof useSubscribeToChanges;
+    useHealthkitAuthorization: (read: import("./types/Shared").ObjectTypeIdentifier[], write?: import("./types/Shared").SampleTypeIdentifierWriteable[]) => readonly [import("./types/Auth").AuthorizationRequestStatus | null, () => Promise<import("./types/Auth").AuthorizationRequestStatus>];
+    useIsHealthDataAvailable: () => boolean | null;
+    useSources: typeof useSources;
+    useStatisticsForQuantity: typeof useStatisticsForQuantity;
+};
+export default _default;

package/lib/typescript/modules.d.ts

@@ -0,0 +1,16 @@
+import type { 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 declare const Core: CoreModule;
+export declare const Workouts: WorkoutsModule;
+export declare const Characteristics: CharacteristicTypeModule;
+export declare const QuantityTypes: QuantityTypeModule;
+export declare const CategoryTypes: CategoryTypeModuleTyped;
+export declare const CorrelationTypes: CorrelationTypeModule;
+export declare const HeartbeatSeries: HeartbeatSeriesModule;
+export declare const StateOfMind: StateOfMindModule;

package/lib/typescript/specs/CategoryTypeModule.nitro.d.ts

@@ -0,0 +1,16 @@
+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 { 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>;
+}
+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/lib/typescript/specs/CharacteristicTypeModule.nitro.d.ts

@@ -0,0 +1,16 @@
+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/lib/typescript/specs/CoreModule.nitro.d.ts

@@ -0,0 +1,60 @@
+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/lib/typescript/specs/CorrelationTypeModule.nitro.d.ts

@@ -0,0 +1,8 @@
+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[]>;
+}

package/lib/typescript/specs/HeartbeatSeriesModule.nitro.d.ts

@@ -0,0 +1,9 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { HeartbeatSeriesSample, HeartbeatSeriesSamplesWithAnchorResponse } from '../types/HeartbeatSeries';
+import type { QueryOptionsWithAnchor, QueryOptionsWithSortOrder } from '../types/QueryOptions';
+export interface HeartbeatSeriesModule extends HybridObject<{
+    ios: 'swift';
+}> {
+    queryHeartbeatSeriesSamples(options?: QueryOptionsWithSortOrder): Promise<readonly HeartbeatSeriesSample[]>;
+    queryHeartbeatSeriesSamplesWithAnchor(options: QueryOptionsWithAnchor): Promise<HeartbeatSeriesSamplesWithAnchorResponse>;
+}

package/lib/typescript/specs/QuantityTypeModule.nitro.d.ts

@@ -0,0 +1,16 @@
+import type { AnyMap, HybridObject } from 'react-native-nitro-modules';
+import type { QuantitySample } from '../types/QuantitySample';
+import type { IntervalComponents, QuantitySamplesWithAnchorResponse, QueryStatisticsResponse, StatisticsOptions, StatisticsQueryOptions } from '../types/QuantityType';
+import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier';
+import type { FilterForSamples, QueryOptionsWithAnchorAndUnit, QueryOptionsWithSortOrderAndUnit } from '../types/QueryOptions';
+export interface QuantityTypeModule extends HybridObject<{
+    ios: 'swift';
+}> {
+    isQuantityCompatibleWithUnit(identifier: QuantityTypeIdentifier, unit: string): boolean;
+    saveQuantitySample(identifier: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: AnyMap): Promise<boolean>;
+    deleteQuantitySamples(identifier: QuantityTypeIdentifier, filter: FilterForSamples): Promise<boolean>;
+    queryQuantitySamples(identifier: QuantityTypeIdentifier, options?: QueryOptionsWithSortOrderAndUnit): Promise<readonly QuantitySample[]>;
+    queryStatisticsForQuantity(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], options?: StatisticsQueryOptions): Promise<QueryStatisticsResponse>;
+    queryStatisticsCollectionForQuantity(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], anchorDate: string, intervalComponents: IntervalComponents, options?: StatisticsQueryOptions): Promise<readonly QueryStatisticsResponse[]>;
+    queryQuantitySamplesWithAnchor(identifier: QuantityTypeIdentifier, options: QueryOptionsWithAnchorAndUnit): Promise<QuantitySamplesWithAnchorResponse>;
+}

package/lib/typescript/specs/SourceProxy.nitro.d.ts

@@ -0,0 +1,14 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+interface Source {
+    readonly name: string;
+    readonly bundleIdentifier: string;
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkobject/1615781-source Apple Docs }
+ */
+export interface SourceProxy extends HybridObject<{
+    ios: 'swift';
+}>, Source {
+    toJSON(key?: string): Source;
+}
+export {};

package/lib/typescript/specs/StateOfMindModule.nitro.d.ts

@@ -0,0 +1,9 @@
+import type { AnyMap, HybridObject } from 'react-native-nitro-modules';
+import type { QueryOptionsWithSortOrder } from '../types/QueryOptions';
+import type { StateOfMindAssociation, StateOfMindKind, StateOfMindLabel, StateOfMindSample } from '../types/StateOfMind';
+export interface StateOfMindModule extends HybridObject<{
+    ios: 'swift';
+}> {
+    queryStateOfMindSamples(options?: QueryOptionsWithSortOrder): Promise<readonly StateOfMindSample[]>;
+    saveStateOfMindSample(date: Date, kind: StateOfMindKind, valence: number, labels: readonly StateOfMindLabel[], associations: readonly StateOfMindAssociation[], metadata?: AnyMap): Promise<boolean>;
+}

package/lib/typescript/specs/WorkoutProxy.nitro.d.ts

@@ -0,0 +1,10 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { LocationForSaving, WorkoutPlan, WorkoutRoute, WorkoutSample } from '../types/Workouts';
+export interface WorkoutProxy extends HybridObject<{
+    ios: 'swift';
+}>, WorkoutSample {
+    toJSON(key?: string): WorkoutSample;
+    saveWorkoutRoute(locations: readonly LocationForSaving[]): Promise<boolean>;
+    getWorkoutPlan(): Promise<WorkoutPlan | null>;
+    getWorkoutRoutes(): Promise<readonly WorkoutRoute[]>;
+}

package/lib/typescript/specs/WorkoutSessionModule.nitro.d.ts

@@ -0,0 +1,47 @@
+import type { AnyMap, HybridObject } from 'react-native-nitro-modules';
+import type { WorkoutConfiguration } from '../types/WorkoutKit';
+import type { WorkoutEventType } from '../types/Workouts';
+export interface WorkoutSessionMirroringStartHandlerOptions {
+    onError(errorMessage: string): void;
+    onStateChange(toState: WorkoutSessionState, fromState: WorkoutSessionState, date: Date): void;
+    onDataReceived(data: RemoteSessionSharableData[]): void;
+    onEventReceived(type: WorkoutEventType): void;
+}
+export interface WorkoutSessionModule extends HybridObject<{
+    ios: 'swift';
+}> {
+    /**
+     * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1648358-startwatchapp Apple Docs }
+     */
+    startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration): Promise<boolean>;
+    workoutSessionMirroringStartHandler(options: WorkoutSessionMirroringStartHandlerOptions): boolean;
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkworkoutsessionstate Apple Docs }
+ */
+export declare enum WorkoutSessionState {
+    NotStarted = 1,
+    Running = 2,
+    Ended = 3,
+    Paused = 4,
+    Prepared = 5,
+    Stopped = 6
+}
+export interface WorkoutStateChangeEvent {
+    readonly toState: WorkoutSessionState;
+    readonly fromState: WorkoutSessionState;
+    readonly date: Date;
+}
+export interface WorkoutErrorEvent {
+    readonly error: string;
+}
+export interface RemoteSessionSharableData {
+    readonly type: string;
+    readonly payload: AnyMap;
+}
+export interface WorkoutDataReceivedEvent {
+    readonly data: readonly RemoteSessionSharableData[];
+}
+export interface WorkoutEventReceivedEvent {
+    readonly type: WorkoutEventType;
+}

package/lib/typescript/specs/WorkoutsModule.nitro.d.ts

@@ -0,0 +1,13 @@
+import type { AnyMap, HybridObject } from 'react-native-nitro-modules';
+import type { QuantitySampleForSaving } from '../types/QuantitySample';
+import type { WorkoutConfiguration } from '../types/WorkoutKit';
+import type { QueryWorkoutSamplesWithAnchorResponse, WorkoutActivityType, WorkoutQueryOptions, WorkoutQueryOptionsWithAnchor, WorkoutTotals } from '../types/Workouts';
+import type { WorkoutProxy } from './WorkoutProxy.nitro';
+export interface WorkoutsModule extends HybridObject<{
+    ios: 'swift';
+}> {
+    saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: readonly QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMap): Promise<string>;
+    queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor): Promise<QueryWorkoutSamplesWithAnchorResponse>;
+    queryWorkoutSamples(options: WorkoutQueryOptions): Promise<WorkoutProxy[]>;
+    startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration): Promise<boolean>;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkauthorizationrequeststatus Apple Docs }
+ */
+export declare enum AuthorizationRequestStatus {
+    unknown = 0,
+    shouldRequest = 1,
+    unnecessary = 2
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkauthorizationstatus Apple Docs }
+ */
+export declare enum AuthorizationStatus {
+    notDetermined = 0,
+    sharingDenied = 1,
+    sharingAuthorized = 2
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkupdatefrequency Apple Docs }
+ */
+export declare enum UpdateFrequency {
+    immediate = 1,
+    hourly = 2,
+    daily = 3,
+    weekly = 4
+}