@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

package/nitrogen/generated/shared/c++/HeartbeatSeriesSamplesWithAnchorResponse.hpp

@@ -0,0 +1,83 @@
+///
+/// HeartbeatSeriesSamplesWithAnchorResponse.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HeartbeatSeriesSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct HeartbeatSeriesSample; }
+// Forward declaration of `DeletedSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct DeletedSample; }
+
+#include <vector>
+#include "HeartbeatSeriesSample.hpp"
+#include "DeletedSample.hpp"
+#include <string>
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * A struct which can be represented as a JavaScript object (HeartbeatSeriesSamplesWithAnchorResponse).
+   */
+  struct HeartbeatSeriesSamplesWithAnchorResponse {
+  public:
+    std::vector<HeartbeatSeriesSample> samples     SWIFT_PRIVATE;
+    std::vector<DeletedSample> deletedSamples     SWIFT_PRIVATE;
+    std::string newAnchor     SWIFT_PRIVATE;
+
+  public:
+    HeartbeatSeriesSamplesWithAnchorResponse() = default;
+    explicit HeartbeatSeriesSamplesWithAnchorResponse(std::vector<HeartbeatSeriesSample> samples, std::vector<DeletedSample> deletedSamples, std::string newAnchor): samples(samples), deletedSamples(deletedSamples), newAnchor(newAnchor) {}
+  };
+
+} // namespace margelo::nitro::healthkit
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::healthkit;
+
+  // C++ HeartbeatSeriesSamplesWithAnchorResponse <> JS HeartbeatSeriesSamplesWithAnchorResponse (object)
+  template <>
+  struct JSIConverter<HeartbeatSeriesSamplesWithAnchorResponse> final {
+    static inline HeartbeatSeriesSamplesWithAnchorResponse fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return HeartbeatSeriesSamplesWithAnchorResponse(
+        JSIConverter<std::vector<HeartbeatSeriesSample>>::fromJSI(runtime, obj.getProperty(runtime, "samples")),
+        JSIConverter<std::vector<DeletedSample>>::fromJSI(runtime, obj.getProperty(runtime, "deletedSamples")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "newAnchor"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const HeartbeatSeriesSamplesWithAnchorResponse& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "samples", JSIConverter<std::vector<HeartbeatSeriesSample>>::toJSI(runtime, arg.samples));
+      obj.setProperty(runtime, "deletedSamples", JSIConverter<std::vector<DeletedSample>>::toJSI(runtime, arg.deletedSamples));
+      obj.setProperty(runtime, "newAnchor", JSIConverter<std::string>::toJSI(runtime, arg.newAnchor));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<std::vector<HeartbeatSeriesSample>>::canConvert(runtime, obj.getProperty(runtime, "samples"))) return false;
+      if (!JSIConverter<std::vector<DeletedSample>>::canConvert(runtime, obj.getProperty(runtime, "deletedSamples"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "newAnchor"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridCategoryTypeModuleSpec.cpp

@@ -0,0 +1,23 @@
+///
+/// HybridCategoryTypeModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCategoryTypeModuleSpec.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  void HybridCategoryTypeModuleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("saveCategorySample", &HybridCategoryTypeModuleSpec::saveCategorySample);
+      prototype.registerHybridMethod("queryCategorySamples", &HybridCategoryTypeModuleSpec::queryCategorySamples);
+      prototype.registerHybridMethod("queryCategorySamplesWithAnchor", &HybridCategoryTypeModuleSpec::queryCategorySamplesWithAnchor);
+    });
+  }
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCategoryTypeModuleSpec.hpp

@@ -0,0 +1,84 @@
+///
+/// HybridCategoryTypeModuleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// 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 `QueryOptionsWithSortOrder` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `CategorySamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySamplesWithAnchorResponse; }
+// 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 <optional>
+#include "QueryOptionsWithSortOrder.hpp"
+#include "CategorySamplesWithAnchorResponse.hpp"
+#include "QueryOptionsWithAnchor.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CategoryTypeModule`
+   * Inherit this class to create instances of `HybridCategoryTypeModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCategoryTypeModule: public HybridCategoryTypeModuleSpec {
+   * public:
+   *   HybridCategoryTypeModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCategoryTypeModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCategoryTypeModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCategoryTypeModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual 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) = 0;
+      virtual std::shared_ptr<Promise<std::vector<CategorySample>>> queryCategorySamples(CategoryTypeIdentifier identifier, const std::optional<QueryOptionsWithSortOrder>& options) = 0;
+      virtual std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>> queryCategorySamplesWithAnchor(CategoryTypeIdentifier identifier, const QueryOptionsWithAnchor& options) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CategoryTypeModule";
+  };
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCharacteristicTypeModuleSpec.cpp

@@ -0,0 +1,30 @@
+///
+/// HybridCharacteristicTypeModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCharacteristicTypeModuleSpec.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  void HybridCharacteristicTypeModuleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getBloodType", &HybridCharacteristicTypeModuleSpec::getBloodType);
+      prototype.registerHybridMethod("getDateOfBirth", &HybridCharacteristicTypeModuleSpec::getDateOfBirth);
+      prototype.registerHybridMethod("getBiologicalSex", &HybridCharacteristicTypeModuleSpec::getBiologicalSex);
+      prototype.registerHybridMethod("getFitzpatrickSkinType", &HybridCharacteristicTypeModuleSpec::getFitzpatrickSkinType);
+      prototype.registerHybridMethod("getWheelchairUse", &HybridCharacteristicTypeModuleSpec::getWheelchairUse);
+      prototype.registerHybridMethod("getBloodTypeAsync", &HybridCharacteristicTypeModuleSpec::getBloodTypeAsync);
+      prototype.registerHybridMethod("getDateOfBirthAsync", &HybridCharacteristicTypeModuleSpec::getDateOfBirthAsync);
+      prototype.registerHybridMethod("getBiologicalSexAsync", &HybridCharacteristicTypeModuleSpec::getBiologicalSexAsync);
+      prototype.registerHybridMethod("getFitzpatrickSkinTypeAsync", &HybridCharacteristicTypeModuleSpec::getFitzpatrickSkinTypeAsync);
+      prototype.registerHybridMethod("getWheelchairUseAsync", &HybridCharacteristicTypeModuleSpec::getWheelchairUseAsync);
+    });
+  }
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCharacteristicTypeModuleSpec.hpp

@@ -0,0 +1,83 @@
+///
+/// HybridCharacteristicTypeModuleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// 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>
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CharacteristicTypeModule`
+   * Inherit this class to create instances of `HybridCharacteristicTypeModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCharacteristicTypeModule: public HybridCharacteristicTypeModuleSpec {
+   * public:
+   *   HybridCharacteristicTypeModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCharacteristicTypeModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCharacteristicTypeModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCharacteristicTypeModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual BloodType getBloodType() = 0;
+      virtual std::chrono::system_clock::time_point getDateOfBirth() = 0;
+      virtual BiologicalSex getBiologicalSex() = 0;
+      virtual FitzpatrickSkinType getFitzpatrickSkinType() = 0;
+      virtual WheelchairUse getWheelchairUse() = 0;
+      virtual std::shared_ptr<Promise<BloodType>> getBloodTypeAsync() = 0;
+      virtual std::shared_ptr<Promise<std::chrono::system_clock::time_point>> getDateOfBirthAsync() = 0;
+      virtual std::shared_ptr<Promise<BiologicalSex>> getBiologicalSexAsync() = 0;
+      virtual std::shared_ptr<Promise<FitzpatrickSkinType>> getFitzpatrickSkinTypeAsync() = 0;
+      virtual std::shared_ptr<Promise<WheelchairUse>> getWheelchairUseAsync() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CharacteristicTypeModule";
+  };
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCoreModuleSpec.cpp

@@ -0,0 +1,42 @@
+///
+/// HybridCoreModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCoreModuleSpec.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  void HybridCoreModuleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("enableBackgroundDelivery", &HybridCoreModuleSpec::enableBackgroundDelivery);
+      prototype.registerHybridMethod("disableBackgroundDelivery", &HybridCoreModuleSpec::disableBackgroundDelivery);
+      prototype.registerHybridMethod("disableAllBackgroundDelivery", &HybridCoreModuleSpec::disableAllBackgroundDelivery);
+      prototype.registerHybridMethod("isHealthDataAvailable", &HybridCoreModuleSpec::isHealthDataAvailable);
+      prototype.registerHybridMethod("isHealthDataAvailableAsync", &HybridCoreModuleSpec::isHealthDataAvailableAsync);
+      prototype.registerHybridMethod("isProtectedDataAvailable", &HybridCoreModuleSpec::isProtectedDataAvailable);
+      prototype.registerHybridMethod("isProtectedDataAvailableAsync", &HybridCoreModuleSpec::isProtectedDataAvailableAsync);
+      prototype.registerHybridMethod("getPreferredUnits", &HybridCoreModuleSpec::getPreferredUnits);
+      prototype.registerHybridMethod("querySources", &HybridCoreModuleSpec::querySources);
+      prototype.registerHybridMethod("subscribeToObserverQuery", &HybridCoreModuleSpec::subscribeToObserverQuery);
+      prototype.registerHybridMethod("unsubscribeQuery", &HybridCoreModuleSpec::unsubscribeQuery);
+      prototype.registerHybridMethod("unsubscribeQueryAsync", &HybridCoreModuleSpec::unsubscribeQueryAsync);
+      prototype.registerHybridMethod("unsubscribeQueries", &HybridCoreModuleSpec::unsubscribeQueries);
+      prototype.registerHybridMethod("unsubscribeQueriesAsync", &HybridCoreModuleSpec::unsubscribeQueriesAsync);
+      prototype.registerHybridMethod("authorizationStatusFor", &HybridCoreModuleSpec::authorizationStatusFor);
+      prototype.registerHybridMethod("getRequestStatusForAuthorization", &HybridCoreModuleSpec::getRequestStatusForAuthorization);
+      prototype.registerHybridMethod("requestAuthorization", &HybridCoreModuleSpec::requestAuthorization);
+      prototype.registerHybridMethod("deleteObjects", &HybridCoreModuleSpec::deleteObjects);
+      prototype.registerHybridMethod("isObjectTypeAvailable", &HybridCoreModuleSpec::isObjectTypeAvailable);
+      prototype.registerHybridMethod("areObjectTypesAvailable", &HybridCoreModuleSpec::areObjectTypesAvailable);
+      prototype.registerHybridMethod("areObjectTypesAvailableAsync", &HybridCoreModuleSpec::areObjectTypesAvailableAsync);
+      prototype.registerHybridMethod("isObjectTypeAvailableAsync", &HybridCoreModuleSpec::isObjectTypeAvailableAsync);
+    });
+  }
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCoreModuleSpec.hpp

@@ -0,0 +1,140 @@
+///
+/// HybridCoreModuleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// 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; }
+
+#include <NitroModules/Promise.hpp>
+#include "ObjectTypeIdentifier.hpp"
+#include "UpdateFrequency.hpp"
+#include <vector>
+#include "IdentifierWithUnit.hpp"
+#include "QuantityTypeIdentifier.hpp"
+#include <optional>
+#include <memory>
+#include "HybridSourceProxySpec.hpp"
+#include "SampleTypeIdentifier.hpp"
+#include <string>
+#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 <unordered_map>
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CoreModule`
+   * Inherit this class to create instances of `HybridCoreModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCoreModule: public HybridCoreModuleSpec {
+   * public:
+   *   HybridCoreModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCoreModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCoreModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCoreModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<bool>> enableBackgroundDelivery(ObjectTypeIdentifier typeIdentifier, UpdateFrequency updateFrequency) = 0;
+      virtual std::shared_ptr<Promise<bool>> disableBackgroundDelivery(ObjectTypeIdentifier typeIdentifier) = 0;
+      virtual std::shared_ptr<Promise<bool>> disableAllBackgroundDelivery() = 0;
+      virtual bool isHealthDataAvailable() = 0;
+      virtual std::shared_ptr<Promise<bool>> isHealthDataAvailableAsync() = 0;
+      virtual bool isProtectedDataAvailable() = 0;
+      virtual std::shared_ptr<Promise<bool>> isProtectedDataAvailableAsync() = 0;
+      virtual std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>> getPreferredUnits(const std::vector<QuantityTypeIdentifier>& identifiers, std::optional<bool> forceUpdate) = 0;
+      virtual std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>> querySources(SampleTypeIdentifier identifier) = 0;
+      virtual std::string subscribeToObserverQuery(SampleTypeIdentifier typeIdentifier, const std::function<void(const OnChangeCallbackArgs& /* args */)>& callback) = 0;
+      virtual bool unsubscribeQuery(const std::string& queryId) = 0;
+      virtual std::shared_ptr<Promise<bool>> unsubscribeQueryAsync(const std::string& queryId) = 0;
+      virtual double unsubscribeQueries(const std::vector<std::string>& queryIds) = 0;
+      virtual std::shared_ptr<Promise<double>> unsubscribeQueriesAsync(const std::vector<std::string>& queryIds) = 0;
+      virtual AuthorizationStatus authorizationStatusFor(ObjectTypeIdentifier type) = 0;
+      virtual std::shared_ptr<Promise<AuthorizationRequestStatus>> getRequestStatusForAuthorization(const std::vector<SampleTypeIdentifierWriteable>& toShare, const std::vector<ObjectTypeIdentifier>& toRead) = 0;
+      virtual std::shared_ptr<Promise<bool>> requestAuthorization(const std::vector<SampleTypeIdentifierWriteable>& toShare, const std::vector<ObjectTypeIdentifier>& toRead) = 0;
+      virtual std::shared_ptr<Promise<double>> deleteObjects(ObjectTypeIdentifier objectTypeIdentifier, const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>& filter) = 0;
+      virtual bool isObjectTypeAvailable(ObjectTypeIdentifier objectTypeIdentifier) = 0;
+      virtual std::unordered_map<std::string, bool> areObjectTypesAvailable(const std::vector<ObjectTypeIdentifier>& objectTypeIdentifiers) = 0;
+      virtual std::shared_ptr<Promise<std::unordered_map<std::string, bool>>> areObjectTypesAvailableAsync(const std::vector<ObjectTypeIdentifier>& objectTypeIdentifiers) = 0;
+      virtual std::shared_ptr<Promise<bool>> isObjectTypeAvailableAsync(ObjectTypeIdentifier objectTypeIdentifier) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CoreModule";
+  };
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCorrelationTypeModuleSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridCorrelationTypeModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCorrelationTypeModuleSpec.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  void HybridCorrelationTypeModuleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("saveCorrelationSample", &HybridCorrelationTypeModuleSpec::saveCorrelationSample);
+      prototype.registerHybridMethod("queryCorrelationSamples", &HybridCorrelationTypeModuleSpec::queryCorrelationSamples);
+    });
+  }
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridCorrelationTypeModuleSpec.hpp

@@ -0,0 +1,80 @@
+///
+/// HybridCorrelationTypeModuleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `CorrelationTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class CorrelationTypeIdentifier; }
+// Forward declaration of `CategorySampleForSaving` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySampleForSaving; }
+// Forward declaration of `QuantitySampleForSaving` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantitySampleForSaving; }
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
+// Forward declaration of `CorrelationSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CorrelationSample; }
+
+#include <NitroModules/Promise.hpp>
+#include "CorrelationTypeIdentifier.hpp"
+#include <vector>
+#include <variant>
+#include "CategorySampleForSaving.hpp"
+#include "QuantitySampleForSaving.hpp"
+#include <chrono>
+#include <NitroModules/AnyMap.hpp>
+#include "CorrelationSample.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CorrelationTypeModule`
+   * Inherit this class to create instances of `HybridCorrelationTypeModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCorrelationTypeModule: public HybridCorrelationTypeModuleSpec {
+   * public:
+   *   HybridCorrelationTypeModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCorrelationTypeModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCorrelationTypeModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCorrelationTypeModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<bool>> saveCorrelationSample(CorrelationTypeIdentifier typeIdentifier, const std::vector<std::variant<CategorySampleForSaving, QuantitySampleForSaving>>& samples, std::chrono::system_clock::time_point start, std::chrono::system_clock::time_point end, const std::shared_ptr<AnyMap>& metadata) = 0;
+      virtual std::shared_ptr<Promise<std::vector<CorrelationSample>>> queryCorrelationSamples(CorrelationTypeIdentifier typeIdentifier, std::chrono::system_clock::time_point from, std::chrono::system_clock::time_point to) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CorrelationTypeModule";
+  };
+
+} // namespace margelo::nitro::healthkit

package/nitrogen/generated/shared/c++/HybridHeartbeatSeriesModuleSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridHeartbeatSeriesModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridHeartbeatSeriesModuleSpec.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  void HybridHeartbeatSeriesModuleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("queryHeartbeatSeriesSamples", &HybridHeartbeatSeriesModuleSpec::queryHeartbeatSeriesSamples);
+      prototype.registerHybridMethod("queryHeartbeatSeriesSamplesWithAnchor", &HybridHeartbeatSeriesModuleSpec::queryHeartbeatSeriesSamplesWithAnchor);
+    });
+  }
+
+} // namespace margelo::nitro::healthkit