@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

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
+}

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

@@ -0,0 +1,144 @@
+import type { AnyMap } from 'react-native-nitro-modules';
+import type { CategoryTypeIdentifier } from './CategoryTypeIdentifier';
+import type { Device } from './Device';
+import type { DeletedSample, GenericMetadata } from './Shared';
+import type { SourceRevision } from './Source';
+export type CategoryTypePresenceIdentifier = 'HKCategoryTypeIdentifierAppetiteChanges' | 'HKCategoryTypeIdentifierSleepChanges';
+export type CategoryTypeValueNotApplicableIdentifier = 'HKCategoryTypeIdentifierHighHeartRateEvent' | 'HKCategoryTypeIdentifierIntermenstrualBleeding' | 'HKCategoryTypeIdentifierMindfulSession' | 'HKCategoryTypeIdentifierSexualActivity';
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvaluepregnancytestresult Apple Docs }
+ */
+declare enum CategoryValuePregnancyTestResult {
+    positive = 2,
+    negative = 1,
+    indeterminate = 3
+}
+export type CategoryTypeSeverityIdentifier = 'HKCategoryTypeIdentifierAbdominalCramps' | 'HKCategoryTypeIdentifierAcne' | 'HKCategoryTypeIdentifierBladderIncontinence' | 'HKCategoryTypeIdentifierBloating' | 'HKCategoryTypeIdentifierBreastPain' | 'HKCategoryTypeIdentifierChestTightnessOrPain' | 'HKCategoryTypeIdentifierChills' | 'HKCategoryTypeIdentifierConstipation' | 'HKCategoryTypeIdentifierCoughing' | 'HKCategoryTypeIdentifierDiarrhea' | 'HKCategoryTypeIdentifierDizziness' | 'HKCategoryTypeIdentifierDrySkin' | 'HKCategoryTypeIdentifierFainting' | 'HKCategoryTypeIdentifierFatigue' | 'HKCategoryTypeIdentifierFever' | 'HKCategoryTypeIdentifierGeneralizedBodyAche' | 'HKCategoryTypeIdentifierHairLoss' | 'HKCategoryTypeIdentifierHeadache' | 'HKCategoryTypeIdentifierHeartburn' | 'HKCategoryTypeIdentifierHotFlashes' | 'HKCategoryTypeIdentifierLossOfSmell' | 'HKCategoryTypeIdentifierLossOfTaste' | 'HKCategoryTypeIdentifierLowerBackPain' | 'HKCategoryTypeIdentifierMemoryLapse' | 'HKCategoryTypeIdentifierMoodChanges' | 'HKCategoryTypeIdentifierNausea' | 'HKCategoryTypeIdentifierNightSweats' | 'HKCategoryTypeIdentifierPelvicPain' | 'HKCategoryTypeIdentifierRapidPoundingOrFlutteringHeartbeat' | 'HKCategoryTypeIdentifierRunnyNose' | 'HKCategoryTypeIdentifierShortnessOfBreath' | 'HKCategoryTypeIdentifierSinusCongestion' | 'HKCategoryTypeIdentifierSkippedHeartbeat' | 'HKCategoryTypeIdentifierSoreThroat' | 'HKCategoryTypeIdentifierVaginalDryness' | 'HKCategoryTypeIdentifierVomiting' | 'HKCategoryTypeIdentifierWheezing';
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvaluecervicalmucusquality Apple Docs }
+ */
+export declare enum CategoryValueCervicalMucusQuality {
+    dry = 1,
+    sticky = 2,
+    creamy = 3,
+    watery = 4,
+    eggWhite = 5
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvaluemenstrualflow Apple Docs }
+ */
+export declare enum CategoryValueMenstrualFlow {
+    unspecified = 1,
+    none = 5,
+    light = 2,
+    medium = 3,
+    heavy = 4
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvalueovulationtestresult Apple Docs }
+ */
+export declare enum CategoryValueOvulationTestResult {
+    negative = 1,
+    luteinizingHormoneSurge = 2,
+    indeterminate = 3,
+    estrogenSurge = 4
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvaluesleepanalysis Apple Docs }
+ */
+export declare enum CategoryValueSleepAnalysis {
+    inBed = 0,
+    asleepUnspecified = 1,
+    awake = 2,
+    asleepCore = 3,
+    asleepDeep = 4,
+    asleepREM = 5
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvalueappetitechanges Apple Docs}
+ */
+export declare enum CategoryValueAppetiteChanges {
+    decreased = 2,
+    increased = 3,
+    noChange = 1,
+    unspecified = 0
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvaluepresence Apple Docs}
+ */
+export declare enum CategoryValuePresence {
+    notPresent = 1,
+    present = 0
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvalueseverity Apple Docs }
+ */
+export declare enum CategoryValueSeverity {
+    notPresent = 1,
+    mild = 2,
+    moderate = 3,
+    severe = 4,
+    unspecified = 0
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvalue/notapplicable Apple Docs }
+ */
+export declare enum CategoryValueNotApplicable {
+    notApplicable = 0
+}
+export declare enum CategoryValueLowCardioFitnessEvent {
+    lowFitness = 1
+}
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategoryvalue Apple Docs }
+ */
+export type CategoryValue = CategoryValueAppetiteChanges | CategoryValueCervicalMucusQuality | CategoryValueLowCardioFitnessEvent | CategoryValueMenstrualFlow | CategoryValueOvulationTestResult | CategoryValuePresence | CategoryValueSeverity | CategoryValueSleepAnalysis | number;
+export declare enum CategoryValueAppleStandHour {
+    stood = 0,
+    idle = 1
+}
+export interface CategorySampleForSaving {
+    readonly start: Date;
+    readonly end: Date;
+    readonly categoryType: CategoryTypeIdentifier;
+    readonly value: CategoryValueForIdentifier;
+    readonly metadata: AnyMap;
+    readonly sourceRevision?: SourceRevision;
+}
+export interface CategorySamplesWithAnchorResponse {
+    readonly samples: readonly CategorySample[];
+    readonly deletedSamples: readonly DeletedSample[];
+    readonly newAnchor: string;
+}
+export interface CategorySample {
+    readonly uuid: string;
+    readonly device?: Device;
+    readonly categoryType: CategoryTypeIdentifier;
+    readonly startDate: Date;
+    readonly endDate: Date;
+    readonly value: CategoryValueForIdentifier;
+    readonly metadata: AnyMap;
+    readonly sourceRevision?: SourceRevision;
+}
+export interface CategorySamplesWithAnchorResponseTyped<T extends CategoryTypeIdentifier> {
+    readonly samples: readonly CategorySampleTyped<T>[];
+    readonly deletedSamples: readonly DeletedSample[];
+    readonly newAnchor: string;
+}
+export interface CategorySampleTyped<T extends CategoryTypeIdentifier> {
+    readonly uuid: string;
+    readonly device?: Device;
+    readonly categoryType: T;
+    readonly startDate: Date;
+    readonly endDate: Date;
+    readonly value: CategoryValueForIdentifier<T>;
+    readonly metadata: MetadataForCategoryIdentifier<T>;
+    readonly sourceRevision?: SourceRevision;
+}
+export type MetadataForCategoryIdentifier<T extends CategoryTypeIdentifier = CategoryTypeIdentifier> = T extends 'HKCategoryTypeIdentifierSexualActivity' ? GenericMetadata & {
+    readonly HKSexualActivityProtectionUsed: boolean;
+} : T extends 'HKCategoryTypeIdentifierMenstrualFlow' ? GenericMetadata & {
+    readonly HKMenstrualCycleStart: boolean;
+} : GenericMetadata;
+export type CategoryValueForIdentifier<T extends CategoryTypeIdentifier = CategoryTypeIdentifier> = T extends 'HKCategoryTypeIdentifierCervicalMucusQuality' ? CategoryValueCervicalMucusQuality : T extends 'CategoryTypeIdentifierMenstrualFlow' ? CategoryValueMenstrualFlow : T extends 'HKCategoryTypeIdentifierOvulationTestResult' ? CategoryValueOvulationTestResult : T extends 'HKCategoryTypeIdentifierSleepAnalysis' ? CategoryValueSleepAnalysis : T extends CategoryTypeValueNotApplicableIdentifier ? CategoryValueNotApplicable : T extends CategoryTypeSeverityIdentifier ? CategoryValueSeverity : T extends CategoryTypePresenceIdentifier ? CategoryValuePresence : T extends 'HKCategoryTypeIdentifierLowCardioFitnessEvent' ? CategoryValueLowCardioFitnessEvent : T extends 'HKCategoryTypeIdentifierPregnancyTestResult' ? CategoryValuePregnancyTestResult : T extends 'HKCategoryTypeIdentifierPregnancyTestResult' ? CategoryValuePregnancyTestResult : T extends 'HKCategoryTypeIdentifierAppleStandHour' ? CategoryValueAppleStandHour : number;
+export {};

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

