@kingstinct/react-native-healthkit 13.4.0 → 14.0.0

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

@@ -15,6 +15,8 @@
 
 // Forward declaration of `CategorySample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct CategorySample; }
+// Forward declaration of `CategoryTypeIdentifierWriteable` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class CategoryTypeIdentifierWriteable; }
 // Forward declaration of `CategoryTypeIdentifier` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class CategoryTypeIdentifier; }
 // Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
@@ -27,10 +29,11 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include "CategorySample.hpp"
 #include <optional>
 #include <NitroModules/Promise.hpp>
-#include "CategoryTypeIdentifier.hpp"
+#include "CategoryTypeIdentifierWriteable.hpp"
 #include <chrono>
 #include <NitroModules/AnyMap.hpp>
 #include <vector>
+#include "CategoryTypeIdentifier.hpp"
 #include "QueryOptionsWithSortOrder.hpp"
 #include "CategorySamplesWithAnchorResponse.hpp"
 #include "QueryOptionsWithAnchor.hpp"
@@ -66,7 +69,7 @@ namespace margelo::nitro::healthkit {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<std::optional<CategorySample>>> saveCategorySample(CategoryTypeIdentifier identifier, double value, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const std::optional<std::shared_ptr<AnyMap>>& metadata) = 0;
+      virtual std::shared_ptr<Promise<std::optional<CategorySample>>> saveCategorySample(CategoryTypeIdentifierWriteable identifier, double value, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const std::optional<std::shared_ptr<AnyMap>>& metadata) = 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;
 

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

@@ -17,6 +17,8 @@ namespace margelo::nitro::healthkit {
       prototype.registerHybridMethod("enableBackgroundDelivery", &HybridCoreModuleSpec::enableBackgroundDelivery);
       prototype.registerHybridMethod("disableBackgroundDelivery", &HybridCoreModuleSpec::disableBackgroundDelivery);
       prototype.registerHybridMethod("disableAllBackgroundDelivery", &HybridCoreModuleSpec::disableAllBackgroundDelivery);
+      prototype.registerHybridMethod("configureBackgroundTypes", &HybridCoreModuleSpec::configureBackgroundTypes);
+      prototype.registerHybridMethod("clearBackgroundTypes", &HybridCoreModuleSpec::clearBackgroundTypes);
       prototype.registerHybridMethod("isHealthDataAvailable", &HybridCoreModuleSpec::isHealthDataAvailable);
       prototype.registerHybridMethod("isHealthDataAvailableAsync", &HybridCoreModuleSpec::isHealthDataAvailableAsync);
       prototype.registerHybridMethod("isProtectedDataAvailable", &HybridCoreModuleSpec::isProtectedDataAvailable);

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

@@ -43,15 +43,15 @@ namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable;
 #include <NitroModules/Promise.hpp>
 #include "ObjectTypeIdentifier.hpp"
 #include "UpdateFrequency.hpp"
+#include <string>
+#include <vector>
 #include <memory>
 #include "HybridSourceProxySpec.hpp"
 #include "IdentifierWithUnit.hpp"
-#include <vector>
 #include "QuantityTypeIdentifier.hpp"
 #include <optional>
 #include "SampleTypeIdentifier.hpp"
 #include "FilterForSamples.hpp"
-#include <string>
 #include "OnChangeCallbackArgs.hpp"
 #include <functional>
 #include "AuthorizationStatus.hpp"
@@ -95,6 +95,8 @@ namespace margelo::nitro::healthkit {
       virtual std::shared_ptr<Promise<bool>> enableBackgroundDelivery(ObjectTypeIdentifier typeIdentifier, UpdateFrequency updateFrequency) = 0;
       virtual std::shared_ptr<Promise<bool>> disableBackgroundDelivery(ObjectTypeIdentifier typeIdentifier) = 0;
       virtual std::shared_ptr<Promise<bool>> disableAllBackgroundDelivery() = 0;
+      virtual std::shared_ptr<Promise<bool>> configureBackgroundTypes(const std::vector<std::string>& typeIdentifiers, UpdateFrequency updateFrequency) = 0;
+      virtual std::shared_ptr<Promise<bool>> clearBackgroundTypes() = 0;
       virtual bool isHealthDataAvailable() = 0;
       virtual std::shared_ptr<Promise<bool>> isHealthDataAvailableAsync() = 0;
       virtual bool isProtectedDataAvailable() = 0;

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

@@ -21,22 +21,22 @@ namespace margelo::nitro::healthkit { enum class AggregationStyle; }
 namespace margelo::nitro::healthkit { struct QuantitySample; }
 // Forward declaration of `QuantityTypeIdentifierWriteable` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifierWriteable; }
-// Forward declaration of `QueryOptionsWithSortOrderAndUnit` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrderAndUnit; }
+// Forward declaration of `QueryOptionsWithSortOrderAndStringUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrderAndStringUnit; }
 // Forward declaration of `QueryStatisticsResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `StatisticsOptions` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class StatisticsOptions; }
-// Forward declaration of `StatisticsQueryOptions` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct StatisticsQueryOptions; }
+// Forward declaration of `StatisticsQueryOptionsWithStringUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StatisticsQueryOptionsWithStringUnit; }
 // Forward declaration of `IntervalComponents` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct IntervalComponents; }
 // Forward declaration of `QueryStatisticsResponseFromSingleSource` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponseFromSingleSource; }
 // Forward declaration of `QuantitySamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QuantitySamplesWithAnchorResponse; }
-// Forward declaration of `QueryOptionsWithAnchorAndUnit` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndUnit; }
+// Forward declaration of `QueryOptionsWithAnchorAndStringUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndStringUnit; }
 
 #include "QuantityTypeIdentifier.hpp"
 #include <string>
@@ -48,14 +48,14 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndUnit; }
 #include <chrono>
 #include <NitroModules/AnyMap.hpp>
 #include <vector>
-#include "QueryOptionsWithSortOrderAndUnit.hpp"
+#include "QueryOptionsWithSortOrderAndStringUnit.hpp"
 #include "QueryStatisticsResponse.hpp"
 #include "StatisticsOptions.hpp"
-#include "StatisticsQueryOptions.hpp"
+#include "StatisticsQueryOptionsWithStringUnit.hpp"
 #include "IntervalComponents.hpp"
 #include "QueryStatisticsResponseFromSingleSource.hpp"
 #include "QuantitySamplesWithAnchorResponse.hpp"
-#include "QueryOptionsWithAnchorAndUnit.hpp"
+#include "QueryOptionsWithAnchorAndStringUnit.hpp"
 
 namespace margelo::nitro::healthkit {
 
@@ -91,12 +91,12 @@ namespace margelo::nitro::healthkit {
       virtual bool isQuantityCompatibleWithUnit(QuantityTypeIdentifier identifier, const std::string& unit) = 0;
       virtual AggregationStyle aggregationStyle(QuantityTypeIdentifier identifier) = 0;
       virtual std::shared_ptr<Promise<std::optional<QuantitySample>>> saveQuantitySample(QuantityTypeIdentifierWriteable identifier, const std::string& unit, double value, std::chrono::system_clock::time_point start, std::chrono::system_clock::time_point end, const std::optional<std::shared_ptr<AnyMap>>& metadata) = 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<std::vector<QueryStatisticsResponseFromSingleSource>>> queryStatisticsForQuantitySeparateBySource(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, const std::optional<StatisticsQueryOptions>& options) = 0;
-      virtual std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>> queryStatisticsCollectionForQuantitySeparateBySource(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;
+      virtual std::shared_ptr<Promise<std::vector<QuantitySample>>> queryQuantitySamples(QuantityTypeIdentifier identifier, const QueryOptionsWithSortOrderAndStringUnit& options) = 0;
+      virtual std::shared_ptr<Promise<QueryStatisticsResponse>> queryStatisticsForQuantity(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, const std::optional<StatisticsQueryOptionsWithStringUnit>& 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<StatisticsQueryOptionsWithStringUnit>& options) = 0;
+      virtual std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>> queryStatisticsForQuantitySeparateBySource(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, const std::optional<StatisticsQueryOptionsWithStringUnit>& options) = 0;
+      virtual std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>> queryStatisticsCollectionForQuantitySeparateBySource(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, std::chrono::system_clock::time_point anchorDate, const IntervalComponents& intervalComponents, const std::optional<StatisticsQueryOptionsWithStringUnit>& options) = 0;
+      virtual std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>> queryQuantitySamplesWithAnchor(QuantityTypeIdentifier identifier, const QueryOptionsWithAnchorAndStringUnit& options) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -22,40 +22,14 @@ namespace margelo::nitro::healthkit {
       prototype.registerHybridGetter("totalFlightsClimbed", &HybridWorkoutProxySpec::getTotalFlightsClimbed);
       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("metadata", &HybridWorkoutProxySpec::getMetadata);
       prototype.registerHybridGetter("sampleType", &HybridWorkoutProxySpec::getSampleType);
       prototype.registerHybridGetter("startDate", &HybridWorkoutProxySpec::getStartDate);
       prototype.registerHybridGetter("endDate", &HybridWorkoutProxySpec::getEndDate);
       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("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

@@ -23,12 +23,6 @@ namespace margelo::nitro::healthkit { struct WorkoutEvent; }
 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.
@@ -52,15 +46,12 @@ namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
 #include "WorkoutEvent.hpp"
 #include <vector>
 #include "WorkoutActivity.hpp"
+#include <NitroModules/AnyMap.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"
@@ -105,40 +96,14 @@ namespace margelo::nitro::healthkit {
       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;
-      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 std::shared_ptr<AnyMap> getMetadata() = 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++/MedicationDoseEvent.hpp

@@ -34,14 +34,6 @@ namespace margelo::nitro::healthkit { enum class MedicationDoseEventScheduleType
 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.
@@ -53,13 +45,9 @@ namespace margelo::nitro::healthkit { struct Device; }
 #include <chrono>
 #include "MedicationDoseEventLogStatus.hpp"
 #include "SampleType.hpp"
-#include "WeatherCondition.hpp"
-#include "Quantity.hpp"
-#include "InsulinDeliveryReason.hpp"
-#include "HeartRateMotionContext.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include "SourceRevision.hpp"
 #include "Device.hpp"
-#include <NitroModules/AnyMap.hpp>
 
 namespace margelo::nitro::healthkit {
 
@@ -80,34 +68,14 @@ namespace margelo::nitro::healthkit {
     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::shared_ptr<AnyMap> metadata     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::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) {}
+    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::shared_ptr<AnyMap> metadata, std::string uuid, SourceRevision sourceRevision, std::optional<Device> device): scheduleType(scheduleType), medicationConceptIdentifier(medicationConceptIdentifier), medicationDisplayText(medicationDisplayText), scheduledDate(scheduledDate), scheduledDoseQuantity(scheduledDoseQuantity), doseQuantity(doseQuantity), logStatus(logStatus), unit(unit), sampleType(sampleType), startDate(startDate), endDate(endDate), hasUndeterminedDuration(hasUndeterminedDuration), metadata(metadata), uuid(uuid), sourceRevision(sourceRevision), device(device) {}
 
   public:
     friend bool operator==(const MedicationDoseEvent& lhs, const MedicationDoseEvent& rhs) = default;
@@ -135,30 +103,10 @@ namespace margelo::nitro {
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "startDate"))),
         JSIConverter<std::chrono::system_clock::time_point>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "endDate"))),
         JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hasUndeterminedDuration"))),
-        JSIConverter<std::optional<margelo::nitro::healthkit::WeatherCondition>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherCondition"))),
-        JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherHumidity"))),
-        JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherTemperature"))),
-        JSIConverter<std::optional<margelo::nitro::healthkit::InsulinDeliveryReason>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataInsulinDeliveryReason"))),
-        JSIConverter<std::optional<margelo::nitro::healthkit::HeartRateMotionContext>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataHeartRateMotionContext"))),
+        JSIConverter<std::shared_ptr<AnyMap>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadata"))),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uuid"))),
         JSIConverter<margelo::nitro::healthkit::SourceRevision>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "sourceRevision"))),
