@kingstinct/react-native-healthkit 13.0.2 → 13.1.0

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

@@ -38,6 +38,7 @@ export type AvailableQuantityTypesIOS17Plus = QuantityTypeIdentifier;
  */
 export type AvailableQuantityTypes<T extends number = typeof currentMajorVersionIOS> = T extends 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 ? AvailableQuantityTypesIOS17Plus : AvailableQuantityTypesBeforeIOS17;
 export declare const authorizationStatusFor: (type: import("./types").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>;
@@ -68,7 +69,7 @@ export declare const queryWorkoutSamples: (options: import("./types").WorkoutQue
 export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
 export declare const querySources: (identifier: import("./types").SampleTypeIdentifier, filter?: import("./types").FilterForSamples) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
 export declare const requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
-export declare const deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
+export declare const 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: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").QuantitySample | undefined>;
@@ -139,7 +140,8 @@ declare const _default: {
     queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
     querySources: (identifier: import("./types").SampleTypeIdentifier, filter?: import("./types").FilterForSamples) => Promise<readonly import("./specs/SourceProxy.nitro").SourceProxy[]>;
     requestAuthorization: (toRequest: import("./specs/CoreModule.nitro").AuthDataTypes) => Promise<boolean>;
-    deleteObjects: (objectTypeIdentifier: import("./types").ObjectTypeIdentifier, filter: import("./types").FilterForSamples) => Promise<number>;
+    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: QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata?: import("react-native-nitro-modules").AnyMap) => Promise<import("./types").QuantitySample | undefined>;

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

@@ -3,7 +3,7 @@ import type { AuthorizationRequestStatus, AuthorizationStatus } from '../types/A
 import type { UpdateFrequency } from '../types/Background';
 import type { QuantityTypeIdentifier } from '../types/QuantityTypeIdentifier';
 import type { FilterForSamples } from '../types/QueryOptions';
-import type { ObjectTypeIdentifier, SampleTypeIdentifier, SampleTypeIdentifierWriteable } from '../types/Shared';
+import type { ObjectTypeIdentifier, PerObjectTypeIdentifier, SampleTypeIdentifier, SampleTypeIdentifierWriteable } from '../types/Shared';
 import type { OnChangeCallbackArgs } from '../types/Subscriptions';
 import type { IdentifierWithUnit } from '../types/Units';
 import type { SourceProxy } from './SourceProxy.nitro';
@@ -58,7 +58,8 @@ export interface CoreModule extends HybridObject<{
      * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs }
      */
     requestAuthorization(toRequest: AuthDataTypes): Promise<boolean>;
-    deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples): Promise<number>;
+    requestPerObjectReadAuthorization(typeIdentifier: PerObjectTypeIdentifier): Promise<void>;
+    deleteObjects(objectTypeIdentifier: SampleTypeIdentifierWriteable, filter: FilterForSamples): Promise<number>;
     isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier): boolean;
     areObjectTypesAvailable(objectTypeIdentifiers: readonly ObjectTypeIdentifier[]): Record<string, boolean>;
     areObjectTypesAvailableAsync(objectTypeIdentifiers: ObjectTypeIdentifier[]): Promise<Record<string, boolean>>;

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

