@kingstinct/react-native-healthkit 13.1.4 → 13.2.1

package/nitrogen/generated/ios/swift/WorkoutSample.swift

@@ -19,8 +19,32 @@ public extension WorkoutSample {
   /**
    * Create a new instance of `WorkoutSample`.
    */
-  init(workoutActivityType: WorkoutActivityType, duration: Quantity, events: [WorkoutEvent]?, activities: [WorkoutActivity]?, metadataAverageMETs: Quantity?, metadataElevationAscended: Quantity?, metadataElevationDescended: Quantity?, metadataIndoorWorkout: Bool?, metadataAverageSpeed: Quantity?, metadataMaximumSpeed: Quantity?, sampleType: SampleType, startDate: Date, endDate: Date, hasUndeterminedDuration: Bool, metadataWeatherCondition: WeatherCondition?, metadataWeatherHumidity: Quantity?, metadataWeatherTemperature: Quantity?, metadataInsulinDeliveryReason: InsulinDeliveryReason?, metadataHeartRateMotionContext: HeartRateMotionContext?, uuid: String, sourceRevision: SourceRevision, device: Device?, metadata: AnyMap, metadataExternalUUID: String?, metadataTimeZone: String?, metadataWasUserEntered: Bool?, metadataDeviceSerialNumber: String?, metadataUdiDeviceIdentifier: String?, metadataUdiProductionIdentifier: String?, metadataDigitalSignature: String?, metadataDeviceName: String?, metadataDeviceManufacturerName: String?, metadataSyncIdentifier: String?, metadataSyncVersion: Double?, metadataWasTakenInLab: Bool?, metadataReferenceRangeLowerLimit: Double?, metadataReferenceRangeUpperLimit: Double?, metadataAlgorithmVersion: Double?) {
-    self.init(workoutActivityType, duration, { () -> bridge.std__optional_std__vector_WorkoutEvent__ in
+  init(workoutActivityType: WorkoutActivityType, duration: Quantity, totalEnergyBurned: Quantity?, totalDistance: Quantity?, totalSwimmingStrokeCount: Quantity?, totalFlightsClimbed: Quantity?, events: [WorkoutEvent]?, activities: [WorkoutActivity]?, metadataAverageMETs: Quantity?, metadataElevationAscended: Quantity?, metadataElevationDescended: Quantity?, metadataIndoorWorkout: Bool?, metadataAverageSpeed: Quantity?, metadataMaximumSpeed: Quantity?, sampleType: SampleType, startDate: Date, endDate: Date, hasUndeterminedDuration: Bool, metadataWeatherCondition: WeatherCondition?, metadataWeatherHumidity: Quantity?, metadataWeatherTemperature: Quantity?, metadataInsulinDeliveryReason: InsulinDeliveryReason?, metadataHeartRateMotionContext: HeartRateMotionContext?, uuid: String, sourceRevision: SourceRevision, device: Device?, metadata: AnyMap, metadataExternalUUID: String?, metadataTimeZone: String?, metadataWasUserEntered: Bool?, metadataDeviceSerialNumber: String?, metadataUdiDeviceIdentifier: String?, metadataUdiProductionIdentifier: String?, metadataDigitalSignature: String?, metadataDeviceName: String?, metadataDeviceManufacturerName: String?, metadataSyncIdentifier: String?, metadataSyncVersion: Double?, metadataWasTakenInLab: Bool?, metadataReferenceRangeLowerLimit: Double?, metadataReferenceRangeUpperLimit: Double?, metadataAlgorithmVersion: Double?) {
+    self.init(workoutActivityType, duration, { () -> bridge.std__optional_Quantity_ in
+      if let __unwrappedValue = totalEnergyBurned {
+        return bridge.create_std__optional_Quantity_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_Quantity_ in
+      if let __unwrappedValue = totalDistance {
+        return bridge.create_std__optional_Quantity_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_Quantity_ in
+      if let __unwrappedValue = totalSwimmingStrokeCount {
+        return bridge.create_std__optional_Quantity_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_Quantity_ in
+      if let __unwrappedValue = totalFlightsClimbed {
+        return bridge.create_std__optional_Quantity_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__vector_WorkoutEvent__ in
       if let __unwrappedValue = events {
         return bridge.create_std__optional_std__vector_WorkoutEvent__({ () -> bridge.std__vector_WorkoutEvent_ in
           var __vector = bridge.create_std__vector_WorkoutEvent_(__unwrappedValue.count)
@@ -231,6 +255,74 @@ public extension WorkoutSample {
     }
   }
   
+  var totalEnergyBurned: Quantity? {
+    @inline(__always)
+    get {
+      return self.__totalEnergyBurned.value
+    }
+    @inline(__always)
+    set {
+      self.__totalEnergyBurned = { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var totalDistance: Quantity? {
+    @inline(__always)
+    get {
+      return self.__totalDistance.value
+    }
+    @inline(__always)
+    set {
+      self.__totalDistance = { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var totalSwimmingStrokeCount: Quantity? {
+    @inline(__always)
+    get {
+      return self.__totalSwimmingStrokeCount.value
+    }
+    @inline(__always)
+    set {
+      self.__totalSwimmingStrokeCount = { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var totalFlightsClimbed: Quantity? {
+    @inline(__always)
+    get {
+      return self.__totalFlightsClimbed.value
+    }
+    @inline(__always)
+    set {
+      self.__totalFlightsClimbed = { () -> bridge.std__optional_Quantity_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_Quantity_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
   var events: [WorkoutEvent]? {
     @inline(__always)
     get {

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

@@ -93,6 +93,11 @@ namespace margelo::nitro::healthkit {
     HKCATEGORYTYPEIDENTIFIERWHEEZING      SWIFT_NAME(hkcategorytypeidentifierwheezing) = 61,
     HKCATEGORYTYPEIDENTIFIERBLEEDINGAFTERPREGNANCY      SWIFT_NAME(hkcategorytypeidentifierbleedingafterpregnancy) = 62,
     HKCATEGORYTYPEIDENTIFIERBLEEDINGDURINGPREGNANCY      SWIFT_NAME(hkcategorytypeidentifierbleedingduringpregnancy) = 63,
+    HKCATEGORYTYPEIDENTIFIERINFREQUENTMENSTRUALCYCLES      SWIFT_NAME(hkcategorytypeidentifierinfrequentmenstrualcycles) = 64,
+    HKCATEGORYTYPEIDENTIFIERIRREGULARMENSTRUALCYCLES      SWIFT_NAME(hkcategorytypeidentifierirregularmenstrualcycles) = 65,
+    HKCATEGORYTYPEIDENTIFIERPERSISTENTINTERMENSTRUALBLEEDING      SWIFT_NAME(hkcategorytypeidentifierpersistentintermenstrualbleeding) = 66,
+    HKCATEGORYTYPEIDENTIFIERPROLONGEDMENSTRUALPERIODS      SWIFT_NAME(hkcategorytypeidentifierprolongedmenstrualperiods) = 67,
+    HKCATEGORYTYPEIDENTIFIERSLEEPAPNEAEVENT      SWIFT_NAME(hkcategorytypeidentifiersleepapneaevent) = 68,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::healthkit
@@ -169,6 +174,11 @@ namespace margelo::nitro {
         case hashString("HKCategoryTypeIdentifierWheezing"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERWHEEZING;
         case hashString("HKCategoryTypeIdentifierBleedingAfterPregnancy"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERBLEEDINGAFTERPREGNANCY;
         case hashString("HKCategoryTypeIdentifierBleedingDuringPregnancy"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERBLEEDINGDURINGPREGNANCY;
+        case hashString("HKCategoryTypeIdentifierInfrequentMenstrualCycles"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERINFREQUENTMENSTRUALCYCLES;
+        case hashString("HKCategoryTypeIdentifierIrregularMenstrualCycles"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERIRREGULARMENSTRUALCYCLES;
+        case hashString("HKCategoryTypeIdentifierPersistentIntermenstrualBleeding"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERPERSISTENTINTERMENSTRUALBLEEDING;
+        case hashString("HKCategoryTypeIdentifierProlongedMenstrualPeriods"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERPROLONGEDMENSTRUALPERIODS;
+        case hashString("HKCategoryTypeIdentifierSleepApneaEvent"): return margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERSLEEPAPNEAEVENT;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum CategoryTypeIdentifier - invalid value!");
       }
@@ -239,6 +249,11 @@ namespace margelo::nitro {
         case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERWHEEZING: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierWheezing");
         case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERBLEEDINGAFTERPREGNANCY: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierBleedingAfterPregnancy");
         case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERBLEEDINGDURINGPREGNANCY: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierBleedingDuringPregnancy");
+        case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERINFREQUENTMENSTRUALCYCLES: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierInfrequentMenstrualCycles");
+        case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERIRREGULARMENSTRUALCYCLES: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierIrregularMenstrualCycles");
+        case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERPERSISTENTINTERMENSTRUALBLEEDING: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierPersistentIntermenstrualBleeding");
+        case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERPROLONGEDMENSTRUALPERIODS: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierProlongedMenstrualPeriods");
+        case margelo::nitro::healthkit::CategoryTypeIdentifier::HKCATEGORYTYPEIDENTIFIERSLEEPAPNEAEVENT: return JSIConverter<std::string>::toJSI(runtime, "HKCategoryTypeIdentifierSleepApneaEvent");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert CategoryTypeIdentifier to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -314,6 +329,11 @@ namespace margelo::nitro {
         case hashString("HKCategoryTypeIdentifierWheezing"):
         case hashString("HKCategoryTypeIdentifierBleedingAfterPregnancy"):
         case hashString("HKCategoryTypeIdentifierBleedingDuringPregnancy"):
+        case hashString("HKCategoryTypeIdentifierInfrequentMenstrualCycles"):
+        case hashString("HKCategoryTypeIdentifierIrregularMenstrualCycles"):
+        case hashString("HKCategoryTypeIdentifierPersistentIntermenstrualBleeding"):
+        case hashString("HKCategoryTypeIdentifierProlongedMenstrualPeriods"):
+        case hashString("HKCategoryTypeIdentifierSleepApneaEvent"):
           return true;
         default:
           return false;

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

@@ -16,6 +16,10 @@ namespace margelo::nitro::healthkit {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridGetter("workoutActivityType", &HybridWorkoutProxySpec::getWorkoutActivityType);
       prototype.registerHybridGetter("duration", &HybridWorkoutProxySpec::getDuration);
+      prototype.registerHybridGetter("totalEnergyBurned", &HybridWorkoutProxySpec::getTotalEnergyBurned);
+      prototype.registerHybridGetter("totalDistance", &HybridWorkoutProxySpec::getTotalDistance);
+      prototype.registerHybridGetter("totalSwimmingStrokeCount", &HybridWorkoutProxySpec::getTotalSwimmingStrokeCount);
+      prototype.registerHybridGetter("totalFlightsClimbed", &HybridWorkoutProxySpec::getTotalFlightsClimbed);
       prototype.registerHybridGetter("events", &HybridWorkoutProxySpec::getEvents);
       prototype.registerHybridGetter("activities", &HybridWorkoutProxySpec::getActivities);
       prototype.registerHybridGetter("metadataAverageMETs", &HybridWorkoutProxySpec::getMetadataAverageMETs);

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

@@ -48,9 +48,9 @@ namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
 
 #include "WorkoutActivityType.hpp"
 #include "Quantity.hpp"
+#include <optional>
 #include "WorkoutEvent.hpp"
 #include <vector>
-#include <optional>
 #include "WorkoutActivity.hpp"
 #include "SampleType.hpp"
 #include <chrono>
@@ -99,6 +99,10 @@ namespace margelo::nitro::healthkit {
       // Properties
       virtual WorkoutActivityType getWorkoutActivityType() = 0;
       virtual Quantity getDuration() = 0;
+      virtual std::optional<Quantity> getTotalEnergyBurned() = 0;
+      virtual std::optional<Quantity> getTotalDistance() = 0;
+      virtual std::optional<Quantity> getTotalSwimmingStrokeCount() = 0;
+      virtual std::optional<Quantity> getTotalFlightsClimbed() = 0;
       virtual std::optional<std::vector<WorkoutEvent>> getEvents() = 0;
       virtual std::optional<std::vector<WorkoutActivity>> getActivities() = 0;
       virtual std::optional<Quantity> getMetadataAverageMETs() = 0;

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

@@ -44,8 +44,8 @@ namespace margelo::nitro::healthkit { struct Device; }
 
 #include "MedicationDoseEventScheduleType.hpp"
 #include <string>
-#include <chrono>
 #include <optional>
+#include <chrono>
 #include "MedicationDoseEventLogStatus.hpp"
 #include "SampleType.hpp"
 #include "WeatherCondition.hpp"
@@ -65,6 +65,7 @@ namespace margelo::nitro::healthkit {
   public:
     MedicationDoseEventScheduleType scheduleType     SWIFT_PRIVATE;
     std::string medicationConceptIdentifier     SWIFT_PRIVATE;
+    std::optional<std::string> medicationDisplayText     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;
@@ -101,7 +102,7 @@ namespace margelo::nitro::healthkit {
 
   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) {}
+    explicit MedicationDoseEvent(MedicationDoseEventScheduleType scheduleType, std::string medicationConceptIdentifier, std::optional<std::string> medicationDisplayText, 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), medicationDisplayText(medicationDisplayText), 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
@@ -116,6 +117,7 @@ namespace margelo::nitro {
       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::string>>::fromJSI(runtime, obj.getProperty(runtime, "medicationDisplayText")),
         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")),
@@ -155,6 +157,7 @@ namespace margelo::nitro {
       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, "medicationDisplayText", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.medicationDisplayText));
       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));
@@ -200,6 +203,7 @@ namespace margelo::nitro {
       }
       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::string>>::canConvert(runtime, obj.getProperty(runtime, "medicationDisplayText"))) 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;