@kingstinct/react-native-healthkit 4.3.0 → 4.4.0

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

@@ -1,9 +1,12 @@
-import { EmitterSubscription, NativeEventEmitter } from 'react-native';
-export declare type HKWorkoutTypeIdentifier = 'HKWorkoutTypeIdentifier';
-export declare type HKAudiogramTypeIdentifier = 'HKAudiogramTypeIdentifier';
-export declare type HKSampleTypeIdentifier = HKWorkoutTypeIdentifier | HKQuantityTypeIdentifier | HKCategoryTypeIdentifier | HKAudiogramTypeIdentifier | HKCorrelationTypeIdentifier;
+import { NativeEventEmitter } from 'react-native';
+import type { EmitterSubscription } from 'react-native';
+export declare const HKWorkoutTypeIdentifier = "HKWorkoutTypeIdentifier";
+export declare const HKAudiogramTypeIdentifier = "HKAudiogramTypeIdentifier";
+export declare const HKWorkoutRouteTypeIdentifier = "HKWorkoutRouteTypeIdentifier";
+export declare const HKDataTypeIdentifierHeartbeatSeries = "HKDataTypeIdentifierHeartbeatSeries";
+export declare type HKSampleTypeIdentifier = HKCategoryTypeIdentifier | HKCorrelationTypeIdentifier | HKQuantityTypeIdentifier | typeof HKAudiogramTypeIdentifier | typeof HKDataTypeIdentifierHeartbeatSeries | typeof HKWorkoutRouteTypeIdentifier | typeof HKWorkoutTypeIdentifier;
 export declare type TypeToUnitMapping = {
-    [key in HKQuantityTypeIdentifier]: HKUnit;
+    readonly [key in HKQuantityTypeIdentifier]: HKUnit;
 };
 export declare enum HKHeartRateMotionContext {
     active = 2,
@@ -109,21 +112,21 @@ export declare enum HKWorkoutActivityType {
     other = 3000
 }
 export declare type HKGenericMetadata = {
-    [key: string]: string | number | boolean | HKQuantity | undefined;
-    HKExternalUUID?: string;
-    HKTimeZone?: string;
-    HKWasUserEntered?: boolean;
-    HKDeviceSerialNumber?: string;
-    HKUDIDeviceIdentifier?: string;
-    HKUDIProductionIdentifier?: string;
-    HKDigitalSignature?: string;
-    HKDeviceName?: string;
-    HKDeviceManufacturerName?: string;
-    HKSyncIdentifier?: string;
-    HKSyncVersion?: number;
-    HKWasTakenInLab?: boolean;
-    HKReferenceRangeLowerLimit?: number;
-    HKReferenceRangeUpperLimit?: number;
+    readonly [key: string]: HKQuantity | boolean | number | string | undefined;
+    readonly HKExternalUUID?: string;
+    readonly HKTimeZone?: string;
+    readonly HKWasUserEntered?: boolean;
+    readonly HKDeviceSerialNumber?: string;
+    readonly HKUDIDeviceIdentifier?: string;
+    readonly HKUDIProductionIdentifier?: string;
+    readonly HKDigitalSignature?: string;
+    readonly HKDeviceName?: string;
+    readonly HKDeviceManufacturerName?: string;
+    readonly HKSyncIdentifier?: string;
+    readonly HKSyncVersion?: number;
+    readonly HKWasTakenInLab?: boolean;
+    readonly HKReferenceRangeLowerLimit?: number;
+    readonly HKReferenceRangeUpperLimit?: number;
 };
 export declare enum HKWeatherCondition {
     none = 0,
@@ -156,8 +159,8 @@ export declare enum HKWeatherCondition {
     tornado = 27
 }
 export interface HKWorkoutMetadata extends HKGenericMetadata {
-    HKWeatherCondition?: HKWeatherCondition;
-    HKWeatherHumidity?: HKQuantity<HKUnit.Percent>;
+    readonly HKWeatherCondition?: HKWeatherCondition;
+    readonly HKWeatherHumidity?: HKQuantity<HKUnit.Percent>;
 }
 export declare enum HKQuantityTypeIdentifier {
     bodyMassIndex = "HKQuantityTypeIdentifierBodyMassIndex",
@@ -262,8 +265,8 @@ export declare enum HKAuthorizationStatus {
     sharingAuthorized = 2
 }
 export declare type HKQuantity<T extends HKUnit = HKUnit> = {
-    unit: T;
-    quantity: number;
+    readonly unit: T;
+    readonly quantity: number;
 };
 export declare enum HKBloodType {
     notSet = 0,
@@ -302,16 +305,16 @@ export declare enum HKStatisticsOptions {
     separateBySource = "separateBySource"
 }
 export declare type QueryStatisticsResponseRaw<TUnit extends HKUnit = HKUnit> = {
-    averageQuantity?: HKQuantity<TUnit>;
-    maximumQuantity?: HKQuantity<TUnit>;
-    minimumQuantity?: HKQuantity<TUnit>;
-    sumQuantity?: HKQuantity<TUnit>;
-    mostRecentQuantity?: HKQuantity<TUnit>;
-    mostRecentQuantityDateInterval?: {
-        from: string;
-        to: string;
+    readonly averageQuantity?: HKQuantity<TUnit>;
+    readonly maximumQuantity?: HKQuantity<TUnit>;
+    readonly minimumQuantity?: HKQuantity<TUnit>;
+    readonly sumQuantity?: HKQuantity<TUnit>;
+    readonly mostRecentQuantity?: HKQuantity<TUnit>;
+    readonly mostRecentQuantityDateInterval?: {
+        readonly from: string;
+        readonly to: string;
     };
-    duration?: HKQuantity<HKUnit.Seconds>;
+    readonly duration?: HKQuantity<HKUnit.Seconds>;
 };
 export declare enum HKCategoryValueCervicalMucusQuality {
     dry = 1,
@@ -358,26 +361,26 @@ export declare enum HKCategoryValueSeverity {
 export declare enum HKCategoryValueNotApplicable {
     notApplicable = 0
 }
-export declare type HKCategoryValue = HKCategoryValueAppetiteChanges | HKCategoryValuePresence | HKCategoryValueSeverity | HKCategoryValuePresence | HKCategoryValueMenstrualFlow | HKCategoryValueSleepAnalysis | HKCategoryValueCervicalMucusQuality | HKCategoryValueOvulationTestResult | number;
+export declare type HKCategoryValue = HKCategoryValueAppetiteChanges | HKCategoryValueCervicalMucusQuality | HKCategoryValueMenstrualFlow | HKCategoryValueOvulationTestResult | HKCategoryValuePresence | HKCategoryValuePresence | HKCategoryValueSeverity | HKCategoryValueSleepAnalysis | number;
 export declare enum HKInsulinDeliveryReason {
     basal = 1,
     bolus = 2
 }
 export declare type MetadataMapperForQuantityIdentifier<TQuantityTypeIdentifier = HKQuantityTypeIdentifier> = TQuantityTypeIdentifier extends HKQuantityTypeIdentifier.insulinDelivery ? HKGenericMetadata & {
-    HKInsulinDeliveryReason: HKInsulinDeliveryReason;
+    readonly HKInsulinDeliveryReason: HKInsulinDeliveryReason;
 } : TQuantityTypeIdentifier extends HKQuantityTypeIdentifier.bloodGlucose ? HKGenericMetadata & {
-    HKBloodGlucoseMealTime?: number;
+    readonly HKBloodGlucoseMealTime?: number;
 } : TQuantityTypeIdentifier extends HKQuantityTypeIdentifier.heartRate ? HKGenericMetadata & {
-    HKHeartRateMotionContext?: HKHeartRateMotionContext;
+    readonly HKHeartRateMotionContext?: HKHeartRateMotionContext;
 } : HKGenericMetadata;
 export declare type MetadataMapperForCorrelationIdentifier<TCorrelationTypeIdentifier = HKCorrelationTypeIdentifier> = TCorrelationTypeIdentifier extends HKCorrelationTypeIdentifier.food ? HKGenericMetadata & {
-    HKFoodType?: string;
+    readonly HKFoodType?: string;
 } : HKGenericMetadata;
 export declare type HKCategoryValueForIdentifier<T extends HKCategoryTypeIdentifier> = T extends HKCategoryTypeIdentifier.cervicalMucusQuality ? HKCategoryValueCervicalMucusQuality : T extends HKCategoryTypeIdentifier.menstrualFlow ? HKCategoryValueMenstrualFlow : T extends HKCategoryTypeIdentifier.ovulationTestResult ? HKCategoryValueOvulationTestResult : T extends HKCategoryTypeIdentifier.sleepAnalysis ? HKCategoryValueSleepAnalysis : T extends HKCategoryTypeIdentifier.mindfulSession ? HKCategoryValueNotApplicable : T extends HKCategoryTypeIdentifier.intermenstrualBleeding ? HKCategoryValueNotApplicable : T extends HKCategoryTypeIdentifier.highHeartRateEvent ? HKCategoryValueNotApplicable : T extends HKCategoryTypeIdentifier.sexualActivity ? HKCategoryValueNotApplicable : T extends HKCategoryTypeIdentifier.appleStandHour ? HKCategoryValueAppleStandHour : number;
 export declare type MetadataMapperForCategoryIdentifier<T extends HKCategoryTypeIdentifier> = T extends HKCategoryTypeIdentifier.sexualActivity ? HKGenericMetadata & {
-    HKSexualActivityProtectionUsed: boolean;
+    readonly HKSexualActivityProtectionUsed: boolean;
 } : T extends HKCategoryTypeIdentifier.menstrualFlow ? HKGenericMetadata & {
-    HKMenstrualCycleStart: boolean;
+    readonly HKMenstrualCycleStart: boolean;
 } : HKGenericMetadata;
 export declare enum HKWheelchairUse {
     notSet = 0,
@@ -451,46 +454,48 @@ export declare enum HKUnit {
     GlucoseMgPerDl = "mg/dL"
 }
 export declare type HKDevice = {
-    name: string;
-    firmwareVersion: string;
-    hardwareVersion: string;
-    localIdentifier: string;
-    manufacturer: string;
-    model: string;
-    softwareVersion: string;
+    readonly name: string;
+    readonly firmwareVersion: string;
+    readonly hardwareVersion: string;
+    readonly localIdentifier: string;
+    readonly manufacturer: string;
+    readonly model: string;
+    readonly softwareVersion: string;
 };
 export declare type HKSource = {
-    name: string;
-    bundleIdentifier: string;
+    readonly name: string;
+    readonly bundleIdentifier: string;
 };
 export declare type HKSourceRevision = {
-    source: HKSource;
-    version: string;
-    operatingSystemVersion?: string;
-    productType?: string;
+    readonly source: HKSource;
+    readonly version: string;
+    readonly operatingSystemVersion?: string;
+    readonly productType?: string;
 };
 export declare type HKQuantitySampleRaw<TQuantityIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit> = {
-    uuid: string;
-    device?: HKDevice;
-    quantityType: TQuantityIdentifier;
-    startDate: string;
-    endDate: string;
-    quantity: number;
-    unit: TUnit;
-    metadata: MetadataMapperForQuantityIdentifier<TQuantityIdentifier>;
-    sourceRevision?: HKSourceRevision;
+    readonly uuid: string;
+    readonly device?: HKDevice;
+    readonly quantityType: TQuantityIdentifier;
+    readonly startDate: string;
+    readonly endDate: string;
+    readonly quantity: number;
+    readonly unit: TUnit;
+    readonly metadata: MetadataMapperForQuantityIdentifier<TQuantityIdentifier>;
+    readonly sourceRevision?: HKSourceRevision;
 };
 export declare type HKWorkoutRaw<TEnergy extends HKUnit, TDistance extends HKUnit> = {
-    workoutActivityType: HKWorkoutActivityType;
-    duration: number;
-    totalDistance?: HKQuantity<TDistance>;
-    totalEnergyBurned?: HKQuantity<TEnergy>;
-    totalSwimmingStrokeCount?: HKQuantity<HKUnit.Count>;
-    totalFlightsClimbed?: HKQuantity<HKUnit.Count>;
-    startDate: string;
-    endDate: string;
-    metadata?: HKWorkoutMetadata;
-    sourceRevision?: HKSourceRevision;
+    readonly uuid: string;
+    readonly device?: HKDevice;
+    readonly workoutActivityType: HKWorkoutActivityType;
+    readonly duration: number;
+    readonly totalDistance?: HKQuantity<TDistance>;
+    readonly totalEnergyBurned?: HKQuantity<TEnergy>;
+    readonly totalSwimmingStrokeCount?: HKQuantity<HKUnit.Count>;
+    readonly totalFlightsClimbed?: HKQuantity<HKUnit.Count>;
+    readonly startDate: string;
+    readonly endDate: string;
+    readonly metadata?: HKWorkoutMetadata;
+    readonly sourceRevision?: HKSourceRevision;
 };
 export declare enum HKCharacteristicTypeIdentifier {
     fitzpatrickSkinType = "HKCharacteristicTypeIdentifierFitzpatrickSkinType",
@@ -499,28 +504,28 @@ export declare enum HKCharacteristicTypeIdentifier {
     dateOfBirth = "HKCharacteristicTypeIdentifierDateOfBirth",
     wheelchairUse = "HKCharacteristicTypeIdentifierWheelchairUse"
 }
-export declare type WritePermssions = {
-    [key in HKCharacteristicTypeIdentifier | HKQuantityTypeIdentifier | HKCategoryTypeIdentifier]: boolean;
+export declare type WritePermissions = {
+    readonly [key in HKCategoryTypeIdentifier | HKCharacteristicTypeIdentifier | HKQuantityTypeIdentifier]: boolean;
 };
-export declare type ReadPermssions = {
-    [key in HKQuantityTypeIdentifier | HKCharacteristicTypeIdentifier | HKCategoryTypeIdentifier]: boolean;
+export declare type ReadPermissions = {
+    readonly [key in HKCategoryTypeIdentifier | HKCharacteristicTypeIdentifier | HKQuantityTypeIdentifier]: boolean;
 };
 export declare type HKCategorySampleRaw<T extends HKCategoryTypeIdentifier = HKCategoryTypeIdentifier> = {
-    uuid: string;
-    device?: HKDevice;
-    categoryType: T;
-    startDate: string;
-    endDate: string;
-    value: HKCategoryValueForIdentifier<T>;
-    metadata: MetadataMapperForCategoryIdentifier<T>;
-    sourceRevision?: HKSourceRevision;
+    readonly uuid: string;
+    readonly device?: HKDevice;
+    readonly categoryType: T;
+    readonly startDate: string;
+    readonly endDate: string;
+    readonly value: HKCategoryValueForIdentifier<T>;
+    readonly metadata: MetadataMapperForCategoryIdentifier<T>;
+    readonly sourceRevision?: HKSourceRevision;
 };
 export declare type HKCorrelationRaw<TIdentifier extends HKCorrelationTypeIdentifier> = {
-    correlationType: HKCorrelationTypeIdentifier;
-    objects: (HKQuantitySampleRaw | HKCategorySampleRaw)[];
-    metadata: MetadataMapperForCorrelationIdentifier<TIdentifier>;
-    startDate: string;
-    endDate: string;
+    readonly correlationType: HKCorrelationTypeIdentifier;
+    readonly objects: readonly (HKCategorySampleRaw | HKQuantitySampleRaw)[];
+    readonly metadata: MetadataMapperForCorrelationIdentifier<TIdentifier>;
+    readonly startDate: string;
+    readonly endDate: string;
 };
 declare type QueryId = string;
 export declare enum HKCorrelationTypeIdentifier {
@@ -534,53 +539,54 @@ export declare enum HKUpdateFrequency {
     weekly = 4
 }
 export declare type WorkoutLocation = {
-    longitude: number;
-    latitude: number;
-    altitude: number;
-    speed: number;
-    timestamp: number;
-    horizontalAccuracy: number;
-    speedAccuracy: number;
-    verticalAccuracy: number;
+    readonly longitude: number;
+    readonly latitude: number;
+    readonly altitude: number;
+    readonly speed: number;
+    readonly timestamp: number;
+    readonly horizontalAccuracy: number;
+    readonly speedAccuracy: number;
+    readonly verticalAccuracy: number;
 };
 export declare type WorkoutRoute = {
-    locations: WorkoutLocation[];
-    HKMetadataKeySyncIdentifier?: string;
-    HKMetadataKeySyncVersion?: number;
+    readonly locations: readonly WorkoutLocation[];
+    readonly HKMetadataKeySyncIdentifier?: string;
+    readonly HKMetadataKeySyncVersion?: number;
 };
+declare type AuthorizationStatusFor = HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier;
 declare type ReactNativeHealthkitTypeNative = {
     isHealthDataAvailable(): Promise<boolean>;
     getBloodType(): Promise<HKBloodType>;
     getDateOfBirth(): Promise<string>;
     getBiologicalSex(): Promise<HKBiologicalSex>;
     getFitzpatrickSkinType(): Promise<HKFitzpatrickSkinType>;
-    getWheelchairUse: () => Promise<HKWheelchairUse>;
-    enableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier, updateFrequency: HKUpdateFrequency) => Promise<boolean>;
-    disableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier) => Promise<boolean>;
-    disableAllBackgroundDelivery: () => Promise<boolean>;
-    saveCorrelationSample: <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, samples: Omit<HKQuantitySampleRaw | HKCategorySampleRaw, 'startDate' | 'endDate' | 'uuid' | 'device'>[], start: string, end: string, metadata: MetadataMapperForCorrelationIdentifier<TIdentifier>) => Promise<boolean>;
-    saveWorkoutSample: (typeIdentifier: HKWorkoutActivityType, quantities: Omit<HKQuantitySampleRaw, 'startDate' | 'endDate' | 'uuid' | 'device'>[], start: string, end: string, metadata: HKWorkoutMetadata) => Promise<boolean>;
-    queryCorrelationSamples: <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, from: string, to: string) => Promise<HKCorrelationRaw<TIdentifier>[]>;
+    readonly getWheelchairUse: () => Promise<HKWheelchairUse>;
+    readonly enableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier, updateFrequency: HKUpdateFrequency) => Promise<boolean>;
+    readonly disableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier) => Promise<boolean>;
+    readonly disableAllBackgroundDelivery: () => Promise<boolean>;
+    readonly saveCorrelationSample: <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, samples: readonly Omit<HKCategorySampleRaw | HKQuantitySampleRaw, 'device' | 'endDate' | 'startDate' | 'uuid'>[], start: string, end: string, metadata: MetadataMapperForCorrelationIdentifier<TIdentifier>) => Promise<boolean>;
+    readonly saveWorkoutSample: (typeIdentifier: HKWorkoutActivityType, quantities: readonly Omit<HKQuantitySampleRaw, 'device' | 'endDate' | 'startDate' | 'uuid'>[], start: string, end: string, metadata: HKWorkoutMetadata) => Promise<boolean>;
+    readonly queryCorrelationSamples: <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, from: string, to: string) => Promise<readonly HKCorrelationRaw<TIdentifier>[]>;
     subscribeToObserverQuery(identifier: HKSampleTypeIdentifier): Promise<QueryId>;
     unsubscribeQuery(queryId: QueryId): Promise<boolean>;
-    authorizationStatusFor(type: HKSampleTypeIdentifier | HKCharacteristicTypeIdentifier): Promise<boolean>;
-    getRequestStatusForAuthorization(write: WritePermssions | {}, read: ReadPermssions | {}): Promise<HKAuthorizationRequestStatus>;
-    requestAuthorization(write: WritePermssions | {}, read: ReadPermssions | {}): Promise<boolean>;
-    saveQuantitySample: (identifier: HKQuantityTypeIdentifier, unit: HKUnit, value: number, start: string, end: string, metadata: Object) => Promise<boolean>;
-    queryWorkoutSamples: <TEnergy extends HKUnit, TDistance extends HKUnit>(energyUnit: TEnergy, distanceUnit: TDistance, from: string, to: string, limit: Number, ascending: boolean) => Promise<HKWorkoutRaw<TEnergy, TDistance>[]>;
-    queryCategorySamples: <T extends HKCategoryTypeIdentifier>(identifier: T, from: string, to: string, limit: Number, ascending: boolean) => Promise<HKCategorySampleRaw<T>[]>;
-    queryQuantitySamples: <TUnit extends HKUnit, TIdentifier extends HKQuantityTypeIdentifier>(identifier: TIdentifier, unit: TUnit, from: string, to: string, limit: Number, ascending: boolean) => Promise<HKQuantitySampleRaw<TIdentifier, TUnit>[]>;
-    saveCategorySample: <T extends HKCategoryTypeIdentifier>(identifier: T, value: HKCategoryValueForIdentifier<T>, start: string, end: string, metadata: Object) => Promise<boolean>;
-    queryStatisticsForQuantity: <TUnit extends HKUnit>(identifier: HKQuantityTypeIdentifier, unit: TUnit, from: string, to: string, options: HKStatisticsOptions[]) => Promise<QueryStatisticsResponseRaw<TUnit>>;
-    getPreferredUnits: (identifiers: HKQuantityTypeIdentifier[]) => Promise<TypeToUnitMapping>;
-    getWorkoutRoutes: (workoutUUID: string) => Promise<WorkoutRoute[]>;
+    authorizationStatusFor(type: AuthorizationStatusFor): Promise<boolean>;
+    getRequestStatusForAuthorization(write: WritePermissions, read: ReadPermissions): Promise<HKAuthorizationRequestStatus>;
+    requestAuthorization(write: WritePermissions, read: ReadPermissions): Promise<boolean>;
+    readonly saveQuantitySample: (identifier: HKQuantityTypeIdentifier, unit: HKUnit, value: number, start: string, end: string, metadata: unknown) => Promise<boolean>;
+    readonly queryWorkoutSamples: <TEnergy extends HKUnit, TDistance extends HKUnit>(energyUnit: TEnergy, distanceUnit: TDistance, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKWorkoutRaw<TEnergy, TDistance>[]>;
+    readonly queryCategorySamples: <T extends HKCategoryTypeIdentifier>(identifier: T, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKCategorySampleRaw<T>[]>;
+    readonly queryQuantitySamples: <TUnit extends HKUnit, TIdentifier extends HKQuantityTypeIdentifier>(identifier: TIdentifier, unit: TUnit, from: string, to: string, limit: number, ascending: boolean) => Promise<readonly HKQuantitySampleRaw<TIdentifier, TUnit>[]>;
+    readonly saveCategorySample: <T extends HKCategoryTypeIdentifier>(identifier: T, value: HKCategoryValueForIdentifier<T>, start: string, end: string, metadata: unknown) => Promise<boolean>;
+    readonly queryStatisticsForQuantity: <TUnit extends HKUnit>(identifier: HKQuantityTypeIdentifier, unit: TUnit, from: string, to: string, options: readonly HKStatisticsOptions[]) => Promise<QueryStatisticsResponseRaw<TUnit>>;
+    readonly getPreferredUnits: (identifiers: readonly HKQuantityTypeIdentifier[]) => Promise<TypeToUnitMapping>;
+    readonly getWorkoutRoutes: (workoutUUID: string) => Promise<readonly WorkoutRoute[]>;
 };
 declare const Native: ReactNativeHealthkitTypeNative;
 declare type OnChangeCallback = ({ typeIdentifier, }: {
-    typeIdentifier: HKSampleTypeIdentifier;
+    readonly typeIdentifier: HKSampleTypeIdentifier;
 }) => void;
 interface HealthkitEventEmitter extends NativeEventEmitter {
-    addListener: (eventType: 'onChange', callback: OnChangeCallback) => EmitterSubscription;
+    readonly addListener: (eventType: 'onChange', callback: OnChangeCallback) => EmitterSubscription;
 }
 export declare const EventEmitter: HealthkitEventEmitter;
 export default Native;

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

@@ -1,30 +1,30 @@
 import type { HKAuthorizationRequestStatus, HKBiologicalSex, HKBloodType, HKCategorySampleRaw, HKCategoryTypeIdentifier, HKCategoryValueForIdentifier, HKCharacteristicTypeIdentifier, HKCorrelationRaw, HKCorrelationTypeIdentifier, HKFitzpatrickSkinType, HKQuantitySampleRaw, HKQuantityTypeIdentifier, HKSampleTypeIdentifier, HKStatisticsOptions, HKUnit, HKUnitSI, HKUnitSIPrefix, HKUpdateFrequency, HKWheelchairUse, HKWorkoutActivityType, HKWorkoutMetadata, HKWorkoutRaw, MetadataMapperForCategoryIdentifier, MetadataMapperForCorrelationIdentifier, MetadataMapperForQuantityIdentifier, QueryStatisticsResponseRaw, WorkoutRoute } from './native-types';
 export interface QueryWorkoutsOptions<TEnergy extends HKUnit, TDistance extends HKUnit> extends GenericQueryOptions {
-    energyUnit?: TEnergy;
-    distanceUnit?: TDistance;
+    readonly energyUnit?: TEnergy;
+    readonly distanceUnit?: TDistance;
 }
-export interface HKCategorySample<T extends HKCategoryTypeIdentifier = HKCategoryTypeIdentifier> extends Omit<HKCategorySampleRaw<T>, 'startDate' | 'endDate'> {
-    startDate: Date;
-    endDate: Date;
+export interface HKCategorySample<T extends HKCategoryTypeIdentifier = HKCategoryTypeIdentifier> extends Omit<HKCategorySampleRaw<T>, 'endDate' | 'startDate'> {
+    readonly startDate: Date;
+    readonly endDate: Date;
 }
 export declare type GenericQueryOptions = {
-    from?: Date;
-    to?: Date;
-    limit?: Number;
-    ascending?: boolean;
+    readonly from?: Date;
+    readonly to?: Date;
+    readonly limit?: number;
+    readonly ascending?: boolean;
 };
-export interface HKWorkout<TEnergy extends HKUnit = HKUnit, TDistance extends HKUnit = HKUnit> extends Omit<HKWorkoutRaw<TEnergy, TDistance>, 'startDate' | 'endDate'> {
-    startDate: Date;
-    endDate: Date;
+export interface HKWorkout<TEnergy extends HKUnit = HKUnit, TDistance extends HKUnit = HKUnit> extends Omit<HKWorkoutRaw<TEnergy, TDistance>, 'endDate' | 'startDate'> {
+    readonly startDate: Date;
+    readonly endDate: Date;
 }
-export interface HKQuantitySample<TIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit> extends Omit<HKQuantitySampleRaw<TIdentifier, TUnit>, 'startDate' | 'endDate'> {
-    startDate: Date;
-    endDate: Date;
+export interface HKQuantitySample<TIdentifier extends HKQuantityTypeIdentifier = HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit> extends Omit<HKQuantitySampleRaw<TIdentifier, TUnit>, 'endDate' | 'startDate'> {
+    readonly startDate: Date;
+    readonly endDate: Date;
 }
 export interface QueryStatisticsResponse<T extends HKUnit = HKUnit> extends Omit<QueryStatisticsResponseRaw<T>, 'mostRecentQuantityDateInterval'> {
-    mostRecentQuantityDateInterval?: {
-        from: Date;
-        to: Date;
+    readonly mostRecentQuantityDateInterval?: {
+        readonly from: Date;
+        readonly to: Date;
     };
 }
 declare type UnsubscribeFunction = () => Promise<boolean>;
@@ -34,25 +34,25 @@ export declare type GetDateOfBirthFn = () => Promise<Date>;
 export declare type GetBiologicalSexFn = () => Promise<HKBiologicalSex>;
 export declare type GetWheelchairUseFn = () => Promise<HKWheelchairUse>;
 export declare type GetFitzpatrickSkinTypeFn = () => Promise<HKFitzpatrickSkinType>;
-export declare type QueryStatisticsForQuantityFn = <TUnit extends HKUnit>(identifier: HKQuantityTypeIdentifier, options: HKStatisticsOptions[], from: Date, to?: Date, unit?: TUnit) => Promise<QueryStatisticsResponse<TUnit>>;
-export declare type QueryWorkoutsFn = <TEnergy extends HKUnit, TDistance extends HKUnit>(options: QueryWorkoutsOptions<TEnergy, TDistance>) => Promise<HKWorkout<TEnergy, TDistance>[]>;
-export declare type AuthorizationStatusForFn = (type: HKSampleTypeIdentifier | HKCharacteristicTypeIdentifier) => Promise<boolean>;
-export declare type QueryCategorySamplesFn = <T extends HKCategoryTypeIdentifier>(identifier: T, options: GenericQueryOptions) => Promise<HKCategorySample<T>[]>;
-export declare type GetRequestStatusForAuthorizationFn = (read: (HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier)[], write?: HKSampleTypeIdentifier[]) => Promise<HKAuthorizationRequestStatus>;
-export declare type RequestAuthorizationFn = (read: (HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier)[], write?: HKSampleTypeIdentifier[]) => Promise<boolean>;
+export declare type QueryStatisticsForQuantityFn = <TUnit extends HKUnit>(identifier: HKQuantityTypeIdentifier, options: readonly HKStatisticsOptions[], from: Date, to?: Date, unit?: TUnit) => Promise<QueryStatisticsResponse<TUnit>>;
+export declare type QueryWorkoutsFn = <TEnergy extends HKUnit, TDistance extends HKUnit>(options: QueryWorkoutsOptions<TEnergy, TDistance>) => Promise<readonly HKWorkout<TEnergy, TDistance>[]>;
+export declare type AuthorizationStatusForFn = (type: HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier) => Promise<boolean>;
+export declare type QueryCategorySamplesFn = <T extends HKCategoryTypeIdentifier>(identifier: T, options: GenericQueryOptions) => Promise<readonly HKCategorySample<T>[]>;
+export declare type GetRequestStatusForAuthorizationFn = (read: readonly (HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier)[], write?: readonly HKSampleTypeIdentifier[]) => Promise<HKAuthorizationRequestStatus>;
+export declare type RequestAuthorizationFn = (read: readonly (HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier)[], write?: readonly HKSampleTypeIdentifier[]) => Promise<boolean>;
 export declare type SaveQuantitySampleFn = <TUnit extends HKQuantityTypeIdentifier>(identifier: TUnit, unit: HKUnit, value: number, options?: {
-    start?: Date;
-    end?: Date;
-    metadata?: MetadataMapperForQuantityIdentifier<TUnit>;
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForQuantityIdentifier<TUnit>;
 }) => Promise<boolean>;
 export declare type QueryQuantitySamplesFn = <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends HKUnit = HKUnit>(identifier: TIdentifier, options: GenericQueryOptions & {
-    unit?: TUnit;
-}) => Promise<HKQuantitySample<TIdentifier, TUnit>[]>;
+    readonly unit?: TUnit;
+}) => Promise<readonly HKQuantitySample<TIdentifier, TUnit>[]>;
 export declare type SubscribeToChangesFn = (identifier: HKSampleTypeIdentifier, callback: () => void) => Promise<UnsubscribeFunction>;
 export declare type SaveCategorySampleFn = <T extends HKCategoryTypeIdentifier>(identifier: T, value: HKCategoryValueForIdentifier<T>, options?: {
-    start?: Date;
-    end?: Date;
-    metadata?: MetadataMapperForCategoryIdentifier<T>;
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForCategoryIdentifier<T>;
 }) => Promise<boolean>;
 export declare type GetMostRecentCategorySampleFn = <T extends HKCategoryTypeIdentifier>(identifier: T) => Promise<HKCategorySample<T> | null>;
 export declare type MostRecentCategorySampleHook = <T extends HKCategoryTypeIdentifier>(identifier: T) => HKCategorySample<T> | null;
@@ -61,58 +61,58 @@ export declare type GetMostRecentQuantitySampleFn = <TIdentifier extends HKQuant
 export declare type MostRecentQuantitySampleHook = <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends HKUnit>(identifier: TIdentifier, unit?: TUnit) => HKQuantitySample<TIdentifier, TUnit> | null;
 export declare type GetMostRecentWorkoutFn = <TEnergy extends HKUnit, TDistance extends HKUnit>(options?: Pick<QueryWorkoutsOptions<TEnergy, TDistance>, 'distanceUnit' | 'energyUnit'>) => Promise<HKWorkout<TEnergy, TDistance> | null>;
 export declare type MostRecentWorkoutHook = <TEnergy extends HKUnit, TDistance extends HKUnit>(options?: Pick<QueryWorkoutsOptions<TEnergy, TDistance>, 'distanceUnit' | 'energyUnit'>) => HKWorkout<TEnergy, TDistance> | null;
-export declare type GetPreferredUnitsFn = (identifiers: HKQuantityTypeIdentifier[]) => Promise<HKUnit[]>;
+export declare type GetPreferredUnitsFn = (identifiers: readonly HKQuantityTypeIdentifier[]) => Promise<readonly HKUnit[]>;
 export declare type GetPreferredUnitFn = (identifier: HKQuantityTypeIdentifier) => Promise<HKUnit>;
-export declare type SaveCorrelationSampleFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, samples: (Omit<HKCategorySample, 'startDate' | 'endDate' | 'uuid' | 'device'> | Omit<HKQuantitySample, 'startDate' | 'endDate' | 'uuid' | 'device'>)[], options?: {
-    start?: Date;
-    end?: Date;
-    metadata?: MetadataMapperForCorrelationIdentifier<TIdentifier>;
+export declare type SaveCorrelationSampleFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, samples: readonly (Omit<HKCategorySample, 'device' | 'endDate' | 'startDate' | 'uuid'> | Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>)[], options?: {
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForCorrelationIdentifier<TIdentifier>;
 }) => Promise<boolean>;
-export declare type SaveWorkoutSampleFn = (typeIdentifier: HKWorkoutActivityType, quantities: Omit<HKQuantitySample, 'startDate' | 'endDate' | 'uuid' | 'device'>[], start: Date, options?: {
-    end?: Date;
-    metadata?: HKWorkoutMetadata;
+export declare type SaveWorkoutSampleFn = (typeIdentifier: HKWorkoutActivityType, quantities: readonly Omit<HKQuantitySample, 'device' | 'endDate' | 'startDate' | 'uuid'>[], start: Date, options?: {
+    readonly end?: Date;
+    readonly metadata?: HKWorkoutMetadata;
 }) => Promise<boolean>;
-export interface HKCorrelation<TIdentifier extends HKCorrelationTypeIdentifier> extends Omit<HKCorrelationRaw<TIdentifier>, 'startDate' | 'endDate' | 'objects'> {
-    objects: (HKQuantitySample | HKCategorySample)[];
-    startDate: Date;
-    endDate: Date;
+export interface HKCorrelation<TIdentifier extends HKCorrelationTypeIdentifier> extends Omit<HKCorrelationRaw<TIdentifier>, 'endDate' | 'objects' | 'startDate'> {
+    readonly objects: readonly (HKCategorySample | HKQuantitySample)[];
+    readonly startDate: Date;
+    readonly endDate: Date;
 }
-export declare type QueryCorrelationSamplesFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, options: Omit<GenericQueryOptions, 'limit' | 'ascending'>) => Promise<HKCorrelation<TIdentifier>[]>;
+export declare type QueryCorrelationSamplesFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, options: Omit<GenericQueryOptions, 'ascending' | 'limit'>) => Promise<readonly HKCorrelation<TIdentifier>[]>;
 export declare type SubscribeToChangesHook = <TIdentifier extends HKSampleTypeIdentifier>(identifier: TIdentifier, onChange: () => void, runInitialUpdate?: boolean) => void;
-export declare type GetWorkoutRoutesFn = (workoutUUID: string) => Promise<WorkoutRoute[]>;
+export declare type GetWorkoutRoutesFn = (workoutUUID: string) => Promise<readonly WorkoutRoute[]>;
 export declare type ReactNativeHealthkit = {
-    authorizationStatusFor: AuthorizationStatusForFn;
-    getBiologicalSex: GetBiologicalSexFn;
-    getBloodType: GetBloodTypeFn;
-    getDateOfBirth: GetDateOfBirthFn;
-    getFitzpatrickSkinType: GetFitzpatrickSkinTypeFn;
-    getMostRecentQuantitySample: GetMostRecentQuantitySampleFn;
-    getMostRecentCategorySample: GetMostRecentCategorySampleFn;
-    getMostRecentWorkout: GetMostRecentWorkoutFn;
-    getPreferredUnit: GetPreferredUnitFn;
-    getPreferredUnits: GetPreferredUnitsFn;
-    getRequestStatusForAuthorization: GetRequestStatusForAuthorizationFn;
-    getWheelchairUse: GetWheelchairUseFn;
-    getWorkoutRoutes: GetWorkoutRoutesFn;
-    buildUnitWithPrefix: (prefix: HKUnitSIPrefix, unit: HKUnitSI) => HKUnit;
-    isHealthDataAvailable: IsHealthDataAvailableFn;
-    queryCategorySamples: QueryCategorySamplesFn;
-    queryQuantitySamples: QueryQuantitySamplesFn;
-    queryStatisticsForQuantity: QueryStatisticsForQuantityFn;
-    queryWorkouts: QueryWorkoutsFn;
-    queryCorrelationSamples: QueryCorrelationSamplesFn;
-    requestAuthorization: RequestAuthorizationFn;
-    saveCategorySample: SaveCategorySampleFn;
-    saveQuantitySample: SaveQuantitySampleFn;
-    saveCorrelationSample: SaveCorrelationSampleFn;
-    saveWorkoutSample: SaveWorkoutSampleFn;
-    enableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier, updateFrequency: HKUpdateFrequency) => Promise<boolean>;
-    disableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier) => Promise<boolean>;
-    disableAllBackgroundDelivery: () => Promise<boolean>;
-    subscribeToChanges: SubscribeToChangesFn;
-    useMostRecentWorkout: MostRecentWorkoutHook;
-    useMostRecentCategorySample: MostRecentCategorySampleHook;
-    useMostRecentQuantitySample: MostRecentQuantitySampleHook;
-    useSubscribeToChanges: SubscribeToChangesHook;
+    readonly authorizationStatusFor: AuthorizationStatusForFn;
+    readonly getBiologicalSex: GetBiologicalSexFn;
+    readonly getBloodType: GetBloodTypeFn;
+    readonly getDateOfBirth: GetDateOfBirthFn;
+    readonly getFitzpatrickSkinType: GetFitzpatrickSkinTypeFn;
+    readonly getMostRecentQuantitySample: GetMostRecentQuantitySampleFn;
+    readonly getMostRecentCategorySample: GetMostRecentCategorySampleFn;
+    readonly getMostRecentWorkout: GetMostRecentWorkoutFn;
+    readonly getPreferredUnit: GetPreferredUnitFn;
+    readonly getPreferredUnits: GetPreferredUnitsFn;
+    readonly getRequestStatusForAuthorization: GetRequestStatusForAuthorizationFn;
+    readonly getWheelchairUse: GetWheelchairUseFn;
+    readonly getWorkoutRoutes: GetWorkoutRoutesFn;
+    readonly buildUnitWithPrefix: (prefix: HKUnitSIPrefix, unit: HKUnitSI) => HKUnit;
+    readonly isHealthDataAvailable: IsHealthDataAvailableFn;
+    readonly queryCategorySamples: QueryCategorySamplesFn;
+    readonly queryQuantitySamples: QueryQuantitySamplesFn;
+    readonly queryStatisticsForQuantity: QueryStatisticsForQuantityFn;
+    readonly queryWorkouts: QueryWorkoutsFn;
+    readonly queryCorrelationSamples: QueryCorrelationSamplesFn;
+    readonly requestAuthorization: RequestAuthorizationFn;
+    readonly saveCategorySample: SaveCategorySampleFn;
+    readonly saveQuantitySample: SaveQuantitySampleFn;
+    readonly saveCorrelationSample: SaveCorrelationSampleFn;
+    readonly saveWorkoutSample: SaveWorkoutSampleFn;
+    readonly enableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier, updateFrequency: HKUpdateFrequency) => Promise<boolean>;
+    readonly disableBackgroundDelivery: (typeIdentifier: HKSampleTypeIdentifier) => Promise<boolean>;
+    readonly disableAllBackgroundDelivery: () => Promise<boolean>;
+    readonly subscribeToChanges: SubscribeToChangesFn;
+    readonly useMostRecentWorkout: MostRecentWorkoutHook;
+    readonly useMostRecentCategorySample: MostRecentCategorySampleHook;
+    readonly useMostRecentQuantitySample: MostRecentQuantitySampleHook;
+    readonly useSubscribeToChanges: SubscribeToChangesHook;
 };
 export {};