@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

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

@@ -0,0 +1,76 @@
+///
+/// HybridHeartbeatSeriesModuleSpec.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 `HeartbeatSeriesSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct HeartbeatSeriesSample; }
+// Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `HeartbeatSeriesSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct HeartbeatSeriesSamplesWithAnchorResponse; }
+// Forward declaration of `QueryOptionsWithAnchor` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
+
+#include <NitroModules/Promise.hpp>
+#include <vector>
+#include "HeartbeatSeriesSample.hpp"
+#include <optional>
+#include "QueryOptionsWithSortOrder.hpp"
+#include "HeartbeatSeriesSamplesWithAnchorResponse.hpp"
+#include "QueryOptionsWithAnchor.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `HeartbeatSeriesModule`
+   * Inherit this class to create instances of `HybridHeartbeatSeriesModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHeartbeatSeriesModule: public HybridHeartbeatSeriesModuleSpec {
+   * public:
+   *   HybridHeartbeatSeriesModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHeartbeatSeriesModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHeartbeatSeriesModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHeartbeatSeriesModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>> queryHeartbeatSeriesSamples(const std::optional<QueryOptionsWithSortOrder>& options) = 0;
+      virtual std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>> queryHeartbeatSeriesSamplesWithAnchor(const QueryOptionsWithAnchor& options) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "HeartbeatSeriesModule";
+  };
+
+} // namespace margelo::nitro::healthkit

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

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

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

@@ -0,0 +1,123 @@
+///
+/// HybridQuantityTypeModuleSpec.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 `QuantityTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
+// 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 `QuantitySample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantitySample; }
+// Forward declaration of `QueryOptionsWithSortOrderAndUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrderAndUnit; }
+// Forward declaration of `QueryStatisticsResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
+// Forward declaration of `StatisticsOptions` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StatisticsOptions; }
+// Forward declaration of `StatisticsQueryOptions` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StatisticsQueryOptions; }
+// Forward declaration of `IntervalComponents` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct IntervalComponents; }
+// Forward declaration of `QuantitySamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantitySamplesWithAnchorResponse; }
+// Forward declaration of `QueryOptionsWithAnchorAndUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndUnit; }
+
+#include "QuantityTypeIdentifier.hpp"
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <chrono>
+#include <NitroModules/AnyMap.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 <vector>
+#include "QuantitySample.hpp"
+#include <optional>
+#include "QueryOptionsWithSortOrderAndUnit.hpp"
+#include "QueryStatisticsResponse.hpp"
+#include "StatisticsOptions.hpp"
+#include "StatisticsQueryOptions.hpp"
+#include "IntervalComponents.hpp"
+#include "QuantitySamplesWithAnchorResponse.hpp"
+#include "QueryOptionsWithAnchorAndUnit.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `QuantityTypeModule`
+   * Inherit this class to create instances of `HybridQuantityTypeModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridQuantityTypeModule: public HybridQuantityTypeModuleSpec {
+   * public:
+   *   HybridQuantityTypeModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridQuantityTypeModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridQuantityTypeModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridQuantityTypeModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual bool isQuantityCompatibleWithUnit(QuantityTypeIdentifier identifier, const std::string& unit) = 0;
+      virtual std::shared_ptr<Promise<bool>> saveQuantitySample(QuantityTypeIdentifier identifier, const std::string& unit, double value, 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<bool>> deleteQuantitySamples(QuantityTypeIdentifier identifier, const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>& filter) = 0;
+      virtual std::shared_ptr<Promise<std::vector<QuantitySample>>> queryQuantitySamples(QuantityTypeIdentifier identifier, const std::optional<QueryOptionsWithSortOrderAndUnit>& options) = 0;
+      virtual std::shared_ptr<Promise<QueryStatisticsResponse>> queryStatisticsForQuantity(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, const std::optional<StatisticsQueryOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>> queryStatisticsCollectionForQuantity(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, const std::string& anchorDate, const IntervalComponents& intervalComponents, const std::optional<StatisticsQueryOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>> queryQuantitySamplesWithAnchor(QuantityTypeIdentifier identifier, const QueryOptionsWithAnchorAndUnit& options) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "QuantityTypeModule";
+  };
+
+} // namespace margelo::nitro::healthkit

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

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

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

@@ -0,0 +1,65 @@
+///
+/// HybridSourceProxySpec.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 `Source` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Source; }
+
+#include <string>
+#include "Source.hpp"
+#include <optional>
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SourceProxy`
+   * Inherit this class to create instances of `HybridSourceProxySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSourceProxy: public HybridSourceProxySpec {
+   * public:
+   *   HybridSourceProxy(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSourceProxySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSourceProxySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSourceProxySpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getBundleIdentifier() = 0;
+
+    public:
+      // Methods
+      virtual Source toJSON(const std::optional<std::string>& key) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SourceProxy";
+  };
+
+} // namespace margelo::nitro::healthkit

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

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

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

@@ -0,0 +1,83 @@
+///
+/// HybridStateOfMindModuleSpec.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 `StateOfMindSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StateOfMindSample; }
+// Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `StateOfMindKind` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindKind; }
+// Forward declaration of `StateOfMindLabel` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindLabel; }
+// Forward declaration of `StateOfMindAssociation` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindAssociation; }
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
+
+#include <NitroModules/Promise.hpp>
+#include <vector>
+#include "StateOfMindSample.hpp"
+#include <optional>
+#include "QueryOptionsWithSortOrder.hpp"
+#include <chrono>
+#include "StateOfMindKind.hpp"
+#include "StateOfMindLabel.hpp"
+#include "StateOfMindAssociation.hpp"
+#include <NitroModules/AnyMap.hpp>
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `StateOfMindModule`
+   * Inherit this class to create instances of `HybridStateOfMindModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridStateOfMindModule: public HybridStateOfMindModuleSpec {
+   * public:
+   *   HybridStateOfMindModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridStateOfMindModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridStateOfMindModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridStateOfMindModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::vector<StateOfMindSample>>> queryStateOfMindSamples(const std::optional<QueryOptionsWithSortOrder>& options) = 0;
+      virtual std::shared_ptr<Promise<bool>> saveStateOfMindSample(std::chrono::system_clock::time_point date, StateOfMindKind kind, double valence, const std::vector<StateOfMindLabel>& labels, const std::vector<StateOfMindAssociation>& associations, const std::optional<std::shared_ptr<AnyMap>>& metadata) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "StateOfMindModule";
+  };
+
+} // namespace margelo::nitro::healthkit

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

@@ -0,0 +1,38 @@
+///
+/// HybridWorkoutProxySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridWorkoutProxySpec.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  void HybridWorkoutProxySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("uuid", &HybridWorkoutProxySpec::getUuid);
+      prototype.registerHybridGetter("device", &HybridWorkoutProxySpec::getDevice);
+      prototype.registerHybridGetter("workoutActivityType", &HybridWorkoutProxySpec::getWorkoutActivityType);
+      prototype.registerHybridGetter("duration", &HybridWorkoutProxySpec::getDuration);
+      prototype.registerHybridGetter("totalDistance", &HybridWorkoutProxySpec::getTotalDistance);
+      prototype.registerHybridGetter("totalEnergyBurned", &HybridWorkoutProxySpec::getTotalEnergyBurned);
+      prototype.registerHybridGetter("totalSwimmingStrokeCount", &HybridWorkoutProxySpec::getTotalSwimmingStrokeCount);
+      prototype.registerHybridGetter("totalFlightsClimbed", &HybridWorkoutProxySpec::getTotalFlightsClimbed);
+      prototype.registerHybridGetter("startDate", &HybridWorkoutProxySpec::getStartDate);
+      prototype.registerHybridGetter("endDate", &HybridWorkoutProxySpec::getEndDate);
+      prototype.registerHybridGetter("metadata", &HybridWorkoutProxySpec::getMetadata);
+      prototype.registerHybridGetter("sourceRevision", &HybridWorkoutProxySpec::getSourceRevision);
+      prototype.registerHybridGetter("events", &HybridWorkoutProxySpec::getEvents);
+      prototype.registerHybridGetter("activities", &HybridWorkoutProxySpec::getActivities);
+      prototype.registerHybridMethod("toJSON", &HybridWorkoutProxySpec::toJSON);
+      prototype.registerHybridMethod("saveWorkoutRoute", &HybridWorkoutProxySpec::saveWorkoutRoute);
+      prototype.registerHybridMethod("getWorkoutPlan", &HybridWorkoutProxySpec::getWorkoutPlan);
+      prototype.registerHybridMethod("getWorkoutRoutes", &HybridWorkoutProxySpec::getWorkoutRoutes);
+    });
+  }
+
+} // namespace margelo::nitro::healthkit

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

@@ -0,0 +1,114 @@
+///
+/// HybridWorkoutProxySpec.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 `Device` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Device; }
+// Forward declaration of `WorkoutActivityType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WorkoutActivityType; }
+// Forward declaration of `Quantity` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Quantity; }
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
+// Forward declaration of `SourceRevision` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct SourceRevision; }
+// Forward declaration of `WorkoutEvent` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutEvent; }
+// Forward declaration of `WorkoutActivity` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutActivity; }
+// Forward declaration of `WorkoutSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutSample; }
+// Forward declaration of `LocationForSaving` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct LocationForSaving; }
+// Forward declaration of `WorkoutPlan` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutPlan; }
+// Forward declaration of `WorkoutRoute` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutRoute; }
+
+#include <string>
+#include <optional>
+#include "Device.hpp"
+#include "WorkoutActivityType.hpp"
+#include "Quantity.hpp"
+#include <chrono>
+#include <NitroModules/AnyMap.hpp>
+#include "SourceRevision.hpp"
+#include <vector>
+#include "WorkoutEvent.hpp"
+#include "WorkoutActivity.hpp"
+#include "WorkoutSample.hpp"
+#include <NitroModules/Promise.hpp>
+#include "LocationForSaving.hpp"
+#include "WorkoutPlan.hpp"
+#include "WorkoutRoute.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `WorkoutProxy`
+   * Inherit this class to create instances of `HybridWorkoutProxySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridWorkoutProxy: public HybridWorkoutProxySpec {
+   * public:
+   *   HybridWorkoutProxy(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridWorkoutProxySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridWorkoutProxySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridWorkoutProxySpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getUuid() = 0;
+      virtual std::optional<Device> getDevice() = 0;
+      virtual WorkoutActivityType getWorkoutActivityType() = 0;
+      virtual Quantity getDuration() = 0;
+      virtual std::optional<Quantity> getTotalDistance() = 0;
+      virtual std::optional<Quantity> getTotalEnergyBurned() = 0;
+      virtual std::optional<Quantity> getTotalSwimmingStrokeCount() = 0;
+      virtual std::optional<Quantity> getTotalFlightsClimbed() = 0;
+      virtual std::chrono::system_clock::time_point getStartDate() = 0;
+      virtual std::chrono::system_clock::time_point getEndDate() = 0;
+      virtual std::optional<std::shared_ptr<AnyMap>> getMetadata() = 0;
+      virtual std::optional<SourceRevision> getSourceRevision() = 0;
+      virtual std::optional<std::vector<WorkoutEvent>> getEvents() = 0;
+      virtual std::optional<std::vector<WorkoutActivity>> getActivities() = 0;
+
+    public:
+      // Methods
+      virtual WorkoutSample toJSON(const std::optional<std::string>& key) = 0;
+      virtual std::shared_ptr<Promise<bool>> saveWorkoutRoute(const std::vector<LocationForSaving>& locations) = 0;
+      virtual std::shared_ptr<Promise<std::optional<WorkoutPlan>>> getWorkoutPlan() = 0;
+      virtual std::shared_ptr<Promise<std::vector<WorkoutRoute>>> getWorkoutRoutes() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "WorkoutProxy";
+  };
+
+} // namespace margelo::nitro::healthkit

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

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

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

@@ -0,0 +1,68 @@
+///
+/// HybridWorkoutSessionModuleSpec.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 `WorkoutConfiguration` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutConfiguration; }
+// Forward declaration of `WorkoutSessionMirroringStartHandlerOptions` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutSessionMirroringStartHandlerOptions; }
+
+#include <NitroModules/Promise.hpp>
+#include "WorkoutConfiguration.hpp"
+#include "WorkoutSessionMirroringStartHandlerOptions.hpp"
+
+namespace margelo::nitro::healthkit {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `WorkoutSessionModule`
+   * Inherit this class to create instances of `HybridWorkoutSessionModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridWorkoutSessionModule: public HybridWorkoutSessionModuleSpec {
+   * public:
+   *   HybridWorkoutSessionModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridWorkoutSessionModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridWorkoutSessionModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridWorkoutSessionModuleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<bool>> startWatchAppWithWorkoutConfiguration(const WorkoutConfiguration& workoutConfiguration) = 0;
+      virtual bool workoutSessionMirroringStartHandler(const WorkoutSessionMirroringStartHandlerOptions& options) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "WorkoutSessionModule";
+  };
+
+} // namespace margelo::nitro::healthkit