@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

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

@@ -17,6 +17,10 @@
 namespace margelo::nitro::healthkit { struct StateOfMindSample; }
 // Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `StateOfMindSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StateOfMindSamplesWithAnchorResponse; }
+// Forward declaration of `QueryOptionsWithAnchor` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 // Forward declaration of `StateOfMindKind` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class StateOfMindKind; }
 // Forward declaration of `StateOfMindLabel` to properly resolve imports.
@@ -28,12 +32,14 @@ namespace margelo::nitro::healthkit { enum class StateOfMindAssociation; }
 #include <vector>
 #include <NitroModules/Promise.hpp>
 #include "QueryOptionsWithSortOrder.hpp"
-#include <optional>
+#include "StateOfMindSamplesWithAnchorResponse.hpp"
+#include "QueryOptionsWithAnchor.hpp"
 #include <chrono>
 #include "StateOfMindKind.hpp"
 #include "StateOfMindLabel.hpp"
 #include "StateOfMindAssociation.hpp"
 #include <NitroModules/AnyMap.hpp>
+#include <optional>
 
 namespace margelo::nitro::healthkit {
 
@@ -66,7 +72,8 @@ namespace margelo::nitro::healthkit {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<std::vector<StateOfMindSample>>> queryStateOfMindSamples(const std::optional<QueryOptionsWithSortOrder>& options) = 0;
+      virtual std::shared_ptr<Promise<std::vector<StateOfMindSample>>> queryStateOfMindSamples(const QueryOptionsWithSortOrder& options) = 0;
+      virtual std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>> queryStateOfMindSamplesWithAnchor(const QueryOptionsWithAnchor& 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:

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

@@ -14,16 +14,44 @@ namespace margelo::nitro::healthkit {
     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("events", &HybridWorkoutProxySpec::getEvents);
+      prototype.registerHybridGetter("activities", &HybridWorkoutProxySpec::getActivities);
+      prototype.registerHybridGetter("metadataAverageMETs", &HybridWorkoutProxySpec::getMetadataAverageMETs);
+      prototype.registerHybridGetter("metadataElevationAscended", &HybridWorkoutProxySpec::getMetadataElevationAscended);
+      prototype.registerHybridGetter("metadataElevationDescended", &HybridWorkoutProxySpec::getMetadataElevationDescended);
+      prototype.registerHybridGetter("metadataIndoorWorkout", &HybridWorkoutProxySpec::getMetadataIndoorWorkout);
+      prototype.registerHybridGetter("metadataAverageSpeed", &HybridWorkoutProxySpec::getMetadataAverageSpeed);
+      prototype.registerHybridGetter("metadataMaximumSpeed", &HybridWorkoutProxySpec::getMetadataMaximumSpeed);
+      prototype.registerHybridGetter("sampleType", &HybridWorkoutProxySpec::getSampleType);
       prototype.registerHybridGetter("startDate", &HybridWorkoutProxySpec::getStartDate);
       prototype.registerHybridGetter("endDate", &HybridWorkoutProxySpec::getEndDate);
-      prototype.registerHybridGetter("metadata", &HybridWorkoutProxySpec::getMetadata);
+      prototype.registerHybridGetter("hasUndeterminedDuration", &HybridWorkoutProxySpec::getHasUndeterminedDuration);
+      prototype.registerHybridGetter("metadataWeatherCondition", &HybridWorkoutProxySpec::getMetadataWeatherCondition);
+      prototype.registerHybridGetter("metadataWeatherHumidity", &HybridWorkoutProxySpec::getMetadataWeatherHumidity);
+      prototype.registerHybridGetter("metadataWeatherTemperature", &HybridWorkoutProxySpec::getMetadataWeatherTemperature);
+      prototype.registerHybridGetter("metadataInsulinDeliveryReason", &HybridWorkoutProxySpec::getMetadataInsulinDeliveryReason);
+      prototype.registerHybridGetter("metadataHeartRateMotionContext", &HybridWorkoutProxySpec::getMetadataHeartRateMotionContext);
+      prototype.registerHybridGetter("uuid", &HybridWorkoutProxySpec::getUuid);
       prototype.registerHybridGetter("sourceRevision", &HybridWorkoutProxySpec::getSourceRevision);
-      prototype.registerHybridGetter("events", &HybridWorkoutProxySpec::getEvents);
-      prototype.registerHybridGetter("activities", &HybridWorkoutProxySpec::getActivities);
+      prototype.registerHybridGetter("device", &HybridWorkoutProxySpec::getDevice);
+      prototype.registerHybridGetter("metadata", &HybridWorkoutProxySpec::getMetadata);
+      prototype.registerHybridGetter("metadataExternalUUID", &HybridWorkoutProxySpec::getMetadataExternalUUID);
+      prototype.registerHybridGetter("metadataTimeZone", &HybridWorkoutProxySpec::getMetadataTimeZone);
+      prototype.registerHybridGetter("metadataWasUserEntered", &HybridWorkoutProxySpec::getMetadataWasUserEntered);
+      prototype.registerHybridGetter("metadataDeviceSerialNumber", &HybridWorkoutProxySpec::getMetadataDeviceSerialNumber);
+      prototype.registerHybridGetter("metadataUdiDeviceIdentifier", &HybridWorkoutProxySpec::getMetadataUdiDeviceIdentifier);
+      prototype.registerHybridGetter("metadataUdiProductionIdentifier", &HybridWorkoutProxySpec::getMetadataUdiProductionIdentifier);
+      prototype.registerHybridGetter("metadataDigitalSignature", &HybridWorkoutProxySpec::getMetadataDigitalSignature);
+      prototype.registerHybridGetter("metadataDeviceName", &HybridWorkoutProxySpec::getMetadataDeviceName);
+      prototype.registerHybridGetter("metadataDeviceManufacturerName", &HybridWorkoutProxySpec::getMetadataDeviceManufacturerName);
+      prototype.registerHybridGetter("metadataSyncIdentifier", &HybridWorkoutProxySpec::getMetadataSyncIdentifier);
+      prototype.registerHybridGetter("metadataSyncVersion", &HybridWorkoutProxySpec::getMetadataSyncVersion);
+      prototype.registerHybridGetter("metadataWasTakenInLab", &HybridWorkoutProxySpec::getMetadataWasTakenInLab);
+      prototype.registerHybridGetter("metadataReferenceRangeLowerLimit", &HybridWorkoutProxySpec::getMetadataReferenceRangeLowerLimit);
+      prototype.registerHybridGetter("metadataReferenceRangeUpperLimit", &HybridWorkoutProxySpec::getMetadataReferenceRangeUpperLimit);
+      prototype.registerHybridGetter("metadataAlgorithmVersion", &HybridWorkoutProxySpec::getMetadataAlgorithmVersion);
       prototype.registerHybridMethod("toJSON", &HybridWorkoutProxySpec::toJSON);
       prototype.registerHybridMethod("saveWorkoutRoute", &HybridWorkoutProxySpec::saveWorkoutRoute);
       prototype.registerHybridMethod("getWorkoutPlan", &HybridWorkoutProxySpec::getWorkoutPlan);

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

@@ -13,18 +13,26 @@
 #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 `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 `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 `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; }
 // Forward declaration of `WorkoutSample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct WorkoutSample; }
 // Forward declaration of `LocationForSaving` to properly resolve imports.
@@ -38,17 +46,21 @@ namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QuantityTypeIdentifier` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
 
-#include <string>
-#include "Device.hpp"
-#include <optional>
 #include "WorkoutActivityType.hpp"
 #include "Quantity.hpp"
-#include <chrono>
-#include <NitroModules/AnyMap.hpp>
-#include "SourceRevision.hpp"
 #include "WorkoutEvent.hpp"
 #include <vector>
+#include <optional>
 #include "WorkoutActivity.hpp"
+#include "SampleType.hpp"
+#include <chrono>
+#include "WeatherCondition.hpp"
+#include "InsulinDeliveryReason.hpp"
+#include "HeartRateMotionContext.hpp"
+#include <string>
+#include "SourceRevision.hpp"
+#include "Device.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include "WorkoutSample.hpp"
 #include <NitroModules/Promise.hpp>
 #include "LocationForSaving.hpp"
@@ -85,16 +97,44 @@ namespace margelo::nitro::healthkit {
 
     public:
       // Properties
-      virtual std::string getUuid() = 0;
-      virtual std::optional<Device> getDevice() = 0;
       virtual WorkoutActivityType getWorkoutActivityType() = 0;
       virtual Quantity getDuration() = 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;
+      virtual std::optional<Quantity> getMetadataAverageMETs() = 0;
+      virtual std::optional<Quantity> getMetadataElevationAscended() = 0;
+      virtual std::optional<Quantity> getMetadataElevationDescended() = 0;
+      virtual std::optional<bool> getMetadataIndoorWorkout() = 0;
+      virtual std::optional<Quantity> getMetadataAverageSpeed() = 0;
+      virtual std::optional<Quantity> getMetadataMaximumSpeed() = 0;
+      virtual SampleType getSampleType() = 0;
+      virtual std::chrono::system_clock::time_point getStartDate() = 0;
+      virtual std::chrono::system_clock::time_point getEndDate() = 0;
+      virtual bool getHasUndeterminedDuration() = 0;
+      virtual std::optional<WeatherCondition> getMetadataWeatherCondition() = 0;
+      virtual std::optional<Quantity> getMetadataWeatherHumidity() = 0;
+      virtual std::optional<Quantity> getMetadataWeatherTemperature() = 0;
+      virtual std::optional<InsulinDeliveryReason> getMetadataInsulinDeliveryReason() = 0;
+      virtual std::optional<HeartRateMotionContext> getMetadataHeartRateMotionContext() = 0;
+      virtual std::string getUuid() = 0;
+      virtual SourceRevision getSourceRevision() = 0;
+      virtual std::optional<Device> getDevice() = 0;
+      virtual std::shared_ptr<AnyMap> getMetadata() = 0;
+      virtual std::optional<std::string> getMetadataExternalUUID() = 0;
+      virtual std::optional<std::string> getMetadataTimeZone() = 0;
+      virtual std::optional<bool> getMetadataWasUserEntered() = 0;
+      virtual std::optional<std::string> getMetadataDeviceSerialNumber() = 0;
+      virtual std::optional<std::string> getMetadataUdiDeviceIdentifier() = 0;
+      virtual std::optional<std::string> getMetadataUdiProductionIdentifier() = 0;
+      virtual std::optional<std::string> getMetadataDigitalSignature() = 0;
+      virtual std::optional<std::string> getMetadataDeviceName() = 0;
+      virtual std::optional<std::string> getMetadataDeviceManufacturerName() = 0;
+      virtual std::optional<std::string> getMetadataSyncIdentifier() = 0;
+      virtual std::optional<double> getMetadataSyncVersion() = 0;
+      virtual std::optional<bool> getMetadataWasTakenInLab() = 0;
+      virtual std::optional<double> getMetadataReferenceRangeLowerLimit() = 0;
+      virtual std::optional<double> getMetadataReferenceRangeUpperLimit() = 0;
+      virtual std::optional<double> getMetadataAlgorithmVersion() = 0;
 
     public:
       // Methods

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

@@ -0,0 +1,62 @@
+///
+/// InsulinDeliveryReason.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
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (InsulinDeliveryReason).
+   */
+  enum class InsulinDeliveryReason {
+    BASAL      SWIFT_NAME(basal) = 1,
+    BOLUS      SWIFT_NAME(bolus) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::healthkit
+
+namespace margelo::nitro {
+
+  // C++ InsulinDeliveryReason <> JS InsulinDeliveryReason (enum)
+  template <>
+  struct JSIConverter<margelo::nitro::healthkit::InsulinDeliveryReason> final {
+    static inline margelo::nitro::healthkit::InsulinDeliveryReason fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<margelo::nitro::healthkit::InsulinDeliveryReason>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::healthkit::InsulinDeliveryReason arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 1 && integer <= 2;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,93 @@
+///
+/// MedicationConcept.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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `GeneralForm` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class GeneralForm; }
+// Forward declaration of `RelatedCoding` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct RelatedCoding; }
+
+#include <string>
+#include "GeneralForm.hpp"
+#include "RelatedCoding.hpp"
+#include <vector>
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MedicationConcept).
+   */
+  struct MedicationConcept {
+  public:
+    std::string identifier     SWIFT_PRIVATE;
+    std::string displayText     SWIFT_PRIVATE;
+    GeneralForm generalForm     SWIFT_PRIVATE;
+    std::vector<RelatedCoding> relatedCodings     SWIFT_PRIVATE;
+
+  public:
+    MedicationConcept() = default;
+    explicit MedicationConcept(std::string identifier, std::string displayText, GeneralForm generalForm, std::vector<RelatedCoding> relatedCodings): identifier(identifier), displayText(displayText), generalForm(generalForm), relatedCodings(relatedCodings) {}
+  };
+
+} // namespace margelo::nitro::healthkit
+
+namespace margelo::nitro {
+
+  // C++ MedicationConcept <> JS MedicationConcept (object)
+  template <>
+  struct JSIConverter<margelo::nitro::healthkit::MedicationConcept> final {
+    static inline margelo::nitro::healthkit::MedicationConcept fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::healthkit::MedicationConcept(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "identifier")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "displayText")),
+        JSIConverter<margelo::nitro::healthkit::GeneralForm>::fromJSI(runtime, obj.getProperty(runtime, "generalForm")),
+        JSIConverter<std::vector<margelo::nitro::healthkit::RelatedCoding>>::fromJSI(runtime, obj.getProperty(runtime, "relatedCodings"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::healthkit::MedicationConcept& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "identifier", JSIConverter<std::string>::toJSI(runtime, arg.identifier));
+      obj.setProperty(runtime, "displayText", JSIConverter<std::string>::toJSI(runtime, arg.displayText));
+      obj.setProperty(runtime, "generalForm", JSIConverter<margelo::nitro::healthkit::GeneralForm>::toJSI(runtime, arg.generalForm));
+      obj.setProperty(runtime, "relatedCodings", JSIConverter<std::vector<margelo::nitro::healthkit::RelatedCoding>>::toJSI(runtime, arg.relatedCodings));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "identifier"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "displayText"))) return false;
+      if (!JSIConverter<margelo::nitro::healthkit::GeneralForm>::canConvert(runtime, obj.getProperty(runtime, "generalForm"))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::healthkit::RelatedCoding>>::canConvert(runtime, obj.getProperty(runtime, "relatedCodings"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,240 @@
+///
+/// MedicationDoseEvent.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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `MedicationDoseEventScheduleType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class MedicationDoseEventScheduleType; }
+// Forward declaration of `MedicationDoseEventLogStatus` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class MedicationDoseEventLogStatus; }
+// 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 "MedicationDoseEventScheduleType.hpp"
+#include <string>
+#include <chrono>
+#include <optional>
+#include "MedicationDoseEventLogStatus.hpp"
+#include "SampleType.hpp"
+#include "WeatherCondition.hpp"
+#include "Quantity.hpp"
+#include "InsulinDeliveryReason.hpp"
+#include "HeartRateMotionContext.hpp"
+#include "SourceRevision.hpp"
+#include "Device.hpp"
+#include <NitroModules/AnyMap.hpp>
+
+namespace margelo::nitro::healthkit {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MedicationDoseEvent).
+   */
+  struct MedicationDoseEvent {
+  public:
+    MedicationDoseEventScheduleType scheduleType     SWIFT_PRIVATE;
+    std::string medicationConceptIdentifier     SWIFT_PRIVATE;
+    std::optional<std::chrono::system_clock::time_point> scheduledDate     SWIFT_PRIVATE;
+    std::optional<double> scheduledDoseQuantity     SWIFT_PRIVATE;
+    std::optional<double> doseQuantity     SWIFT_PRIVATE;
+    MedicationDoseEventLogStatus logStatus     SWIFT_PRIVATE;
+    std::string unit     SWIFT_PRIVATE;
+    SampleType sampleType     SWIFT_PRIVATE;
+    std::chrono::system_clock::time_point startDate     SWIFT_PRIVATE;
+    std::chrono::system_clock::time_point endDate     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:
+    MedicationDoseEvent() = default;
+    explicit MedicationDoseEvent(MedicationDoseEventScheduleType scheduleType, std::string medicationConceptIdentifier, std::optional<std::chrono::system_clock::time_point> scheduledDate, std::optional<double> scheduledDoseQuantity, std::optional<double> doseQuantity, MedicationDoseEventLogStatus logStatus, std::string unit, 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): scheduleType(scheduleType), medicationConceptIdentifier(medicationConceptIdentifier), scheduledDate(scheduledDate), scheduledDoseQuantity(scheduledDoseQuantity), doseQuantity(doseQuantity), logStatus(logStatus), unit(unit), 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
+
+namespace margelo::nitro {
+
+  // C++ MedicationDoseEvent <> JS MedicationDoseEvent (object)
+  template <>
+  struct JSIConverter<margelo::nitro::healthkit::MedicationDoseEvent> final {
+    static inline margelo::nitro::healthkit::MedicationDoseEvent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::healthkit::MedicationDoseEvent(
+        JSIConverter<margelo::nitro::healthkit::MedicationDoseEventScheduleType>::fromJSI(runtime, obj.getProperty(runtime, "scheduleType")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "medicationConceptIdentifier")),
+        JSIConverter<std::optional<std::chrono::system_clock::time_point>>::fromJSI(runtime, obj.getProperty(runtime, "scheduledDate")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "scheduledDoseQuantity")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "doseQuantity")),
+        JSIConverter<margelo::nitro::healthkit::MedicationDoseEventLogStatus>::fromJSI(runtime, obj.getProperty(runtime, "logStatus")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "unit")),
+        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<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::MedicationDoseEvent& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "scheduleType", JSIConverter<margelo::nitro::healthkit::MedicationDoseEventScheduleType>::toJSI(runtime, arg.scheduleType));
+      obj.setProperty(runtime, "medicationConceptIdentifier", JSIConverter<std::string>::toJSI(runtime, arg.medicationConceptIdentifier));
+      obj.setProperty(runtime, "scheduledDate", JSIConverter<std::optional<std::chrono::system_clock::time_point>>::toJSI(runtime, arg.scheduledDate));
+      obj.setProperty(runtime, "scheduledDoseQuantity", JSIConverter<std::optional<double>>::toJSI(runtime, arg.scheduledDoseQuantity));
+      obj.setProperty(runtime, "doseQuantity", JSIConverter<std::optional<double>>::toJSI(runtime, arg.doseQuantity));
+      obj.setProperty(runtime, "logStatus", JSIConverter<margelo::nitro::healthkit::MedicationDoseEventLogStatus>::toJSI(runtime, arg.logStatus));
+      obj.setProperty(runtime, "unit", JSIConverter<std::string>::toJSI(runtime, arg.unit));
+      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, "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) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<margelo::nitro::healthkit::MedicationDoseEventScheduleType>::canConvert(runtime, obj.getProperty(runtime, "scheduleType"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "medicationConceptIdentifier"))) return false;
+      if (!JSIConverter<std::optional<std::chrono::system_clock::time_point>>::canConvert(runtime, obj.getProperty(runtime, "scheduledDate"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "scheduledDoseQuantity"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "doseQuantity"))) return false;
+      if (!JSIConverter<margelo::nitro::healthkit::MedicationDoseEventLogStatus>::canConvert(runtime, obj.getProperty(runtime, "logStatus"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "unit"))) 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<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;
+    }
+  };
+
+} // namespace margelo::nitro