@kingstinct/react-native-healthkit 9.0.9 → 9.0.11

package/README.md

@@ -184,7 +184,7 @@ See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the
 
 If you're using @kingstinct/react-native-healthkit to build your production app [please consider funding its continued development](https://github.com/sponsors/Kingstinct). It helps us spend more time on keeping this library as good as it can be.
 
-At Kingstinct we're also able to provide enterprise-grade support for this package, [find us here](https://kingstinct.com) or [drop an email](mailto:healthkit@kingstinct.com) for more information. Also feel free to join our [Discord community](https://discord.gg/EHScS93v).
+At Kingstinct we're also able to provide enterprise-grade support for this package, [find us here](https://kingstinct.com) or [drop an email](mailto:healthkit@kingstinct.com) for more information. Also feel free to join our [Discord community](https://discord.gg/hrgnETpsJA).
 
 ## License
 

package/ios/CategoryTypeModule.swift

@@ -7,7 +7,7 @@ class CategoryTypeModule: HybridCategoryTypeModuleSpec {
         value: Double,
         startDate: Date,
         endDate: Date,
-        metadata: AnyMapHolder
+        metadata: AnyMap
     ) throws -> Promise<Bool> {
         let type = try initializeCategoryType(identifier.stringValue)
 

package/ios/CorrelationTypeModule.swift

@@ -7,7 +7,7 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
         samples: [SampleForSaving],
         start: Date,
         end: Date,
-        metadata: AnyMapHolder
+        metadata: AnyMap
     ) throws -> Promise<Bool> {
         let correlationType = try initializeCorrelationType(typeIdentifier.stringValue)
 

package/ios/QuantityTypeModule.swift

@@ -79,7 +79,7 @@ func saveQuantitySampleInternal(
     }
 }
 