@@ -49,6 +49,9 @@ export interface MedicationModule extends HybridObject<{
     ios: 'swift';
 }> {
     queryMedications(): Promise<readonly UserAnnotatedMedication[]>;
+    /**
+     * @deprecated Use requestPerObjectReadAuthorization instead.
+     */
     requestMedicationsAuthorization(): Promise<boolean>;
     queryMedicationEvents(options: QueryOptionsWithSortOrder): Promise<readonly MedicationDoseEvent[]>;
     queryMedicationEventsWithAnchor(options: QueryOptionsWithAnchor): Promise<MedicationDoseEventsWithAnchorResponse>;

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

@@ -24,3 +24,14 @@ export declare const HeartbeatSeriesTypeIdentifier: "HKDataTypeIdentifierHeartbe
  */
 export declare const ElectrocardiogramTypeIdentifier: "HKElectrocardiogramType";
 export declare const UserAnnotatedMedicationTypeIdentifier = "HKUserAnnotatedMedicationTypeIdentifier";
+/**
+ * Represents a type that identifies activity summary objects.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkactivitysummarytype Apple Docs HKActivitySummaryType}
+ */
+export declare const ActivitySummaryTypeIdentifier: "HKActivitySummaryTypeIdentifier";
+export declare const HKVisionPrescriptionTypeIdentifier: "HKVisionPrescriptionTypeIdentifier";
+/**
+ * Represents an audiogram type identifier.
+ * @see {@link https://developer.apple.com/documentation/healthkit/HKAudiogramSampleType Apple Docs HKAudiogramSampleType}
+ */
+export declare const AudiogramTypeIdentifier: "HKAudiogramSampleType";

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

@@ -1,7 +1,7 @@
 import type { AnyMap } from 'react-native-nitro-modules';
 import type { CategoryTypeIdentifier, CategoryTypeIdentifierWriteable } from './CategoryTypeIdentifier';
 import type { CharacteristicTypeIdentifier } from './Characteristics';
-import type { ElectrocardiogramTypeIdentifier, HeartbeatSeriesTypeIdentifier, StateOfMindTypeIdentifier, WorkoutRouteTypeIdentifier, WorkoutTypeIdentifier } from './Constants';
+import type { ActivitySummaryTypeIdentifier, AudiogramTypeIdentifier, ElectrocardiogramTypeIdentifier, HeartbeatSeriesTypeIdentifier, HKVisionPrescriptionTypeIdentifier, StateOfMindTypeIdentifier, UserAnnotatedMedicationTypeIdentifier, WorkoutRouteTypeIdentifier, WorkoutTypeIdentifier } from './Constants';
 import type { CorrelationTypeIdentifier } from './CorrelationType';
 import type { Device } from './Device';
 import type { HeartRateMotionContext, InsulinDeliveryReason, Quantity } from './QuantityType';
@@ -13,6 +13,7 @@ export interface DeletedSample {
     readonly metadata?: AnyMap;
 }
 export type ObjectTypeIdentifier = CharacteristicTypeIdentifier | SampleTypeIdentifier | typeof ActivitySummaryTypeIdentifier;
+export type PerObjectTypeIdentifier = typeof HKVisionPrescriptionTypeIdentifier | typeof UserAnnotatedMedicationTypeIdentifier;
 export type SampleTypeIdentifier = CategoryTypeIdentifier | CorrelationTypeIdentifier | QuantityTypeIdentifier | typeof StateOfMindTypeIdentifier | typeof AudiogramTypeIdentifier | typeof HeartbeatSeriesTypeIdentifier | typeof WorkoutRouteTypeIdentifier | typeof WorkoutTypeIdentifier | typeof ElectrocardiogramTypeIdentifier;
 export type SampleTypeIdentifierWriteable = CategoryTypeIdentifierWriteable | CorrelationTypeIdentifier | QuantityTypeIdentifierWriteable | typeof StateOfMindTypeIdentifier | typeof AudiogramTypeIdentifier | typeof HeartbeatSeriesTypeIdentifier | typeof WorkoutRouteTypeIdentifier | typeof WorkoutTypeIdentifier;
 export interface GenericMetadata {
@@ -31,16 +32,6 @@ export interface GenericMetadata {
     readonly HKReferenceRangeLowerLimit?: number;
     readonly HKReferenceRangeUpperLimit?: number;
 }
-/**
- * Represents a type that identifies activity summary objects.
- * @see {@link https://developer.apple.com/documentation/healthkit/hkactivitysummarytype Apple Docs HKActivitySummaryType}
- */
-export declare const ActivitySummaryTypeIdentifier: "ActivitySummaryTypeIdentifier";
-/**
- * Represents an audiogram type identifier.
- * @see {@link https://developer.apple.com/documentation/healthkit/HKAudiogramSampleType Apple Docs HKAudiogramSampleType}
- */
-export declare const AudiogramTypeIdentifier: "HKAudiogramSampleType";
 export interface BaseObject {
     readonly uuid: string;
     readonly sourceRevision: SourceRevision;

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

@@ -3,8 +3,8 @@ import type { SourceProxy } from '../specs/SourceProxy.nitro';
  * @see {@link https://developer.apple.com/documentation/healthkit/hkobject/1615483-sourcerevision Apple Docs }
  */
 export interface SourceRevision {
-    readonly source?: SourceProxy;
+    readonly source: SourceProxy;
     readonly version?: string;
-    readonly operatingSystemVersion?: string;
+    readonly operatingSystemVersion: string;
     readonly productType?: string;
 }

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.cpp

@@ -209,6 +209,14 @@ namespace margelo::nitro::healthkit::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeHealthkit::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::unordered_map<std::string, bool>& /* result */)>
   Func_void_std__unordered_map_std__string__bool_ create_Func_void_std__unordered_map_std__string__bool_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__unordered_map_std__string__bool_::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.hpp

@@ -404,21 +404,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_HybridSourceProxySpec_ = std::weak_ptr<HybridSourceProxySpec>;
   inline std__weak_ptr_HybridSourceProxySpec_ weakify_std__shared_ptr_HybridSourceProxySpec_(const std::shared_ptr<HybridSourceProxySpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::optional<std::shared_ptr<HybridSourceProxySpec>>
-  /**
-   * Specialized version of `std::optional<std::shared_ptr<HybridSourceProxySpec>>`.
-   */
-  using std__optional_std__shared_ptr_HybridSourceProxySpec__ = std::optional<std::shared_ptr<HybridSourceProxySpec>>;
-  inline std::optional<std::shared_ptr<HybridSourceProxySpec>> create_std__optional_std__shared_ptr_HybridSourceProxySpec__(const std::shared_ptr<HybridSourceProxySpec>& value) noexcept {
-    return std::optional<std::shared_ptr<HybridSourceProxySpec>>(value);
-  }
-  inline bool has_value_std__optional_std__shared_ptr_HybridSourceProxySpec__(const std::optional<std::shared_ptr<HybridSourceProxySpec>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::shared_ptr<HybridSourceProxySpec> get_std__optional_std__shared_ptr_HybridSourceProxySpec__(const std::optional<std::shared_ptr<HybridSourceProxySpec>>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::optional<std::string>
   /**
    * Specialized version of `std::optional<std::string>`.
@@ -1468,6 +1453,40 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::unordered_map<std::string, bool>
   /**
    * Specialized version of `std::unordered_map<std::string, bool>`.
@@ -1629,6 +1648,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<AuthorizationRequestStatus>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::unordered_map<std::string, bool>>
   using Result_std__unordered_map_std__string__bool__ = Result<std::unordered_map<std::string, bool>>;
   inline Result_std__unordered_map_std__string__bool__ create_Result_std__unordered_map_std__string__bool__(const std::unordered_map<std::string, bool>& value) noexcept {

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp

@@ -122,6 +122,8 @@ namespace margelo::nitro::healthkit { struct MedicationDoseEventsWithAnchorRespo
 namespace margelo::nitro::healthkit { enum class ObjectTypeIdentifier; }
 // Forward declaration of `OnChangeCallbackArgs` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct OnChangeCallbackArgs; }
+// Forward declaration of `PerObjectTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PerObjectTypeIdentifier; }
 // Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
 // Forward declaration of `QuantityDateInterval` to properly resolve imports.
@@ -275,6 +277,7 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "MedicationDoseEventsWithAnchorResponse.hpp"
 #include "ObjectTypeIdentifier.hpp"
 #include "OnChangeCallbackArgs.hpp"
+#include "PerObjectTypeIdentifier.hpp"
 #include "PredicateWithMetadataKey.hpp"
 #include "Quantity.hpp"
 #include "QuantityDateInterval.hpp"

package/nitrogen/generated/ios/c++/HybridCoreModuleSpecSwift.hpp

@@ -46,6 +46,8 @@ namespace margelo::nitro::healthkit { enum class AuthorizationRequestStatus; }
 namespace margelo::nitro::healthkit { struct AuthDataTypes; }
 // Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
+// Forward declaration of `PerObjectTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PerObjectTypeIdentifier; }
 
 #include <NitroModules/Promise.hpp>
 #include "ObjectTypeIdentifier.hpp"
@@ -72,6 +74,7 @@ namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable;
 #include "AuthorizationRequestStatus.hpp"
 #include "AuthDataTypes.hpp"
 #include "SampleTypeIdentifierWriteable.hpp"
+#include "PerObjectTypeIdentifier.hpp"
 #include <unordered_map>
 
 #include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
@@ -262,7 +265,15 @@ namespace margelo::nitro::healthkit {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<double>> deleteObjects(ObjectTypeIdentifier objectTypeIdentifier, const FilterForSamples& filter) override {
+    inline std::shared_ptr<Promise<void>> requestPerObjectReadAuthorization(PerObjectTypeIdentifier typeIdentifier) override {
+      auto __result = _swiftPart.requestPerObjectReadAuthorization(static_cast<int>(typeIdentifier));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> deleteObjects(SampleTypeIdentifierWriteable objectTypeIdentifier, const FilterForSamples& filter) override {
       auto __result = _swiftPart.deleteObjects(static_cast<int>(objectTypeIdentifier), std::forward<decltype(filter)>(filter));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `() -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void {
+  public typealias bridge = margelo.nitro.healthkit.bridge.swift
+
+  private let closure: () -> Void
+
+  public init(_ closure: @escaping () -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call() -> Void {
+    self.closure()
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void {
+    return Unmanaged<Func_void>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridCoreModuleSpec.swift

@@ -32,7 +32,8 @@ public protocol HybridCoreModuleSpec_protocol: HybridObject {
   func authorizationStatusFor(type: ObjectTypeIdentifier) throws -> AuthorizationStatus
   func getRequestStatusForAuthorization(toCheck: AuthDataTypes) throws -> Promise<AuthorizationRequestStatus>
   func requestAuthorization(toRequest: AuthDataTypes) throws -> Promise<Bool>
-  func deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples) throws -> Promise<Double>
+  func requestPerObjectReadAuthorization(typeIdentifier: PerObjectTypeIdentifier) throws -> Promise<Void>
+  func deleteObjects(objectTypeIdentifier: SampleTypeIdentifierWriteable, filter: FilterForSamples) throws -> Promise<Double>
   func isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier) throws -> Bool
   func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) throws -> Dictionary<String, Bool>
   func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) throws -> Promise<Dictionary<String, Bool>>

package/nitrogen/generated/ios/swift/HybridCoreModuleSpec_cxx.swift

@@ -440,10 +440,29 @@ open class HybridCoreModuleSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func requestPerObjectReadAuthorization(typeIdentifier: Int32) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.requestPerObjectReadAuthorization(typeIdentifier: margelo.nitro.healthkit.PerObjectTypeIdentifier(rawValue: typeIdentifier)!)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func deleteObjects(objectTypeIdentifier: Int32, filter: FilterForSamples) -> bridge.Result_std__shared_ptr_Promise_double___ {
     do {
-      let __result = try self.__implementation.deleteObjects(objectTypeIdentifier: margelo.nitro.healthkit.ObjectTypeIdentifier(rawValue: objectTypeIdentifier)!, filter: filter)
+      let __result = try self.__implementation.deleteObjects(objectTypeIdentifier: margelo.nitro.healthkit.SampleTypeIdentifierWriteable(rawValue: objectTypeIdentifier)!, filter: filter)
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in
         let __promise = bridge.create_std__shared_ptr_Promise_double__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_double__(__promise)

package/nitrogen/generated/ios/swift/ObjectTypeIdentifier.swift

@@ -411,8 +411,8 @@ public extension ObjectTypeIdentifier {
         self = .hkworkouttypeidentifier
       case "HKElectrocardiogramType":
         self = .hkelectrocardiogramtype
-      case "ActivitySummaryTypeIdentifier":
-        self = .activitysummarytypeidentifier
+      case "HKActivitySummaryTypeIdentifier":
+        self = .hkactivitysummarytypeidentifier
       default:
         return nil
     }
@@ -817,8 +817,8 @@ public extension ObjectTypeIdentifier {
         return "HKWorkoutTypeIdentifier"
       case .hkelectrocardiogramtype:
         return "HKElectrocardiogramType"
-      case .activitysummarytypeidentifier:
-        return "ActivitySummaryTypeIdentifier"
+      case .hkactivitysummarytypeidentifier:
+        return "HKActivitySummaryTypeIdentifier"
     }
   }
 }

package/nitrogen/generated/ios/swift/PerObjectTypeIdentifier.swift

@@ -0,0 +1,40 @@
+///
+/// PerObjectTypeIdentifier.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `PerObjectTypeIdentifier`, backed by a C++ enum.
+ */
+public typealias PerObjectTypeIdentifier = margelo.nitro.healthkit.PerObjectTypeIdentifier
+
+public extension PerObjectTypeIdentifier {
+  /**
+   * Get a PerObjectTypeIdentifier for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "HKVisionPrescriptionTypeIdentifier":
+        self = .hkvisionprescriptiontypeidentifier
+      case "HKUserAnnotatedMedicationTypeIdentifier":
+        self = .hkuserannotatedmedicationtypeidentifier
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this PerObjectTypeIdentifier represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .hkvisionprescriptiontypeidentifier:
+        return "HKVisionPrescriptionTypeIdentifier"
+      case .hkuserannotatedmedicationtypeidentifier:
+        return "HKUserAnnotatedMedicationTypeIdentifier"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/SourceRevision.swift

@@ -19,29 +19,17 @@ public extension SourceRevision {
   /**
    * Create a new instance of `SourceRevision`.
    */
-  init(source: (any HybridSourceProxySpec)?, version: String?, operatingSystemVersion: String?, productType: String?) {
-    self.init({ () -> bridge.std__optional_std__shared_ptr_HybridSourceProxySpec__ in
-      if let __unwrappedValue = source {
-        return bridge.create_std__optional_std__shared_ptr_HybridSourceProxySpec__({ () -> bridge.std__shared_ptr_HybridSourceProxySpec_ in
-          let __cxxWrapped = __unwrappedValue.getCxxWrapper()
-          return __cxxWrapped.getCxxPart()
-        }())
-      } else {
-        return .init()
-      }
+  init(source: (any HybridSourceProxySpec), version: String?, operatingSystemVersion: String, productType: String?) {
+    self.init({ () -> bridge.std__shared_ptr_HybridSourceProxySpec_ in
+      let __cxxWrapped = source.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
     }(), { () -> bridge.std__optional_std__string_ in
       if let __unwrappedValue = version {
         return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
       } else {
         return .init()
       }
-    }(), { () -> bridge.std__optional_std__string_ in
-      if let __unwrappedValue = operatingSystemVersion {
-        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
-      } else {
-        return .init()
-      }
-    }(), { () -> bridge.std__optional_std__string_ in
+    }(), std.string(operatingSystemVersion), { () -> bridge.std__optional_std__string_ in
       if let __unwrappedValue = productType {
         return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
       } else {
@@ -50,33 +38,20 @@ public extension SourceRevision {
     }())
   }
 
-  var source: (any HybridSourceProxySpec)? {
+  var source: (any HybridSourceProxySpec) {
     @inline(__always)
     get {
-      return { () -> (any HybridSourceProxySpec)? in
-        if bridge.has_value_std__optional_std__shared_ptr_HybridSourceProxySpec__(self.__source) {
-          let __unwrapped = bridge.get_std__optional_std__shared_ptr_HybridSourceProxySpec__(self.__source)
-          return { () -> HybridSourceProxySpec in
-            let __unsafePointer = bridge.get_std__shared_ptr_HybridSourceProxySpec_(__unwrapped)
-            let __instance = HybridSourceProxySpec_cxx.fromUnsafe(__unsafePointer)
-            return __instance.getHybridSourceProxySpec()
-          }()
-        } else {
-          return nil
-        }
+      return { () -> HybridSourceProxySpec in
+        let __unsafePointer = bridge.get_std__shared_ptr_HybridSourceProxySpec_(self.__source)
+        let __instance = HybridSourceProxySpec_cxx.fromUnsafe(__unsafePointer)
+        return __instance.getHybridSourceProxySpec()
       }()
     }
     @inline(__always)
     set {
-      self.__source = { () -> bridge.std__optional_std__shared_ptr_HybridSourceProxySpec__ in
-        if let __unwrappedValue = newValue {
-          return bridge.create_std__optional_std__shared_ptr_HybridSourceProxySpec__({ () -> bridge.std__shared_ptr_HybridSourceProxySpec_ in
-            let __cxxWrapped = __unwrappedValue.getCxxWrapper()
-            return __cxxWrapped.getCxxPart()
-          }())
-        } else {
-          return .init()
-        }
+      self.__source = { () -> bridge.std__shared_ptr_HybridSourceProxySpec_ in
+        let __cxxWrapped = newValue.getCxxWrapper()
+        return __cxxWrapped.getCxxPart()
       }()
     }
   }
@@ -105,27 +80,14 @@ public extension SourceRevision {
     }
   }
   
-  var operatingSystemVersion: String? {
+  var operatingSystemVersion: String {
     @inline(__always)
     get {
-      return { () -> String? in
-        if bridge.has_value_std__optional_std__string_(self.__operatingSystemVersion) {
-          let __unwrapped = bridge.get_std__optional_std__string_(self.__operatingSystemVersion)
-          return String(__unwrapped)
-        } else {
-          return nil
-        }
-      }()
+      return String(self.__operatingSystemVersion)
     }
     @inline(__always)
     set {
-      self.__operatingSystemVersion = { () -> bridge.std__optional_std__string_ in
-        if let __unwrappedValue = newValue {
-          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
-        } else {
-          return .init()
-        }
-      }()
+      self.__operatingSystemVersion = std.string(newValue)
     }
   }
   

package/nitrogen/generated/shared/c++/HybridCoreModuleSpec.cpp

@@ -32,6 +32,7 @@ namespace margelo::nitro::healthkit {
       prototype.registerHybridMethod("authorizationStatusFor", &HybridCoreModuleSpec::authorizationStatusFor);
       prototype.registerHybridMethod("getRequestStatusForAuthorization", &HybridCoreModuleSpec::getRequestStatusForAuthorization);
       prototype.registerHybridMethod("requestAuthorization", &HybridCoreModuleSpec::requestAuthorization);
+      prototype.registerHybridMethod("requestPerObjectReadAuthorization", &HybridCoreModuleSpec::requestPerObjectReadAuthorization);
       prototype.registerHybridMethod("deleteObjects", &HybridCoreModuleSpec::deleteObjects);
       prototype.registerHybridMethod("isObjectTypeAvailable", &HybridCoreModuleSpec::isObjectTypeAvailable);
       prototype.registerHybridMethod("areObjectTypesAvailable", &HybridCoreModuleSpec::areObjectTypesAvailable);

package/nitrogen/generated/shared/c++/HybridCoreModuleSpec.hpp

@@ -35,6 +35,10 @@ namespace margelo::nitro::healthkit { enum class AuthorizationStatus; }
 namespace margelo::nitro::healthkit { enum class AuthorizationRequestStatus; }
 // Forward declaration of `AuthDataTypes` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct AuthDataTypes; }
+// Forward declaration of `PerObjectTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PerObjectTypeIdentifier; }
+// Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
 
 #include <NitroModules/Promise.hpp>
 #include "ObjectTypeIdentifier.hpp"
@@ -53,6 +57,8 @@ namespace margelo::nitro::healthkit { struct AuthDataTypes; }
 #include "AuthorizationStatus.hpp"
 #include "AuthorizationRequestStatus.hpp"
 #include "AuthDataTypes.hpp"
+#include "PerObjectTypeIdentifier.hpp"
+#include "SampleTypeIdentifierWriteable.hpp"
 #include <unordered_map>
 
 namespace margelo::nitro::healthkit {
@@ -104,7 +110,8 @@ namespace margelo::nitro::healthkit {
       virtual AuthorizationStatus authorizationStatusFor(ObjectTypeIdentifier type) = 0;
       virtual std::shared_ptr<Promise<AuthorizationRequestStatus>> getRequestStatusForAuthorization(const AuthDataTypes& toCheck) = 0;
       virtual std::shared_ptr<Promise<bool>> requestAuthorization(const AuthDataTypes& toRequest) = 0;
-      virtual std::shared_ptr<Promise<double>> deleteObjects(ObjectTypeIdentifier objectTypeIdentifier, const FilterForSamples& filter) = 0;
+      virtual std::shared_ptr<Promise<void>> requestPerObjectReadAuthorization(PerObjectTypeIdentifier typeIdentifier) = 0;
+      virtual std::shared_ptr<Promise<double>> deleteObjects(SampleTypeIdentifierWriteable objectTypeIdentifier, const FilterForSamples& filter) = 0;
       virtual bool isObjectTypeAvailable(ObjectTypeIdentifier objectTypeIdentifier) = 0;
       virtual std::unordered_map<std::string, bool> areObjectTypesAvailable(const std::vector<ObjectTypeIdentifier>& objectTypeIdentifiers) = 0;
       virtual std::shared_ptr<Promise<std::unordered_map<std::string, bool>>> areObjectTypesAvailableAsync(const std::vector<ObjectTypeIdentifier>& objectTypeIdentifiers) = 0;

package/nitrogen/generated/shared/c++/ObjectTypeIdentifier.hpp

@@ -226,7 +226,7 @@ namespace margelo::nitro::healthkit {
     HKWORKOUTROUTETYPEIDENTIFIER      SWIFT_NAME(hkworkoutroutetypeidentifier) = 194,
     HKWORKOUTTYPEIDENTIFIER      SWIFT_NAME(hkworkouttypeidentifier) = 195,
     HKELECTROCARDIOGRAMTYPE      SWIFT_NAME(hkelectrocardiogramtype) = 196,
-    ACTIVITYSUMMARYTYPEIDENTIFIER      SWIFT_NAME(activitysummarytypeidentifier) = 197,
+    HKACTIVITYSUMMARYTYPEIDENTIFIER      SWIFT_NAME(hkactivitysummarytypeidentifier) = 197,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::healthkit
@@ -436,7 +436,7 @@ namespace margelo::nitro {
         case hashString("HKWorkoutRouteTypeIdentifier"): return margelo::nitro::healthkit::ObjectTypeIdentifier::HKWORKOUTROUTETYPEIDENTIFIER;
         case hashString("HKWorkoutTypeIdentifier"): return margelo::nitro::healthkit::ObjectTypeIdentifier::HKWORKOUTTYPEIDENTIFIER;
         case hashString("HKElectrocardiogramType"): return margelo::nitro::healthkit::ObjectTypeIdentifier::HKELECTROCARDIOGRAMTYPE;
-        case hashString("ActivitySummaryTypeIdentifier"): return margelo::nitro::healthkit::ObjectTypeIdentifier::ACTIVITYSUMMARYTYPEIDENTIFIER;
+        case hashString("HKActivitySummaryTypeIdentifier"): return margelo::nitro::healthkit::ObjectTypeIdentifier::HKACTIVITYSUMMARYTYPEIDENTIFIER;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum ObjectTypeIdentifier - invalid value!");
       }
@@ -640,7 +640,7 @@ namespace margelo::nitro {
         case margelo::nitro::healthkit::ObjectTypeIdentifier::HKWORKOUTROUTETYPEIDENTIFIER: return JSIConverter<std::string>::toJSI(runtime, "HKWorkoutRouteTypeIdentifier");
         case margelo::nitro::healthkit::ObjectTypeIdentifier::HKWORKOUTTYPEIDENTIFIER: return JSIConverter<std::string>::toJSI(runtime, "HKWorkoutTypeIdentifier");
         case margelo::nitro::healthkit::ObjectTypeIdentifier::HKELECTROCARDIOGRAMTYPE: return JSIConverter<std::string>::toJSI(runtime, "HKElectrocardiogramType");
-        case margelo::nitro::healthkit::ObjectTypeIdentifier::ACTIVITYSUMMARYTYPEIDENTIFIER: return JSIConverter<std::string>::toJSI(runtime, "ActivitySummaryTypeIdentifier");
+        case margelo::nitro::healthkit::ObjectTypeIdentifier::HKACTIVITYSUMMARYTYPEIDENTIFIER: return JSIConverter<std::string>::toJSI(runtime, "HKActivitySummaryTypeIdentifier");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert ObjectTypeIdentifier to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -849,7 +849,7 @@ namespace margelo::nitro {
         case hashString("HKWorkoutRouteTypeIdentifier"):
         case hashString("HKWorkoutTypeIdentifier"):
         case hashString("HKElectrocardiogramType"):
-        case hashString("ActivitySummaryTypeIdentifier"):
+        case hashString("HKActivitySummaryTypeIdentifier"):
           return true;
         default:
           return false;