@kingstinct/react-native-healthkit 10.1.0 → 11.0.0

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

@@ -23,7 +23,7 @@
 namespace margelo::nitro::healthkit::bridge::swift {
 
   // pragma MARK: std::function<void(bool /* result */)>
-  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_bool::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
       swiftClosure.call(result);
@@ -31,79 +31,79 @@ 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) {
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridSourceProxySpec>
+  std::shared_ptr<HybridSourceProxySpec> create_std__shared_ptr_HybridSourceProxySpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridSourceProxySpec_(std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridSourceProxySpec_(std__shared_ptr_HybridSourceProxySpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridSourceProxySpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridSourceProxySpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridSourceProxySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::vector<CategorySample>& /* result */)>
-  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridWorkoutProxySpec>
+  std::shared_ptr<HybridWorkoutProxySpec> create_std__shared_ptr_HybridWorkoutProxySpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridWorkoutProxySpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridWorkoutProxySpec_(std__shared_ptr_HybridWorkoutProxySpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridWorkoutProxySpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridWorkoutProxySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>
-  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_CategorySamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const CategorySamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridCategoryTypeModuleSpec>
+  std::shared_ptr<HybridCategoryTypeModuleSpec> create_std__shared_ptr_HybridCategoryTypeModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridCategoryTypeModuleSpec_(std__shared_ptr_HybridCategoryTypeModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridCategoryTypeModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridCategoryTypeModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(BloodType /* result */)>
-  Func_void_BloodType create_Func_void_BloodType(void* _Nonnull swiftClosureWrapper) {
+  Func_void_BloodType create_Func_void_BloodType(void* _Nonnull 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));
@@ -111,7 +111,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) {
+  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 {
     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);
@@ -119,7 +119,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(BiologicalSex /* result */)>
-  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull swiftClosureWrapper) {
+  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull 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));
@@ -127,7 +127,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(FitzpatrickSkinType /* result */)>
-  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull swiftClosureWrapper) {
+  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull 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));
@@ -135,47 +135,47 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(WheelchairUse /* result */)>
-  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull swiftClosureWrapper) {
+  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull 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));
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridCharacteristicTypeModuleSpec>
+  std::shared_ptr<HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(std__shared_ptr_HybridCharacteristicTypeModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridCharacteristicTypeModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridCharacteristicTypeModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>
-  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>
-  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) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& result) mutable -> void {
+  // 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 {
+    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);
     };
   }
   
   // pragma MARK: std::function<void(const OnChangeCallbackArgs& /* args */)>
-  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper) {
+  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_OnChangeCallbackArgs::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const OnChangeCallbackArgs& args) mutable -> void {
       swiftClosure.call(args);
@@ -183,7 +183,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(double /* result */)>
-  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper) {
+  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_double::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
       swiftClosure.call(result);
@@ -191,7 +191,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(AuthorizationRequestStatus /* result */)>
-  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull swiftClosureWrapper) {
+  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull 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));
@@ -199,55 +199,55 @@ 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) {
+  Func_void_std__unordered_map_std__string__bool_ create_Func_void_std__unordered_map_std__string__bool_(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridCoreModuleSpec>
+  std::shared_ptr<HybridCoreModuleSpec> create_std__shared_ptr_HybridCoreModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridCoreModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridCoreModuleSpec_(std__shared_ptr_HybridCoreModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCoreModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridCoreModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridCoreModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::vector<CorrelationSample>& /* result */)>
-  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridCorrelationTypeModuleSpec>
+  std::shared_ptr<HybridCorrelationTypeModuleSpec> create_std__shared_ptr_HybridCorrelationTypeModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridCorrelationTypeModuleSpec_(std__shared_ptr_HybridCorrelationTypeModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridCorrelationTypeModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridCorrelationTypeModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>
-  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* _Nonnull 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);
@@ -255,31 +255,31 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>
-  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_HeartbeatSeriesSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const HeartbeatSeriesSamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridHeartbeatSeriesModuleSpec>
+  std::shared_ptr<HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_HybridHeartbeatSeriesModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridHeartbeatSeriesModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridHeartbeatSeriesModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::vector<QuantitySample>& /* result */)>
-  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* _Nonnull 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);
@@ -287,7 +287,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) {
+  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QueryStatisticsResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const QueryStatisticsResponse& result) mutable -> void {
       swiftClosure.call(result);
@@ -295,7 +295,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) {
+  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* _Nonnull 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);
@@ -303,55 +303,55 @@ namespace margelo::nitro::healthkit::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>
-  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QuantitySamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const QuantitySamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridQuantityTypeModuleSpec>
+  std::shared_ptr<HybridQuantityTypeModuleSpec> create_std__shared_ptr_HybridQuantityTypeModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridQuantityTypeModuleSpec_(std__shared_ptr_HybridQuantityTypeModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridQuantityTypeModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridQuantityTypeModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::vector<StateOfMindSample>& /* result */)>
-  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridStateOfMindModuleSpec>
+  std::shared_ptr<HybridStateOfMindModuleSpec> create_std__shared_ptr_HybridStateOfMindModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridStateOfMindModuleSpec_(std__shared_ptr_HybridStateOfMindModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridStateOfMindModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridStateOfMindModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
   
   // pragma MARK: std::function<void(const std::optional<WorkoutPlan>& /* result */)>
-  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* _Nonnull 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);
@@ -359,49 +359,65 @@ 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) {
+  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* _Nonnull 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);
     };
   }
   
-  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& /* result */)>
-  Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ create_Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& result) mutable -> void {
+  // 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 {
+    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);
+    };
+  }
+  
+  // 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 {
+    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);
+    };
+  }
+  
+  // 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 {
+    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);
     };
   }
   
   // pragma MARK: std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>
-  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QueryWorkoutSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const QueryWorkoutSamplesWithAnchorResponse& result) mutable -> void {
       swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>
-  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) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& result) mutable -> void {
+  // 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 {
+    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);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridWorkoutsModuleSpec>
+  std::shared_ptr<HybridWorkoutsModuleSpec> create_std__shared_ptr_HybridWorkoutsModuleSpec_(void* _Nonnull 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_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ cppType) {
+  void* _Nonnull get_std__shared_ptr_HybridWorkoutsModuleSpec_(std__shared_ptr_HybridWorkoutsModuleSpec_ cppType) noexcept {
     std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridWorkoutsModuleSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     ReactNativeHealthkit::HybridWorkoutsModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }