@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

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

@@ -23,21 +23,36 @@
 #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 `Heartbeat` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct Heartbeat; }
+// Forward declaration of `SampleType` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct SampleType; }
+// Forward declaration of `WeatherCondition` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WeatherCondition; }
+// Forward declaration of `Quantity` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Quantity; }
+// Forward declaration of `InsulinDeliveryReason` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class InsulinDeliveryReason; }
+// Forward declaration of `HeartRateMotionContext` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class HeartRateMotionContext; }
 // Forward declaration of `SourceRevision` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct SourceRevision; }
+// Forward declaration of `Device` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Device; }
 
-#include <string>
-#include "Device.hpp"
-#include <optional>
-#include <chrono>
 #include "Heartbeat.hpp"
 #include <vector>
-#include <NitroModules/AnyMap.hpp>
+#include "SampleType.hpp"
+#include <chrono>
+#include "WeatherCondition.hpp"
+#include <optional>
+#include "Quantity.hpp"
+#include "InsulinDeliveryReason.hpp"
+#include "HeartRateMotionContext.hpp"
+#include <string>
 #include "SourceRevision.hpp"
+#include "Device.hpp"
+#include <NitroModules/AnyMap.hpp>
 
 namespace margelo::nitro::healthkit {
 
@@ -46,17 +61,39 @@ namespace margelo::nitro::healthkit {
    */
   struct HeartbeatSeriesSample {
   public:
-    std::string uuid     SWIFT_PRIVATE;
-    std::optional<Device> device     SWIFT_PRIVATE;
+    std::vector<Heartbeat> heartbeats     SWIFT_PRIVATE;
+    SampleType sampleType     SWIFT_PRIVATE;
     std::chrono::system_clock::time_point startDate     SWIFT_PRIVATE;
     std::chrono::system_clock::time_point endDate     SWIFT_PRIVATE;
-    std::vector<Heartbeat> heartbeats     SWIFT_PRIVATE;
-    std::optional<std::shared_ptr<AnyMap>> metadata     SWIFT_PRIVATE;
-    std::optional<SourceRevision> sourceRevision     SWIFT_PRIVATE;
+    bool hasUndeterminedDuration     SWIFT_PRIVATE;
+    std::optional<WeatherCondition> metadataWeatherCondition     SWIFT_PRIVATE;
+    std::optional<Quantity> metadataWeatherHumidity     SWIFT_PRIVATE;
+    std::optional<Quantity> metadataWeatherTemperature     SWIFT_PRIVATE;
+    std::optional<InsulinDeliveryReason> metadataInsulinDeliveryReason     SWIFT_PRIVATE;
+    std::optional<HeartRateMotionContext> metadataHeartRateMotionContext     SWIFT_PRIVATE;
+    std::string uuid     SWIFT_PRIVATE;
+    SourceRevision sourceRevision     SWIFT_PRIVATE;
+    std::optional<Device> device     SWIFT_PRIVATE;
+    std::shared_ptr<AnyMap> metadata     SWIFT_PRIVATE;
+    std::optional<std::string> metadataExternalUUID     SWIFT_PRIVATE;
+    std::optional<std::string> metadataTimeZone     SWIFT_PRIVATE;
+    std::optional<bool> metadataWasUserEntered     SWIFT_PRIVATE;
+    std::optional<std::string> metadataDeviceSerialNumber     SWIFT_PRIVATE;
+    std::optional<std::string> metadataUdiDeviceIdentifier     SWIFT_PRIVATE;
+    std::optional<std::string> metadataUdiProductionIdentifier     SWIFT_PRIVATE;
+    std::optional<std::string> metadataDigitalSignature     SWIFT_PRIVATE;
+    std::optional<std::string> metadataDeviceName     SWIFT_PRIVATE;
+    std::optional<std::string> metadataDeviceManufacturerName     SWIFT_PRIVATE;
+    std::optional<std::string> metadataSyncIdentifier     SWIFT_PRIVATE;
+    std::optional<double> metadataSyncVersion     SWIFT_PRIVATE;
+    std::optional<bool> metadataWasTakenInLab     SWIFT_PRIVATE;
+    std::optional<double> metadataReferenceRangeLowerLimit     SWIFT_PRIVATE;
+    std::optional<double> metadataReferenceRangeUpperLimit     SWIFT_PRIVATE;
+    std::optional<double> metadataAlgorithmVersion     SWIFT_PRIVATE;
 
   public:
     HeartbeatSeriesSample() = default;
-    explicit HeartbeatSeriesSample(std::string uuid, std::optional<Device> device, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, std::vector<Heartbeat> heartbeats, std::optional<std::shared_ptr<AnyMap>> metadata, std::optional<SourceRevision> sourceRevision): uuid(uuid), device(device), startDate(startDate), endDate(endDate), heartbeats(heartbeats), metadata(metadata), sourceRevision(sourceRevision) {}
+    explicit HeartbeatSeriesSample(std::vector<Heartbeat> heartbeats, SampleType sampleType, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, bool hasUndeterminedDuration, std::optional<WeatherCondition> metadataWeatherCondition, std::optional<Quantity> metadataWeatherHumidity, std::optional<Quantity> metadataWeatherTemperature, std::optional<InsulinDeliveryReason> metadataInsulinDeliveryReason, std::optional<HeartRateMotionContext> metadataHeartRateMotionContext, std::string uuid, SourceRevision sourceRevision, std::optional<Device> device, std::shared_ptr<AnyMap> metadata, std::optional<std::string> metadataExternalUUID, std::optional<std::string> metadataTimeZone, std::optional<bool> metadataWasUserEntered, std::optional<std::string> metadataDeviceSerialNumber, std::optional<std::string> metadataUdiDeviceIdentifier, std::optional<std::string> metadataUdiProductionIdentifier, std::optional<std::string> metadataDigitalSignature, std::optional<std::string> metadataDeviceName, std::optional<std::string> metadataDeviceManufacturerName, std::optional<std::string> metadataSyncIdentifier, std::optional<double> metadataSyncVersion, std::optional<bool> metadataWasTakenInLab, std::optional<double> metadataReferenceRangeLowerLimit, std::optional<double> metadataReferenceRangeUpperLimit, std::optional<double> metadataAlgorithmVersion): heartbeats(heartbeats), sampleType(sampleType), startDate(startDate), endDate(endDate), hasUndeterminedDuration(hasUndeterminedDuration), metadataWeatherCondition(metadataWeatherCondition), metadataWeatherHumidity(metadataWeatherHumidity), metadataWeatherTemperature(metadataWeatherTemperature), metadataInsulinDeliveryReason(metadataInsulinDeliveryReason), metadataHeartRateMotionContext(metadataHeartRateMotionContext), uuid(uuid), sourceRevision(sourceRevision), device(device), metadata(metadata), metadataExternalUUID(metadataExternalUUID), metadataTimeZone(metadataTimeZone), metadataWasUserEntered(metadataWasUserEntered), metadataDeviceSerialNumber(metadataDeviceSerialNumber), metadataUdiDeviceIdentifier(metadataUdiDeviceIdentifier), metadataUdiProductionIdentifier(metadataUdiProductionIdentifier), metadataDigitalSignature(metadataDigitalSignature), metadataDeviceName(metadataDeviceName), metadataDeviceManufacturerName(metadataDeviceManufacturerName), metadataSyncIdentifier(metadataSyncIdentifier), metadataSyncVersion(metadataSyncVersion), metadataWasTakenInLab(metadataWasTakenInLab), metadataReferenceRangeLowerLimit(metadataReferenceRangeLowerLimit), metadataReferenceRangeUpperLimit(metadataReferenceRangeUpperLimit), metadataAlgorithmVersion(metadataAlgorithmVersion) {}
   };
 
 } // namespace margelo::nitro::healthkit
@@ -69,24 +106,68 @@ namespace margelo::nitro {
     static inline margelo::nitro::healthkit::HeartbeatSeriesSample fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::healthkit::HeartbeatSeriesSample(
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "uuid")),
-        JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::fromJSI(runtime, obj.getProperty(runtime, "device")),
+        JSIConverter<std::vector<margelo::nitro::healthkit::Heartbeat>>::fromJSI(runtime, obj.getProperty(runtime, "heartbeats")),
+        JSIConverter<margelo::nitro::healthkit::SampleType>::fromJSI(runtime, obj.getProperty(runtime, "sampleType")),
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, "startDate")),
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, "endDate")),
-        JSIConverter<std::vector<margelo::nitro::healthkit::Heartbeat>>::fromJSI(runtime, obj.getProperty(runtime, "heartbeats")),
-        JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::fromJSI(runtime, obj.getProperty(runtime, "metadata")),
-        JSIConverter<std::optional<margelo::nitro::healthkit::SourceRevision>>::fromJSI(runtime, obj.getProperty(runtime, "sourceRevision"))
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "hasUndeterminedDuration")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::WeatherCondition>>::fromJSI(runtime, obj.getProperty(runtime, "metadataWeatherCondition")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "metadataWeatherHumidity")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::fromJSI(runtime, obj.getProperty(runtime, "metadataWeatherTemperature")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::InsulinDeliveryReason>>::fromJSI(runtime, obj.getProperty(runtime, "metadataInsulinDeliveryReason")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::HeartRateMotionContext>>::fromJSI(runtime, obj.getProperty(runtime, "metadataHeartRateMotionContext")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "uuid")),
+        JSIConverter<margelo::nitro::healthkit::SourceRevision>::fromJSI(runtime, obj.getProperty(runtime, "sourceRevision")),
+        JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::fromJSI(runtime, obj.getProperty(runtime, "device")),
+        JSIConverter<std::shared_ptr<AnyMap>>::fromJSI(runtime, obj.getProperty(runtime, "metadata")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataExternalUUID")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataTimeZone")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "metadataWasUserEntered")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataDeviceSerialNumber")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataUdiDeviceIdentifier")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataUdiProductionIdentifier")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataDigitalSignature")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataDeviceName")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataDeviceManufacturerName")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadataSyncIdentifier")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "metadataSyncVersion")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "metadataWasTakenInLab")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "metadataReferenceRangeLowerLimit")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "metadataReferenceRangeUpperLimit")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "metadataAlgorithmVersion"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::healthkit::HeartbeatSeriesSample& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "uuid", JSIConverter<std::string>::toJSI(runtime, arg.uuid));
-      obj.setProperty(runtime, "device", JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::toJSI(runtime, arg.device));
+      obj.setProperty(runtime, "heartbeats", JSIConverter<std::vector<margelo::nitro::healthkit::Heartbeat>>::toJSI(runtime, arg.heartbeats));
+      obj.setProperty(runtime, "sampleType", JSIConverter<margelo::nitro::healthkit::SampleType>::toJSI(runtime, arg.sampleType));
       obj.setProperty(runtime, "startDate", JSIConverter<std::chrono::system_clock::time_point>::toJSI(runtime, arg.startDate));
       obj.setProperty(runtime, "endDate", JSIConverter<std::chrono::system_clock::time_point>::toJSI(runtime, arg.endDate));
-      obj.setProperty(runtime, "heartbeats", JSIConverter<std::vector<margelo::nitro::healthkit::Heartbeat>>::toJSI(runtime, arg.heartbeats));
-      obj.setProperty(runtime, "metadata", JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::toJSI(runtime, arg.metadata));
-      obj.setProperty(runtime, "sourceRevision", JSIConverter<std::optional<margelo::nitro::healthkit::SourceRevision>>::toJSI(runtime, arg.sourceRevision));
+      obj.setProperty(runtime, "hasUndeterminedDuration", JSIConverter<bool>::toJSI(runtime, arg.hasUndeterminedDuration));
+      obj.setProperty(runtime, "metadataWeatherCondition", JSIConverter<std::optional<margelo::nitro::healthkit::WeatherCondition>>::toJSI(runtime, arg.metadataWeatherCondition));
+      obj.setProperty(runtime, "metadataWeatherHumidity", JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::toJSI(runtime, arg.metadataWeatherHumidity));
+      obj.setProperty(runtime, "metadataWeatherTemperature", JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::toJSI(runtime, arg.metadataWeatherTemperature));
+      obj.setProperty(runtime, "metadataInsulinDeliveryReason", JSIConverter<std::optional<margelo::nitro::healthkit::InsulinDeliveryReason>>::toJSI(runtime, arg.metadataInsulinDeliveryReason));
+      obj.setProperty(runtime, "metadataHeartRateMotionContext", JSIConverter<std::optional<margelo::nitro::healthkit::HeartRateMotionContext>>::toJSI(runtime, arg.metadataHeartRateMotionContext));
+      obj.setProperty(runtime, "uuid", JSIConverter<std::string>::toJSI(runtime, arg.uuid));
+      obj.setProperty(runtime, "sourceRevision", JSIConverter<margelo::nitro::healthkit::SourceRevision>::toJSI(runtime, arg.sourceRevision));
+      obj.setProperty(runtime, "device", JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::toJSI(runtime, arg.device));
+      obj.setProperty(runtime, "metadata", JSIConverter<std::shared_ptr<AnyMap>>::toJSI(runtime, arg.metadata));
+      obj.setProperty(runtime, "metadataExternalUUID", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataExternalUUID));
+      obj.setProperty(runtime, "metadataTimeZone", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataTimeZone));
+      obj.setProperty(runtime, "metadataWasUserEntered", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.metadataWasUserEntered));
+      obj.setProperty(runtime, "metadataDeviceSerialNumber", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDeviceSerialNumber));
+      obj.setProperty(runtime, "metadataUdiDeviceIdentifier", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataUdiDeviceIdentifier));
+      obj.setProperty(runtime, "metadataUdiProductionIdentifier", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataUdiProductionIdentifier));
+      obj.setProperty(runtime, "metadataDigitalSignature", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDigitalSignature));
+      obj.setProperty(runtime, "metadataDeviceName", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDeviceName));
+      obj.setProperty(runtime, "metadataDeviceManufacturerName", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDeviceManufacturerName));
+      obj.setProperty(runtime, "metadataSyncIdentifier", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataSyncIdentifier));
+      obj.setProperty(runtime, "metadataSyncVersion", JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataSyncVersion));
+      obj.setProperty(runtime, "metadataWasTakenInLab", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.metadataWasTakenInLab));
+      obj.setProperty(runtime, "metadataReferenceRangeLowerLimit", JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataReferenceRangeLowerLimit));
+      obj.setProperty(runtime, "metadataReferenceRangeUpperLimit", JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataReferenceRangeUpperLimit));
+      obj.setProperty(runtime, "metadataAlgorithmVersion", JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataAlgorithmVersion));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -97,13 +178,35 @@ namespace margelo::nitro {
       if (!nitro::isPlainObject(runtime, obj)) {
         return false;
       }
-      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "uuid"))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::canConvert(runtime, obj.getProperty(runtime, "device"))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::healthkit::Heartbeat>>::canConvert(runtime, obj.getProperty(runtime, "heartbeats"))) return false;
+      if (!JSIConverter<margelo::nitro::healthkit::SampleType>::canConvert(runtime, obj.getProperty(runtime, "sampleType"))) return false;
       if (!JSIConverter<std::chrono::system_clock::time_point>::canConvert(runtime, obj.getProperty(runtime, "startDate"))) return false;
       if (!JSIConverter<std::chrono::system_clock::time_point>::canConvert(runtime, obj.getProperty(runtime, "endDate"))) return false;
-      if (!JSIConverter<std::vector<margelo::nitro::healthkit::Heartbeat>>::canConvert(runtime, obj.getProperty(runtime, "heartbeats"))) return false;
-      if (!JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::canConvert(runtime, obj.getProperty(runtime, "metadata"))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::SourceRevision>>::canConvert(runtime, obj.getProperty(runtime, "sourceRevision"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "hasUndeterminedDuration"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::WeatherCondition>>::canConvert(runtime, obj.getProperty(runtime, "metadataWeatherCondition"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::canConvert(runtime, obj.getProperty(runtime, "metadataWeatherHumidity"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::canConvert(runtime, obj.getProperty(runtime, "metadataWeatherTemperature"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::InsulinDeliveryReason>>::canConvert(runtime, obj.getProperty(runtime, "metadataInsulinDeliveryReason"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::HeartRateMotionContext>>::canConvert(runtime, obj.getProperty(runtime, "metadataHeartRateMotionContext"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "uuid"))) return false;
+      if (!JSIConverter<margelo::nitro::healthkit::SourceRevision>::canConvert(runtime, obj.getProperty(runtime, "sourceRevision"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::canConvert(runtime, obj.getProperty(runtime, "device"))) return false;
+      if (!JSIConverter<std::shared_ptr<AnyMap>>::canConvert(runtime, obj.getProperty(runtime, "metadata"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataExternalUUID"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataTimeZone"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "metadataWasUserEntered"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataDeviceSerialNumber"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataUdiDeviceIdentifier"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataUdiProductionIdentifier"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataDigitalSignature"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataDeviceName"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataDeviceManufacturerName"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadataSyncIdentifier"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "metadataSyncVersion"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "metadataWasTakenInLab"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "metadataReferenceRangeLowerLimit"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "metadataReferenceRangeUpperLimit"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "metadataAlgorithmVersion"))) return false;
       return true;
     }
   };

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

@@ -31,7 +31,6 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include "CategorySample.hpp"
 #include <vector>
 #include "QueryOptionsWithSortOrder.hpp"
-#include <optional>
 #include "CategorySamplesWithAnchorResponse.hpp"
 #include "QueryOptionsWithAnchor.hpp"
 
@@ -67,7 +66,7 @@ namespace margelo::nitro::healthkit {
     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<std::vector<CategorySample>>> queryCategorySamples(CategoryTypeIdentifier identifier, const QueryOptionsWithSortOrder& options) = 0;
       virtual std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>> queryCategorySamplesWithAnchor(CategoryTypeIdentifier identifier, const QueryOptionsWithAnchor& options) = 0;
 
     protected:

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

@@ -21,6 +21,7 @@ namespace margelo::nitro::healthkit {
       prototype.registerHybridMethod("isHealthDataAvailableAsync", &HybridCoreModuleSpec::isHealthDataAvailableAsync);
       prototype.registerHybridMethod("isProtectedDataAvailable", &HybridCoreModuleSpec::isProtectedDataAvailable);
       prototype.registerHybridMethod("isProtectedDataAvailableAsync", &HybridCoreModuleSpec::isProtectedDataAvailableAsync);
+      prototype.registerHybridMethod("currentAppSource", &HybridCoreModuleSpec::currentAppSource);
       prototype.registerHybridMethod("getPreferredUnits", &HybridCoreModuleSpec::getPreferredUnits);
       prototype.registerHybridMethod("querySources", &HybridCoreModuleSpec::querySources);
       prototype.registerHybridMethod("subscribeToObserverQuery", &HybridCoreModuleSpec::subscribeToObserverQuery);

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

@@ -17,14 +17,16 @@
 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 `HybridSourceProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
 // 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 `FilterForSamples` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamples; }
 // Forward declaration of `OnChangeCallbackArgs` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct OnChangeCallbackArgs; }
 // Forward declaration of `AuthorizationStatus` to properly resolve imports.
@@ -33,45 +35,24 @@ namespace margelo::nitro::healthkit { enum class AuthorizationStatus; }
 namespace margelo::nitro::healthkit { enum class AuthorizationRequestStatus; }
 // Forward declaration of `AuthDataTypes` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct AuthDataTypes; }
-// 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 <memory>
+#include "HybridSourceProxySpec.hpp"
 #include "IdentifierWithUnit.hpp"
 #include <vector>
 #include "QuantityTypeIdentifier.hpp"
 #include <optional>
-#include <memory>
-#include "HybridSourceProxySpec.hpp"
 #include "SampleTypeIdentifier.hpp"
+#include "FilterForSamples.hpp"
 #include <string>
 #include "OnChangeCallbackArgs.hpp"
 #include <functional>
 #include "AuthorizationStatus.hpp"
 #include "AuthorizationRequestStatus.hpp"
 #include "AuthDataTypes.hpp"
-#include "PredicateWithUUID.hpp"
-#include "PredicateWithUUIDs.hpp"
-#include "PredicateWithMetadataKey.hpp"
-#include "PredicateWithStartAndEnd.hpp"
-#include "PredicateFromWorkout.hpp"
-#include "FilterForSamplesAnd.hpp"
-#include "FilterForSamplesOr.hpp"
-#include <variant>
 #include <unordered_map>
 
 namespace margelo::nitro::healthkit {
@@ -112,8 +93,9 @@ namespace margelo::nitro::healthkit {
       virtual std::shared_ptr<Promise<bool>> isHealthDataAvailableAsync() = 0;
       virtual bool isProtectedDataAvailable() = 0;
       virtual std::shared_ptr<Promise<bool>> isProtectedDataAvailableAsync() = 0;
+      virtual std::shared_ptr<HybridSourceProxySpec> currentAppSource() = 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<HybridSourceProxySpec>>>> querySources(SampleTypeIdentifier identifier) = 0;
+      virtual std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridSourceProxySpec>>>> querySources(SampleTypeIdentifier identifier, const std::optional<FilterForSamples>& filter) = 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;
@@ -122,7 +104,7 @@ namespace margelo::nitro::healthkit {
       virtual AuthorizationStatus authorizationStatusFor(ObjectTypeIdentifier type) = 0;
       virtual std::shared_ptr<Promise<AuthorizationRequestStatus>> getRequestStatusForAuthorization(const AuthDataTypes& toCheck) = 0;
       virtual std::shared_ptr<Promise<bool>> requestAuthorization(const AuthDataTypes& toRequest) = 0;
-      virtual std::shared_ptr<Promise<double>> deleteObjects(ObjectTypeIdentifier objectTypeIdentifier, const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>& filter) = 0;
+      virtual std::shared_ptr<Promise<double>> deleteObjects(ObjectTypeIdentifier objectTypeIdentifier, const FilterForSamples& 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;

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

@@ -16,6 +16,7 @@ namespace margelo::nitro::healthkit {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("saveCorrelationSample", &HybridCorrelationTypeModuleSpec::saveCorrelationSample);
       prototype.registerHybridMethod("queryCorrelationSamples", &HybridCorrelationTypeModuleSpec::queryCorrelationSamples);
+      prototype.registerHybridMethod("queryCorrelationSamplesWithAnchor", &HybridCorrelationTypeModuleSpec::queryCorrelationSamplesWithAnchor);
     });
   }
 

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

@@ -21,6 +21,12 @@ namespace margelo::nitro::healthkit { struct CategorySampleForSaving; }
 namespace margelo::nitro::healthkit { struct QuantitySampleForSaving; }
 // Forward declaration of `CorrelationSample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct CorrelationSample; }
+// Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `QueryCorrelationSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryCorrelationSamplesWithAnchorResponse; }
+// Forward declaration of `QueryOptionsWithAnchor` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 
 #include <NitroModules/Promise.hpp>
 #include "CorrelationTypeIdentifier.hpp"
@@ -31,6 +37,9 @@ namespace margelo::nitro::healthkit { struct CorrelationSample; }
 #include <chrono>
 #include <NitroModules/AnyMap.hpp>
 #include "CorrelationSample.hpp"
+#include "QueryOptionsWithSortOrder.hpp"
+#include "QueryCorrelationSamplesWithAnchorResponse.hpp"
+#include "QueryOptionsWithAnchor.hpp"
 
 namespace margelo::nitro::healthkit {
 
@@ -64,7 +73,8 @@ namespace margelo::nitro::healthkit {
     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;
+      virtual std::shared_ptr<Promise<std::vector<CorrelationSample>>> queryCorrelationSamples(CorrelationTypeIdentifier typeIdentifier, const QueryOptionsWithSortOrder& options) = 0;
+      virtual std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>> queryCorrelationSamplesWithAnchor(CorrelationTypeIdentifier typeIdentifier, const QueryOptionsWithAnchor& options) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -26,7 +26,6 @@ namespace margelo::nitro::healthkit { struct ECGQueryOptionsWithAnchor; }
 #include <vector>
 #include <NitroModules/Promise.hpp>
 #include "ECGQueryOptionsWithSortOrder.hpp"
-#include <optional>
 #include "ElectrocardiogramSamplesWithAnchorResponse.hpp"
 #include "ECGQueryOptionsWithAnchor.hpp"
 
@@ -61,7 +60,7 @@ namespace margelo::nitro::healthkit {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<std::vector<ElectrocardiogramSample>>> queryElectrocardiogramSamples(const std::optional<ECGQueryOptionsWithSortOrder>& options) = 0;
+      virtual std::shared_ptr<Promise<std::vector<ElectrocardiogramSample>>> queryElectrocardiogramSamples(const ECGQueryOptionsWithSortOrder& options) = 0;
       virtual std::shared_ptr<Promise<ElectrocardiogramSamplesWithAnchorResponse>> queryElectrocardiogramSamplesWithAnchor(const ECGQueryOptionsWithAnchor& options) = 0;
 
     protected:

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

@@ -26,7 +26,6 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include <vector>
 #include <NitroModules/Promise.hpp>
 #include "QueryOptionsWithSortOrder.hpp"
-#include <optional>
 #include "HeartbeatSeriesSamplesWithAnchorResponse.hpp"
 #include "QueryOptionsWithAnchor.hpp"
 
@@ -61,7 +60,7 @@ namespace margelo::nitro::healthkit {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>> queryHeartbeatSeriesSamples(const std::optional<QueryOptionsWithSortOrder>& options) = 0;
+      virtual std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>> queryHeartbeatSeriesSamples(const QueryOptionsWithSortOrder& options) = 0;
       virtual std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>> queryHeartbeatSeriesSamplesWithAnchor(const QueryOptionsWithAnchor& options) = 0;
 
     protected:

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

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

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

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

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

@@ -15,8 +15,8 @@ namespace margelo::nitro::healthkit {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("isQuantityCompatibleWithUnit", &HybridQuantityTypeModuleSpec::isQuantityCompatibleWithUnit);
+      prototype.registerHybridMethod("aggregationStyle", &HybridQuantityTypeModuleSpec::aggregationStyle);
       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);

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

@@ -15,20 +15,8 @@
 
 // Forward declaration of `QuantityTypeIdentifier` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
-// 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 `AggregationStyle` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class AggregationStyle; }
 // Forward declaration of `QuantitySample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QuantitySample; }
 // Forward declaration of `QueryOptionsWithSortOrderAndUnit` to properly resolve imports.
@@ -48,24 +36,17 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndUnit; }
 
 #include "QuantityTypeIdentifier.hpp"
 #include <string>
+#include "AggregationStyle.hpp"
 #include <NitroModules/Promise.hpp>
 #include <chrono>
 #include <NitroModules/AnyMap.hpp>
-#include "PredicateWithUUID.hpp"
-#include "PredicateWithUUIDs.hpp"
-#include "PredicateWithMetadataKey.hpp"
-#include "PredicateWithStartAndEnd.hpp"
-#include "PredicateFromWorkout.hpp"
-#include "FilterForSamplesAnd.hpp"
-#include "FilterForSamplesOr.hpp"
-#include <variant>
 #include "QuantitySample.hpp"
 #include <vector>
 #include "QueryOptionsWithSortOrderAndUnit.hpp"
-#include <optional>
 #include "QueryStatisticsResponse.hpp"
 #include "StatisticsOptions.hpp"
 #include "StatisticsQueryOptions.hpp"
+#include <optional>
 #include "IntervalComponents.hpp"
 #include "QuantitySamplesWithAnchorResponse.hpp"
 #include "QueryOptionsWithAnchorAndUnit.hpp"
@@ -102,9 +83,9 @@ namespace margelo::nitro::healthkit {
     public:
       // Methods
       virtual bool isQuantityCompatibleWithUnit(QuantityTypeIdentifier identifier, const std::string& unit) = 0;
+      virtual AggregationStyle aggregationStyle(QuantityTypeIdentifier identifier) = 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<std::vector<QuantitySample>>> queryQuantitySamples(QuantityTypeIdentifier identifier, const 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, std::chrono::system_clock::time_point anchorDate, const IntervalComponents& intervalComponents, const std::optional<StatisticsQueryOptions>& options) = 0;
       virtual std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>> queryQuantitySamplesWithAnchor(QuantityTypeIdentifier identifier, const QueryOptionsWithAnchorAndUnit& options) = 0;

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

@@ -15,6 +15,7 @@ namespace margelo::nitro::healthkit {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("queryStateOfMindSamples", &HybridStateOfMindModuleSpec::queryStateOfMindSamples);
+      prototype.registerHybridMethod("queryStateOfMindSamplesWithAnchor", &HybridStateOfMindModuleSpec::queryStateOfMindSamplesWithAnchor);
       prototype.registerHybridMethod("saveStateOfMindSample", &HybridStateOfMindModuleSpec::saveStateOfMindSample);
     });
   }