@kingstinct/react-native-healthkit 11.1.0 → 11.1.2

package/ios/Constants.swift

@@ -24,6 +24,7 @@ let HKWorkoutTypeIdentifier = "HKWorkoutTypeIdentifier"
 let HKWorkoutRouteTypeIdentifier = "HKWorkoutRouteTypeIdentifier"
 let HKDataTypeIdentifierHeartbeatSeries = "HKDataTypeIdentifierHeartbeatSeries"
 let HKStateOfMindTypeIdentifier = "HKStateOfMindTypeIdentifier"
+let HKElectrocardiogramType = "HKElectrocardiogramType"
 
 let HKWorkoutActivityTypePropertyName = "activityType"
 let HKWorkoutSessionLocationTypePropertyName = "locationType"

package/ios/CoreModule.swift

@@ -9,7 +9,12 @@ import NitroModules
 
 var store = HKHealthStore.init()
 
-var quantityTypeUnitCache = [HKQuantityType: HKUnit]()
+// Thread-safe cache with concurrent read/exclusive write access
+private let quantityTypeCacheQueue = DispatchQueue(
+    label: "com.kingstinct.healthkit.cache",
+    attributes: .concurrent
+)
+private var quantityTypeUnitCache = [HKQuantityType: HKUnit]()
 
 func getUnitToUse(unitOverride: String?, quantityType: HKQuantityType) async throws -> HKUnit {
     if let unitOverride = unitOverride {
@@ -32,8 +37,11 @@ func getUnitToUse(unitOverride: String?, quantityType: HKQuantityType) async thr
 func getPreferredUnitsInternal(quantityTypes: [HKQuantityType], forceUpdate: Bool? = false) async throws -> [HKQuantityType: HKUnit] {
 
     if forceUpdate != true {
-        let itemsInCache = quantityTypeUnitCache.filter { (quantityType: HKQuantityType, _: HKUnit) in
-            return quantityTypes.contains(where: { $0 == quantityType })
+        // Thread-safe read: concurrent reads are allowed
+        let itemsInCache = quantityTypeCacheQueue.sync {
+            return quantityTypeUnitCache.filter {
+                quantityTypes.contains($0.key)
+            }
         }
         if itemsInCache.count == quantityTypes.count {
             return itemsInCache
@@ -47,8 +55,11 @@ func getPreferredUnitsInternal(quantityTypes: [HKQuantityType], forceUpdate: Boo
                 return continuation.resume(throwing: error)
             }
 
-            typePerUnits.forEach { (type: HKQuantityType, unit: HKUnit) in
-                quantityTypeUnitCache.updateValue(unit, forKey: type)
+            // Thread-safe write: barrier ensures exclusive access
+            quantityTypeCacheQueue.sync(flags: .barrier) {
+                typePerUnits.forEach { (type: HKQuantityType, unit: HKUnit) in
+                    quantityTypeUnitCache.updateValue(unit, forKey: type)
+                }
             }
 
             return continuation.resume(returning: typePerUnits)

package/ios/ElectrocardiogramModule.swift

@@ -146,7 +146,7 @@ class ElectrocardiogramModule: HybridElectrocardiogramModuleSpec {
             symptomsStatus: serializeSymptomsStatus(sample.symptomsStatus),
             averageHeartRateBpm: avgHR,
             samplingFrequencyHz: freqHz,
-            numberOfVoltageMeasurements: sample.numberOfVoltageMeasurements,
+            numberOfVoltageMeasurements: Double(sample.numberOfVoltageMeasurements),
             algorithmVersion: algorithmVersion,
             voltages: voltages,
             metadata: serializeMetadata(sample.metadata),
@@ -178,6 +178,8 @@ class ElectrocardiogramModule: HybridElectrocardiogramModuleSpec {
 
                 case .done:
                     continuation.resume(returning: all)
+                @unknown default:
+                  continuation.resume(throwing: RuntimeError.error(withMessage: "HKElectrocardiogramQuery received unknown result type"))
                 }
             }
             store.execute(q)

package/ios/Helpers.swift

@@ -413,6 +413,12 @@ private func sampleTypeFromStringNullable(typeIdentifier: String) throws -> HKSa
         }
     }
 
+    if #available(iOS 14, *) {
+        if typeIdentifier == HKElectrocardiogramType {
+            return HKSampleType.electrocardiogramType()
+        }
+    }
+
     #if compiler(>=6)
         if #available(iOS 18, *) {
             if typeIdentifier == HKStateOfMindTypeIdentifier {

package/lib/commonjs/healthkit.js

@@ -26,9 +26,8 @@ const Characteristics_1 = require("./types/Characteristics");
 __exportStar(require("./types"), exports);
 const notAvailableError = `[@kingstinct/react-native-healthkit] Platform "${react_native_1.Platform.OS}" not supported. HealthKit is only available on iOS.`;
 let hasWarned = false;
-// @ts-ignore
 function UnavailableFnFromModule(_fn, defaultValue) {
-    // @ts-ignore
+    // @ts-expect-error
     return () => {
         if (react_native_1.Platform.OS !== 'ios' && !hasWarned) {
             console.warn(notAvailableError);

package/lib/commonjs/types/Constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeartbeatSeriesTypeIdentifier = exports.StateOfMindTypeIdentifier = exports.WorkoutRouteTypeIdentifier = exports.WorkoutTypeIdentifier = void 0;
+exports.ElectrocardiogramTypeIdentifier = exports.HeartbeatSeriesTypeIdentifier = exports.StateOfMindTypeIdentifier = exports.WorkoutRouteTypeIdentifier = exports.WorkoutTypeIdentifier = void 0;
 /**
  * Represents a workout type identifier.
  * @see {@link https://developer.apple.com/documentation/healthkit/hkworkouttypeidentifier Apple Docs HKWorkoutTypeIdentifier}
@@ -17,7 +17,12 @@ exports.WorkoutRouteTypeIdentifier = 'HKWorkoutRouteTypeIdentifier';
  */
 exports.StateOfMindTypeIdentifier = 'HKStateOfMindTypeIdentifier';
 /**
- * Represents a series sample containing heartbeat data..
+ * Represents a series sample containing heartbeat data.
  * @see {@link https://developer.apple.com/documentation/healthkit/HKDataTypeIdentifierHeartbeatSeries Apple Docs DataTypeIdentifierHeartbeatSeries}
  */
 exports.HeartbeatSeriesTypeIdentifier = 'HKDataTypeIdentifierHeartbeatSeries';
+/**
+ * A type that identifies samples containing electrocardiogram data.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkelectrocardiogramtype Apple Docs HKElectrocardiogramType}
+ */
+exports.ElectrocardiogramTypeIdentifier = 'HKElectrocardiogramType';

package/lib/module/healthkit.js

@@ -4,9 +4,8 @@ import { BiologicalSex, BloodType, FitzpatrickSkinType, WheelchairUse, } from '.
 export * from './types';
 const notAvailableError = `[@kingstinct/react-native-healthkit] Platform "${Platform.OS}" not supported. HealthKit is only available on iOS.`;
 let hasWarned = false;
-// @ts-ignore
 function UnavailableFnFromModule(_fn, defaultValue) {
-    // @ts-ignore
+    // @ts-expect-error
     return () => {
         if (Platform.OS !== 'ios' && !hasWarned) {
             console.warn(notAvailableError);

package/lib/module/types/Constants.js

@@ -14,7 +14,12 @@ export const WorkoutRouteTypeIdentifier = 'HKWorkoutRouteTypeIdentifier';
  */
 export const StateOfMindTypeIdentifier = 'HKStateOfMindTypeIdentifier';
 /**
- * Represents a series sample containing heartbeat data..
+ * Represents a series sample containing heartbeat data.
  * @see {@link https://developer.apple.com/documentation/healthkit/HKDataTypeIdentifierHeartbeatSeries Apple Docs DataTypeIdentifierHeartbeatSeries}
  */
 export const HeartbeatSeriesTypeIdentifier = 'HKDataTypeIdentifierHeartbeatSeries';
+/**
+ * A type that identifies samples containing electrocardiogram data.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkelectrocardiogramtype Apple Docs HKElectrocardiogramType}
+ */
+export const ElectrocardiogramTypeIdentifier = 'HKElectrocardiogramType';

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

@@ -14,7 +14,12 @@ export declare const WorkoutRouteTypeIdentifier: "HKWorkoutRouteTypeIdentifier";
  */
 export declare const StateOfMindTypeIdentifier: "HKStateOfMindTypeIdentifier";
 /**
- * Represents a series sample containing heartbeat data..
+ * Represents a series sample containing heartbeat data.
  * @see {@link https://developer.apple.com/documentation/healthkit/HKDataTypeIdentifierHeartbeatSeries Apple Docs DataTypeIdentifierHeartbeatSeries}
  */
 export declare const HeartbeatSeriesTypeIdentifier: "HKDataTypeIdentifierHeartbeatSeries";
+/**
+ * A type that identifies samples containing electrocardiogram data.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkelectrocardiogramtype Apple Docs HKElectrocardiogramType}
+ */
+export declare const ElectrocardiogramTypeIdentifier: "HKElectrocardiogramType";

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 { HeartbeatSeriesTypeIdentifier, StateOfMindTypeIdentifier, WorkoutRouteTypeIdentifier, WorkoutTypeIdentifier } from './Constants';
+import type { ElectrocardiogramTypeIdentifier, HeartbeatSeriesTypeIdentifier, StateOfMindTypeIdentifier, WorkoutRouteTypeIdentifier, WorkoutTypeIdentifier } from './Constants';
 import type { CorrelationTypeIdentifier } from './CorrelationType';
 import type { QuantityTypeIdentifier, QuantityTypeIdentifierWriteable } from './QuantityTypeIdentifier';
 export interface GenericMetadata {
@@ -25,7 +25,7 @@ export interface DeletedSample {
     readonly metadata?: AnyMap;
 }
 export type ObjectTypeIdentifier = CharacteristicTypeIdentifier | SampleTypeIdentifier | typeof ActivitySummaryTypeIdentifier;
-export type SampleTypeIdentifier = CategoryTypeIdentifier | CorrelationTypeIdentifier | QuantityTypeIdentifier | typeof StateOfMindTypeIdentifier | typeof AudiogramTypeIdentifier | typeof HeartbeatSeriesTypeIdentifier | typeof WorkoutRouteTypeIdentifier | typeof WorkoutTypeIdentifier;
+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;
 /**
  * Represents a type that identifies activity summary objects.

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

@@ -24,7 +24,7 @@
 namespace margelo::nitro::healthkit::bridge::swift {
 
   // pragma MARK: std::function<void(bool /* result */)>
-  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_bool::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
       swiftClosure.call(result);
@@ -32,7 +32,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
       swiftClosure.call(error);
@@ -40,11 +40,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridSourceProxySpec>
-  std::shared_ptr<HybridSourceProxySpec> create_std__shared_ptr_HybridSourceProxySpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridSourceProxySpec> create_std__shared_ptr_HybridSourceProxySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridSourceProxySpec_cxx swiftPart = ReactNativeHealthkit::HybridSourceProxySpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridSourceProxySpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridSourceProxySpec_(std__shared_ptr_HybridSourceProxySpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridSourceProxySpec_(std__shared_ptr_HybridSourceProxySpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridSourceProxySpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -56,7 +56,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<CategorySample>& /* result */)>
-  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_CategorySample_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<CategorySample>& result) mutable -> void {
       swiftClosure.call(result);
@@ -64,11 +64,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridWorkoutProxySpec>
-  std::shared_ptr<HybridWorkoutProxySpec> create_std__shared_ptr_HybridWorkoutProxySpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridWorkoutProxySpec> create_std__shared_ptr_HybridWorkoutProxySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridWorkoutProxySpec_cxx swiftPart = ReactNativeHealthkit::HybridWorkoutProxySpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridWorkoutProxySpec_(std__shared_ptr_HybridWorkoutProxySpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridWorkoutProxySpec_(std__shared_ptr_HybridWorkoutProxySpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -80,7 +80,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>
-  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_CategorySamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const CategorySamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -88,11 +88,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridCategoryTypeModuleSpec>
-  std::shared_ptr<HybridCategoryTypeModuleSpec> create_std__shared_ptr_HybridCategoryTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridCategoryTypeModuleSpec> create_std__shared_ptr_HybridCategoryTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridCategoryTypeModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridCategoryTypeModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridCategoryTypeModuleSpec_(std__shared_ptr_HybridCategoryTypeModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridCategoryTypeModuleSpec_(std__shared_ptr_HybridCategoryTypeModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -104,7 +104,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(BloodType /* result */)>
-  Func_void_BloodType create_Func_void_BloodType(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_BloodType create_Func_void_BloodType(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_BloodType::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](BloodType result) mutable -> void {
       swiftClosure.call(static_cast<int>(result));
@@ -112,7 +112,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>
-  Func_void_std__optional_std__chrono__system_clock__time_point_ create_Func_void_std__optional_std__chrono__system_clock__time_point_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__optional_std__chrono__system_clock__time_point_ create_Func_void_std__optional_std__chrono__system_clock__time_point_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__optional_std__chrono__system_clock__time_point_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](std::optional<std::chrono::system_clock::time_point> result) mutable -> void {
       swiftClosure.call(result);
@@ -120,7 +120,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(BiologicalSex /* result */)>
-  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_BiologicalSex::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](BiologicalSex result) mutable -> void {
       swiftClosure.call(static_cast<int>(result));
@@ -128,7 +128,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(FitzpatrickSkinType /* result */)>
-  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_FitzpatrickSkinType::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](FitzpatrickSkinType result) mutable -> void {
       swiftClosure.call(static_cast<int>(result));
@@ -136,7 +136,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(WheelchairUse /* result */)>
-  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_WheelchairUse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](WheelchairUse result) mutable -> void {
       swiftClosure.call(static_cast<int>(result));
@@ -144,11 +144,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridCharacteristicTypeModuleSpec>
-  std::shared_ptr<HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridCharacteristicTypeModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridCharacteristicTypeModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(std__shared_ptr_HybridCharacteristicTypeModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(std__shared_ptr_HybridCharacteristicTypeModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -160,7 +160,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>
-  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_IdentifierWithUnit_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<IdentifierWithUnit>& result) mutable -> void {
       swiftClosure.call(result);
@@ -168,7 +168,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridSourceProxySpec>>& /* result */)>
-  Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<HybridSourceProxySpec>>& result) mutable -> void {
       swiftClosure.call(result);
@@ -176,7 +176,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const OnChangeCallbackArgs& /* args */)>
-  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_OnChangeCallbackArgs::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const OnChangeCallbackArgs& args) mutable -> void {
       swiftClosure.call(args);
@@ -184,7 +184,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(double /* result */)>
-  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_double::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
       swiftClosure.call(result);
@@ -192,7 +192,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(AuthorizationRequestStatus /* result */)>
-  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_AuthorizationRequestStatus::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](AuthorizationRequestStatus result) mutable -> void {
       swiftClosure.call(static_cast<int>(result));
@@ -200,7 +200,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // 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* _Nonnull swiftClosureWrapper) noexcept {
+  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);
     return [swiftClosure = std::move(swiftClosure)](const std::unordered_map<std::string, bool>& result) mutable -> void {
       swiftClosure.call(result);
@@ -208,11 +208,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridCoreModuleSpec>
-  std::shared_ptr<HybridCoreModuleSpec> create_std__shared_ptr_HybridCoreModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridCoreModuleSpec> create_std__shared_ptr_HybridCoreModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridCoreModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridCoreModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridCoreModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridCoreModuleSpec_(std__shared_ptr_HybridCoreModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridCoreModuleSpec_(std__shared_ptr_HybridCoreModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCoreModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -224,7 +224,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<CorrelationSample>& /* result */)>
-  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_CorrelationSample_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<CorrelationSample>& result) mutable -> void {
       swiftClosure.call(result);
@@ -232,11 +232,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridCorrelationTypeModuleSpec>
-  std::shared_ptr<HybridCorrelationTypeModuleSpec> create_std__shared_ptr_HybridCorrelationTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridCorrelationTypeModuleSpec> create_std__shared_ptr_HybridCorrelationTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridCorrelationTypeModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridCorrelationTypeModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridCorrelationTypeModuleSpec_(std__shared_ptr_HybridCorrelationTypeModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridCorrelationTypeModuleSpec_(std__shared_ptr_HybridCorrelationTypeModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -248,7 +248,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<ElectrocardiogramSample>& /* result */)>
-  Func_void_std__vector_ElectrocardiogramSample_ create_Func_void_std__vector_ElectrocardiogramSample_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_ElectrocardiogramSample_ create_Func_void_std__vector_ElectrocardiogramSample_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_ElectrocardiogramSample_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<ElectrocardiogramSample>& result) mutable -> void {
       swiftClosure.call(result);
@@ -256,7 +256,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const ElectrocardiogramSamplesWithAnchorResponse& /* result */)>
-  Func_void_ElectrocardiogramSamplesWithAnchorResponse create_Func_void_ElectrocardiogramSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_ElectrocardiogramSamplesWithAnchorResponse create_Func_void_ElectrocardiogramSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_ElectrocardiogramSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const ElectrocardiogramSamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -264,11 +264,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridElectrocardiogramModuleSpec>
-  std::shared_ptr<HybridElectrocardiogramModuleSpec> create_std__shared_ptr_HybridElectrocardiogramModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridElectrocardiogramModuleSpec> create_std__shared_ptr_HybridElectrocardiogramModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridElectrocardiogramModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridElectrocardiogramModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridElectrocardiogramModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridElectrocardiogramModuleSpec_(std__shared_ptr_HybridElectrocardiogramModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridElectrocardiogramModuleSpec_(std__shared_ptr_HybridElectrocardiogramModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridElectrocardiogramModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridElectrocardiogramModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -280,7 +280,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>
-  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_HeartbeatSeriesSample_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<HeartbeatSeriesSample>& result) mutable -> void {
       swiftClosure.call(result);
@@ -288,7 +288,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>
-  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_HeartbeatSeriesSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const HeartbeatSeriesSamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -296,11 +296,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridHeartbeatSeriesModuleSpec>
-  std::shared_ptr<HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridHeartbeatSeriesModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridHeartbeatSeriesModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_HybridHeartbeatSeriesModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_HybridHeartbeatSeriesModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -312,7 +312,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<QuantitySample>& /* result */)>
-  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_QuantitySample_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<QuantitySample>& result) mutable -> void {
       swiftClosure.call(result);
@@ -320,7 +320,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const QueryStatisticsResponse& /* result */)>
-  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QueryStatisticsResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const QueryStatisticsResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -328,7 +328,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>
-  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_QueryStatisticsResponse_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<QueryStatisticsResponse>& result) mutable -> void {
       swiftClosure.call(result);
@@ -336,7 +336,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>
-  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QuantitySamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const QuantitySamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -344,11 +344,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridQuantityTypeModuleSpec>
-  std::shared_ptr<HybridQuantityTypeModuleSpec> create_std__shared_ptr_HybridQuantityTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridQuantityTypeModuleSpec> create_std__shared_ptr_HybridQuantityTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridQuantityTypeModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridQuantityTypeModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridQuantityTypeModuleSpec_(std__shared_ptr_HybridQuantityTypeModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridQuantityTypeModuleSpec_(std__shared_ptr_HybridQuantityTypeModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -360,7 +360,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<StateOfMindSample>& /* result */)>
-  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_StateOfMindSample_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<StateOfMindSample>& result) mutable -> void {
       swiftClosure.call(result);
@@ -368,11 +368,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridStateOfMindModuleSpec>
-  std::shared_ptr<HybridStateOfMindModuleSpec> create_std__shared_ptr_HybridStateOfMindModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridStateOfMindModuleSpec> create_std__shared_ptr_HybridStateOfMindModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridStateOfMindModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridStateOfMindModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridStateOfMindModuleSpec_(std__shared_ptr_HybridStateOfMindModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridStateOfMindModuleSpec_(std__shared_ptr_HybridStateOfMindModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -384,7 +384,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::optional<WorkoutPlan>& /* result */)>
-  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__optional_WorkoutPlan_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::optional<WorkoutPlan>& result) mutable -> void {
       swiftClosure.call(result);
@@ -392,7 +392,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<WorkoutRoute>& /* result */)>
-  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_WorkoutRoute_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<WorkoutRoute>& result) mutable -> void {
       swiftClosure.call(result);
@@ -400,7 +400,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::optional<QueryStatisticsResponse>& /* result */)>
-  Func_void_std__optional_QueryStatisticsResponse_ create_Func_void_std__optional_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__optional_QueryStatisticsResponse_ create_Func_void_std__optional_QueryStatisticsResponse_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__optional_QueryStatisticsResponse_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::optional<QueryStatisticsResponse>& result) mutable -> void {
       swiftClosure.call(result);
@@ -408,7 +408,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::unordered_map<std::string, QueryStatisticsResponse>& /* result */)>
-  Func_void_std__unordered_map_std__string__QueryStatisticsResponse_ create_Func_void_std__unordered_map_std__string__QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__unordered_map_std__string__QueryStatisticsResponse_ create_Func_void_std__unordered_map_std__string__QueryStatisticsResponse_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__unordered_map_std__string__QueryStatisticsResponse_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::unordered_map<std::string, QueryStatisticsResponse>& result) mutable -> void {
       swiftClosure.call(result);
@@ -416,7 +416,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::shared_ptr<HybridWorkoutProxySpec>& /* result */)>
-  Func_void_std__shared_ptr_HybridWorkoutProxySpec_ create_Func_void_std__shared_ptr_HybridWorkoutProxySpec_(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__shared_ptr_HybridWorkoutProxySpec_ create_Func_void_std__shared_ptr_HybridWorkoutProxySpec_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__shared_ptr_HybridWorkoutProxySpec_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridWorkoutProxySpec>& result) mutable -> void {
       swiftClosure.call(result);
@@ -424,7 +424,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>
-  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QueryWorkoutSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const QueryWorkoutSamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -432,7 +432,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridWorkoutProxySpec>>& /* result */)>
-  Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__(void* _Nonnull swiftClosureWrapper) noexcept {
+  Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<HybridWorkoutProxySpec>>& result) mutable -> void {
       swiftClosure.call(result);
@@ -440,11 +440,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridWorkoutsModuleSpec>
-  std::shared_ptr<HybridWorkoutsModuleSpec> create_std__shared_ptr_HybridWorkoutsModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept {
+  std::shared_ptr<HybridWorkoutsModuleSpec> create_std__shared_ptr_HybridWorkoutsModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeHealthkit::HybridWorkoutsModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridWorkoutsModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridWorkoutsModuleSpec_(std__shared_ptr_HybridWorkoutsModuleSpec_ cppType) noexcept {
+  void* NON_NULL get_std__shared_ptr_HybridWorkoutsModuleSpec_(std__shared_ptr_HybridWorkoutsModuleSpec_ cppType) {
     std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {