@kingstinct/react-native-healthkit 13.3.1 → 14.0.0

package/lib/typescript/healthkit.d.ts

@@ -1,18 +1,21 @@
 import type ReactNativeHealthkit from './healthkit.ios';
 import type { SourceProxy } from './specs/SourceProxy.nitro';
-import type { WorkoutProxy } from './specs/WorkoutProxy.nitro';
 import { AuthorizationRequestStatus, AuthorizationStatus } from './types/Auth';
-import type { CategorySamplesWithAnchorResponseTyped, CategorySampleTyped } from './types/CategoryType';
-import type { CategoryTypeIdentifier } from './types/CategoryTypeIdentifier';
+import type { CategorySamplesWithAnchorResponseTyped, CategorySampleTyped, CategoryValueForIdentifier, MetadataForCategoryIdentifier } from './types/CategoryType';
+import type { CategoryTypeIdentifier, CategoryTypeIdentifierWriteable } from './types/CategoryTypeIdentifier';
 import { BiologicalSex, BloodType, FitzpatrickSkinType, WheelchairUse } from './types/Characteristics';
-import type { QuantitySample } from './types/QuantitySample';
-import type { QueryOptionsWithAnchor, QueryOptionsWithSortOrder } from './types/QueryOptions';
+import type { MetadataForQuantityIdentifier, QuantitySampleTyped } from './types/QuantitySample';
+import type { IntervalComponents, QuantitySamplesWithAnchorResponseTyped, QueryStatisticsResponse, QueryStatisticsResponseFromSingleSource, StatisticsOptions, StatisticsQueryOptions, UnitForIdentifier } from './types/QuantityType';
+import type { QuantityTypeIdentifier, QuantityTypeIdentifierWriteable } from './types/QuantityTypeIdentifier';
+import type { QueryOptionsWithAnchor, QueryOptionsWithAnchorAndUnit, QueryOptionsWithSortOrder, QueryOptionsWithSortOrderAndUnit } from './types/QueryOptions';
 export * from './types';
 export declare const authorizationStatusFor: (type: import("./types").ObjectTypeIdentifier) => AuthorizationStatus;
 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 configureBackgroundTypes: (typeIdentifiers: string[], updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
+export declare const clearBackgroundTypes: () => Promise<boolean>;
+export declare const getPreferredUnits: (identifiers: readonly QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types").IdentifierWithUnit[]>;
 export declare const getRequestStatusForAuthorization: (toCheck: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<AuthorizationRequestStatus>;
 export declare const isHealthDataAvailable: () => boolean;
 export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
@@ -32,37 +35,37 @@ export declare const getBloodType: () => BloodType;
 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: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
-export declare const queryStatisticsForQuantitySeparateBySource: (identifier: import("./types").QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions) => Promise<import("./types").QueryStatisticsResponseFromSingleSource[]>;
-export declare const queryStatisticsCollectionForQuantitySeparateBySource: (identifier: import("./types").QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponseFromSingleSource[]>;
-export declare const saveQuantitySample: (identifier: import("./types").QuantityTypeIdentifierWriteable, unit: string, value: number, start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<QuantitySample | undefined>;
-export declare const isQuantityCompatibleWithUnit: (identifier: import("./types").QuantityTypeIdentifier, unit: string) => boolean;
+export declare function queryQuantitySamples<T extends QuantityTypeIdentifier>(_identifier: T, _options: QueryOptionsWithSortOrderAndUnit<UnitForIdentifier<T>>): Promise<readonly QuantitySampleTyped<T>[]>;
+export declare function queryQuantitySamplesWithAnchor<T extends QuantityTypeIdentifier>(_identifier: T, _options: QueryOptionsWithAnchorAndUnit<UnitForIdentifier<T>>): Promise<QuantitySamplesWithAnchorResponseTyped<T>>;
+export declare function queryStatisticsForQuantity<T extends QuantityTypeIdentifier>(_identifier: T, _statistics: readonly StatisticsOptions[], _options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<QueryStatisticsResponse>;
+export declare function queryStatisticsCollectionForQuantity<T extends QuantityTypeIdentifier>(_identifier: T, _statistics: readonly StatisticsOptions[], _anchorDate: Date, _intervalComponents: IntervalComponents, _options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<readonly QueryStatisticsResponse[]>;
+export declare function queryStatisticsForQuantitySeparateBySource<T extends QuantityTypeIdentifier>(_identifier: T, _statistics: readonly StatisticsOptions[], _options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<QueryStatisticsResponseFromSingleSource[]>;
+export declare function queryStatisticsCollectionForQuantitySeparateBySource<T extends QuantityTypeIdentifier>(_identifier: T, _statistics: readonly StatisticsOptions[], _anchorDate: Date, _intervalComponents: IntervalComponents, _options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<readonly QueryStatisticsResponseFromSingleSource[]>;
+export declare function saveQuantitySample<T extends QuantityTypeIdentifierWriteable>(_identifier: T, _unit: UnitForIdentifier<T>, _value: number, _start: Date, _end: Date, _metadata?: MetadataForQuantityIdentifier<T>): Promise<QuantitySampleTyped<T> | undefined>;
+export declare function isQuantityCompatibleWithUnit<T extends QuantityTypeIdentifier>(_identifier: T, _unit: UnitForIdentifier<T>): boolean;
 export declare function queryCategorySamples<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T, _options: QueryOptionsWithSortOrder): Promise<CategorySampleTyped<T>[]>;
 export declare function queryCategorySamplesWithAnchor<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T, _options: QueryOptionsWithAnchor): Promise<CategorySamplesWithAnchorResponseTyped<T>>;
-export declare const saveCategorySample: <T extends CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata?: import("./types").MetadataForCategoryIdentifier<T>) => Promise<import("./types").CategorySample | undefined>;
-export declare const queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").CorrelationSample[]>;
-export declare const saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").CorrelationSample | undefined>;
-export declare const queryHeartbeatSeriesSamples: (options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
-export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
-export declare const queryElectrocardiogramSamples: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithSortOrder) => Promise<readonly import("./types/ElectrocardiogramSample").ElectrocardiogramSample[]>;
-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 function saveCategorySample<T extends CategoryTypeIdentifierWriteable>(_identifier: T, _value: CategoryValueForIdentifier<T>, _startDate: Date, _endDate: Date, _metadata?: MetadataForCategoryIdentifier<T>): Promise<CategorySampleTyped<T> | undefined>;
+export declare const queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").CorrelationSampleTyped[]>;
+export declare const saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap | undefined) => Promise<import("./types").CorrelationSampleTyped | undefined>;
+export declare const queryHeartbeatSeriesSamples: (options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSampleTyped[]>;
+export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponseTyped>;
+export declare const queryElectrocardiogramSamples: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithSortOrder) => Promise<readonly import("./types/ElectrocardiogramSample").ElectrocardiogramSampleTyped[]>;
+export declare const queryElectrocardiogramSamplesWithAnchor: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithAnchor) => Promise<import("./types/ElectrocardiogramSample").ElectrocardiogramSamplesWithAnchorResponseTyped>;
+export declare const queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<readonly import("./types").WorkoutProxyTyped[]>;
+export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponseTyped>;
+export declare const saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals?: import("./types").WorkoutTotals | undefined, metadata?: import("react-native-nitro-modules").AnyMap | undefined) => Promise<import("./types").WorkoutProxyTyped>;
 export declare const startWatchApp: (workoutConfiguration: import("./types").WorkoutConfiguration) => Promise<boolean>;
-export declare const queryStateOfMindSamples: (options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
-export declare const queryStateOfMindSamplesWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").StateOfMindSamplesWithAnchorResponse>;
-export declare const queryCorrelationSamplesWithAnchor: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: QueryOptionsWithAnchor) => Promise<import("./types").QueryCorrelationSamplesWithAnchorResponse>;
-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<import("./types").StateOfMindSample | undefined>;
+export declare const queryStateOfMindSamples: (options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSampleTyped[]>;
+export declare const queryStateOfMindSamplesWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").StateOfMindSamplesWithAnchorResponseTyped>;
+export declare const queryCorrelationSamplesWithAnchor: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: QueryOptionsWithAnchor) => Promise<import("./types").QueryCorrelationSamplesWithAnchorResponseTyped>;
+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 | undefined) => Promise<import("./types").StateOfMindSampleTyped | undefined>;
 export declare function getMostRecentCategorySample<T extends CategoryTypeIdentifier>(_identifier: T): Promise<CategorySampleTyped<T> | undefined>;
-export declare const getMostRecentQuantitySample: typeof import("./healthkit.ios").getMostRecentQuantitySample;
-export declare const getMostRecentWorkout: () => Promise<WorkoutProxy | undefined>;
-export declare const getPreferredUnit: (quantityType: import("./types").QuantityTypeIdentifier) => Promise<string>;
+export declare function getMostRecentQuantitySample<T extends QuantityTypeIdentifier>(_identifier: T, _unit?: UnitForIdentifier<T>): Promise<QuantitySampleTyped<T> | undefined>;
+export declare const getMostRecentWorkout: () => Promise<import("./types").WorkoutProxyTyped | undefined>;
+export declare function getPreferredUnit<T extends QuantityTypeIdentifier>(_quantityType: T): Promise<UnitForIdentifier<T>>;
 export declare function useMostRecentCategorySample<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T): CategorySampleTyped<T> | undefined;
-export declare const useMostRecentQuantitySample: typeof import("./healthkit.ios").useMostRecentQuantitySample;
+export declare function useMostRecentQuantitySample<T extends QuantityTypeIdentifier>(_identifier: T, _unit?: UnitForIdentifier<T>): QuantitySampleTyped<T> | undefined;
 export declare const useMostRecentWorkout: typeof import("./healthkit.ios").useMostRecentWorkout;
 export declare const useSubscribeToChanges: typeof import("./healthkit.ios").useSubscribeToChanges;
 export declare const useHealthkitAuthorization: ({ toWrite, toRead, }: {
@@ -77,14 +80,14 @@ export declare const getBloodTypeAsync: () => Promise<BloodType>;
 export declare const getDateOfBirthAsync: () => Promise<Date | undefined>;
 export declare const getFitzpatrickSkinTypeAsync: () => Promise<FitzpatrickSkinType>;
 export declare const getWheelchairUseAsync: () => Promise<WheelchairUse>;
-declare const subscribeToQuantitySamples: (identifier: import("./types").QuantityTypeIdentifier, callback: (args: import("./types").OnQuantitySamplesCallback) => void, after?: Date) => {
+declare const subscribeToQuantitySamples: <TIdentifier extends QuantityTypeIdentifier>(identifier: TIdentifier, callback: (args: import("./types").OnQuantitySamplesCallback<TIdentifier>) => void, after?: Date) => {
     remove: () => boolean;
 };
 export { subscribeToQuantitySamples };
 export declare const currentAppSource: () => SourceProxy;
-export declare const queryMedications: () => Promise<readonly import("./specs/MedicationModule.nitro").UserAnnotatedMedication[]>;
-export declare const queryMedicationEvents: (options: QueryOptionsWithSortOrder) => Promise<readonly import("./specs/MedicationModule.nitro").MedicationDoseEvent[]>;
-export declare const queryMedicationEventsWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./specs/MedicationModule.nitro").MedicationDoseEventsWithAnchorResponse>;
+export declare const queryMedications: () => Promise<readonly import("./types").UserAnnotatedMedication[]>;
+export declare const queryMedicationEvents: (options: QueryOptionsWithSortOrder) => Promise<readonly import("./types").MedicationDoseEventTyped[]>;
+export declare const queryMedicationEventsWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").MedicationDoseEventsWithAnchorResponseTyped>;
 export declare const useSubscribeToQuantitySamples: typeof import("./healthkit.ios").useSubscribeToQuantitySamples;
 export declare const useSubscribeToCategorySamples: typeof import("./healthkit.ios").useSubscribeToCategorySamples;
 export declare const requestPerObjectReadAuthorization: (typeIdentifier: import("./types").PerObjectTypeIdentifier) => Promise<void>;

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

@@ -8,7 +8,13 @@ import useStatisticsForQuantity from './hooks/useStatisticsForQuantity';
 import useSubscribeToCategorySamples from './hooks/useSubscribeToCategorySamples';
 import useSubscribeToChanges from './hooks/useSubscribeToChanges';
 import useSubscribeToQuantitySamples from './hooks/useSubscribeToQuantitySamples';
+import type { CorrelationSampleTyped, QueryCorrelationSamplesWithAnchorResponseTyped } from './types/CorrelationType';
+import type { ElectrocardiogramSamplesWithAnchorResponseTyped, ElectrocardiogramSampleTyped } from './types/ElectrocardiogramSample';
+import type { HeartbeatSeriesSamplesWithAnchorResponseTyped, HeartbeatSeriesSampleTyped } from './types/HeartbeatSeries';
+import type { MedicationDoseEventsWithAnchorResponseTyped, MedicationDoseEventTyped } from './types/Medication';
 import type { QuantityTypeIdentifier } from './types/QuantityTypeIdentifier';
+import type { StateOfMindSamplesWithAnchorResponseTyped, StateOfMindSampleTyped } from './types/StateOfMind';
+import type { QueryWorkoutSamplesWithAnchorResponseTyped, WorkoutProxyTyped } from './types/Workouts';
 import getMostRecentCategorySample from './utils/getMostRecentCategorySample';
 import getMostRecentQuantitySample from './utils/getMostRecentQuantitySample';
 import getMostRecentWorkout from './utils/getMostRecentWorkout';
@@ -37,11 +43,14 @@ export type AvailableQuantityTypesIOS17Plus = QuantityTypeIdentifier;
  * @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;
+type BoundMethod<TMethod, TReturn = TMethod extends (...args: infer _Args) => infer TResult ? TResult : never> = (...args: TMethod extends (...args: infer TArgs) => unknown ? TArgs : never) => TReturn;
 export declare const authorizationStatusFor: (type: import("./types").ObjectTypeIdentifier) => import("./types").AuthorizationStatus;
 export declare const requestPerObjectReadAuthorization: (typeIdentifier: import("./types").PerObjectTypeIdentifier) => Promise<void>;
 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 configureBackgroundTypes: (typeIdentifiers: string[], updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
+export declare const clearBackgroundTypes: () => Promise<boolean>;
 export declare const getBiologicalSex: () => import("./types").BiologicalSex;
 export declare const getBloodType: () => import("./types").BloodType;
 export declare const getDateOfBirth: () => Date | undefined;
@@ -53,41 +62,41 @@ export declare const isHealthDataAvailable: () => boolean;
 export declare const isHealthDataAvailableAsync: () => Promise<boolean>;
 export declare const queryCategorySamples: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CategorySampleTyped<T>[]>;
 export declare const queryCategorySamplesWithAnchor: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").CategorySamplesWithAnchorResponseTyped<T>>;
-export declare const queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CorrelationSample[]>;
-export declare const queryCorrelationSamplesWithAnchor: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").QueryCorrelationSamplesWithAnchorResponse>;
-export declare const queryHeartbeatSeriesSamples: (options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
-export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
-export declare const queryElectrocardiogramSamples: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithSortOrder) => Promise<readonly import("./types/ElectrocardiogramSample").ElectrocardiogramSample[]>;
-export declare const queryElectrocardiogramSamplesWithAnchor: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithAnchor) => Promise<import("./types/ElectrocardiogramSample").ElectrocardiogramSamplesWithAnchorResponse>;
-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: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
-export declare const queryStatisticsForQuantitySeparateBySource: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions) => Promise<import("./types").QueryStatisticsResponseFromSingleSource[]>;
-export declare const queryStatisticsCollectionForQuantitySeparateBySource: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponseFromSingleSource[]>;
-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 queryCorrelationSamples: BoundMethod<(typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CorrelationSample[]>, Promise<readonly CorrelationSampleTyped[]>>;
+export declare const queryCorrelationSamplesWithAnchor: BoundMethod<(typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").QueryCorrelationSamplesWithAnchorResponse>, Promise<QueryCorrelationSamplesWithAnchorResponseTyped>>;
+export declare const queryHeartbeatSeriesSamples: BoundMethod<(options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>, Promise<readonly HeartbeatSeriesSampleTyped[]>>;
+export declare const queryHeartbeatSeriesSamplesWithAnchor: BoundMethod<(options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>, Promise<HeartbeatSeriesSamplesWithAnchorResponseTyped>>;
+export declare const queryElectrocardiogramSamples: BoundMethod<(options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithSortOrder) => Promise<readonly import("./types/ElectrocardiogramSample").ElectrocardiogramSample[]>, Promise<readonly ElectrocardiogramSampleTyped[]>>;
+export declare const queryElectrocardiogramSamplesWithAnchor: BoundMethod<(options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithAnchor) => Promise<import("./types/ElectrocardiogramSample").ElectrocardiogramSamplesWithAnchorResponse>, Promise<ElectrocardiogramSamplesWithAnchorResponseTyped>>;
+export declare const queryQuantitySamples: <T extends QuantityTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithSortOrderAndUnit<import("./types").UnitForIdentifier<T>>) => Promise<readonly import("./types").QuantitySampleTyped<T>[]>;
+export declare const queryQuantitySamplesWithAnchor: <T extends QuantityTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchorAndUnit<import("./types").UnitForIdentifier<T>>) => Promise<import("./types").QuantitySamplesWithAnchorResponseTyped<T>>;
+export declare const queryStatisticsForQuantity: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<import("./types").QueryStatisticsResponse>;
+export declare const queryStatisticsCollectionForQuantity: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
+export declare const queryStatisticsForQuantitySeparateBySource: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<import("./types").QueryStatisticsResponseFromSingleSource[]>;
+export declare const queryStatisticsCollectionForQuantitySeparateBySource: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<readonly import("./types").QueryStatisticsResponseFromSingleSource[]>;
+export declare const queryWorkoutSamples: BoundMethod<(options: import("./types").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>, Promise<readonly WorkoutProxyTyped[]>>;
+export declare const queryWorkoutSamplesWithAnchor: BoundMethod<(options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>, Promise<QueryWorkoutSamplesWithAnchorResponseTyped>>;
 export declare const querySources: (identifier: import("./types").SampleTypeIdentifier, filter?: import("./types").FilterForSamples) => Promise<import("./specs/SourceProxy.nitro").SourceProxy[]>;
 export declare const requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
 export declare const deleteObjects: (objectTypeIdentifier: import("./types").SampleTypeIdentifierWriteable, 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<import("./types").CategorySample | undefined>;
-export declare const saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").CorrelationSample | undefined>;
-export declare const saveQuantitySample: (identifier: import("./types").QuantityTypeIdentifierWriteable, unit: string, value: number, start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").QuantitySample | undefined>;
-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 saveCategorySample: <T extends import("./types").CategoryTypeIdentifierWriteable>(identifier: T, value: import("./types").CategoryValueForIdentifier<T>, startDate: Date, endDate: Date, metadata?: import("./types").MetadataForCategoryIdentifier<T>) => Promise<import("./types").CategorySampleTyped<T> | undefined>;
+export declare const saveCorrelationSample: BoundMethod<(typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").CorrelationSample | undefined>, Promise<CorrelationSampleTyped | undefined>>;
+export declare const saveQuantitySample: <T extends import("./types").QuantityTypeIdentifierWriteable>(identifier: T, unit: import("./types").UnitForIdentifier<T>, value: number, start: Date, end: Date, metadata?: import("./types").MetadataForQuantityIdentifier<T>) => Promise<import("./types").QuantitySampleTyped<T> | undefined>;
+export declare const saveWorkoutSample: BoundMethod<(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>, Promise<WorkoutProxyTyped>>;
 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 queryStateOfMindSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").StateOfMindSamplesWithAnchorResponse>;
-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<import("./types").StateOfMindSample | undefined>;
-export declare const isQuantityCompatibleWithUnit: (identifier: QuantityTypeIdentifier, unit: string) => boolean;
+export declare const queryStateOfMindSamples: BoundMethod<(options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>, Promise<readonly StateOfMindSampleTyped[]>>;
+export declare const queryStateOfMindSamplesWithAnchor: BoundMethod<(options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").StateOfMindSamplesWithAnchorResponse>, Promise<StateOfMindSamplesWithAnchorResponseTyped>>;
+export declare const saveStateOfMindSample: BoundMethod<(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<import("./types").StateOfMindSample | undefined>, Promise<StateOfMindSampleTyped | undefined>>;
+export declare const isQuantityCompatibleWithUnit: <T extends QuantityTypeIdentifier>(identifier: T, unit: import("./types").UnitForIdentifier<T>) => boolean;
 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 requestMedicationsAuthorization: () => Promise<boolean>;
-export declare const queryMedications: () => Promise<readonly import("./specs/MedicationModule.nitro").UserAnnotatedMedication[]>;
-export declare const queryMedicationEvents: (options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./specs/MedicationModule.nitro").MedicationDoseEvent[]>;
-export declare const queryMedicationEventsWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./specs/MedicationModule.nitro").MedicationDoseEventsWithAnchorResponse>;
+export declare const queryMedications: () => Promise<readonly import("./types").UserAnnotatedMedication[]>;
+export declare const queryMedicationEvents: BoundMethod<(options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./specs/MedicationModule.nitro").MedicationDoseEvent[]>, Promise<readonly MedicationDoseEventTyped[]>>;
+export declare const queryMedicationEventsWithAnchor: BoundMethod<(options: import("./types").QueryOptionsWithAnchor) => Promise<import("./specs/MedicationModule.nitro").MedicationDoseEventsWithAnchorResponse>, Promise<MedicationDoseEventsWithAnchorResponseTyped>>;
 export declare const currentAppSource: () => import("./specs/SourceProxy.nitro").SourceProxy;
 export declare const getBiologicalSexAsync: () => Promise<import("./types").BiologicalSex>;
 export declare const getBloodTypeAsync: () => Promise<import("./types").BloodType>;
@@ -100,7 +109,9 @@ declare const _default: {
     isObjectTypeAvailableAsync: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier) => Promise<boolean>;
     areObjectTypesAvailable: (objectTypeIdentifiers: readonly import("./types").ObjectTypeIdentifier[]) => Record<string, boolean>;
     areObjectTypesAvailableAsync: (objectTypeIdentifiers: import("./types").ObjectTypeIdentifier[]) => Promise<Record<string, boolean>>;
-    isQuantityCompatibleWithUnit: (identifier: QuantityTypeIdentifier, unit: string) => boolean;
+    isQuantityCompatibleWithUnit: <T extends QuantityTypeIdentifier>(identifier: T, unit: import("./types").UnitForIdentifier<T>) => boolean;
+    configureBackgroundTypes: (typeIdentifiers: string[], updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
+    clearBackgroundTypes: () => Promise<boolean>;
     disableAllBackgroundDelivery: () => Promise<boolean>;
     disableBackgroundDelivery: (typeIdentifier: import("./types").ObjectTypeIdentifier) => Promise<boolean>;
     enableBackgroundDelivery: (typeIdentifier: import("./types").ObjectTypeIdentifier, updateFrequency: import("./types").UpdateFrequency) => Promise<boolean>;
@@ -115,53 +126,53 @@ declare const _default: {
     getWheelchairUseAsync: () => Promise<import("./types").WheelchairUse>;
     getMostRecentCategorySample: typeof getMostRecentCategorySample;
     getMostRecentQuantitySample: typeof getMostRecentQuantitySample;
-    getMostRecentWorkout: () => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy | undefined>;
+    getMostRecentWorkout: () => Promise<WorkoutProxyTyped | undefined>;
     getPreferredUnits: (identifiers: readonly QuantityTypeIdentifier[], forceUpdate?: boolean) => Promise<import("./types").IdentifierWithUnit[]>;
-    getPreferredUnit: (quantityType: QuantityTypeIdentifier) => Promise<string>;
+    getPreferredUnit: <T extends QuantityTypeIdentifier>(quantityType: T) => Promise<import("./types").UnitForIdentifier<T>>;
     getRequestStatusForAuthorization: (toCheck: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<import("./types").AuthorizationRequestStatus>;
     getWheelchairUse: () => import("./types").WheelchairUse;
     isHealthDataAvailable: () => boolean;
     isHealthDataAvailableAsync: () => Promise<boolean>;
     queryCategorySamples: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CategorySampleTyped<T>[]>;
     queryCategorySamplesWithAnchor: <T extends import("./types").CategoryTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").CategorySamplesWithAnchorResponseTyped<T>>;
-    queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CorrelationSample[]>;
-    queryCorrelationSamplesWithAnchor: (typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").QueryCorrelationSamplesWithAnchorResponse>;
-    queryHeartbeatSeriesSamples: (options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
-    queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
-    queryElectrocardiogramSamples: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithSortOrder) => Promise<readonly import("./types/ElectrocardiogramSample").ElectrocardiogramSample[]>;
-    queryElectrocardiogramSamplesWithAnchor: (options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithAnchor) => Promise<import("./types/ElectrocardiogramSample").ElectrocardiogramSamplesWithAnchorResponse>;
-    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: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
-    queryStatisticsForQuantitySeparateBySource: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions) => Promise<import("./types").QueryStatisticsResponseFromSingleSource[]>;
-    queryStatisticsCollectionForQuantitySeparateBySource: (identifier: QuantityTypeIdentifier, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions) => Promise<readonly import("./types").QueryStatisticsResponseFromSingleSource[]>;
-    queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>;
-    queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
+    queryCorrelationSamples: BoundMethod<(typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").CorrelationSample[]>, Promise<readonly CorrelationSampleTyped[]>>;
+    queryCorrelationSamplesWithAnchor: BoundMethod<(typeIdentifier: import("./types").CorrelationTypeIdentifier, options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").QueryCorrelationSamplesWithAnchorResponse>, Promise<QueryCorrelationSamplesWithAnchorResponseTyped>>;
+    queryHeartbeatSeriesSamples: BoundMethod<(options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>, Promise<readonly HeartbeatSeriesSampleTyped[]>>;
+    queryHeartbeatSeriesSamplesWithAnchor: BoundMethod<(options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>, Promise<HeartbeatSeriesSamplesWithAnchorResponseTyped>>;
+    queryElectrocardiogramSamples: BoundMethod<(options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithSortOrder) => Promise<readonly import("./types/ElectrocardiogramSample").ElectrocardiogramSample[]>, Promise<readonly ElectrocardiogramSampleTyped[]>>;
+    queryElectrocardiogramSamplesWithAnchor: BoundMethod<(options: import("./types/ElectrocardiogramSample").ECGQueryOptionsWithAnchor) => Promise<import("./types/ElectrocardiogramSample").ElectrocardiogramSamplesWithAnchorResponse>, Promise<ElectrocardiogramSamplesWithAnchorResponseTyped>>;
+    queryQuantitySamples: <T extends QuantityTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithSortOrderAndUnit<import("./types").UnitForIdentifier<T>>) => Promise<readonly import("./types").QuantitySampleTyped<T>[]>;
+    queryQuantitySamplesWithAnchor: <T extends QuantityTypeIdentifier>(identifier: T, options: import("./types").QueryOptionsWithAnchorAndUnit<import("./types").UnitForIdentifier<T>>) => Promise<import("./types").QuantitySamplesWithAnchorResponseTyped<T>>;
+    queryStatisticsForQuantity: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<import("./types").QueryStatisticsResponse>;
+    queryStatisticsCollectionForQuantity: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<readonly import("./types").QueryStatisticsResponse[]>;
+    queryStatisticsForQuantitySeparateBySource: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<import("./types").QueryStatisticsResponseFromSingleSource[]>;
+    queryStatisticsCollectionForQuantitySeparateBySource: <T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly import("./types").StatisticsOptions[], anchorDate: Date, intervalComponents: import("./types").IntervalComponents, options?: import("./types").StatisticsQueryOptions<import("./types").UnitForIdentifier<T>>) => Promise<readonly import("./types").QueryStatisticsResponseFromSingleSource[]>;
+    queryWorkoutSamples: BoundMethod<(options: import("./types").WorkoutQueryOptions) => Promise<import("./specs/WorkoutProxy.nitro").WorkoutProxy[]>, Promise<readonly WorkoutProxyTyped[]>>;
+    queryWorkoutSamplesWithAnchor: BoundMethod<(options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>, Promise<QueryWorkoutSamplesWithAnchorResponseTyped>>;
     querySources: (identifier: import("./types").SampleTypeIdentifier, filter?: import("./types").FilterForSamples) => Promise<import("./specs/SourceProxy.nitro").SourceProxy[]>;
     requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
     requestPerObjectReadAuthorization: (typeIdentifier: import("./types").PerObjectTypeIdentifier) => Promise<void>;
     deleteObjects: (objectTypeIdentifier: import("./types").SampleTypeIdentifierWriteable, 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<import("./types").CategorySample | undefined>;
-    saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").CorrelationSample | undefined>;
-    saveQuantitySample: (identifier: import("./types").QuantityTypeIdentifierWriteable, unit: string, value: number, start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").QuantitySample | undefined>;
-    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>;
+    saveCategorySample: <T extends import("./types").CategoryTypeIdentifierWriteable>(identifier: T, value: import("./types").CategoryValueForIdentifier<T>, startDate: Date, endDate: Date, metadata?: import("./types").MetadataForCategoryIdentifier<T>) => Promise<import("./types").CategorySampleTyped<T> | undefined>;
+    saveCorrelationSample: BoundMethod<(typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").CorrelationSample | undefined>, Promise<CorrelationSampleTyped | undefined>>;
+    saveQuantitySample: <T extends import("./types").QuantityTypeIdentifierWriteable>(identifier: T, unit: import("./types").UnitForIdentifier<T>, value: number, start: Date, end: Date, metadata?: import("./types").MetadataForQuantityIdentifier<T>) => Promise<import("./types").QuantitySampleTyped<T> | undefined>;
+    saveWorkoutSample: BoundMethod<(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>, Promise<WorkoutProxyTyped>>;
     subscribeToChanges: (identifier: import("./types").SampleTypeIdentifier, callback: (args: import("./types").OnChangeCallbackArgs) => void) => {
         remove: () => boolean;
     };
-    subscribeToQuantitySamples: (identifier: QuantityTypeIdentifier, callback: (args: import("./types").OnQuantitySamplesCallback) => void, after?: Date) => {
+    subscribeToQuantitySamples: <TIdentifier extends QuantityTypeIdentifier>(identifier: TIdentifier, callback: (args: import("./types").OnQuantitySamplesCallback<TIdentifier>) => void, after?: Date) => {
         remove: () => boolean;
     };
     startWatchApp: (workoutConfiguration: import("./types").WorkoutConfiguration) => Promise<boolean>;
     isProtectedDataAvailable: () => boolean;
-    queryStateOfMindSamples: (options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>;
-    queryStateOfMindSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").StateOfMindSamplesWithAnchorResponse>;
-    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<import("./types").StateOfMindSample | undefined>;
+    queryStateOfMindSamples: BoundMethod<(options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").StateOfMindSample[]>, Promise<readonly StateOfMindSampleTyped[]>>;
+    queryStateOfMindSamplesWithAnchor: BoundMethod<(options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").StateOfMindSamplesWithAnchorResponse>, Promise<StateOfMindSamplesWithAnchorResponseTyped>>;
+    saveStateOfMindSample: BoundMethod<(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<import("./types").StateOfMindSample | undefined>, Promise<StateOfMindSampleTyped | undefined>>;
     requestMedicationsAuthorization: () => Promise<boolean>;
     currentAppSource: () => import("./specs/SourceProxy.nitro").SourceProxy;
-    queryMedicationEventsWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./specs/MedicationModule.nitro").MedicationDoseEventsWithAnchorResponse>;
-    queryMedicationEvents: (options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./specs/MedicationModule.nitro").MedicationDoseEvent[]>;
-    queryMedications: () => Promise<readonly import("./specs/MedicationModule.nitro").UserAnnotatedMedication[]>;
+    queryMedicationEventsWithAnchor: BoundMethod<(options: import("./types").QueryOptionsWithAnchor) => Promise<import("./specs/MedicationModule.nitro").MedicationDoseEventsWithAnchorResponse>, Promise<MedicationDoseEventsWithAnchorResponseTyped>>;
+    queryMedicationEvents: BoundMethod<(options: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./specs/MedicationModule.nitro").MedicationDoseEvent[]>, Promise<readonly MedicationDoseEventTyped[]>>;
+    queryMedications: () => Promise<readonly import("./types").UserAnnotatedMedication[]>;
     subscribeToCategorySamples: typeof subscribeToCategorySamples;
     useSubscribeToCategorySamples: typeof useSubscribeToCategorySamples;
     useMostRecentCategorySample: typeof useMostRecentCategorySample;

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

@@ -1,7 +1,8 @@
-import type { QuantitySample } from '../types/QuantitySample';
+import type { QuantitySampleTyped } from '../types/QuantitySample';
+import type { UnitForIdentifier } from '../types/QuantityType';
 import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier';
 /**
  * @returns the most recent sample for the given quantity type.
  */
-export declare function useMostRecentQuantitySample(identifier: QuantityTypeIdentifier, unit?: string): QuantitySample | undefined;
+export declare function useMostRecentQuantitySample<T extends QuantityTypeIdentifier>(identifier: T, unit?: UnitForIdentifier<T>): QuantitySampleTyped<T> | undefined;
 export default useMostRecentQuantitySample;

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

@@ -1,6 +1,6 @@
-import type { WorkoutProxy } from '../specs/WorkoutProxy.nitro';
+import type { WorkoutProxyTyped } from '../types/Workouts';
 /**
  * @returns the most recent workout sample.
  */
-export declare function useMostRecentWorkout(): WorkoutProxy | undefined;
+export declare function useMostRecentWorkout(): WorkoutProxyTyped | undefined;
 export default useMostRecentWorkout;

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

@@ -1,13 +1,14 @@
-import type { QuantitySample } from '../types/QuantitySample';
+import type { QuantitySampleTyped } from '../types/QuantitySample';
+import type { UnitForIdentifier } from '../types/QuantityType';
 import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier';
 /**
  * @returns the most recent sample for the given quantity type.
  */
-export declare function useQuantitySampleById(identifier: QuantityTypeIdentifier, uuid: string, options?: {
+export declare function useQuantitySampleById<T extends QuantityTypeIdentifier>(identifier: T, uuid: string, options?: {
     /** The unit to use for the sample. */
-    unit?: string;
+    unit?: UnitForIdentifier<T>;
 }): {
-    sample: QuantitySample | undefined;
+    sample: QuantitySampleTyped<T> | undefined;
     isLoading: boolean;
     error: Error | null;
 };

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

@@ -1,4 +1,4 @@
-import type { QueryStatisticsResponse, StatisticsOptions } from '../types/QuantityType';
+import type { QueryStatisticsResponse, StatisticsOptions, UnitForIdentifier } from '../types/QuantityType';
 import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier';
-export declare function useStatisticsForQuantity<TIdentifier extends QuantityTypeIdentifier>(identifier: TIdentifier, options: readonly StatisticsOptions[], from: Date, to?: Date, unit?: string): QueryStatisticsResponse | null;
+export declare function useStatisticsForQuantity<TIdentifier extends QuantityTypeIdentifier>(identifier: TIdentifier, options: readonly StatisticsOptions[], from: Date, to?: Date, unit?: UnitForIdentifier<TIdentifier>): QueryStatisticsResponse | null;
 export default useStatisticsForQuantity;

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

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

package/lib/typescript/modules.d.ts

@@ -5,14 +5,14 @@ import type { CorrelationTypeModule } from './specs/CorrelationTypeModule.nitro'
 import type { ElectrocardiogramModule } from './specs/ElectrocardiogramModule.nitro';
 import type { HeartbeatSeriesModule } from './specs/HeartbeatSeriesModule.nitro';
 import type { MedicationModule } from './specs/MedicationModule.nitro';
-import type { QuantityTypeModule } from './specs/QuantityTypeModule.nitro';
+import type { QuantityTypeModuleTyped } 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 Medication: MedicationModule;
 export declare const Workouts: WorkoutsModule;
 export declare const Characteristics: CharacteristicTypeModule;
-export declare const QuantityTypes: QuantityTypeModule;
+export declare const QuantityTypes: QuantityTypeModuleTyped;
 export declare const CategoryTypes: CategoryTypeModuleTyped;
 export declare const CorrelationTypes: CorrelationTypeModule;
 export declare const Electrocardiograms: ElectrocardiogramModule;

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

@@ -1,16 +1,16 @@
 import type { AnyMap, HybridObject } from 'react-native-nitro-modules';
 import type { CategorySample, CategorySamplesWithAnchorResponse, CategorySamplesWithAnchorResponseTyped, CategorySampleTyped, CategoryValueForIdentifier, MetadataForCategoryIdentifier } from '../types/CategoryType';
-import type { CategoryTypeIdentifier } from '../types/CategoryTypeIdentifier';
+import type { CategoryTypeIdentifier, CategoryTypeIdentifierWriteable } 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<CategorySample | undefined>;
+    saveCategorySample(identifier: CategoryTypeIdentifierWriteable, value: CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata?: AnyMap): Promise<CategorySample | undefined>;
     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<CategorySample | undefined>;
+    saveCategorySample<T extends CategoryTypeIdentifierWriteable>(identifier: T, value: CategoryValueForIdentifier<T>, startDate: Date, endDate: Date, metadata?: MetadataForCategoryIdentifier<T>): Promise<CategorySampleTyped<T> | undefined>;
     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/CoreModule.nitro.d.ts

@@ -26,6 +26,21 @@ export interface CoreModule extends HybridObject<{
      * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614158-disableallbackgrounddelivery Apple Docs }
      */
     disableAllBackgroundDelivery(): Promise<boolean>;
+    /**
+     * Configure background delivery types that will be registered natively in
+     * AppDelegate.didFinishLaunchingWithOptions — surviving app termination.
+     * Types and frequency are persisted to UserDefaults so they're available
+     * before the JS bridge boots on subsequent cold launches.
+     *
+     * Requires the Expo config plugin with `background: true` (default) or
+     * manual AppDelegate setup: `BackgroundDeliveryManager.shared.setupBackgroundObservers()`
+     */
+    configureBackgroundTypes(typeIdentifiers: string[], updateFrequency: UpdateFrequency): Promise<boolean>;
+    /**
+     * Clear persisted background delivery configuration and stop all observer queries.
+     * After calling this, the app will no longer register observers on cold launch.
+     */
+    clearBackgroundTypes(): Promise<boolean>;
     /**
      *  @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614180-ishealthdataavailable Apple Docs }
      */

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

@@ -1,18 +1,29 @@
 import type { AnyMap, HybridObject } from 'react-native-nitro-modules';
-import type { QuantitySample } from '../types/QuantitySample';
-import type { AggregationStyle, IntervalComponents, QuantitySamplesWithAnchorResponse, QueryStatisticsResponse, QueryStatisticsResponseFromSingleSource, StatisticsOptions, StatisticsQueryOptions } from '../types/QuantityType';
+import type { MetadataForQuantityIdentifier, QuantitySample, QuantitySampleTyped } from '../types/QuantitySample';
+import type { AggregationStyle, IntervalComponents, QuantitySamplesWithAnchorResponse, QuantitySamplesWithAnchorResponseTyped, QueryStatisticsResponse, QueryStatisticsResponseFromSingleSource, StatisticsOptions, StatisticsQueryOptions, StatisticsQueryOptionsWithStringUnit, UnitForIdentifier } from '../types/QuantityType';
 import type { QuantityTypeIdentifier, QuantityTypeIdentifierWriteable } from '../types/QuantityTypeIdentifier';
-import type { QueryOptionsWithAnchorAndUnit, QueryOptionsWithSortOrderAndUnit } from '../types/QueryOptions';
+import type { QueryOptionsWithAnchorAndStringUnit, QueryOptionsWithAnchorAndUnit, QueryOptionsWithSortOrderAndStringUnit, QueryOptionsWithSortOrderAndUnit } from '../types/QueryOptions';
 export interface QuantityTypeModule extends HybridObject<{
     ios: 'swift';
 }> {
     isQuantityCompatibleWithUnit(identifier: QuantityTypeIdentifier, unit: string): boolean;
     aggregationStyle(identifier: QuantityTypeIdentifier): AggregationStyle;
     saveQuantitySample(identifier: QuantityTypeIdentifierWriteable, unit: string, value: number, start: Date, end: Date, metadata?: AnyMap): Promise<QuantitySample | undefined>;
-    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: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptions): Promise<readonly QueryStatisticsResponse[]>;
-    queryStatisticsForQuantitySeparateBySource(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], options?: StatisticsQueryOptions): Promise<QueryStatisticsResponseFromSingleSource[]>;
-    queryStatisticsCollectionForQuantitySeparateBySource(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], anchorDate: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptions): Promise<readonly QueryStatisticsResponseFromSingleSource[]>;
-    queryQuantitySamplesWithAnchor(identifier: QuantityTypeIdentifier, options: QueryOptionsWithAnchorAndUnit): Promise<QuantitySamplesWithAnchorResponse>;
+    queryQuantitySamples(identifier: QuantityTypeIdentifier, options: QueryOptionsWithSortOrderAndStringUnit): Promise<readonly QuantitySample[]>;
+    queryStatisticsForQuantity(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], options?: StatisticsQueryOptionsWithStringUnit): Promise<QueryStatisticsResponse>;
+    queryStatisticsCollectionForQuantity(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], anchorDate: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptionsWithStringUnit): Promise<readonly QueryStatisticsResponse[]>;
+    queryStatisticsForQuantitySeparateBySource(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], options?: StatisticsQueryOptionsWithStringUnit): Promise<QueryStatisticsResponseFromSingleSource[]>;
+    queryStatisticsCollectionForQuantitySeparateBySource(identifier: QuantityTypeIdentifier, statistics: readonly StatisticsOptions[], anchorDate: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptionsWithStringUnit): Promise<readonly QueryStatisticsResponseFromSingleSource[]>;
+    queryQuantitySamplesWithAnchor(identifier: QuantityTypeIdentifier, options: QueryOptionsWithAnchorAndStringUnit): Promise<QuantitySamplesWithAnchorResponse>;
+}
+export interface QuantityTypeModuleTyped {
+    isQuantityCompatibleWithUnit<T extends QuantityTypeIdentifier>(identifier: T, unit: UnitForIdentifier<T>): boolean;
+    aggregationStyle(identifier: QuantityTypeIdentifier): AggregationStyle;
+    saveQuantitySample<T extends QuantityTypeIdentifierWriteable>(identifier: T, unit: UnitForIdentifier<T>, value: number, start: Date, end: Date, metadata?: MetadataForQuantityIdentifier<T>): Promise<QuantitySampleTyped<T> | undefined>;
+    queryQuantitySamples<T extends QuantityTypeIdentifier>(identifier: T, options: QueryOptionsWithSortOrderAndUnit<UnitForIdentifier<T>>): Promise<readonly QuantitySampleTyped<T>[]>;
+    queryStatisticsForQuantity<T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly StatisticsOptions[], options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<QueryStatisticsResponse>;
+    queryStatisticsCollectionForQuantity<T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly StatisticsOptions[], anchorDate: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<readonly QueryStatisticsResponse[]>;
+    queryStatisticsForQuantitySeparateBySource<T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly StatisticsOptions[], options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<QueryStatisticsResponseFromSingleSource[]>;
+    queryStatisticsCollectionForQuantitySeparateBySource<T extends QuantityTypeIdentifier>(identifier: T, statistics: readonly StatisticsOptions[], anchorDate: Date, intervalComponents: IntervalComponents, options?: StatisticsQueryOptions<UnitForIdentifier<T>>): Promise<readonly QueryStatisticsResponseFromSingleSource[]>;
+    queryQuantitySamplesWithAnchor<T extends QuantityTypeIdentifier>(identifier: T, options: QueryOptionsWithAnchorAndUnit<UnitForIdentifier<T>>): Promise<QuantitySamplesWithAnchorResponseTyped<T>>;
 }

package/lib/typescript/type-tests/generated-typing.d.ts

@@ -0,0 +1 @@
+export {};