-        JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "device"))),
-        JSIConverter<std::shared_ptr<AnyMap>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadata"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataExternalUUID"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataTimeZone"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWasUserEntered"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceSerialNumber"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataUdiDeviceIdentifier"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataUdiProductionIdentifier"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDigitalSignature"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceName"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceManufacturerName"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataSyncIdentifier"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataSyncVersion"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWasTakenInLab"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataReferenceRangeLowerLimit"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataReferenceRangeUpperLimit"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataAlgorithmVersion")))
+        JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "device")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::healthkit::MedicationDoseEvent& arg) {
@@ -175,30 +123,10 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "startDate"), JSIConverter<std::chrono::system_clock::time_point>::toJSI(runtime, arg.startDate));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "endDate"), JSIConverter<std::chrono::system_clock::time_point>::toJSI(runtime, arg.endDate));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "hasUndeterminedDuration"), JSIConverter<bool>::toJSI(runtime, arg.hasUndeterminedDuration));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherCondition"), JSIConverter<std::optional<margelo::nitro::healthkit::WeatherCondition>>::toJSI(runtime, arg.metadataWeatherCondition));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherHumidity"), JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::toJSI(runtime, arg.metadataWeatherHumidity));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherTemperature"), JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::toJSI(runtime, arg.metadataWeatherTemperature));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataInsulinDeliveryReason"), JSIConverter<std::optional<margelo::nitro::healthkit::InsulinDeliveryReason>>::toJSI(runtime, arg.metadataInsulinDeliveryReason));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataHeartRateMotionContext"), JSIConverter<std::optional<margelo::nitro::healthkit::HeartRateMotionContext>>::toJSI(runtime, arg.metadataHeartRateMotionContext));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadata"), JSIConverter<std::shared_ptr<AnyMap>>::toJSI(runtime, arg.metadata));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "uuid"), JSIConverter<std::string>::toJSI(runtime, arg.uuid));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "sourceRevision"), JSIConverter<margelo::nitro::healthkit::SourceRevision>::toJSI(runtime, arg.sourceRevision));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "device"), JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::toJSI(runtime, arg.device));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadata"), JSIConverter<std::shared_ptr<AnyMap>>::toJSI(runtime, arg.metadata));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataExternalUUID"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataExternalUUID));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataTimeZone"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataTimeZone));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataWasUserEntered"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.metadataWasUserEntered));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceSerialNumber"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDeviceSerialNumber));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataUdiDeviceIdentifier"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataUdiDeviceIdentifier));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataUdiProductionIdentifier"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataUdiProductionIdentifier));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataDigitalSignature"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDigitalSignature));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceName"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDeviceName));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceManufacturerName"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataDeviceManufacturerName));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataSyncIdentifier"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.metadataSyncIdentifier));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataSyncVersion"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataSyncVersion));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataWasTakenInLab"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.metadataWasTakenInLab));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataReferenceRangeLowerLimit"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataReferenceRangeLowerLimit));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataReferenceRangeUpperLimit"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataReferenceRangeUpperLimit));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "metadataAlgorithmVersion"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.metadataAlgorithmVersion));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -221,30 +149,10 @@ namespace margelo::nitro {
       if (!JSIConverter<std::chrono::system_clock::time_point>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "startDate")))) return false;
       if (!JSIConverter<std::chrono::system_clock::time_point>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "endDate")))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hasUndeterminedDuration")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::WeatherCondition>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherCondition")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherHumidity")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::Quantity>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWeatherTemperature")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::InsulinDeliveryReason>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataInsulinDeliveryReason")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::healthkit::HeartRateMotionContext>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataHeartRateMotionContext")))) return false;
+      if (!JSIConverter<std::shared_ptr<AnyMap>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadata")))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uuid")))) return false;
       if (!JSIConverter<margelo::nitro::healthkit::SourceRevision>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "sourceRevision")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::healthkit::Device>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "device")))) return false;
-      if (!JSIConverter<std::shared_ptr<AnyMap>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadata")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataExternalUUID")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataTimeZone")))) return false;
-      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWasUserEntered")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceSerialNumber")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataUdiDeviceIdentifier")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataUdiProductionIdentifier")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDigitalSignature")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceName")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataDeviceManufacturerName")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataSyncIdentifier")))) return false;
-      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataSyncVersion")))) return false;
-      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataWasTakenInLab")))) return false;
-      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataReferenceRangeLowerLimit")))) return false;
-      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataReferenceRangeUpperLimit")))) return false;
-      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "metadataAlgorithmVersion")))) return false;
       return true;
     }
   };