-func getAnyMapValue(_ anyMap: AnyMapHolder, key: String) -> Any? {
+func getAnyMapValue(_ anyMap: AnyMap, key: String) -> Any? {
     if anyMap.isBool(key: key) {
         return anyMap.getBoolean(key: key)
     }
@@ -104,7 +104,7 @@ func getAnyMapValue(_ anyMap: AnyMapHolder, key: String) -> Any? {
     return nil
 }
 
-func anyMapToDictionary(_ anyMap: AnyMapHolder) -> [String: Any] {
+func anyMapToDictionary(_ anyMap: AnyMap) -> [String: Any] {
     var dict = [String: Any]()
     anyMap.getAllKeys().forEach { key in
         dict[key] = getAnyMapValue(anyMap, key: key)
@@ -169,9 +169,9 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
 
         let quantityType = try initializeQuantityType(identifier.stringValue)
         let predicate = try createPredicate(filter: options?.filter)
-        let unit = HKUnit.init(from: options?.unit ?? "count")
 
         return Promise.async {
+            let unit = try await getUnitToUse(unitOverride: options?.unit, quantityType: quantityType)
             return try await withCheckedThrowingContinuation { continuation in
                 let query = HKStatisticsQuery.init(
                     quantityType: quantityType,
@@ -254,7 +254,6 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
         let quantityType = try initializeQuantityType(identifier.stringValue)
 
         let predicate = try createPredicate(filter: options?.filter)
-        let unit = HKUnit.init(from: options?.unit ?? "count")
 
         // Convert the anchor date string to Date
         let dateFormatter = ISO8601DateFormatter()
@@ -284,6 +283,7 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
         let opts = buildStatisticsOptions(statistics: statistics)
 
         return Promise.async {
+            let unit = try await getUnitToUse(unitOverride: options?.unit, quantityType: quantityType)
             return try await withCheckedThrowingContinuation { continuation in
                 let query = HKStatisticsCollectionQuery.init(
                     quantityType: quantityType,
@@ -453,7 +453,7 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
         }
     }
 
-    func saveQuantitySample(identifier: QuantityTypeIdentifier, unit: String, value: Double, start: Date, end: Date, metadata: AnyMapHolder) throws -> Promise<Bool> {
+    func saveQuantitySample(identifier: QuantityTypeIdentifier, unit: String, value: Double, start: Date, end: Date, metadata: AnyMap) throws -> Promise<Bool> {
         return saveQuantitySampleInternal(
             typeIdentifier: HKQuantityType(
                 HKQuantityTypeIdentifier(rawValue: identifier.stringValue)

package/ios/Serializers.swift

@@ -207,8 +207,8 @@ func serializeUnknownQuantity(quantity: HKQuantity) -> [String: AnyValue]? {
     return nil
 }
 
-func serializeMetadata(_ metadata: [String: Any]?) -> AnyMapHolder {
-    let serialized = AnyMapHolder()
+func serializeMetadata(_ metadata: [String: Any]?) -> AnyMap {
+    let serialized = AnyMap()
     if let m = metadata {
         for item in m {
             if let bool = item.value as? Bool {

package/ios/StateOfMindModule.swift

@@ -91,7 +91,7 @@ class StateOfMindModule: HybridStateOfMindModuleSpec {
         valence: Double,
         labels: [StateOfMindLabel],
         associations: [StateOfMindAssociation],
-        metadata: AnyMapHolder?
+        metadata: AnyMap?
     ) throws -> Promise<Bool> {
         if #available(iOS 18, *) {
             return Promise.async {
@@ -119,7 +119,7 @@ class StateOfMindModule: HybridStateOfMindModuleSpec {
                             valence: valence,
                             labels: hkLabels,
                             associations: hkAssociations,
-                            metadata: anyMapToDictionary(metadata ?? AnyMapHolder())
+                            metadata: anyMapToDictionary(metadata ?? AnyMap())
                         )
 
                         store.save(sample) { (success: Bool, error: Error?) in

package/ios/WorkoutProxy.swift

@@ -328,7 +328,7 @@ class WorkoutProxy: HybridWorkoutProxySpec {
     }
   }
 
-  var metadata: AnyMapHolder? {
+  var metadata: AnyMap? {
     get {
       return serializeMetadata(workout.metadata)
     }

package/ios/WorkoutsModule.swift

@@ -101,7 +101,7 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
         startDate: Date,
         endDate: Date,
         totals: WorkoutTotals,
-        metadata: AnyMapHolder
+        metadata: AnyMap
     ) throws -> Promise<String> {
 
         let type = try initializeWorkoutActivityType(UInt(workoutActivityType.rawValue))

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

@@ -295,13 +295,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_bool_Wrapper final {
   public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_shared<std::function<void(bool /* result */)>>(std::move(func))) {}
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
     inline void call(bool result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(bool /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper);
   inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) {
     return Func_void_bool_Wrapper(std::move(value));
@@ -317,13 +317,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__exception_ptr_Wrapper final {
   public:
-    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_shared<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
     inline void call(std::exception_ptr error) const {
       _function->operator()(error);
     }
   private:
-    std::shared_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
@@ -410,13 +410,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_CategorySample__Wrapper final {
   public:
-    explicit Func_void_std__vector_CategorySample__Wrapper(std::function<void(const std::vector<CategorySample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<CategorySample>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_CategorySample__Wrapper(std::function<void(const std::vector<CategorySample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<CategorySample>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<CategorySample> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<CategorySample>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<CategorySample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_CategorySample__Wrapper wrap_Func_void_std__vector_CategorySample_(Func_void_std__vector_CategorySample_ value) {
     return Func_void_std__vector_CategorySample__Wrapper(std::move(value));
@@ -649,13 +649,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_CategorySamplesWithAnchorResponse_Wrapper final {
   public:
-    explicit Func_void_CategorySamplesWithAnchorResponse_Wrapper(std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    explicit Func_void_CategorySamplesWithAnchorResponse_Wrapper(std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
     inline void call(CategorySamplesWithAnchorResponse result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
   inline Func_void_CategorySamplesWithAnchorResponse_Wrapper wrap_Func_void_CategorySamplesWithAnchorResponse(Func_void_CategorySamplesWithAnchorResponse value) {
     return Func_void_CategorySamplesWithAnchorResponse_Wrapper(std::move(value));
@@ -722,13 +722,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_BloodType_Wrapper final {
   public:
-    explicit Func_void_BloodType_Wrapper(std::function<void(BloodType /* result */)>&& func): _function(std::make_shared<std::function<void(BloodType /* result */)>>(std::move(func))) {}
+    explicit Func_void_BloodType_Wrapper(std::function<void(BloodType /* result */)>&& func): _function(std::make_unique<std::function<void(BloodType /* result */)>>(std::move(func))) {}
     inline void call(int result) const {
       _function->operator()(static_cast<BloodType>(result));
     }
   private:
-    std::shared_ptr<std::function<void(BloodType /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(BloodType /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_BloodType create_Func_void_BloodType(void* _Nonnull swiftClosureWrapper);
   inline Func_void_BloodType_Wrapper wrap_Func_void_BloodType(Func_void_BloodType value) {
     return Func_void_BloodType_Wrapper(std::move(value));
@@ -756,13 +756,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper final {
   public:
-    explicit Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper(std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>&& func): _function(std::make_shared<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper(std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>&& func): _function(std::make_unique<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>>(std::move(func))) {}
     inline void call(std::optional<std::chrono::system_clock::time_point> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__optional_std__chrono__system_clock__time_point_ create_Func_void_std__optional_std__chrono__system_clock__time_point_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper wrap_Func_void_std__optional_std__chrono__system_clock__time_point_(Func_void_std__optional_std__chrono__system_clock__time_point_ value) {
     return Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper(std::move(value));
@@ -790,13 +790,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_BiologicalSex_Wrapper final {
   public:
-    explicit Func_void_BiologicalSex_Wrapper(std::function<void(BiologicalSex /* result */)>&& func): _function(std::make_shared<std::function<void(BiologicalSex /* result */)>>(std::move(func))) {}
+    explicit Func_void_BiologicalSex_Wrapper(std::function<void(BiologicalSex /* result */)>&& func): _function(std::make_unique<std::function<void(BiologicalSex /* result */)>>(std::move(func))) {}
     inline void call(int result) const {
       _function->operator()(static_cast<BiologicalSex>(result));
     }
   private:
-    std::shared_ptr<std::function<void(BiologicalSex /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(BiologicalSex /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull swiftClosureWrapper);
   inline Func_void_BiologicalSex_Wrapper wrap_Func_void_BiologicalSex(Func_void_BiologicalSex value) {
     return Func_void_BiologicalSex_Wrapper(std::move(value));
@@ -824,13 +824,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_FitzpatrickSkinType_Wrapper final {
   public:
-    explicit Func_void_FitzpatrickSkinType_Wrapper(std::function<void(FitzpatrickSkinType /* result */)>&& func): _function(std::make_shared<std::function<void(FitzpatrickSkinType /* result */)>>(std::move(func))) {}
+    explicit Func_void_FitzpatrickSkinType_Wrapper(std::function<void(FitzpatrickSkinType /* result */)>&& func): _function(std::make_unique<std::function<void(FitzpatrickSkinType /* result */)>>(std::move(func))) {}
     inline void call(int result) const {
       _function->operator()(static_cast<FitzpatrickSkinType>(result));
     }
   private:
-    std::shared_ptr<std::function<void(FitzpatrickSkinType /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(FitzpatrickSkinType /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull swiftClosureWrapper);
   inline Func_void_FitzpatrickSkinType_Wrapper wrap_Func_void_FitzpatrickSkinType(Func_void_FitzpatrickSkinType value) {
     return Func_void_FitzpatrickSkinType_Wrapper(std::move(value));
@@ -858,13 +858,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_WheelchairUse_Wrapper final {
   public:
-    explicit Func_void_WheelchairUse_Wrapper(std::function<void(WheelchairUse /* result */)>&& func): _function(std::make_shared<std::function<void(WheelchairUse /* result */)>>(std::move(func))) {}
+    explicit Func_void_WheelchairUse_Wrapper(std::function<void(WheelchairUse /* result */)>&& func): _function(std::make_unique<std::function<void(WheelchairUse /* result */)>>(std::move(func))) {}
     inline void call(int result) const {
       _function->operator()(static_cast<WheelchairUse>(result));
     }
   private:
-    std::shared_ptr<std::function<void(WheelchairUse /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(WheelchairUse /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull swiftClosureWrapper);
   inline Func_void_WheelchairUse_Wrapper wrap_Func_void_WheelchairUse(Func_void_WheelchairUse value) {
     return Func_void_WheelchairUse_Wrapper(std::move(value));
@@ -1005,13 +1005,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_IdentifierWithUnit__Wrapper final {
   public:
-    explicit Func_void_std__vector_IdentifierWithUnit__Wrapper(std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_IdentifierWithUnit__Wrapper(std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<IdentifierWithUnit> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_IdentifierWithUnit__Wrapper wrap_Func_void_std__vector_IdentifierWithUnit_(Func_void_std__vector_IdentifierWithUnit_ value) {
     return Func_void_std__vector_IdentifierWithUnit__Wrapper(std::move(value));
@@ -1061,13 +1061,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper final {
   public:
-    explicit Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ create_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__(Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ value) {
     return Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper(std::move(value));
@@ -1083,13 +1083,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_OnChangeCallbackArgs_Wrapper final {
   public:
-    explicit Func_void_OnChangeCallbackArgs_Wrapper(std::function<void(const OnChangeCallbackArgs& /* args */)>&& func): _function(std::make_shared<std::function<void(const OnChangeCallbackArgs& /* args */)>>(std::move(func))) {}
+    explicit Func_void_OnChangeCallbackArgs_Wrapper(std::function<void(const OnChangeCallbackArgs& /* args */)>&& func): _function(std::make_unique<std::function<void(const OnChangeCallbackArgs& /* args */)>>(std::move(func))) {}
     inline void call(OnChangeCallbackArgs args) const {
       _function->operator()(args);
     }
   private:
-    std::shared_ptr<std::function<void(const OnChangeCallbackArgs& /* args */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const OnChangeCallbackArgs& /* args */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper);
   inline Func_void_OnChangeCallbackArgs_Wrapper wrap_Func_void_OnChangeCallbackArgs(Func_void_OnChangeCallbackArgs value) {
     return Func_void_OnChangeCallbackArgs_Wrapper(std::move(value));
@@ -1117,13 +1117,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_double_Wrapper final {
   public:
-    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_shared<std::function<void(double /* result */)>>(std::move(func))) {}
+    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_unique<std::function<void(double /* result */)>>(std::move(func))) {}
     inline void call(double result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(double /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(double /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper);
   inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) {
     return Func_void_double_Wrapper(std::move(value));
@@ -1151,13 +1151,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_AuthorizationRequestStatus_Wrapper final {
   public:
-    explicit Func_void_AuthorizationRequestStatus_Wrapper(std::function<void(AuthorizationRequestStatus /* result */)>&& func): _function(std::make_shared<std::function<void(AuthorizationRequestStatus /* result */)>>(std::move(func))) {}
+    explicit Func_void_AuthorizationRequestStatus_Wrapper(std::function<void(AuthorizationRequestStatus /* result */)>&& func): _function(std::make_unique<std::function<void(AuthorizationRequestStatus /* result */)>>(std::move(func))) {}
     inline void call(int result) const {
       _function->operator()(static_cast<AuthorizationRequestStatus>(result));
     }
   private:
-    std::shared_ptr<std::function<void(AuthorizationRequestStatus /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(AuthorizationRequestStatus /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull swiftClosureWrapper);
   inline Func_void_AuthorizationRequestStatus_Wrapper wrap_Func_void_AuthorizationRequestStatus(Func_void_AuthorizationRequestStatus value) {
     return Func_void_AuthorizationRequestStatus_Wrapper(std::move(value));
@@ -1229,13 +1229,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__unordered_map_std__string__bool__Wrapper final {
   public:
-    explicit Func_void_std__unordered_map_std__string__bool__Wrapper(std::function<void(const std::unordered_map<std::string, bool>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__unordered_map_std__string__bool__Wrapper(std::function<void(const std::unordered_map<std::string, bool>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>>(std::move(func))) {}
     inline void call(std::unordered_map<std::string, bool> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__unordered_map_std__string__bool_ create_Func_void_std__unordered_map_std__string__bool_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__unordered_map_std__string__bool__Wrapper wrap_Func_void_std__unordered_map_std__string__bool_(Func_void_std__unordered_map_std__string__bool_ value) {
     return Func_void_std__unordered_map_std__string__bool__Wrapper(std::move(value));
@@ -1456,13 +1456,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_CorrelationSample__Wrapper final {
   public:
-    explicit Func_void_std__vector_CorrelationSample__Wrapper(std::function<void(const std::vector<CorrelationSample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<CorrelationSample>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_CorrelationSample__Wrapper(std::function<void(const std::vector<CorrelationSample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<CorrelationSample>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<CorrelationSample> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<CorrelationSample>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<CorrelationSample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_CorrelationSample__Wrapper wrap_Func_void_std__vector_CorrelationSample_(Func_void_std__vector_CorrelationSample_ value) {
     return Func_void_std__vector_CorrelationSample__Wrapper(std::move(value));
@@ -1533,13 +1533,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_HeartbeatSeriesSample__Wrapper final {
   public:
-    explicit Func_void_std__vector_HeartbeatSeriesSample__Wrapper(std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_HeartbeatSeriesSample__Wrapper(std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<HeartbeatSeriesSample> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_HeartbeatSeriesSample__Wrapper wrap_Func_void_std__vector_HeartbeatSeriesSample_(Func_void_std__vector_HeartbeatSeriesSample_ value) {
     return Func_void_std__vector_HeartbeatSeriesSample__Wrapper(std::move(value));
@@ -1567,13 +1567,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper final {
   public:
-    explicit Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper(std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    explicit Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper(std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
     inline void call(HeartbeatSeriesSamplesWithAnchorResponse result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
   inline Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper wrap_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(Func_void_HeartbeatSeriesSamplesWithAnchorResponse value) {
     return Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper(std::move(value));
@@ -1642,13 +1642,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_QuantitySample__Wrapper final {
   public:
-    explicit Func_void_std__vector_QuantitySample__Wrapper(std::function<void(const std::vector<QuantitySample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<QuantitySample>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_QuantitySample__Wrapper(std::function<void(const std::vector<QuantitySample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<QuantitySample>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<QuantitySample> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<QuantitySample>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<QuantitySample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_QuantitySample__Wrapper wrap_Func_void_std__vector_QuantitySample_(Func_void_std__vector_QuantitySample_ value) {
     return Func_void_std__vector_QuantitySample__Wrapper(std::move(value));
@@ -1703,13 +1703,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_QueryStatisticsResponse_Wrapper final {
   public:
-    explicit Func_void_QueryStatisticsResponse_Wrapper(std::function<void(const QueryStatisticsResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const QueryStatisticsResponse& /* result */)>>(std::move(func))) {}
+    explicit Func_void_QueryStatisticsResponse_Wrapper(std::function<void(const QueryStatisticsResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const QueryStatisticsResponse& /* result */)>>(std::move(func))) {}
     inline void call(QueryStatisticsResponse result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const QueryStatisticsResponse& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const QueryStatisticsResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* _Nonnull swiftClosureWrapper);
   inline Func_void_QueryStatisticsResponse_Wrapper wrap_Func_void_QueryStatisticsResponse(Func_void_QueryStatisticsResponse value) {
     return Func_void_QueryStatisticsResponse_Wrapper(std::move(value));
@@ -1768,13 +1768,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_QueryStatisticsResponse__Wrapper final {
   public:
-    explicit Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<QueryStatisticsResponse> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_QueryStatisticsResponse__Wrapper wrap_Func_void_std__vector_QueryStatisticsResponse_(Func_void_std__vector_QueryStatisticsResponse_ value) {
     return Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::move(value));
@@ -1802,13 +1802,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_QuantitySamplesWithAnchorResponse_Wrapper final {
   public:
-    explicit Func_void_QuantitySamplesWithAnchorResponse_Wrapper(std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    explicit Func_void_QuantitySamplesWithAnchorResponse_Wrapper(std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
     inline void call(QuantitySamplesWithAnchorResponse result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
   inline Func_void_QuantitySamplesWithAnchorResponse_Wrapper wrap_Func_void_QuantitySamplesWithAnchorResponse(Func_void_QuantitySamplesWithAnchorResponse value) {
     return Func_void_QuantitySamplesWithAnchorResponse_Wrapper(std::move(value));
@@ -1926,13 +1926,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_StateOfMindSample__Wrapper final {
   public:
-    explicit Func_void_std__vector_StateOfMindSample__Wrapper(std::function<void(const std::vector<StateOfMindSample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<StateOfMindSample>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_StateOfMindSample__Wrapper(std::function<void(const std::vector<StateOfMindSample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<StateOfMindSample>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<StateOfMindSample> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<StateOfMindSample>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<StateOfMindSample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_StateOfMindSample__Wrapper wrap_Func_void_std__vector_StateOfMindSample_(Func_void_std__vector_StateOfMindSample_ value) {
     return Func_void_std__vector_StateOfMindSample__Wrapper(std::move(value));
@@ -2041,13 +2041,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__optional_WorkoutPlan__Wrapper final {
   public:
-    explicit Func_void_std__optional_WorkoutPlan__Wrapper(std::function<void(const std::optional<WorkoutPlan>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::optional<WorkoutPlan>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__optional_WorkoutPlan__Wrapper(std::function<void(const std::optional<WorkoutPlan>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<WorkoutPlan>& /* result */)>>(std::move(func))) {}
     inline void call(std::optional<WorkoutPlan> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::optional<WorkoutPlan>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::optional<WorkoutPlan>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__optional_WorkoutPlan__Wrapper wrap_Func_void_std__optional_WorkoutPlan_(Func_void_std__optional_WorkoutPlan_ value) {
     return Func_void_std__optional_WorkoutPlan__Wrapper(std::move(value));
@@ -2097,13 +2097,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_WorkoutRoute__Wrapper final {
   public:
-    explicit Func_void_std__vector_WorkoutRoute__Wrapper(std::function<void(const std::vector<WorkoutRoute>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<WorkoutRoute>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_WorkoutRoute__Wrapper(std::function<void(const std::vector<WorkoutRoute>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<WorkoutRoute>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<WorkoutRoute> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<WorkoutRoute>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<WorkoutRoute>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_WorkoutRoute__Wrapper wrap_Func_void_std__vector_WorkoutRoute_(Func_void_std__vector_WorkoutRoute_ value) {
     return Func_void_std__vector_WorkoutRoute__Wrapper(std::move(value));
@@ -2158,13 +2158,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__string_Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
     inline void call(std::string result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::string& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
     return Func_void_std__string_Wrapper(std::move(value));
@@ -2214,13 +2214,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper final {
   public:
-    explicit Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    explicit Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
     inline void call(QueryWorkoutSamplesWithAnchorResponse result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
   inline Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper wrap_Func_void_QueryWorkoutSamplesWithAnchorResponse(Func_void_QueryWorkoutSamplesWithAnchorResponse value) {
     return Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::move(value));
@@ -2398,13 +2398,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
    */
   class Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper final {
   public:
-    explicit Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>>(std::move(func))) {}
+    explicit Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>> _function;
-  };
+    std::unique_ptr<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
   Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ create_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__(Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ value) {
     return Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::move(value));

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

@@ -273,7 +273,7 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 
 // Common C++ types used in Swift
 #include <NitroModules/ArrayBufferHolder.hpp>
-#include <NitroModules/AnyMapHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
 #include <NitroModules/RuntimeError.hpp>
 #include <NitroModules/DateToChronoDate.hpp>
 

package/nitrogen/generated/ios/swift/CategorySample.swift

@@ -18,7 +18,7 @@ public extension CategorySample {
   /**
    * Create a new instance of `CategorySample`.
    */
-  init(uuid: String, device: Device?, categoryType: CategoryTypeIdentifier, startDate: Date, endDate: Date, value: Double, metadata: AnyMapHolder, sourceRevision: SourceRevision?) {
+  init(uuid: String, device: Device?, categoryType: CategoryTypeIdentifier, startDate: Date, endDate: Date, value: Double, metadata: AnyMap, sourceRevision: SourceRevision?) {
     self.init(std.string(uuid), { () -> bridge.std__optional_Device_ in
       if let __unwrappedValue = device {
         return bridge.create_std__optional_Device_(__unwrappedValue)
@@ -112,10 +112,10 @@ public extension CategorySample {
     }
   }
   
-  var metadata: AnyMapHolder {
+  var metadata: AnyMap {
     @inline(__always)
     get {
-      return AnyMapHolder(withCppPart: self.__metadata)
+      return AnyMap(withCppPart: self.__metadata)
     }
     @inline(__always)
     set {

package/nitrogen/generated/ios/swift/CategorySampleForSaving.swift

@@ -18,7 +18,7 @@ public extension CategorySampleForSaving {
   /**
    * Create a new instance of `CategorySampleForSaving`.
    */
-  init(start: Date, end: Date, categoryType: CategoryTypeIdentifier, value: Double, metadata: AnyMapHolder, sourceRevision: SourceRevision?) {
+  init(start: Date, end: Date, categoryType: CategoryTypeIdentifier, value: Double, metadata: AnyMap, sourceRevision: SourceRevision?) {
     self.init(start.toCpp(), end.toCpp(), categoryType, value, metadata.cppPart, { () -> bridge.std__optional_SourceRevision_ in
       if let __unwrappedValue = sourceRevision {
         return bridge.create_std__optional_SourceRevision_(__unwrappedValue)
@@ -72,10 +72,10 @@ public extension CategorySampleForSaving {
     }
   }
   
-  var metadata: AnyMapHolder {
+  var metadata: AnyMap {
     @inline(__always)
     get {
-      return AnyMapHolder(withCppPart: self.__metadata)
+      return AnyMap(withCppPart: self.__metadata)
     }
     @inline(__always)
     set {

package/nitrogen/generated/ios/swift/CorrelationSample.swift

@@ -18,7 +18,7 @@ public extension CorrelationSample {
   /**
    * Create a new instance of `CorrelationSample`.
    */
-  init(correlationType: CorrelationTypeIdentifier, objects: [CorrelationObject], metadata: AnyMapHolder, startDate: Date, endDate: Date) {
+  init(correlationType: CorrelationTypeIdentifier, objects: [CorrelationObject], metadata: AnyMap, startDate: Date, endDate: Date) {
     self.init(correlationType, { () -> bridge.std__vector_std__variant_CategorySample__QuantitySample__ in
       var __vector = bridge.create_std__vector_std__variant_CategorySample__QuantitySample__(objects.count)
       for __item in objects {
@@ -82,10 +82,10 @@ public extension CorrelationSample {
     }
   }
   
-  var metadata: AnyMapHolder {
+  var metadata: AnyMap {
     @inline(__always)
     get {
-      return AnyMapHolder(withCppPart: self.__metadata)
+      return AnyMap(withCppPart: self.__metadata)
     }
     @inline(__always)
     set {

package/nitrogen/generated/ios/swift/DeletedSample.swift

@@ -18,7 +18,7 @@ public extension DeletedSample {
   /**
    * Create a new instance of `DeletedSample`.
    */
-  init(uuid: String, metadata: AnyMapHolder?) {
+  init(uuid: String, metadata: AnyMap?) {
     self.init(std.string(uuid), { () -> bridge.std__optional_std__shared_ptr_AnyMap__ in
       if let __unwrappedValue = metadata {
         return bridge.create_std__optional_std__shared_ptr_AnyMap__(__unwrappedValue.cppPart)
@@ -39,12 +39,12 @@ public extension DeletedSample {
     }
   }
   
-  var metadata: AnyMapHolder? {
+  var metadata: AnyMap? {
     @inline(__always)
     get {
-      return { () -> AnyMapHolder? in
+      return { () -> AnyMap? in
         if let __unwrapped = self.__metadata.value {
-          return AnyMapHolder(withCppPart: __unwrapped)
+          return AnyMap(withCppPart: __unwrapped)
         } else {
           return nil
         }

package/nitrogen/generated/ios/swift/HeartbeatSeriesSample.swift

@@ -18,7 +18,7 @@ public extension HeartbeatSeriesSample {
   /**
    * Create a new instance of `HeartbeatSeriesSample`.
    */
-  init(uuid: String, device: Device?, startDate: Date, endDate: Date, heartbeats: [Heartbeat], metadata: AnyMapHolder?, sourceRevision: SourceRevision?) {
+  init(uuid: String, device: Device?, startDate: Date, endDate: Date, heartbeats: [Heartbeat], metadata: AnyMap?, sourceRevision: SourceRevision?) {
     self.init(std.string(uuid), { () -> bridge.std__optional_Device_ in
       if let __unwrappedValue = device {
         return bridge.create_std__optional_Device_(__unwrappedValue)
@@ -119,12 +119,12 @@ public extension HeartbeatSeriesSample {
     }
   }
   
-  var metadata: AnyMapHolder? {
+  var metadata: AnyMap? {
     @inline(__always)
     get {
-      return { () -> AnyMapHolder? in
+      return { () -> AnyMap? in
         if let __unwrapped = self.__metadata.value {
-          return AnyMapHolder(withCppPart: __unwrapped)
+          return AnyMap(withCppPart: __unwrapped)
         } else {
           return nil
         }

package/nitrogen/generated/ios/swift/HybridCategoryTypeModuleSpec.swift

@@ -14,7 +14,7 @@ public protocol HybridCategoryTypeModuleSpec_protocol: HybridObject {
   
 
   // Methods
-  func saveCategorySample(identifier: CategoryTypeIdentifier, value: Double, startDate: Date, endDate: Date, metadata: AnyMapHolder) throws -> Promise<Bool>
+  func saveCategorySample(identifier: CategoryTypeIdentifier, value: Double, startDate: Date, endDate: Date, metadata: AnyMap) throws -> Promise<Bool>
   func queryCategorySamples(identifier: CategoryTypeIdentifier, options: QueryOptionsWithSortOrder?) throws -> Promise<[CategorySample]>
   func queryCategorySamplesWithAnchor(identifier: CategoryTypeIdentifier, options: QueryOptionsWithAnchor) throws -> Promise<CategorySamplesWithAnchorResponse>
 }

package/nitrogen/generated/ios/swift/HybridCategoryTypeModuleSpec_cxx.swift

@@ -101,9 +101,9 @@ public class HybridCategoryTypeModuleSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func saveCategorySample(identifier: Int32, value: Double, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, metadata: margelo.nitro.TSharedMap) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+  public final func saveCategorySample(identifier: Int32, value: Double, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
-      let __result = try self.__implementation.saveCategorySample(identifier: margelo.nitro.healthkit.CategoryTypeIdentifier(rawValue: identifier)!, value: value, startDate: Date(fromChrono: startDate), endDate: Date(fromChrono: endDate), metadata: AnyMapHolder(withCppPart: metadata))
+      let __result = try self.__implementation.saveCategorySample(identifier: margelo.nitro.healthkit.CategoryTypeIdentifier(rawValue: identifier)!, value: value, startDate: Date(fromChrono: startDate), endDate: Date(fromChrono: endDate), metadata: AnyMap(withCppPart: metadata))
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
         let __promise = bridge.create_std__shared_ptr_Promise_bool__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)

package/nitrogen/generated/ios/swift/HybridCorrelationTypeModuleSpec.swift

@@ -14,7 +14,7 @@ public protocol HybridCorrelationTypeModuleSpec_protocol: HybridObject {
   
 
   // Methods
-  func saveCorrelationSample(typeIdentifier: CorrelationTypeIdentifier, samples: [SampleForSaving], start: Date, end: Date, metadata: AnyMapHolder) throws -> Promise<Bool>
+  func saveCorrelationSample(typeIdentifier: CorrelationTypeIdentifier, samples: [SampleForSaving], start: Date, end: Date, metadata: AnyMap) throws -> Promise<Bool>
   func queryCorrelationSamples(typeIdentifier: CorrelationTypeIdentifier, from: Date, to: Date) throws -> Promise<[CorrelationSample]>
 }
 

package/nitrogen/generated/ios/swift/HybridCorrelationTypeModuleSpec_cxx.swift

@@ -101,7 +101,7 @@ public class HybridCorrelationTypeModuleSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func saveCorrelationSample(typeIdentifier: Int32, samples: bridge.std__vector_std__variant_CategorySampleForSaving__QuantitySampleForSaving__, start: margelo.nitro.chrono_time, end: margelo.nitro.chrono_time, metadata: margelo.nitro.TSharedMap) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+  public final func saveCorrelationSample(typeIdentifier: Int32, samples: bridge.std__vector_std__variant_CategorySampleForSaving__QuantitySampleForSaving__, start: margelo.nitro.chrono_time, end: margelo.nitro.chrono_time, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
       let __result = try self.__implementation.saveCorrelationSample(typeIdentifier: margelo.nitro.healthkit.CorrelationTypeIdentifier(rawValue: typeIdentifier)!, samples: samples.map({ __item in { () -> SampleForSaving in
         let __variant = bridge.std__variant_CategorySampleForSaving__QuantitySampleForSaving_(__item)
@@ -115,7 +115,7 @@ public class HybridCorrelationTypeModuleSpec_cxx {
           default:
             fatalError("Variant can never have index \(__variant.index())!")
         }
-      }() }), start: Date(fromChrono: start), end: Date(fromChrono: end), metadata: AnyMapHolder(withCppPart: metadata))
+      }() }), start: Date(fromChrono: start), end: Date(fromChrono: end), metadata: AnyMap(withCppPart: metadata))
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
         let __promise = bridge.create_std__shared_ptr_Promise_bool__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)

package/nitrogen/generated/ios/swift/HybridQuantityTypeModuleSpec.swift

@@ -15,7 +15,7 @@ public protocol HybridQuantityTypeModuleSpec_protocol: HybridObject {
 
   // Methods
   func isQuantityCompatibleWithUnit(identifier: QuantityTypeIdentifier, unit: String) throws -> Bool
-  func saveQuantitySample(identifier: QuantityTypeIdentifier, unit: String, value: Double, start: Date, end: Date, metadata: AnyMapHolder) throws -> Promise<Bool>
+  func saveQuantitySample(identifier: QuantityTypeIdentifier, unit: String, value: Double, start: Date, end: Date, metadata: AnyMap) throws -> Promise<Bool>
   func deleteQuantitySamples(identifier: QuantityTypeIdentifier, filter: FilterForSamples) throws -> Promise<Bool>
   func queryQuantitySamples(identifier: QuantityTypeIdentifier, options: QueryOptionsWithSortOrderAndUnit?) throws -> Promise<[QuantitySample]>
   func queryStatisticsForQuantity(identifier: QuantityTypeIdentifier, statistics: [StatisticsOptions], options: StatisticsQueryOptions?) throws -> Promise<QueryStatisticsResponse>

package/nitrogen/generated/ios/swift/HybridQuantityTypeModuleSpec_cxx.swift

@@ -113,9 +113,9 @@ public class HybridQuantityTypeModuleSpec_cxx {
   }
   
   @inline(__always)
-  public final func saveQuantitySample(identifier: Int32, unit: std.string, value: Double, start: margelo.nitro.chrono_time, end: margelo.nitro.chrono_time, metadata: margelo.nitro.TSharedMap) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+  public final func saveQuantitySample(identifier: Int32, unit: std.string, value: Double, start: margelo.nitro.chrono_time, end: margelo.nitro.chrono_time, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
-      let __result = try self.__implementation.saveQuantitySample(identifier: margelo.nitro.healthkit.QuantityTypeIdentifier(rawValue: identifier)!, unit: String(unit), value: value, start: Date(fromChrono: start), end: Date(fromChrono: end), metadata: AnyMapHolder(withCppPart: metadata))
+      let __result = try self.__implementation.saveQuantitySample(identifier: margelo.nitro.healthkit.QuantityTypeIdentifier(rawValue: identifier)!, unit: String(unit), value: value, start: Date(fromChrono: start), end: Date(fromChrono: end), metadata: AnyMap(withCppPart: metadata))
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
         let __promise = bridge.create_std__shared_ptr_Promise_bool__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)

package/nitrogen/generated/ios/swift/HybridStateOfMindModuleSpec.swift

@@ -15,7 +15,7 @@ public protocol HybridStateOfMindModuleSpec_protocol: HybridObject {
 
   // Methods
   func queryStateOfMindSamples(options: QueryOptionsWithSortOrder?) throws -> Promise<[StateOfMindSample]>
-  func saveStateOfMindSample(date: Date, kind: StateOfMindKind, valence: Double, labels: [StateOfMindLabel], associations: [StateOfMindAssociation], metadata: AnyMapHolder?) throws -> Promise<Bool>
+  func saveStateOfMindSample(date: Date, kind: StateOfMindKind, valence: Double, labels: [StateOfMindLabel], associations: [StateOfMindAssociation], metadata: AnyMap?) throws -> Promise<Bool>
 }
 
 /// See ``HybridStateOfMindModuleSpec``

package/nitrogen/generated/ios/swift/HybridStateOfMindModuleSpec_cxx.swift

@@ -134,9 +134,9 @@ public class HybridStateOfMindModuleSpec_cxx {
   @inline(__always)
   public final func saveStateOfMindSample(date: margelo.nitro.chrono_time, kind: Int32, valence: Double, labels: bridge.std__vector_StateOfMindLabel_, associations: bridge.std__vector_StateOfMindAssociation_, metadata: bridge.std__optional_std__shared_ptr_AnyMap__) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
-      let __result = try self.__implementation.saveStateOfMindSample(date: Date(fromChrono: date), kind: margelo.nitro.healthkit.StateOfMindKind(rawValue: kind)!, valence: valence, labels: labels.map({ __item in __item }), associations: associations.map({ __item in __item }), metadata: { () -> AnyMapHolder? in
+      let __result = try self.__implementation.saveStateOfMindSample(date: Date(fromChrono: date), kind: margelo.nitro.healthkit.StateOfMindKind(rawValue: kind)!, valence: valence, labels: labels.map({ __item in __item }), associations: associations.map({ __item in __item }), metadata: { () -> AnyMap? in
         if let __unwrapped = metadata.value {
-          return AnyMapHolder(withCppPart: __unwrapped)
+          return AnyMap(withCppPart: __unwrapped)
         } else {
           return nil
         }

package/nitrogen/generated/ios/swift/HybridWorkoutProxySpec.swift

@@ -21,7 +21,7 @@ public protocol HybridWorkoutProxySpec_protocol: HybridObject {
   var totalFlightsClimbed: Quantity? { get }
   var startDate: Date { get }
   var endDate: Date { get }
-  var metadata: AnyMapHolder? { get }
+  var metadata: AnyMap? { get }
   var sourceRevision: SourceRevision? { get }
   var events: [WorkoutEvent]? { get }
   var activities: [WorkoutActivity]? { get }

package/nitrogen/generated/ios/swift/HybridWorkoutsModuleSpec.swift

@@ -14,7 +14,7 @@ public protocol HybridWorkoutsModuleSpec_protocol: HybridObject {
   
 
   // Methods
-  func saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: [QuantitySampleForSaving], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMapHolder) throws -> Promise<String>
+  func saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: [QuantitySampleForSaving], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMap) throws -> Promise<String>
   func queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor) throws -> Promise<QueryWorkoutSamplesWithAnchorResponse>
   func queryWorkoutSamples(options: WorkoutQueryOptions) throws -> Promise<[(any HybridWorkoutProxySpec)]>
   func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) throws -> Promise<Bool>

package/nitrogen/generated/ios/swift/HybridWorkoutsModuleSpec_cxx.swift

@@ -101,9 +101,9 @@ public class HybridWorkoutsModuleSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func saveWorkoutSample(workoutActivityType: Int32, quantities: bridge.std__vector_QuantitySampleForSaving_, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, totals: WorkoutTotals, metadata: margelo.nitro.TSharedMap) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+  public final func saveWorkoutSample(workoutActivityType: Int32, quantities: bridge.std__vector_QuantitySampleForSaving_, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, totals: WorkoutTotals, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
     do {
-      let __result = try self.__implementation.saveWorkoutSample(workoutActivityType: margelo.nitro.healthkit.WorkoutActivityType(rawValue: workoutActivityType)!, quantities: quantities.map({ __item in __item }), startDate: Date(fromChrono: startDate), endDate: Date(fromChrono: endDate), totals: totals, metadata: AnyMapHolder(withCppPart: metadata))
+      let __result = try self.__implementation.saveWorkoutSample(workoutActivityType: margelo.nitro.healthkit.WorkoutActivityType(rawValue: workoutActivityType)!, quantities: quantities.map({ __item in __item }), startDate: Date(fromChrono: startDate), endDate: Date(fromChrono: endDate), totals: totals, metadata: AnyMap(withCppPart: metadata))
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
         let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)

package/nitrogen/generated/ios/swift/QuantitySample.swift

@@ -18,7 +18,7 @@ public extension QuantitySample {
   /**
    * Create a new instance of `QuantitySample`.
    */
-  init(uuid: String, device: Device?, quantityType: QuantityTypeIdentifier, startDate: Date, endDate: Date, quantity: Double, unit: String, metadata: AnyMapHolder, sourceRevision: SourceRevision?) {
+  init(uuid: String, device: Device?, quantityType: QuantityTypeIdentifier, startDate: Date, endDate: Date, quantity: Double, unit: String, metadata: AnyMap, sourceRevision: SourceRevision?) {
     self.init(std.string(uuid), { () -> bridge.std__optional_Device_ in
       if let __unwrappedValue = device {
         return bridge.create_std__optional_Device_(__unwrappedValue)
@@ -123,10 +123,10 @@ public extension QuantitySample {
     }
   }
   
-  var metadata: AnyMapHolder {
+  var metadata: AnyMap {
     @inline(__always)
     get {
-      return AnyMapHolder(withCppPart: self.__metadata)
+      return AnyMap(withCppPart: self.__metadata)
     }
     @inline(__always)
     set {

package/nitrogen/generated/ios/swift/QuantitySampleForSaving.swift

@@ -18,7 +18,7 @@ public extension QuantitySampleForSaving {
   /**
    * Create a new instance of `QuantitySampleForSaving`.
    */
-  init(startDate: Date, endDate: Date, quantityType: QuantityTypeIdentifier, quantity: Double, unit: String, metadata: AnyMapHolder, sourceRevision: SourceRevision?) {
+  init(startDate: Date, endDate: Date, quantityType: QuantityTypeIdentifier, quantity: Double, unit: String, metadata: AnyMap, sourceRevision: SourceRevision?) {
     self.init(startDate.toCpp(), endDate.toCpp(), quantityType, quantity, std.string(unit), metadata.cppPart, { () -> bridge.std__optional_SourceRevision_ in
       if let __unwrappedValue = sourceRevision {
         return bridge.create_std__optional_SourceRevision_(__unwrappedValue)
@@ -83,10 +83,10 @@ public extension QuantitySampleForSaving {
     }
   }
   
-  var metadata: AnyMapHolder {
+  var metadata: AnyMap {
     @inline(__always)
     get {
-      return AnyMapHolder(withCppPart: self.__metadata)
+      return AnyMap(withCppPart: self.__metadata)
     }
     @inline(__always)
     set {

package/nitrogen/generated/ios/swift/StateOfMindSample.swift

@@ -18,7 +18,7 @@ public extension StateOfMindSample {
   /**
    * Create a new instance of `StateOfMindSample`.
    */
-  init(uuid: String, device: Device?, startDate: Date, endDate: Date, metadata: AnyMapHolder?, sourceRevision: SourceRevision?, valence: Double, kind: StateOfMindKind, valenceClassification: StateOfMindValenceClassification, associations: [StateOfMindAssociation], labels: [StateOfMindLabel]) {
+  init(uuid: String, device: Device?, startDate: Date, endDate: Date, metadata: AnyMap?, sourceRevision: SourceRevision?, valence: Double, kind: StateOfMindKind, valenceClassification: StateOfMindValenceClassification, associations: [StateOfMindAssociation], labels: [StateOfMindLabel]) {
     self.init(std.string(uuid), { () -> bridge.std__optional_Device_ in
       if let __unwrappedValue = device {
         return bridge.create_std__optional_Device_(__unwrappedValue)
@@ -108,12 +108,12 @@ public extension StateOfMindSample {
     }
   }
   
-  var metadata: AnyMapHolder? {
+  var metadata: AnyMap? {
     @inline(__always)
     get {
-      return { () -> AnyMapHolder? in
+      return { () -> AnyMap? in
         if let __unwrapped = self.__metadata.value {
-          return AnyMapHolder(withCppPart: __unwrapped)
+          return AnyMap(withCppPart: __unwrapped)
         } else {
           return nil
         }

package/nitrogen/generated/ios/swift/WorkoutSample.swift

@@ -18,7 +18,7 @@ public extension WorkoutSample {
   /**
    * Create a new instance of `WorkoutSample`.
    */
-  init(uuid: String, device: Device?, workoutActivityType: WorkoutActivityType, duration: Quantity, totalDistance: Quantity?, totalEnergyBurned: Quantity?, totalSwimmingStrokeCount: Quantity?, totalFlightsClimbed: Quantity?, startDate: Date, endDate: Date, metadata: AnyMapHolder?, sourceRevision: SourceRevision?, events: [WorkoutEvent]?, activities: [WorkoutActivity]?) {
+  init(uuid: String, device: Device?, workoutActivityType: WorkoutActivityType, duration: Quantity, totalDistance: Quantity?, totalEnergyBurned: Quantity?, totalSwimmingStrokeCount: Quantity?, totalFlightsClimbed: Quantity?, startDate: Date, endDate: Date, metadata: AnyMap?, sourceRevision: SourceRevision?, events: [WorkoutEvent]?, activities: [WorkoutActivity]?) {
     self.init(std.string(uuid), { () -> bridge.std__optional_Device_ in
       if let __unwrappedValue = device {
         return bridge.create_std__optional_Device_(__unwrappedValue)
@@ -258,12 +258,12 @@ public extension WorkoutSample {
     }
   }
   
-  var metadata: AnyMapHolder? {
+  var metadata: AnyMap? {
     @inline(__always)
     get {
-      return { () -> AnyMapHolder? in
+      return { () -> AnyMap? in
         if let __unwrapped = self.__metadata.value {
-          return AnyMapHolder(withCppPart: __unwrapped)
+          return AnyMap(withCppPart: __unwrapped)
         } else {
           return nil
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingstinct/react-native-healthkit",
-  "version": "9.0.9",
+  "version": "9.0.11",
   "description": "React Native bindings for HealthKit",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -90,10 +90,10 @@
   "devDependencies": {
     "@testing-library/react-native": "^13.2.0",
     "@types/react": "~19.0.14",
-    "nitro-codegen": "^0.26.2",
+    "nitro-codegen": "^0.26.4",
     "react": "19.0.0",
     "react-native": "*",
-    "react-native-nitro-modules": "^0.26.2",
+    "react-native-nitro-modules": "^0.26.4",
     "typescript": "~5.8.3"
   },
   "peerDependencies": {