@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

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

@@ -0,0 +1,146 @@
+///
+/// HybridCategoryTypeModuleSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridCategoryTypeModuleSpec.hpp"
+
+// Forward declaration of `HybridCategoryTypeModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridCategoryTypeModuleSpec_cxx; }
+
+// Forward declaration of `CategoryTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class CategoryTypeIdentifier; }
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
+// Forward declaration of `CategorySample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySample; }
+// Forward declaration of `Device` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Device; }
+// Forward declaration of `SourceRevision` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct SourceRevision; }
+// Forward declaration of `HybridSourceProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
+// Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `PredicateWithUUID` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithUUID; }
+// Forward declaration of `PredicateWithUUIDs` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithUUIDs; }
+// Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
+// Forward declaration of `PredicateWithStartAndEnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
+// Forward declaration of `PredicateFromWorkout` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
+// Forward declaration of `FilterForSamplesAnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
+// Forward declaration of `FilterForSamplesOr` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
+// Forward declaration of `CategorySamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySamplesWithAnchorResponse; }
+// Forward declaration of `DeletedSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct DeletedSample; }
+// Forward declaration of `QueryOptionsWithAnchor` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
+
+#include <NitroModules/Promise.hpp>
+#include "CategoryTypeIdentifier.hpp"
+#include <chrono>
+#include <NitroModules/AnyMap.hpp>
+#include <vector>
+#include "CategorySample.hpp"
+#include <string>
+#include <optional>
+#include "Device.hpp"
+#include "SourceRevision.hpp"
+#include <memory>
+#include "HybridSourceProxySpec.hpp"
+#include "QueryOptionsWithSortOrder.hpp"
+#include <variant>
+#include "PredicateWithUUID.hpp"
+#include "PredicateWithUUIDs.hpp"
+#include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithStartAndEnd.hpp"
+#include "PredicateFromWorkout.hpp"
+#include "FilterForSamplesAnd.hpp"
+#include "FilterForSamplesOr.hpp"
+#include "HybridWorkoutProxySpec.hpp"
+#include "CategorySamplesWithAnchorResponse.hpp"
+#include "DeletedSample.hpp"
+#include "QueryOptionsWithAnchor.hpp"
+
+#include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * The C++ part of HybridCategoryTypeModuleSpec_cxx.swift.
+   *
+   * HybridCategoryTypeModuleSpecSwift (C++) accesses HybridCategoryTypeModuleSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridCategoryTypeModuleSpec_cxx can directly inherit from the C++ class HybridCategoryTypeModuleSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridCategoryTypeModuleSpecSwift: public virtual HybridCategoryTypeModuleSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridCategoryTypeModuleSpecSwift(const ReactNativeHealthkit::HybridCategoryTypeModuleSpec_cxx& swiftPart):
+      HybridObject(HybridCategoryTypeModuleSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeHealthkit::HybridCategoryTypeModuleSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    // Get memory pressure
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<bool>> saveCategorySample(CategoryTypeIdentifier identifier, double value, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const std::shared_ptr<AnyMap>& metadata) override {
+      auto __result = _swiftPart.saveCategorySample(static_cast<int>(identifier), std::forward<decltype(value)>(value), startDate, endDate, metadata);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<CategorySample>>> queryCategorySamples(CategoryTypeIdentifier identifier, const std::optional<QueryOptionsWithSortOrder>& options) override {
+      auto __result = _swiftPart.queryCategorySamples(static_cast<int>(identifier), options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>> queryCategorySamplesWithAnchor(CategoryTypeIdentifier identifier, const QueryOptionsWithAnchor& options) override {
+      auto __result = _swiftPart.queryCategorySamplesWithAnchor(static_cast<int>(identifier), options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeHealthkit::HybridCategoryTypeModuleSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/ios/c++/HybridCharacteristicTypeModuleSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridCharacteristicTypeModuleSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCharacteristicTypeModuleSpecSwift.hpp"
+
+namespace margelo::nitro::healthkit {
+} // namespace margelo::nitro::healthkit

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

@@ -0,0 +1,155 @@
+///
+/// HybridCharacteristicTypeModuleSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridCharacteristicTypeModuleSpec.hpp"
+
+// Forward declaration of `HybridCharacteristicTypeModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridCharacteristicTypeModuleSpec_cxx; }
+
+// Forward declaration of `BloodType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class BloodType; }
+// Forward declaration of `BiologicalSex` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class BiologicalSex; }
+// Forward declaration of `FitzpatrickSkinType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class FitzpatrickSkinType; }
+// Forward declaration of `WheelchairUse` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WheelchairUse; }
+
+#include "BloodType.hpp"
+#include <chrono>
+#include "BiologicalSex.hpp"
+#include "FitzpatrickSkinType.hpp"
+#include "WheelchairUse.hpp"
+#include <NitroModules/Promise.hpp>
+
+#include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * The C++ part of HybridCharacteristicTypeModuleSpec_cxx.swift.
+   *
+   * HybridCharacteristicTypeModuleSpecSwift (C++) accesses HybridCharacteristicTypeModuleSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridCharacteristicTypeModuleSpec_cxx can directly inherit from the C++ class HybridCharacteristicTypeModuleSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridCharacteristicTypeModuleSpecSwift: public virtual HybridCharacteristicTypeModuleSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridCharacteristicTypeModuleSpecSwift(const ReactNativeHealthkit::HybridCharacteristicTypeModuleSpec_cxx& swiftPart):
+      HybridObject(HybridCharacteristicTypeModuleSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeHealthkit::HybridCharacteristicTypeModuleSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    // Get memory pressure
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline BloodType getBloodType() override {
+      auto __result = _swiftPart.getBloodType();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::chrono::system_clock::time_point getDateOfBirth() override {
+      auto __result = _swiftPart.getDateOfBirth();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline BiologicalSex getBiologicalSex() override {
+      auto __result = _swiftPart.getBiologicalSex();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline FitzpatrickSkinType getFitzpatrickSkinType() override {
+      auto __result = _swiftPart.getFitzpatrickSkinType();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline WheelchairUse getWheelchairUse() override {
+      auto __result = _swiftPart.getWheelchairUse();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BloodType>> getBloodTypeAsync() override {
+      auto __result = _swiftPart.getBloodTypeAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::chrono::system_clock::time_point>> getDateOfBirthAsync() override {
+      auto __result = _swiftPart.getDateOfBirthAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BiologicalSex>> getBiologicalSexAsync() override {
+      auto __result = _swiftPart.getBiologicalSexAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FitzpatrickSkinType>> getFitzpatrickSkinTypeAsync() override {
+      auto __result = _swiftPart.getFitzpatrickSkinTypeAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<WheelchairUse>> getWheelchairUseAsync() override {
+      auto __result = _swiftPart.getWheelchairUseAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeHealthkit::HybridCharacteristicTypeModuleSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::healthkit

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

@@ -0,0 +1,11 @@
+///
+/// HybridCoreModuleSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCoreModuleSpecSwift.hpp"
+
+namespace margelo::nitro::healthkit {
+} // namespace margelo::nitro::healthkit

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

@@ -0,0 +1,300 @@
+///
+/// HybridCoreModuleSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridCoreModuleSpec.hpp"
+
+// Forward declaration of `HybridCoreModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridCoreModuleSpec_cxx; }
+
+// Forward declaration of `ObjectTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class ObjectTypeIdentifier; }
+// Forward declaration of `UpdateFrequency` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class UpdateFrequency; }
+// Forward declaration of `IdentifierWithUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct IdentifierWithUnit; }
+// Forward declaration of `QuantityTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
+// Forward declaration of `HybridSourceProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
+// Forward declaration of `SampleTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class SampleTypeIdentifier; }
+// Forward declaration of `OnChangeCallbackArgs` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct OnChangeCallbackArgs; }
+// Forward declaration of `AuthorizationStatus` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class AuthorizationStatus; }
+// Forward declaration of `AuthorizationRequestStatus` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class AuthorizationRequestStatus; }
+// Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
+// Forward declaration of `PredicateWithUUID` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithUUID; }
+// Forward declaration of `PredicateWithUUIDs` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithUUIDs; }
+// Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
+// Forward declaration of `PredicateWithStartAndEnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
+// Forward declaration of `PredicateFromWorkout` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
+// Forward declaration of `FilterForSamplesAnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
+// Forward declaration of `FilterForSamplesOr` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
+
+#include <NitroModules/Promise.hpp>
+#include "ObjectTypeIdentifier.hpp"
+#include "UpdateFrequency.hpp"
+#include <vector>
+#include "IdentifierWithUnit.hpp"
+#include <string>
+#include "QuantityTypeIdentifier.hpp"
+#include <optional>
+#include <memory>
+#include "HybridSourceProxySpec.hpp"
+#include "SampleTypeIdentifier.hpp"
+#include <functional>
+#include "OnChangeCallbackArgs.hpp"
+#include "AuthorizationStatus.hpp"
+#include "AuthorizationRequestStatus.hpp"
+#include "SampleTypeIdentifierWriteable.hpp"
+#include <variant>
+#include "PredicateWithUUID.hpp"
+#include "PredicateWithUUIDs.hpp"
+#include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithStartAndEnd.hpp"
+#include "PredicateFromWorkout.hpp"
+#include "FilterForSamplesAnd.hpp"
+#include "FilterForSamplesOr.hpp"
+#include <chrono>
+#include "HybridWorkoutProxySpec.hpp"
+#include <unordered_map>
+
+#include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * The C++ part of HybridCoreModuleSpec_cxx.swift.
+   *
+   * HybridCoreModuleSpecSwift (C++) accesses HybridCoreModuleSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridCoreModuleSpec_cxx can directly inherit from the C++ class HybridCoreModuleSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridCoreModuleSpecSwift: public virtual HybridCoreModuleSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridCoreModuleSpecSwift(const ReactNativeHealthkit::HybridCoreModuleSpec_cxx& swiftPart):
+      HybridObject(HybridCoreModuleSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeHealthkit::HybridCoreModuleSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    // Get memory pressure
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<bool>> enableBackgroundDelivery(ObjectTypeIdentifier typeIdentifier, UpdateFrequency updateFrequency) override {
+      auto __result = _swiftPart.enableBackgroundDelivery(static_cast<int>(typeIdentifier), static_cast<int>(updateFrequency));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> disableBackgroundDelivery(ObjectTypeIdentifier typeIdentifier) override {
+      auto __result = _swiftPart.disableBackgroundDelivery(static_cast<int>(typeIdentifier));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> disableAllBackgroundDelivery() override {
+      auto __result = _swiftPart.disableAllBackgroundDelivery();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isHealthDataAvailable() override {
+      auto __result = _swiftPart.isHealthDataAvailable();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> isHealthDataAvailableAsync() override {
+      auto __result = _swiftPart.isHealthDataAvailableAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isProtectedDataAvailable() override {
+      auto __result = _swiftPart.isProtectedDataAvailable();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> isProtectedDataAvailableAsync() override {
+      auto __result = _swiftPart.isProtectedDataAvailableAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>> getPreferredUnits(const std::vector<QuantityTypeIdentifier>& identifiers, std::optional<bool> forceUpdate) override {
+      auto __result = _swiftPart.getPreferredUnits(identifiers, forceUpdate);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>> querySources(SampleTypeIdentifier identifier) override {
+      auto __result = _swiftPart.querySources(static_cast<int>(identifier));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::string subscribeToObserverQuery(SampleTypeIdentifier typeIdentifier, const std::function<void(const OnChangeCallbackArgs& /* args */)>& callback) override {
+      auto __result = _swiftPart.subscribeToObserverQuery(static_cast<int>(typeIdentifier), callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool unsubscribeQuery(const std::string& queryId) override {
+      auto __result = _swiftPart.unsubscribeQuery(queryId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> unsubscribeQueryAsync(const std::string& queryId) override {
+      auto __result = _swiftPart.unsubscribeQueryAsync(queryId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double unsubscribeQueries(const std::vector<std::string>& queryIds) override {
+      auto __result = _swiftPart.unsubscribeQueries(queryIds);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> unsubscribeQueriesAsync(const std::vector<std::string>& queryIds) override {
+      auto __result = _swiftPart.unsubscribeQueriesAsync(queryIds);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline AuthorizationStatus authorizationStatusFor(ObjectTypeIdentifier type) override {
+      auto __result = _swiftPart.authorizationStatusFor(static_cast<int>(type));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<AuthorizationRequestStatus>> getRequestStatusForAuthorization(const std::vector<SampleTypeIdentifierWriteable>& toShare, const std::vector<ObjectTypeIdentifier>& toRead) override {
+      auto __result = _swiftPart.getRequestStatusForAuthorization(toShare, toRead);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> requestAuthorization(const std::vector<SampleTypeIdentifierWriteable>& toShare, const std::vector<ObjectTypeIdentifier>& toRead) override {
+      auto __result = _swiftPart.requestAuthorization(toShare, toRead);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> deleteObjects(ObjectTypeIdentifier objectTypeIdentifier, const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>& filter) override {
+      auto __result = _swiftPart.deleteObjects(static_cast<int>(objectTypeIdentifier), filter);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isObjectTypeAvailable(ObjectTypeIdentifier objectTypeIdentifier) override {
+      auto __result = _swiftPart.isObjectTypeAvailable(static_cast<int>(objectTypeIdentifier));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::unordered_map<std::string, bool> areObjectTypesAvailable(const std::vector<ObjectTypeIdentifier>& objectTypeIdentifiers) override {
+      auto __result = _swiftPart.areObjectTypesAvailable(objectTypeIdentifiers);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::unordered_map<std::string, bool>>> areObjectTypesAvailableAsync(const std::vector<ObjectTypeIdentifier>& objectTypeIdentifiers) override {
+      auto __result = _swiftPart.areObjectTypesAvailableAsync(objectTypeIdentifiers);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> isObjectTypeAvailableAsync(ObjectTypeIdentifier objectTypeIdentifier) override {
+      auto __result = _swiftPart.isObjectTypeAvailableAsync(static_cast<int>(objectTypeIdentifier));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeHealthkit::HybridCoreModuleSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/ios/c++/HybridCorrelationTypeModuleSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridCorrelationTypeModuleSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCorrelationTypeModuleSpecSwift.hpp"
+
+namespace margelo::nitro::healthkit {
+} // namespace margelo::nitro::healthkit