@@ -0,0 +1,31 @@
+export type CategoryTypeIdentifierReadOnly = 'HKCategoryTypeIdentifierAppleStandHour' | 'HKCategoryTypeIdentifierHighHeartRateEvent' | 'HKCategoryTypeIdentifierLowHeartRateEvent' | 'HKCategoryTypeIdentifierHeadphoneAudioExposureEvent';
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategorytypeidentifier Apple Docs }
+ */
+export type CategoryTypeIdentifierWriteable = 'HKCategoryTypeIdentifierSleepAnalysis' | 'HKCategoryTypeIdentifierCervicalMucusQuality' | 'HKCategoryTypeIdentifierOvulationTestResult'
+/**
+ * @deprecated In iOS 18 beta
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategorytypeidentifiermenstrualflow Apple Docs }
+ */
+ | 'HKCategoryTypeIdentifierMenstrualFlow' | 'HKCategoryTypeIdentifierIntermenstrualBleeding' | 'HKCategoryTypeIdentifierSexualActivity' | 'HKCategoryTypeIdentifierMindfulSession' | 'HKCategoryTypeIdentifierIrregularHeartRhythmEvent'
+/**
+ * @deprecated Use environmentalAudioExposureEvent instead.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategorytypeidentifier/audioexposureevent Apple Docs }
+ */
+ | 'HKCategoryTypeIdentifierAudioExposureEvent' | 'HKCategoryTypeIdentifierToothbrushingEvent' | 'HKCategoryTypeIdentifierLowCardioFitnessEvent' | 'HKCategoryTypeIdentifierContraceptive' | 'HKCategoryTypeIdentifierLactation' | 'HKCategoryTypeIdentifierPregnancy' | 'HKCategoryTypeIdentifierPregnancyTestResult' | 'HKCategoryTypeIdentifierProgesteroneTestResult' | 'HKCategoryTypeIdentifierEnvironmentalAudioExposureEvent' | 'HKCategoryTypeIdentifierAppleWalkingSteadinessEvent' | 'HKCategoryTypeIdentifierHandwashingEvent' | 'HKCategoryTypeIdentifierAbdominalCramps' | 'HKCategoryTypeIdentifierAcne' | 'HKCategoryTypeIdentifierAppetiteChanges' | 'HKCategoryTypeIdentifierBladderIncontinence' | 'HKCategoryTypeIdentifierBloating' | 'HKCategoryTypeIdentifierBreastPain' | 'HKCategoryTypeIdentifierChestTightnessOrPain' | 'HKCategoryTypeIdentifierChills' | 'HKCategoryTypeIdentifierConstipation' | 'HKCategoryTypeIdentifierCoughing' | 'HKCategoryTypeIdentifierDiarrhea' | 'HKCategoryTypeIdentifierDizziness' | 'HKCategoryTypeIdentifierDrySkin' | 'HKCategoryTypeIdentifierFainting' | 'HKCategoryTypeIdentifierFatigue' | 'HKCategoryTypeIdentifierFever' | 'HKCategoryTypeIdentifierGeneralizedBodyAche' | 'HKCategoryTypeIdentifierHairLoss' | 'HKCategoryTypeIdentifierHeadache' | 'HKCategoryTypeIdentifierHeartburn' | 'HKCategoryTypeIdentifierHotFlashes' | 'HKCategoryTypeIdentifierLossOfSmell' | 'HKCategoryTypeIdentifierLossOfTaste' | 'HKCategoryTypeIdentifierLowerBackPain' | 'HKCategoryTypeIdentifierMemoryLapse' | 'HKCategoryTypeIdentifierMoodChanges' | 'HKCategoryTypeIdentifierNausea' | 'HKCategoryTypeIdentifierNightSweats' | 'HKCategoryTypeIdentifierPelvicPain' | 'HKCategoryTypeIdentifierRapidPoundingOrFlutteringHeartbeat' | 'HKCategoryTypeIdentifierRunnyNose' | 'HKCategoryTypeIdentifierShortnessOfBreath' | 'HKCategoryTypeIdentifierSinusCongestion' | 'HKCategoryTypeIdentifierSkippedHeartbeat' | 'HKCategoryTypeIdentifierSleepChanges' | 'HKCategoryTypeIdentifierSoreThroat' | 'HKCategoryTypeIdentifierVaginalDryness' | 'HKCategoryTypeIdentifierVomiting' | 'HKCategoryTypeIdentifierWheezing'
+/**
+ * Bleeding After Pregnancy
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategorytypeidentifierbleedingafterpregnancy Apple Docs }
+ * @since iOS 18
+ */
+ | 'HKCategoryTypeIdentifierBleedingAfterPregnancy'
+/**
+ * Bleeding During Pregnancy
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategorytypeidentifierbleedingduringpregnancy Apple Docs }
+ * @since iOS 18
+ */
+ | 'HKCategoryTypeIdentifierBleedingDuringPregnancy';
+/**
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkcategorytypeidentifier Apple Docs }
+ */
+export type CategoryTypeIdentifier = CategoryTypeIdentifierReadOnly | CategoryTypeIdentifierWriteable;