@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

package/nitrogen/generated/ios/ReactNativeHealthkit+autolinking.rb

@@ -0,0 +1,60 @@
+#
+# ReactNativeHealthkit+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2025 Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/ReactNativeHealthkit+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 ReactNativeHealthkit is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only C)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+  })
+end

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

@@ -0,0 +1,450 @@
+///
+/// ReactNativeHealthkit-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "ReactNativeHealthkit-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+#include "HybridCategoryTypeModuleSpecSwift.hpp"
+#include "HybridCharacteristicTypeModuleSpecSwift.hpp"
+#include "HybridCoreModuleSpecSwift.hpp"
+#include "HybridCorrelationTypeModuleSpecSwift.hpp"
+#include "HybridHeartbeatSeriesModuleSpecSwift.hpp"
+#include "HybridQuantityTypeModuleSpecSwift.hpp"
+#include "HybridSourceProxySpecSwift.hpp"
+#include "HybridStateOfMindModuleSpecSwift.hpp"
+#include "HybridWorkoutProxySpecSwift.hpp"
+#include "HybridWorkoutSessionModuleSpecSwift.hpp"
+#include "HybridWorkoutsModuleSpecSwift.hpp"
+#include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::healthkit::bridge::swift {
+
+  // pragma MARK: std::function<void(bool /* result */)>
+  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridSourceProxySpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridSourceProxySpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutProxySpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridWorkoutProxySpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCategoryTypeModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridCategoryTypeModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_BloodType::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](BloodType result) mutable -> void {
+      swiftClosure.call(static_cast<int>(result));
+    };
+  }
+  
+  // pragma MARK: std::function<void(std::chrono::system_clock::time_point /* result */)>
+  Func_void_std__chrono__system_clock__time_point create_Func_void_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_std__chrono__system_clock__time_point::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](std::chrono::system_clock::time_point result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(BiologicalSex /* result */)>
+  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_BiologicalSex::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](BiologicalSex result) mutable -> void {
+      swiftClosure.call(static_cast<int>(result));
+    };
+  }
+  
+  // pragma MARK: std::function<void(FitzpatrickSkinType /* result */)>
+  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_FitzpatrickSkinType::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](FitzpatrickSkinType result) mutable -> void {
+      swiftClosure.call(static_cast<int>(result));
+    };
+  }
+  
+  // pragma MARK: std::function<void(WheelchairUse /* result */)>
+  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull swiftClosureWrapper) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridCharacteristicTypeModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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 {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const OnChangeCallbackArgs& /* args */)>
+  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_OnChangeCallbackArgs::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const OnChangeCallbackArgs& args) mutable -> void {
+      swiftClosure.call(args);
+    };
+  }
+  
+  // pragma MARK: std::function<void(double /* result */)>
+  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(AuthorizationRequestStatus /* result */)>
+  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_AuthorizationRequestStatus::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](AuthorizationRequestStatus result) mutable -> void {
+      swiftClosure.call(static_cast<int>(result));
+    };
+  }
+  
+  // 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) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCoreModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridCoreModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridCorrelationTypeModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>
+  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridHeartbeatSeriesModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const QueryStatisticsResponse& /* result */)>
+  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_QueryStatisticsResponse::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const QueryStatisticsResponse& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>
+  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) {
+    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);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>
+  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridQuantityTypeModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridQuantityTypeModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridStateOfMindModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridStateOfMindModuleSpec\" is not implemented in Swift!");
+    }
+  #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) {
+    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);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<WorkoutRoute>& /* result */)>
+  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* _Nonnull swiftClosureWrapper) {
+    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::string& /* errorMessage */)>
+  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& errorMessage) mutable -> void {
+      swiftClosure.call(errorMessage);
+    };
+  }
+  
+  // pragma MARK: std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>
+  Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point create_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](WorkoutSessionState toState, WorkoutSessionState fromState, std::chrono::system_clock::time_point date) mutable -> void {
+      swiftClosure.call(static_cast<int>(toState), static_cast<int>(fromState), date);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>
+  Func_void_std__vector_RemoteSessionSharableData_ create_Func_void_std__vector_RemoteSessionSharableData_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_RemoteSessionSharableData_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<RemoteSessionSharableData>& data) mutable -> void {
+      swiftClosure.call(data);
+    };
+  }
+  
+  // pragma MARK: std::function<void(WorkoutEventType /* type */)>
+  Func_void_WorkoutEventType create_Func_void_WorkoutEventType(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = ReactNativeHealthkit::Func_void_WorkoutEventType::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](WorkoutEventType type) mutable -> void {
+      swiftClosure.call(static_cast<int>(type));
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
+  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(void* _Nonnull swiftUnsafePointer) {
+    ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift>(swiftPart);
+  }
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridWorkoutSessionModuleSpec\" is not implemented in Swift!");
+    }
+  #endif
+    ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
+  // pragma MARK: std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>
+  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
+    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 {
+      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) {
+    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) {
+    std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutsModuleSpecSwift>(cppType);
+  #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridWorkoutsModuleSpec\" is not implemented in Swift!");
+    }
+  #endif
+    ReactNativeHealthkit::HybridWorkoutsModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+
+} // namespace margelo::nitro::healthkit::bridge::swift