@kingstinct/react-native-healthkit 11.1.2 → 12.1.0

package/lib/typescript/healthkit.d.ts

@@ -12,13 +12,15 @@ export declare const disableAllBackgroundDelivery: () => Promise<boolean>;
 export declare const disableBackgroundDelivery: (typeIdentifier: import("./types").ObjectTypeIdentifier) => Promise<boolean>;
 export declare const enableBackgroundDelivery: (typeIdentifier: import("./types").ObjectTypeIdentifier, updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
 export declare const getPreferredUnits: (identifiers: readonly import("./types").QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types").IdentifierWithUnit[]>;
-export declare const getRequestStatusForAuthorization: (toShare: readonly import("./types").SampleTypeIdentifierWriteable[], toRead: readonly import("./types").ObjectTypeIdentifier[]) => Promise<AuthorizationRequestStatus>;
+export declare const getRequestStatusForAuthorization: (toCheck: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<AuthorizationRequestStatus>;
 export declare const isHealthDataAvailable: () => boolean;
 export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
 export declare const querySources: (identifier: import("./types").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
-export declare const requestAuthorization: (toShare: readonly import("./types").SampleTypeIdentifierWriteable[], toRead: readonly import("./types").ObjectTypeIdentifier[]) => Promise<boolean>;
+export declare const requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
 export declare const deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
-export declare const subscribeToChanges: (typeIdentifier: import("./types").SampleTypeIdentifier, callback: (args: import("./types").OnChangeCallbackArgs) => void) => string;
+export declare const subscribeToChanges: (identifier: import("./types").SampleTypeIdentifier, callback: (args: import("./types").OnChangeCallbackArgs) => void) => {
+    remove: () => boolean;
+};
 export declare const isProtectedDataAvailable: () => boolean;
 export declare const isObjectTypeAvailable: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier) => boolean;
 export declare const isObjectTypeAvailableAsync: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier) => Promise<boolean>;
@@ -26,13 +28,13 @@ export declare const areObjectTypesAvailable: (objectTypeIdentifiers: readonly i
 export declare const areObjectTypesAvailableAsync: (objectTypeIdentifiers: import("./types").ObjectTypeIdentifier[]) => Promise<Record<string, boolean>>;
 export declare const getBiologicalSex: () => BiologicalSex;
 export declare const getBloodType: () => BloodType;
-export declare const getDateOfBirth: () => Date | null;
+export declare const getDateOfBirth: () => Date | undefined;
 export declare const getFitzpatrickSkinType: () => FitzpatrickSkinType;
 export declare const getWheelchairUse: () => WheelchairUse;
 export declare const queryQuantitySamples: (identifier: import("./types").QuantityTypeIdentifier, options?: import("./types").QueryOptionsWithSortOrderAndUnit) => Promise<readonly QuantitySample[]>;
 export declare const queryQuantitySamplesWithAnchor: (identifier: import("./types").QuantityTypeIdentifier, options: import("./types").QueryOptionsWithAnchorAndUnit) => Promise<import("./types").QuantitySamplesWithAnchorResponse>;
 export declare const queryStatisticsForQuantity: (identifier: import("./types").QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions) => Promise<import("./types").QueryStatisticsResponse>;
-export declare const queryStatisticsCollectionForQuantity: (identifier: import("./types").QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
+export declare const queryStatisticsCollectionForQuantity: (identifier: import("./types").QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
 export declare const saveQuantitySample: (identifier: import("./types").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, unit: string) => boolean;
 export declare function queryCategorySamples<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T, _options?: QueryOptionsWithSortOrder): Promise<CategorySampleTyped<T>[]>;
@@ -46,7 +48,7 @@ export declare const queryElectrocardiogramSamples: (options?: import("./types/E
 export declare const queryElectrocardiogramSamplesWithAnchor: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithAnchor) => Promise<import("./types/ElectrocardiogramSample").ElectrocardiogramSamplesWithAnchorResponse>;
 export declare const queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<WorkoutProxy[]>;
 export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
-export declare const saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<WorkoutProxy>;
+export declare const saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals?: import("./types").WorkoutTotals, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<WorkoutProxy>;
 export declare const startWatchApp: (workoutConfiguration: import("./types").WorkoutConfiguration) => Promise<boolean>;
 export declare const queryStateOfMindSamples: (options?: QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
 export declare const saveStateOfMindSample: (date: Date, kind: import("./types").StateOfMindKind, valence: number, labels: readonly import("./types").StateOfMindLabel[], associations: readonly import("./types").StateOfMindAssociation[], metadata?: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
@@ -58,15 +60,23 @@ export declare function useMostRecentCategorySample<T extends CategoryTypeIdenti
 export declare const useMostRecentQuantitySample: typeof import("./healthkit.ios").useMostRecentQuantitySample;
 export declare const useMostRecentWorkout: typeof import("./healthkit.ios").useMostRecentWorkout;
 export declare const useSubscribeToChanges: typeof import("./healthkit.ios").useSubscribeToChanges;
-export declare const useHealthkitAuthorization: (read: readonly import("./types").ObjectTypeIdentifier[], write?: readonly import("./types").SampleTypeIdentifierWriteable[]) => readonly [AuthorizationRequestStatus | null, () => Promise<AuthorizationRequestStatus>];
+export declare const useHealthkitAuthorization: ({ toWrite, toRead, }: {
+    toRead?: readonly import("./types").ObjectTypeIdentifier[];
+    toWrite?: readonly import("./types").SampleTypeIdentifierWriteable[];
+}) => readonly [AuthorizationRequestStatus | null, () => Promise<AuthorizationRequestStatus>];
 export declare const useIsHealthDataAvailable: () => boolean | null;
 export declare const useSources: typeof import("./healthkit.ios").useSources;
 export declare const useStatisticsForQuantity: typeof import("./healthkit.ios").useStatisticsForQuantity;
 export declare const getBiologicalSexAsync: () => Promise<BiologicalSex>;
 export declare const getBloodTypeAsync: () => Promise<BloodType>;
-export declare const getDateOfBirthAsync: () => Promise<Date | null>;
+export declare const getDateOfBirthAsync: () => Promise<Date | undefined>;
 export declare const getFitzpatrickSkinTypeAsync: () => Promise<FitzpatrickSkinType>;
 export declare const getWheelchairUseAsync: () => Promise<WheelchairUse>;
-export declare const unsubscribeQueries: (queryIds: string[]) => number;
+declare const subscribeToQuantitySamples: (identifier: import("./types").QuantityTypeIdentifier, callback: (args: import("./types").OnQuantitySamplesCallback) => void, after?: Date) => {
+    remove: () => boolean;
+};
+export { subscribeToQuantitySamples };
+declare const useSubscribeToQuantitySamples: typeof import("./healthkit.ios").useSubscribeToQuantitySamples;
+export { useSubscribeToQuantitySamples };
 declare const _default: typeof ReactNativeHealthkit;
 export default _default;

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

@@ -6,11 +6,14 @@ import useMostRecentWorkout from './hooks/useMostRecentWorkout';
 import useSources from './hooks/useSources';
 import useStatisticsForQuantity from './hooks/useStatisticsForQuantity';
 import useSubscribeToChanges from './hooks/useSubscribeToChanges';
+import useSubscribeToQuantitySamples from './hooks/useSubscribeToQuantitySamples';
 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';
+import { subscribeToChanges } from './utils/subscribeToChanges';
+import { subscribeToQuantitySamples } from './utils/subscribeToQuantitySamples';
 export * from './types';
 declare const currentMajorVersionIOS: number;
 /**
@@ -21,7 +24,7 @@ type QuantityTypesIOS17Plus = 'HKQuantityTypeIdentifierCyclingCadence' | 'HKQuan
  * 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, };
+export { getMostRecentCategorySample, getMostRecentQuantitySample, getMostRecentWorkout, getPreferredUnit, subscribeToChanges, subscribeToQuantitySamples, useHealthkitAuthorization, useIsHealthDataAvailable, useMostRecentCategorySample, useMostRecentQuantitySample, useMostRecentWorkout, useSources, useStatisticsForQuantity, useSubscribeToChanges, useSubscribeToQuantitySamples, };
 /**
  * Available quantity types for iOS 17 and later (all quantity types)
  */
@@ -38,10 +41,10 @@ export declare const disableBackgroundDelivery: (typeIdentifier: import("./types
 export declare const enableBackgroundDelivery: (typeIdentifier: import("./types").ObjectTypeIdentifier, updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
 export declare const getBiologicalSex: () => import("./types").BiologicalSex;
 export declare const getBloodType: () => import("./types").BloodType;
-export declare const getDateOfBirth: () => Date | null;
+export declare const getDateOfBirth: () => Date | undefined;
 export declare const getFitzpatrickSkinType: () => import("./types").FitzpatrickSkinType;
 export declare const getPreferredUnits: (identifiers: readonly QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types").IdentifierWithUnit[]>;
-export declare const getRequestStatusForAuthorization: (toShare: readonly import("./types").SampleTypeIdentifierWriteable[], toRead: readonly import("./types").ObjectTypeIdentifier[]) => Promise<import("./types").AuthorizationRequestStatus>;
+export declare const getRequestStatusForAuthorization: (toCheck: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<import("./types").AuthorizationRequestStatus>;
 export declare const getWheelchairUse: () => import("./types").WheelchairUse;
 export declare const isHealthDataAvailable: () => boolean;
 export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
@@ -55,30 +58,28 @@ export declare const queryElectrocardiogramSamplesWithAnchor: (options: import("
 export declare const queryQuantitySamples: (identifier: QuantityTypeIdentifier, options?: import("./types").QueryOptionsWithSortOrderAndUnit) => Promise<readonly import("./types").QuantitySample[]>;
 export declare const queryQuantitySamplesWithAnchor: (identifier: QuantityTypeIdentifier, options: import("./types").QueryOptionsWithAnchorAndUnit) => Promise<import("./types").QuantitySamplesWithAnchorResponse>;
 export declare const queryStatisticsForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions) => Promise<import("./types").QueryStatisticsResponse>;
-export declare const queryStatisticsCollectionForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
+export declare const queryStatisticsCollectionForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
 export declare const queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>;
 export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
 export declare const querySources: (identifier: import("./types").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
-export declare const requestAuthorization: (toShare: readonly import("./types").SampleTypeIdentifierWriteable[], toRead: readonly import("./types").ObjectTypeIdentifier[]) => Promise<boolean>;
+export declare const requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
 export declare const deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
 export declare const saveCategorySample: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
 export declare const saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").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").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy>;
-export declare const subscribeToChanges: (typeIdentifier: import("./types").SampleTypeIdentifier, callback: (args: import("./types").OnChangeCallbackArgs) => void) => string;
+export declare const saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals?: import("./types").WorkoutTotals, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy>;
 export declare const startWatchApp: (workoutConfiguration: import("./types").WorkoutConfiguration) => Promise<boolean>;
 export declare const isProtectedDataAvailable: () => boolean;
 export declare const queryStateOfMindSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
 export declare const saveStateOfMindSample: (date: Date, kind: import("./types").StateOfMindKind, valence: number, labels: readonly import("./types").StateOfMindLabel[], associations: readonly import("./types").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").ObjectTypeIdentifier) => boolean;
 export declare const isObjectTypeAvailableAsync: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier) => Promise<boolean>;
 export declare const areObjectTypesAvailable: (objectTypeIdentifiers: readonly import("./types").ObjectTypeIdentifier[]) => Record<string, boolean>;
 export declare const areObjectTypesAvailableAsync: (objectTypeIdentifiers: import("./types").ObjectTypeIdentifier[]) => Promise<Record<string, boolean>>;
 export declare const getBiologicalSexAsync: () => Promise<import("./types").BiologicalSex>;
 export declare const getBloodTypeAsync: () => Promise<import("./types").BloodType>;
-export declare const getDateOfBirthAsync: () => Promise<Date | null>;
+export declare const getDateOfBirthAsync: () => Promise<Date | undefined>;
 export declare const getFitzpatrickSkinTypeAsync: () => Promise<import("./types").FitzpatrickSkinType>;
 export declare const getWheelchairUseAsync: () => Promise<import("./types").WheelchairUse>;
 declare const _default: {
@@ -93,11 +94,11 @@ declare const _default: {
     enableBackgroundDelivery: (typeIdentifier: import("./types").ObjectTypeIdentifier, updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
     getBiologicalSex: () => import("./types").BiologicalSex;
     getBloodType: () => import("./types").BloodType;
-    getDateOfBirth: () => Date | null;
+    getDateOfBirth: () => Date | undefined;
     getFitzpatrickSkinType: () => import("./types").FitzpatrickSkinType;
     getBiologicalSexAsync: () => Promise<import("./types").BiologicalSex>;
     getBloodTypeAsync: () => Promise<import("./types").BloodType>;
-    getDateOfBirthAsync: () => Promise<Date | null>;
+    getDateOfBirthAsync: () => Promise<Date | undefined>;
     getFitzpatrickSkinTypeAsync: () => Promise<import("./types").FitzpatrickSkinType>;
     getWheelchairUseAsync: () => Promise<import("./types").WheelchairUse>;
     getMostRecentCategorySample: typeof getMostRecentCategorySample;
@@ -105,7 +106,7 @@ declare const _default: {
     getMostRecentWorkout: () => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy | undefined>;
     getPreferredUnits: (identifiers: readonly QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types").IdentifierWithUnit[]>;
     getPreferredUnit: (quantityType: QuantityTypeIdentifier) => Promise<string>;
-    getRequestStatusForAuthorization: (toShare: readonly import("./types").SampleTypeIdentifierWriteable[], toRead: readonly import("./types").ObjectTypeIdentifier[]) => Promise<import("./types").AuthorizationRequestStatus>;
+    getRequestStatusForAuthorization: (toCheck: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<import("./types").AuthorizationRequestStatus>;
     getWheelchairUse: () => import("./types").WheelchairUse;
     isHealthDataAvailable: () => boolean;
     isHealthDataAvailableAsync: () => Promise<boolean>;
@@ -119,18 +120,22 @@ declare const _default: {
     queryQuantitySamples: (identifier: QuantityTypeIdentifier, options?: import("./types").QueryOptionsWithSortOrderAndUnit) => Promise<readonly import("./types").QuantitySample[]>;
     queryQuantitySamplesWithAnchor: (identifier: QuantityTypeIdentifier, options: import("./types").QueryOptionsWithAnchorAndUnit) => Promise<import("./types").QuantitySamplesWithAnchorResponse>;
     queryStatisticsForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions) => Promise<import("./types").QueryStatisticsResponse>;
-    queryStatisticsCollectionForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: string, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
+    queryStatisticsCollectionForQuantity: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
     queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>;
     queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
     querySources: (identifier: import("./types").SampleTypeIdentifier) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
-    requestAuthorization: (toShare: readonly import("./types").SampleTypeIdentifierWriteable[], toRead: readonly import("./types").ObjectTypeIdentifier[]) => Promise<boolean>;
+    requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
     deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
     saveCategorySample: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
     saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").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").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy>;
-    subscribeToChanges: (typeIdentifier: import("./types").SampleTypeIdentifier, callback: (args: import("./types").OnChangeCallbackArgs) => void) => string;
-    unsubscribeQueries: (queryIds: string[]) => number;
+    saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals?: import("./types").WorkoutTotals, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy>;
+    subscribeToChanges: (identifier: import("./types").SampleTypeIdentifier, callback: (args: import("./types").OnChangeCallbackArgs) => void) => {
+        remove: () => boolean;
+    };
+    subscribeToQuantitySamples: (identifier: QuantityTypeIdentifier, callback: (args: import("./types").OnQuantitySamplesCallback) => void, after?: Date) => {
+        remove: () => boolean;
+    };
     startWatchApp: (workoutConfiguration: import("./types").WorkoutConfiguration) => Promise<boolean>;
     isProtectedDataAvailable: () => boolean;
     queryStateOfMindSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
@@ -139,7 +144,11 @@ declare const _default: {
     useMostRecentQuantitySample: typeof useMostRecentQuantitySample;
     useMostRecentWorkout: typeof useMostRecentWorkout;
     useSubscribeToChanges: typeof useSubscribeToChanges;
-    useHealthkitAuthorization: (read: readonly import("./types").ObjectTypeIdentifier[], write?: readonly import("./types").SampleTypeIdentifierWriteable[]) => readonly [import("./types").AuthorizationRequestStatus | null, () => Promise<import("./types").AuthorizationRequestStatus>];
+    useSubscribeToQuantitySamples: typeof useSubscribeToQuantitySamples;
+    useHealthkitAuthorization: ({ toWrite, toRead, }: {
+        toRead?: readonly import("./types").ObjectTypeIdentifier[];
+        toWrite?: readonly import("./types").SampleTypeIdentifierWriteable[];
+    }) => readonly [import("./types").AuthorizationRequestStatus | null, () => Promise<import("./types").AuthorizationRequestStatus>];
     useIsHealthDataAvailable: () => boolean | null;
     useSources: typeof useSources;
     useStatisticsForQuantity: typeof useStatisticsForQuantity;

package/lib/typescript/hooks/useHealthkitAuthorization.d.ts

@@ -5,5 +5,8 @@ import type { ObjectTypeIdentifier, SampleTypeIdentifierWriteable } from '../typ
  * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs - requestAuthorization}
  * @see {@link https://developer.apple.com/documentation/healthkit/authorizing_access_to_health_data Apple Docs - Authorizing access to health data}
  */
-export declare const useHealthkitAuthorization: (read: readonly ObjectTypeIdentifier[], write?: readonly SampleTypeIdentifierWriteable[]) => readonly [AuthorizationRequestStatus | null, () => Promise<AuthorizationRequestStatus>];
+export declare const useHealthkitAuthorization: ({ toWrite, toRead, }: {
+    toRead?: readonly ObjectTypeIdentifier[];
+    toWrite?: readonly SampleTypeIdentifierWriteable[];
+}) => readonly [AuthorizationRequestStatus | null, () => Promise<AuthorizationRequestStatus>];
 export default useHealthkitAuthorization;

package/lib/typescript/hooks/useSubscribeToQuantitySamples.d.ts

@@ -0,0 +1,3 @@
+import type { OnQuantitySamplesCallback, QuantityTypeIdentifier } from '../types';
+export declare function useSubscribeToQuantitySamples<TIdentifier extends QuantityTypeIdentifier>(identifier: TIdentifier, onChange: (args: OnQuantitySamplesCallback) => void): void;
+export default useSubscribeToQuantitySamples;

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

@@ -4,12 +4,12 @@ export interface CharacteristicTypeModule extends HybridObject<{
     ios: 'swift';
 }> {
     getBloodType(): BloodType;
-    getDateOfBirth(): Date | null;
+    getDateOfBirth(): Date | undefined;
     getBiologicalSex(): BiologicalSex;
     getFitzpatrickSkinType(): FitzpatrickSkinType;
     getWheelchairUse(): WheelchairUse;
     getBloodTypeAsync(): Promise<BloodType>;
-    getDateOfBirthAsync(): Promise<Date | null>;
+    getDateOfBirthAsync(): Promise<Date | undefined>;
     getBiologicalSexAsync(): Promise<BiologicalSex>;
     getFitzpatrickSkinTypeAsync(): Promise<FitzpatrickSkinType>;
     getWheelchairUseAsync(): Promise<WheelchairUse>;

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

@@ -7,6 +7,10 @@ import type { ObjectTypeIdentifier, SampleTypeIdentifier, SampleTypeIdentifierWr
 import type { OnChangeCallbackArgs } from '../types/Subscriptions';
 import type { IdentifierWithUnit } from '../types/Units';
 import type { SourceProxy } from './SourceProxy.nitro';
+export interface AuthDataTypes {
+    toShare?: readonly SampleTypeIdentifierWriteable[];
+    toRead?: readonly ObjectTypeIdentifier[];
+}
 export interface CoreModule extends HybridObject<{
     ios: 'swift';
 }> {
@@ -41,17 +45,18 @@ export interface CoreModule extends HybridObject<{
     unsubscribeQueries(queryIds: string[]): number;
     unsubscribeQueriesAsync(queryIds: string[]): Promise<number>;
     /**
+     * Returns the app’s authorization status for sharing the specified data type.
      * @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: readonly SampleTypeIdentifierWriteable[], toRead: readonly ObjectTypeIdentifier[]): Promise<AuthorizationRequestStatus>;
+    getRequestStatusForAuthorization(toCheck: AuthDataTypes): Promise<AuthorizationRequestStatus>;
     /**
      * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs }
      */
-    requestAuthorization(toShare: readonly SampleTypeIdentifierWriteable[], toRead: readonly ObjectTypeIdentifier[]): Promise<boolean>;
+    requestAuthorization(toRequest: AuthDataTypes): Promise<boolean>;
     deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples): Promise<number>;
     isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier): boolean;
     areObjectTypesAvailable(objectTypeIdentifiers: readonly ObjectTypeIdentifier[]): Record<string, boolean>;

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

@@ -11,6 +11,6 @@ export interface QuantityTypeModule extends HybridObject<{
     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[]>;
+    queryStatisticsCollectionForQuantity(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], anchorDate: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptions): Promise<readonly QueryStatisticsResponse[]>;
     queryQuantitySamplesWithAnchor(identifier: QuantityTypeIdentifier, options: QueryOptionsWithAnchorAndUnit): Promise<QuantitySamplesWithAnchorResponse>;
 }

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

@@ -1,21 +1,13 @@
 import type { HybridObject } from 'react-native-nitro-modules';
-import type { Quantity, QuantityTypeIdentifier, QueryStatisticsResponse } from '../types';
+import type { QuantityTypeIdentifier, QueryStatisticsResponse } from '../types';
 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>;
+    getWorkoutPlan(): Promise<WorkoutPlan | undefined>;
     getWorkoutRoutes(): Promise<readonly WorkoutRoute[]>;
-    getStatistic(quantityType: QuantityTypeIdentifier, unitOverride?: string): Promise<QueryStatisticsResponse | null>;
+    getStatistic(quantityType: QuantityTypeIdentifier, unitOverride?: string): Promise<QueryStatisticsResponse | undefined>;
     getAllStatistics(): Promise<Record<string, QueryStatisticsResponse>>;
-    /** @deprecated Use allStatistics or statistic() method instead */
-    readonly totalDistance?: Quantity;
-    /** @deprecated Use allStatistics or statistic() method instead */
-    readonly totalEnergyBurned?: Quantity;
-    /** @deprecated Use allStatistics or statistic() method instead */
-    readonly totalSwimmingStrokeCount?: Quantity;
-    /** @deprecated Use allStatistics or statistic() method instead */
-    readonly totalFlightsClimbed?: Quantity;
 }

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

@@ -6,7 +6,7 @@ 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<WorkoutProxy>;
+    saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: readonly QuantitySampleForSaving[], startDate: Date, endDate: Date, totals?: WorkoutTotals, metadata?: AnyMap): Promise<WorkoutProxy>;
     queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor): Promise<QueryWorkoutSamplesWithAnchorResponse>;
     queryWorkoutSamples(options: WorkoutQueryOptions): Promise<WorkoutProxy[]>;
     /**

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

@@ -2,12 +2,12 @@
  * @see {@link https://developer.apple.com/documentation/healthkit/hkdevice Apple Docs }
  */
 export interface Device {
-    readonly name: string | null;
-    readonly firmwareVersion: string | null;
-    readonly hardwareVersion: string | null;
-    readonly localIdentifier: string | null;
-    readonly manufacturer: string | null;
-    readonly model: string | null;
-    readonly softwareVersion: string | null;
-    readonly udiDeviceIdentifier: string | null;
+    readonly name?: string;
+    readonly firmwareVersion?: string;
+    readonly hardwareVersion?: string;
+    readonly localIdentifier?: string;
+    readonly manufacturer?: string;
+    readonly model?: string;
+    readonly softwareVersion?: string;
+    readonly udiDeviceIdentifier?: string;
 }

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

@@ -5,6 +5,6 @@ import type { SourceProxy } from '../specs/SourceProxy.nitro';
 export interface SourceRevision {
     readonly source?: SourceProxy;
     readonly version?: string;
-    readonly operatingSystemVersion?: string | null;
-    readonly productType?: string | null;
+    readonly operatingSystemVersion?: string;
+    readonly productType?: string;
 }

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

@@ -1,4 +1,6 @@
-import type { SampleTypeIdentifier } from './Shared';
+import type { QuantitySample } from './QuantitySample';
+import type { QuantityTypeIdentifier } from './QuantityTypeIdentifier';
+import type { DeletedSample, SampleTypeIdentifier } from './Shared';
 export interface EmitterSubscription {
     remove: () => void;
 }
@@ -6,3 +8,14 @@ export interface OnChangeCallbackArgs {
     readonly typeIdentifier: SampleTypeIdentifier;
     readonly errorMessage?: string;
 }
+export interface OnQuantitySamplesCallbackError {
+    readonly typeIdentifier: QuantityTypeIdentifier;
+    readonly errorMessage: string;
+}
+export interface OnQuantitySamplesCallbackSuccess {
+    readonly typeIdentifier: QuantityTypeIdentifier;
+    readonly anchor: string;
+    readonly samples: readonly QuantitySample[];
+    readonly deletedSamples: readonly DeletedSample[];
+}
+export type OnQuantitySamplesCallback = OnQuantitySamplesCallbackError | OnQuantitySamplesCallbackSuccess;

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

@@ -205,7 +205,7 @@ export interface WorkoutRouteLocation {
     readonly altitude: number;
     readonly course: number;
     readonly date: Date;
-    readonly distance: number | null;
+    readonly distance?: number;
     readonly horizontalAccuracy: number;
     readonly latitude: number;
     readonly longitude: number;

package/lib/typescript/utils/subscribeToQuantitySamples.d.ts

@@ -0,0 +1,5 @@
+import type { QuantityTypeIdentifier } from '../types';
+import type { OnQuantitySamplesCallback } from '../types/Subscriptions';
+export declare const subscribeToQuantitySamples: (identifier: QuantityTypeIdentifier, callback: (args: OnQuantitySamplesCallback) => void, after?: Date) => {
+    remove: () => boolean;
+};