@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AggregationStyle` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class AggregationStyle; }
 // Forward declaration of `AuthorizationRequestStatus` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class AuthorizationRequestStatus; }
 // Forward declaration of `AuthorizationStatus` to properly resolve imports.
@@ -30,12 +32,12 @@ namespace margelo::nitro::healthkit { enum class ComparisonPredicateOperator; }
 namespace margelo::nitro::healthkit { struct CorrelationSample; }
 // Forward declaration of `CorrelationTypeIdentifier` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class CorrelationTypeIdentifier; }
+// Forward declaration of `DateFilter` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct DateFilter; }
 // Forward declaration of `DeletedSample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct DeletedSample; }
 // Forward declaration of `Device` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct Device; }
-// Forward declaration of `ECGQueryOptionsWithSortOrder` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct ECGQueryOptionsWithSortOrder; }
 // Forward declaration of `ElectrocardiogramClassification` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class ElectrocardiogramClassification; }
 // Forward declaration of `ElectrocardiogramLead` to properly resolve imports.
@@ -48,12 +50,20 @@ namespace margelo::nitro::healthkit { struct ElectrocardiogramSamplesWithAnchorR
 namespace margelo::nitro::healthkit { enum class ElectrocardiogramSymptomsStatus; }
 // Forward declaration of `ElectrocardiogramVoltage` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct ElectrocardiogramVoltage; }
-// Forward declaration of `FilterForSamplesAnd` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
-// Forward declaration of `FilterForSamplesOr` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `FilterForSamplesBase` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesBase; }
+// Forward declaration of `FilterForSamples` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamples; }
+// Forward declaration of `FilterForWorkoutsBase` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForWorkoutsBase; }
+// Forward declaration of `FilterForWorkouts` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForWorkouts; }
 // Forward declaration of `FitzpatrickSkinType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class FitzpatrickSkinType; }
+// Forward declaration of `GeneralForm` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class GeneralForm; }
+// Forward declaration of `HeartRateMotionContext` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class HeartRateMotionContext; }
 // Forward declaration of `HeartbeatSeriesSample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct HeartbeatSeriesSample; }
 // Forward declaration of `HeartbeatSeriesSamplesWithAnchorResponse` to properly resolve imports.
@@ -72,6 +82,8 @@ namespace margelo::nitro::healthkit { class HybridCorrelationTypeModuleSpec; }
 namespace margelo::nitro::healthkit { class HybridElectrocardiogramModuleSpec; }
 // Forward declaration of `HybridHeartbeatSeriesModuleSpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridHeartbeatSeriesModuleSpec; }
+// Forward declaration of `HybridMedicationModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridMedicationModuleSpec; }
 // Forward declaration of `HybridQuantityTypeModuleSpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridQuantityTypeModuleSpec; }
 // Forward declaration of `HybridSourceProxySpec` to properly resolve imports.
@@ -84,28 +96,26 @@ namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 namespace margelo::nitro::healthkit { class HybridWorkoutsModuleSpec; }
 // Forward declaration of `IdentifierWithUnit` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct IdentifierWithUnit; }
+// Forward declaration of `InsulinDeliveryReason` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class InsulinDeliveryReason; }
 // Forward declaration of `LocationForSaving` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct LocationForSaving; }
+// Forward declaration of `MedicationConcept` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct MedicationConcept; }
+// Forward declaration of `MedicationDoseEventLogStatus` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class MedicationDoseEventLogStatus; }
+// Forward declaration of `MedicationDoseEventScheduleType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class MedicationDoseEventScheduleType; }
+// Forward declaration of `MedicationDoseEvent` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct MedicationDoseEvent; }
+// Forward declaration of `MedicationDoseEventsWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct MedicationDoseEventsWithAnchorResponse; }
 // Forward declaration of `ObjectTypeIdentifier` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class ObjectTypeIdentifier; }
 // Forward declaration of `OnChangeCallbackArgs` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct OnChangeCallbackArgs; }
-// Forward declaration of `PredicateForWorkoutsAnd` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct PredicateForWorkoutsAnd; }
-// Forward declaration of `PredicateForWorkoutsOr` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
-// Forward declaration of `PredicateFromWorkout` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 // Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
-// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
-namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
-// Forward declaration of `PredicateWithStartAndEnd` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
-// Forward declaration of `PredicateWithUUID` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct PredicateWithUUID; }
-// Forward declaration of `PredicateWithUUIDs` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct PredicateWithUUIDs; }
 // Forward declaration of `QuantityDateInterval` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QuantityDateInterval; }
 // Forward declaration of `QuantitySampleForSaving` to properly resolve imports.
@@ -118,18 +128,20 @@ namespace margelo::nitro::healthkit { struct QuantitySamplesWithAnchorResponse;
 namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
 // Forward declaration of `Quantity` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct Quantity; }
-// Forward declaration of `QueryOptionsWithSortOrderAndUnit` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrderAndUnit; }
-// Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `QueryCorrelationSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryCorrelationSamplesWithAnchorResponse; }
 // Forward declaration of `QueryStatisticsResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
+// Forward declaration of `RelatedCoding` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct RelatedCoding; }
 // Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
 // Forward declaration of `SampleTypeIdentifier` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class SampleTypeIdentifier; }
+// Forward declaration of `SampleType` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct SampleType; }
 // Forward declaration of `SourceRevision` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct SourceRevision; }
 // Forward declaration of `Source` to properly resolve imports.
@@ -142,16 +154,20 @@ namespace margelo::nitro::healthkit { enum class StateOfMindKind; }
 namespace margelo::nitro::healthkit { enum class StateOfMindLabel; }
 // Forward declaration of `StateOfMindSample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct StateOfMindSample; }
+// Forward declaration of `StateOfMindSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StateOfMindSamplesWithAnchorResponse; }
 // Forward declaration of `StateOfMindValenceClassification` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class StateOfMindValenceClassification; }
 // 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 `UserAnnotatedMedication` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct UserAnnotatedMedication; }
+// Forward declaration of `WeatherCondition` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WeatherCondition; }
 // Forward declaration of `WheelchairUse` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WheelchairUse; }
-// Forward declaration of `WorkoutActivityTypePredicate` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct WorkoutActivityTypePredicate; }
 // Forward declaration of `WorkoutActivityType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WorkoutActivityType; }
 // Forward declaration of `WorkoutActivity` to properly resolve imports.
@@ -188,6 +204,8 @@ namespace ReactNativeHealthkit { class HybridCorrelationTypeModuleSpec_cxx; }
 namespace ReactNativeHealthkit { class HybridElectrocardiogramModuleSpec_cxx; }
 // Forward declaration of `HybridHeartbeatSeriesModuleSpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridHeartbeatSeriesModuleSpec_cxx; }
+// Forward declaration of `HybridMedicationModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridMedicationModuleSpec_cxx; }
 // Forward declaration of `HybridQuantityTypeModuleSpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridQuantityTypeModuleSpec_cxx; }
 // Forward declaration of `HybridSourceProxySpec_cxx` to properly resolve imports.
@@ -200,6 +218,7 @@ namespace ReactNativeHealthkit { class HybridWorkoutProxySpec_cxx; }
 namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 
 // Include C++ defined types
+#include "AggregationStyle.hpp"
 #include "AuthorizationRequestStatus.hpp"
 #include "AuthorizationStatus.hpp"
 #include "BiologicalSex.hpp"
@@ -211,18 +230,22 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "ComparisonPredicateOperator.hpp"
 #include "CorrelationSample.hpp"
 #include "CorrelationTypeIdentifier.hpp"
+#include "DateFilter.hpp"
 #include "DeletedSample.hpp"
 #include "Device.hpp"
-#include "ECGQueryOptionsWithSortOrder.hpp"
 #include "ElectrocardiogramClassification.hpp"
 #include "ElectrocardiogramLead.hpp"
 #include "ElectrocardiogramSample.hpp"
 #include "ElectrocardiogramSamplesWithAnchorResponse.hpp"
 #include "ElectrocardiogramSymptomsStatus.hpp"
 #include "ElectrocardiogramVoltage.hpp"
-#include "FilterForSamplesAnd.hpp"
-#include "FilterForSamplesOr.hpp"
+#include "FilterForSamples.hpp"
+#include "FilterForSamplesBase.hpp"
+#include "FilterForWorkouts.hpp"
+#include "FilterForWorkoutsBase.hpp"
 #include "FitzpatrickSkinType.hpp"
+#include "GeneralForm.hpp"
+#include "HeartRateMotionContext.hpp"
 #include "Heartbeat.hpp"
 #include "HeartbeatSeriesSample.hpp"
 #include "HeartbeatSeriesSamplesWithAnchorResponse.hpp"
@@ -232,33 +255,34 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "HybridCorrelationTypeModuleSpec.hpp"
 #include "HybridElectrocardiogramModuleSpec.hpp"
 #include "HybridHeartbeatSeriesModuleSpec.hpp"
+#include "HybridMedicationModuleSpec.hpp"
 #include "HybridQuantityTypeModuleSpec.hpp"
 #include "HybridSourceProxySpec.hpp"
 #include "HybridStateOfMindModuleSpec.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 #include "HybridWorkoutsModuleSpec.hpp"
 #include "IdentifierWithUnit.hpp"
+#include "InsulinDeliveryReason.hpp"
 #include "LocationForSaving.hpp"
+#include "MedicationConcept.hpp"
+#include "MedicationDoseEvent.hpp"
+#include "MedicationDoseEventLogStatus.hpp"
+#include "MedicationDoseEventScheduleType.hpp"
+#include "MedicationDoseEventsWithAnchorResponse.hpp"
 #include "ObjectTypeIdentifier.hpp"
 #include "OnChangeCallbackArgs.hpp"
-#include "PredicateForWorkoutsAnd.hpp"
-#include "PredicateForWorkoutsOr.hpp"
-#include "PredicateFromWorkout.hpp"
 #include "PredicateWithMetadataKey.hpp"
-#include "PredicateWithMetadataOperator.hpp"
-#include "PredicateWithStartAndEnd.hpp"
-#include "PredicateWithUUID.hpp"
-#include "PredicateWithUUIDs.hpp"
 #include "Quantity.hpp"
 #include "QuantityDateInterval.hpp"
 #include "QuantitySample.hpp"
 #include "QuantitySampleForSaving.hpp"
 #include "QuantitySamplesWithAnchorResponse.hpp"
 #include "QuantityTypeIdentifier.hpp"
-#include "QueryOptionsWithSortOrder.hpp"
-#include "QueryOptionsWithSortOrderAndUnit.hpp"
+#include "QueryCorrelationSamplesWithAnchorResponse.hpp"
 #include "QueryStatisticsResponse.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
+#include "RelatedCoding.hpp"
+#include "SampleType.hpp"
 #include "SampleTypeIdentifier.hpp"
 #include "SampleTypeIdentifierWriteable.hpp"
 #include "Source.hpp"
@@ -267,13 +291,15 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "StateOfMindKind.hpp"
 #include "StateOfMindLabel.hpp"
 #include "StateOfMindSample.hpp"
+#include "StateOfMindSamplesWithAnchorResponse.hpp"
 #include "StateOfMindValenceClassification.hpp"
 #include "StatisticsOptions.hpp"
 #include "StatisticsQueryOptions.hpp"
+#include "UserAnnotatedMedication.hpp"
+#include "WeatherCondition.hpp"
 #include "WheelchairUse.hpp"
 #include "WorkoutActivity.hpp"
 #include "WorkoutActivityType.hpp"
-#include "WorkoutActivityTypePredicate.hpp"
 #include "WorkoutDurationPredicate.hpp"
 #include "WorkoutEvent.hpp"
 #include "WorkoutEventType.hpp"
@@ -359,33 +385,63 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::string>
+  // pragma MARK: std::optional<WeatherCondition>
   /**
-   * Specialized version of `std::optional<std::string>`.
+   * Specialized version of `std::optional<WeatherCondition>`.
    */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
+  using std__optional_WeatherCondition_ = std::optional<WeatherCondition>;
+  inline std::optional<WeatherCondition> create_std__optional_WeatherCondition_(const WeatherCondition& value) noexcept {
+    return std::optional<WeatherCondition>(value);
   }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+  inline bool has_value_std__optional_WeatherCondition_(const std::optional<WeatherCondition>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+  inline WeatherCondition get_std__optional_WeatherCondition_(const std::optional<WeatherCondition>& optional) noexcept {
     return *optional;
   }
   
-  // pragma MARK: std::optional<Device>
+  // pragma MARK: std::optional<Quantity>
   /**
-   * Specialized version of `std::optional<Device>`.
+   * Specialized version of `std::optional<Quantity>`.
    */
-  using std__optional_Device_ = std::optional<Device>;
-  inline std::optional<Device> create_std__optional_Device_(const Device& value) noexcept {
-    return std::optional<Device>(value);
+  using std__optional_Quantity_ = std::optional<Quantity>;
+  inline std::optional<Quantity> create_std__optional_Quantity_(const Quantity& value) noexcept {
+    return std::optional<Quantity>(value);
   }
-  inline bool has_value_std__optional_Device_(const std::optional<Device>& optional) noexcept {
+  inline bool has_value_std__optional_Quantity_(const std::optional<Quantity>& optional) noexcept {
     return optional.has_value();
   }
-  inline Device get_std__optional_Device_(const std::optional<Device>& optional) noexcept {
+  inline Quantity get_std__optional_Quantity_(const std::optional<Quantity>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<InsulinDeliveryReason>
+  /**
+   * Specialized version of `std::optional<InsulinDeliveryReason>`.
+   */
+  using std__optional_InsulinDeliveryReason_ = std::optional<InsulinDeliveryReason>;
+  inline std::optional<InsulinDeliveryReason> create_std__optional_InsulinDeliveryReason_(const InsulinDeliveryReason& value) noexcept {
+    return std::optional<InsulinDeliveryReason>(value);
+  }
+  inline bool has_value_std__optional_InsulinDeliveryReason_(const std::optional<InsulinDeliveryReason>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline InsulinDeliveryReason get_std__optional_InsulinDeliveryReason_(const std::optional<InsulinDeliveryReason>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<HeartRateMotionContext>
+  /**
+   * Specialized version of `std::optional<HeartRateMotionContext>`.
+   */
+  using std__optional_HeartRateMotionContext_ = std::optional<HeartRateMotionContext>;
+  inline std::optional<HeartRateMotionContext> create_std__optional_HeartRateMotionContext_(const HeartRateMotionContext& value) noexcept {
+    return std::optional<HeartRateMotionContext>(value);
+  }
+  inline bool has_value_std__optional_HeartRateMotionContext_(const std::optional<HeartRateMotionContext>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline HeartRateMotionContext get_std__optional_HeartRateMotionContext_(const std::optional<HeartRateMotionContext>& optional) noexcept {
     return *optional;
   }
   
@@ -416,18 +472,63 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return *optional;
   }
   
-  // pragma MARK: std::optional<SourceRevision>
+  // pragma MARK: std::optional<std::string>
   /**
-   * Specialized version of `std::optional<SourceRevision>`.
+   * Specialized version of `std::optional<std::string>`.
    */
-  using std__optional_SourceRevision_ = std::optional<SourceRevision>;
-  inline std::optional<SourceRevision> create_std__optional_SourceRevision_(const SourceRevision& value) noexcept {
-    return std::optional<SourceRevision>(value);
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
   }
-  inline bool has_value_std__optional_SourceRevision_(const std::optional<SourceRevision>& optional) noexcept {
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
     return optional.has_value();
   }
-  inline SourceRevision get_std__optional_SourceRevision_(const std::optional<SourceRevision>& optional) noexcept {
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<Device>
+  /**
+   * Specialized version of `std::optional<Device>`.
+   */
+  using std__optional_Device_ = std::optional<Device>;
+  inline std::optional<Device> create_std__optional_Device_(const Device& value) noexcept {
+    return std::optional<Device>(value);
+  }
+  inline bool has_value_std__optional_Device_(const std::optional<Device>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Device get_std__optional_Device_(const std::optional<Device>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
     return *optional;
   }
   
@@ -476,21 +577,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_CategorySample__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<bool>
-  /**
-   * Specialized version of `std::optional<bool>`.
-   */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
-    return std::optional<bool>(value);
-  }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::vector<std::string>
   /**
    * Specialized version of `std::vector<std::string>`.
@@ -502,18 +588,33 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<PredicateWithMetadataOperator>
+  // pragma MARK: std::optional<std::vector<std::string>>
+  /**
+   * Specialized version of `std::optional<std::vector<std::string>>`.
+   */
+  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
+  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
+    return std::optional<std::vector<std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<ComparisonPredicateOperator>
   /**
-   * Specialized version of `std::optional<PredicateWithMetadataOperator>`.
+   * Specialized version of `std::optional<ComparisonPredicateOperator>`.
    */
-  using std__optional_PredicateWithMetadataOperator_ = std::optional<PredicateWithMetadataOperator>;
-  inline std::optional<PredicateWithMetadataOperator> create_std__optional_PredicateWithMetadataOperator_(const PredicateWithMetadataOperator& value) noexcept {
-    return std::optional<PredicateWithMetadataOperator>(value);
+  using std__optional_ComparisonPredicateOperator_ = std::optional<ComparisonPredicateOperator>;
+  inline std::optional<ComparisonPredicateOperator> create_std__optional_ComparisonPredicateOperator_(const ComparisonPredicateOperator& value) noexcept {
+    return std::optional<ComparisonPredicateOperator>(value);
   }
-  inline bool has_value_std__optional_PredicateWithMetadataOperator_(const std::optional<PredicateWithMetadataOperator>& optional) noexcept {
+  inline bool has_value_std__optional_ComparisonPredicateOperator_(const std::optional<ComparisonPredicateOperator>& optional) noexcept {
     return optional.has_value();
   }
-  inline PredicateWithMetadataOperator get_std__optional_PredicateWithMetadataOperator_(const std::optional<PredicateWithMetadataOperator>& optional) noexcept {
+  inline ComparisonPredicateOperator get_std__optional_ComparisonPredicateOperator_(const std::optional<ComparisonPredicateOperator>& optional) noexcept {
     return *optional;
   }
   
@@ -573,6 +674,21 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<PredicateWithMetadataKey>
+  /**
+   * Specialized version of `std::optional<PredicateWithMetadataKey>`.
+   */
+  using std__optional_PredicateWithMetadataKey_ = std::optional<PredicateWithMetadataKey>;
+  inline std::optional<PredicateWithMetadataKey> create_std__optional_PredicateWithMetadataKey_(const PredicateWithMetadataKey& value) noexcept {
+    return std::optional<PredicateWithMetadataKey>(value);
+  }
+  inline bool has_value_std__optional_PredicateWithMetadataKey_(const std::optional<PredicateWithMetadataKey>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PredicateWithMetadataKey get_std__optional_PredicateWithMetadataKey_(const std::optional<PredicateWithMetadataKey>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<std::chrono::system_clock::time_point>
   /**
    * Specialized version of `std::optional<std::chrono::system_clock::time_point>`.
@@ -588,6 +704,21 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<DateFilter>
+  /**
+   * Specialized version of `std::optional<DateFilter>`.
+   */
+  using std__optional_DateFilter_ = std::optional<DateFilter>;
+  inline std::optional<DateFilter> create_std__optional_DateFilter_(const DateFilter& value) noexcept {
+    return std::optional<DateFilter>(value);
+  }
+  inline bool has_value_std__optional_DateFilter_(const std::optional<DateFilter>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline DateFilter get_std__optional_DateFilter_(const std::optional<DateFilter>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridWorkoutProxySpec>
   /**
    * Specialized version of `std::shared_ptr<HybridWorkoutProxySpec>`.
@@ -600,165 +731,85 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_HybridWorkoutProxySpec_ = std::weak_ptr<HybridWorkoutProxySpec>;
   inline std__weak_ptr_HybridWorkoutProxySpec_ weakify_std__shared_ptr_HybridWorkoutProxySpec_(const std::shared_ptr<HybridWorkoutProxySpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>
+  // pragma MARK: std::optional<std::shared_ptr<HybridWorkoutProxySpec>>
   /**
-   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>`.
-   * std::variant cannot be used in Swift because of a Swift bug.
-   * Not even specializing it works. So we create a wrapper struct.
+   * Specialized version of `std::optional<std::shared_ptr<HybridWorkoutProxySpec>>`.
    */
-  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ {
-    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout> variant;
-    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout> variant): variant(variant) { }
-    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline PredicateWithUUID get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline PredicateWithUUIDs get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-    inline PredicateWithMetadataKey get_2() const noexcept {
-      return std::get<2>(variant);
-    }
-    inline PredicateWithStartAndEnd get_3() const noexcept {
-      return std::get<3>(variant);
-    }
-    inline PredicateFromWorkout get_4() const noexcept {
-      return std::get<4>(variant);
-    }
-  };
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithUUID& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithUUIDs& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  using std__optional_std__shared_ptr_HybridWorkoutProxySpec__ = std::optional<std::shared_ptr<HybridWorkoutProxySpec>>;
+  inline std::optional<std::shared_ptr<HybridWorkoutProxySpec>> create_std__optional_std__shared_ptr_HybridWorkoutProxySpec__(const std::shared_ptr<HybridWorkoutProxySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridWorkoutProxySpec>>(value);
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithMetadataKey& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithStartAndEnd& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  inline bool has_value_std__optional_std__shared_ptr_HybridWorkoutProxySpec__(const std::optional<std::shared_ptr<HybridWorkoutProxySpec>>& optional) noexcept {
+    return optional.has_value();
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateFromWorkout& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  inline std::shared_ptr<HybridWorkoutProxySpec> get_std__optional_std__shared_ptr_HybridWorkoutProxySpec__(const std::optional<std::shared_ptr<HybridWorkoutProxySpec>>& optional) noexcept {
+    return *optional;
   }
   
-  // pragma MARK: std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>
+  // pragma MARK: std::vector<std::shared_ptr<HybridSourceProxySpec>>
   /**
-   * Specialized version of `std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>`.
+   * Specialized version of `std::vector<std::shared_ptr<HybridSourceProxySpec>>`.
    */
-  using std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__ = std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>;
-  inline std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> create_std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__(size_t size) noexcept {
-    std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> vector;
+  using std__vector_std__shared_ptr_HybridSourceProxySpec__ = std::vector<std::shared_ptr<HybridSourceProxySpec>>;
+  inline std::vector<std::shared_ptr<HybridSourceProxySpec>> create_std__vector_std__shared_ptr_HybridSourceProxySpec__(size_t size) noexcept {
+    std::vector<std::shared_ptr<HybridSourceProxySpec>> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>
+  // pragma MARK: std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>>
   /**
-   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>`.
-   * std::variant cannot be used in Swift because of a Swift bug.
-   * Not even specializing it works. So we create a wrapper struct.
+   * Specialized version of `std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>>`.
    */
-  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ {
-    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr> variant;
-    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr> variant): variant(variant) { }
-    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline PredicateWithUUID get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline PredicateWithUUIDs get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-    inline PredicateWithMetadataKey get_2() const noexcept {
-      return std::get<2>(variant);
-    }
-    inline PredicateWithStartAndEnd get_3() const noexcept {
-      return std::get<3>(variant);
-    }
-    inline PredicateFromWorkout get_4() const noexcept {
-      return std::get<4>(variant);
-    }
-    inline FilterForSamplesAnd get_5() const noexcept {
-      return std::get<5>(variant);
-    }
-    inline FilterForSamplesOr get_6() const noexcept {
-      return std::get<6>(variant);
-    }
-  };
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithUUID& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithUUIDs& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithMetadataKey& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  using std__optional_std__vector_std__shared_ptr_HybridSourceProxySpec___ = std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>>;
+  inline std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>> create_std__optional_std__vector_std__shared_ptr_HybridSourceProxySpec___(const std::vector<std::shared_ptr<HybridSourceProxySpec>>& value) noexcept {
+    return std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>>(value);
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithStartAndEnd& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateFromWorkout& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const FilterForSamplesAnd& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  inline bool has_value_std__optional_std__vector_std__shared_ptr_HybridSourceProxySpec___(const std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>>& optional) noexcept {
+    return optional.has_value();
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const FilterForSamplesOr& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  inline std::vector<std::shared_ptr<HybridSourceProxySpec>> get_std__optional_std__vector_std__shared_ptr_HybridSourceProxySpec___(const std::optional<std::vector<std::shared_ptr<HybridSourceProxySpec>>>& optional) noexcept {
+    return *optional;
   }
   
-  // pragma MARK: std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>
+  // pragma MARK: std::vector<FilterForSamplesBase>
   /**
-   * Specialized version of `std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>`.
+   * Specialized version of `std::vector<FilterForSamplesBase>`.
    */
-  using std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__ = std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>;
-  inline std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>> create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__(const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>& value) noexcept {
-    return std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>(value);
-  }
-  inline bool has_value_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__(const std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr> get_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__(const std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>& optional) noexcept {
-    return *optional;
+  using std__vector_FilterForSamplesBase_ = std::vector<FilterForSamplesBase>;
+  inline std::vector<FilterForSamplesBase> create_std__vector_FilterForSamplesBase_(size_t size) noexcept {
+    std::vector<FilterForSamplesBase> vector;
+    vector.reserve(size);
+    return vector;
   }
   
-  // pragma MARK: std::optional<double>
+  // pragma MARK: std::optional<std::vector<FilterForSamplesBase>>
   /**
-   * Specialized version of `std::optional<double>`.
+   * Specialized version of `std::optional<std::vector<FilterForSamplesBase>>`.
    */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
+  using std__optional_std__vector_FilterForSamplesBase__ = std::optional<std::vector<FilterForSamplesBase>>;
+  inline std::optional<std::vector<FilterForSamplesBase>> create_std__optional_std__vector_FilterForSamplesBase__(const std::vector<FilterForSamplesBase>& value) noexcept {
+    return std::optional<std::vector<FilterForSamplesBase>>(value);
   }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline bool has_value_std__optional_std__vector_FilterForSamplesBase__(const std::optional<std::vector<FilterForSamplesBase>>& optional) noexcept {
     return optional.has_value();
   }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline std::vector<FilterForSamplesBase> get_std__optional_std__vector_FilterForSamplesBase__(const std::optional<std::vector<FilterForSamplesBase>>& optional) noexcept {
     return *optional;
   }
   
-  // pragma MARK: std::optional<QueryOptionsWithSortOrder>
+  // pragma MARK: std::optional<FilterForSamples>
   /**
-   * Specialized version of `std::optional<QueryOptionsWithSortOrder>`.
+   * Specialized version of `std::optional<FilterForSamples>`.
    */
-  using std__optional_QueryOptionsWithSortOrder_ = std::optional<QueryOptionsWithSortOrder>;
-  inline std::optional<QueryOptionsWithSortOrder> create_std__optional_QueryOptionsWithSortOrder_(const QueryOptionsWithSortOrder& value) noexcept {
-    return std::optional<QueryOptionsWithSortOrder>(value);
+  using std__optional_FilterForSamples_ = std::optional<FilterForSamples>;
+  inline std::optional<FilterForSamples> create_std__optional_FilterForSamples_(const FilterForSamples& value) noexcept {
+    return std::optional<FilterForSamples>(value);
   }
-  inline bool has_value_std__optional_QueryOptionsWithSortOrder_(const std::optional<QueryOptionsWithSortOrder>& optional) noexcept {
+  inline bool has_value_std__optional_FilterForSamples_(const std::optional<FilterForSamples>& optional) noexcept {
     return optional.has_value();
   }
-  inline QueryOptionsWithSortOrder get_std__optional_QueryOptionsWithSortOrder_(const std::optional<QueryOptionsWithSortOrder>& optional) noexcept {
+  inline FilterForSamples get_std__optional_FilterForSamples_(const std::optional<FilterForSamples>& optional) noexcept {
     return *optional;
   }
   
@@ -1189,17 +1240,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::vector<std::shared_ptr<HybridSourceProxySpec>>
-  /**
-   * Specialized version of `std::vector<std::shared_ptr<HybridSourceProxySpec>>`.
-   */
-  using std__vector_std__shared_ptr_HybridSourceProxySpec__ = std::vector<std::shared_ptr<HybridSourceProxySpec>>;
-  inline std::vector<std::shared_ptr<HybridSourceProxySpec>> create_std__vector_std__shared_ptr_HybridSourceProxySpec__(size_t size) noexcept {
-    std::vector<std::shared_ptr<HybridSourceProxySpec>> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
   // pragma MARK: std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridSourceProxySpec>>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridSourceProxySpec>>>>`.
@@ -1456,6 +1496,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<bool>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<HybridSourceProxySpec>>
+  using Result_std__shared_ptr_HybridSourceProxySpec__ = Result<std::shared_ptr<HybridSourceProxySpec>>;
+  inline Result_std__shared_ptr_HybridSourceProxySpec__ create_Result_std__shared_ptr_HybridSourceProxySpec__(const std::shared_ptr<HybridSourceProxySpec>& value) noexcept {
+    return Result<std::shared_ptr<HybridSourceProxySpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_HybridSourceProxySpec__ create_Result_std__shared_ptr_HybridSourceProxySpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<HybridSourceProxySpec>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>>
   using Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____ = Result<std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____ create_Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____(const std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>& value) noexcept {
@@ -1537,6 +1586,21 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>>::withError(error);
   }
   
+  // pragma MARK: std::optional<SourceRevision>
+  /**
+   * Specialized version of `std::optional<SourceRevision>`.
+   */
+  using std__optional_SourceRevision_ = std::optional<SourceRevision>;
+  inline std::optional<SourceRevision> create_std__optional_SourceRevision_(const SourceRevision& value) noexcept {
+    return std::optional<SourceRevision>(value);
+  }
+  inline bool has_value_std__optional_SourceRevision_(const std::optional<SourceRevision>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SourceRevision get_std__optional_SourceRevision_(const std::optional<SourceRevision>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::variant<CategorySampleForSaving, QuantitySampleForSaving>
   /**
    * Wrapper struct for `std::variant<CategorySampleForSaving, QuantitySampleForSaving>`.
@@ -1662,6 +1726,40 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_CorrelationSample__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse__ = std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>> create_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse__() noexcept {
+    return Promise<QueryCorrelationSamplesWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<QueryCorrelationSamplesWithAnchorResponse> wrap_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse__(std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>> promise) noexcept {
+    return PromiseHolder<QueryCorrelationSamplesWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const QueryCorrelationSamplesWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const QueryCorrelationSamplesWithAnchorResponse&)>`.
+   */
+  using Func_void_QueryCorrelationSamplesWithAnchorResponse = std::function<void(const QueryCorrelationSamplesWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const QueryCorrelationSamplesWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_QueryCorrelationSamplesWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_QueryCorrelationSamplesWithAnchorResponse_Wrapper(std::function<void(const QueryCorrelationSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const QueryCorrelationSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(QueryCorrelationSamplesWithAnchorResponse result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const QueryCorrelationSamplesWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_QueryCorrelationSamplesWithAnchorResponse create_Func_void_QueryCorrelationSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_QueryCorrelationSamplesWithAnchorResponse_Wrapper wrap_Func_void_QueryCorrelationSamplesWithAnchorResponse(Func_void_QueryCorrelationSamplesWithAnchorResponse value) noexcept {
+    return Func_void_QueryCorrelationSamplesWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridCorrelationTypeModuleSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridCorrelationTypeModuleSpec>`.
@@ -1683,6 +1781,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<CorrelationSample>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>>
+  using Result_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse___ = Result<std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>>;
+  inline Result_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse___(const std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_QueryCorrelationSamplesWithAnchorResponse___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<QueryCorrelationSamplesWithAnchorResponse>>>::withError(error);
+  }
+  
   // pragma MARK: std::vector<ElectrocardiogramVoltage>
   /**
    * Specialized version of `std::vector<ElectrocardiogramVoltage>`.
@@ -1754,21 +1861,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_ElectrocardiogramSample__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<ECGQueryOptionsWithSortOrder>
-  /**
-   * Specialized version of `std::optional<ECGQueryOptionsWithSortOrder>`.
-   */
-  using std__optional_ECGQueryOptionsWithSortOrder_ = std::optional<ECGQueryOptionsWithSortOrder>;
-  inline std::optional<ECGQueryOptionsWithSortOrder> create_std__optional_ECGQueryOptionsWithSortOrder_(const ECGQueryOptionsWithSortOrder& value) noexcept {
-    return std::optional<ECGQueryOptionsWithSortOrder>(value);
-  }
-  inline bool has_value_std__optional_ECGQueryOptionsWithSortOrder_(const std::optional<ECGQueryOptionsWithSortOrder>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline ECGQueryOptionsWithSortOrder get_std__optional_ECGQueryOptionsWithSortOrder_(const std::optional<ECGQueryOptionsWithSortOrder>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::shared_ptr<Promise<ElectrocardiogramSamplesWithAnchorResponse>>
   /**
    * Specialized version of `std::shared_ptr<Promise<ElectrocardiogramSamplesWithAnchorResponse>>`.
@@ -1953,6 +2045,180 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>>::withError(error);
   }
   
+  // pragma MARK: std::vector<RelatedCoding>
+  /**
+   * Specialized version of `std::vector<RelatedCoding>`.
+   */
+  using std__vector_RelatedCoding_ = std::vector<RelatedCoding>;
+  inline std::vector<RelatedCoding> create_std__vector_RelatedCoding_(size_t size) noexcept {
+    std::vector<RelatedCoding> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<UserAnnotatedMedication>
+  /**
+   * Specialized version of `std::vector<UserAnnotatedMedication>`.
+   */
+  using std__vector_UserAnnotatedMedication_ = std::vector<UserAnnotatedMedication>;
+  inline std::vector<UserAnnotatedMedication> create_std__vector_UserAnnotatedMedication_(size_t size) noexcept {
+    std::vector<UserAnnotatedMedication> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_UserAnnotatedMedication___ = std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>;
+  inline std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>> create_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication___() noexcept {
+    return Promise<std::vector<UserAnnotatedMedication>>::create();
+  }
+  inline PromiseHolder<std::vector<UserAnnotatedMedication>> wrap_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication___(std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>> promise) noexcept {
+    return PromiseHolder<std::vector<UserAnnotatedMedication>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<UserAnnotatedMedication>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<UserAnnotatedMedication>&)>`.
+   */
+  using Func_void_std__vector_UserAnnotatedMedication_ = std::function<void(const std::vector<UserAnnotatedMedication>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<UserAnnotatedMedication>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_UserAnnotatedMedication__Wrapper final {
+  public:
+    explicit Func_void_std__vector_UserAnnotatedMedication__Wrapper(std::function<void(const std::vector<UserAnnotatedMedication>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<UserAnnotatedMedication>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<UserAnnotatedMedication> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<UserAnnotatedMedication>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_UserAnnotatedMedication_ create_Func_void_std__vector_UserAnnotatedMedication_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_UserAnnotatedMedication__Wrapper wrap_Func_void_std__vector_UserAnnotatedMedication_(Func_void_std__vector_UserAnnotatedMedication_ value) noexcept {
+    return Func_void_std__vector_UserAnnotatedMedication__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<MedicationDoseEvent>
+  /**
+   * Specialized version of `std::vector<MedicationDoseEvent>`.
+   */
+  using std__vector_MedicationDoseEvent_ = std::vector<MedicationDoseEvent>;
+  inline std::vector<MedicationDoseEvent> create_std__vector_MedicationDoseEvent_(size_t size) noexcept {
+    std::vector<MedicationDoseEvent> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_MedicationDoseEvent___ = std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>;
+  inline std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>> create_std__shared_ptr_Promise_std__vector_MedicationDoseEvent___() noexcept {
+    return Promise<std::vector<MedicationDoseEvent>>::create();
+  }
+  inline PromiseHolder<std::vector<MedicationDoseEvent>> wrap_std__shared_ptr_Promise_std__vector_MedicationDoseEvent___(std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>> promise) noexcept {
+    return PromiseHolder<std::vector<MedicationDoseEvent>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<MedicationDoseEvent>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<MedicationDoseEvent>&)>`.
+   */
+  using Func_void_std__vector_MedicationDoseEvent_ = std::function<void(const std::vector<MedicationDoseEvent>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<MedicationDoseEvent>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_MedicationDoseEvent__Wrapper final {
+  public:
+    explicit Func_void_std__vector_MedicationDoseEvent__Wrapper(std::function<void(const std::vector<MedicationDoseEvent>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<MedicationDoseEvent>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<MedicationDoseEvent> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<MedicationDoseEvent>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_MedicationDoseEvent_ create_Func_void_std__vector_MedicationDoseEvent_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_MedicationDoseEvent__Wrapper wrap_Func_void_std__vector_MedicationDoseEvent_(Func_void_std__vector_MedicationDoseEvent_ value) noexcept {
+    return Func_void_std__vector_MedicationDoseEvent__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse__ = std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>> create_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse__() noexcept {
+    return Promise<MedicationDoseEventsWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<MedicationDoseEventsWithAnchorResponse> wrap_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse__(std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>> promise) noexcept {
+    return PromiseHolder<MedicationDoseEventsWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const MedicationDoseEventsWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const MedicationDoseEventsWithAnchorResponse&)>`.
+   */
+  using Func_void_MedicationDoseEventsWithAnchorResponse = std::function<void(const MedicationDoseEventsWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const MedicationDoseEventsWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_MedicationDoseEventsWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_MedicationDoseEventsWithAnchorResponse_Wrapper(std::function<void(const MedicationDoseEventsWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const MedicationDoseEventsWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(MedicationDoseEventsWithAnchorResponse result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const MedicationDoseEventsWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_MedicationDoseEventsWithAnchorResponse create_Func_void_MedicationDoseEventsWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_MedicationDoseEventsWithAnchorResponse_Wrapper wrap_Func_void_MedicationDoseEventsWithAnchorResponse(Func_void_MedicationDoseEventsWithAnchorResponse value) noexcept {
+    return Func_void_MedicationDoseEventsWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridMedicationModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridMedicationModuleSpec>`.
+   */
+  using std__shared_ptr_HybridMedicationModuleSpec_ = std::shared_ptr<HybridMedicationModuleSpec>;
+  std::shared_ptr<HybridMedicationModuleSpec> create_std__shared_ptr_HybridMedicationModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridMedicationModuleSpec_(std__shared_ptr_HybridMedicationModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridMedicationModuleSpec>
+  using std__weak_ptr_HybridMedicationModuleSpec_ = std::weak_ptr<HybridMedicationModuleSpec>;
+  inline std__weak_ptr_HybridMedicationModuleSpec_ weakify_std__shared_ptr_HybridMedicationModuleSpec_(const std::shared_ptr<HybridMedicationModuleSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>>
+  using Result_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication____ = Result<std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication____ create_Result_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication____(const std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication____ create_Result_std__shared_ptr_Promise_std__vector_UserAnnotatedMedication____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<UserAnnotatedMedication>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>>
+  using Result_std__shared_ptr_Promise_std__vector_MedicationDoseEvent____ = Result<std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_MedicationDoseEvent____ create_Result_std__shared_ptr_Promise_std__vector_MedicationDoseEvent____(const std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_MedicationDoseEvent____ create_Result_std__shared_ptr_Promise_std__vector_MedicationDoseEvent____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<MedicationDoseEvent>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>>
+  using Result_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse___ = Result<std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>>;
+  inline Result_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse___ create_Result_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse___(const std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse___ create_Result_std__shared_ptr_Promise_MedicationDoseEventsWithAnchorResponse___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>>::withError(error);
+  }
+  
   // pragma MARK: std::vector<QuantitySample>
   /**
    * Specialized version of `std::vector<QuantitySample>`.
@@ -1998,36 +2264,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_QuantitySample__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<QueryOptionsWithSortOrderAndUnit>
-  /**
-   * Specialized version of `std::optional<QueryOptionsWithSortOrderAndUnit>`.
-   */
-  using std__optional_QueryOptionsWithSortOrderAndUnit_ = std::optional<QueryOptionsWithSortOrderAndUnit>;
-  inline std::optional<QueryOptionsWithSortOrderAndUnit> create_std__optional_QueryOptionsWithSortOrderAndUnit_(const QueryOptionsWithSortOrderAndUnit& value) noexcept {
-    return std::optional<QueryOptionsWithSortOrderAndUnit>(value);
-  }
-  inline bool has_value_std__optional_QueryOptionsWithSortOrderAndUnit_(const std::optional<QueryOptionsWithSortOrderAndUnit>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline QueryOptionsWithSortOrderAndUnit get_std__optional_QueryOptionsWithSortOrderAndUnit_(const std::optional<QueryOptionsWithSortOrderAndUnit>& optional) noexcept {
-    return *optional;
-  }
-  
-  // pragma MARK: std::optional<Quantity>
-  /**
-   * Specialized version of `std::optional<Quantity>`.
-   */
-  using std__optional_Quantity_ = std::optional<Quantity>;
-  inline std::optional<Quantity> create_std__optional_Quantity_(const Quantity& value) noexcept {
-    return std::optional<Quantity>(value);
-  }
-  inline bool has_value_std__optional_Quantity_(const std::optional<Quantity>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline Quantity get_std__optional_Quantity_(const std::optional<Quantity>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::optional<QuantityDateInterval>
   /**
    * Specialized version of `std::optional<QuantityDateInterval>`.
@@ -2194,6 +2430,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_HybridQuantityTypeModuleSpec_ = std::weak_ptr<HybridQuantityTypeModuleSpec>;
   inline std__weak_ptr_HybridQuantityTypeModuleSpec_ weakify_std__shared_ptr_HybridQuantityTypeModuleSpec_(const std::shared_ptr<HybridQuantityTypeModuleSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<AggregationStyle>
+  using Result_AggregationStyle_ = Result<AggregationStyle>;
+  inline Result_AggregationStyle_ create_Result_AggregationStyle_(AggregationStyle value) noexcept {
+    return Result<AggregationStyle>::withValue(std::move(value));
+  }
+  inline Result_AggregationStyle_ create_Result_AggregationStyle_(const std::exception_ptr& error) noexcept {
+    return Result<AggregationStyle>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<QuantitySample>>>>
   using Result_std__shared_ptr_Promise_std__vector_QuantitySample____ = Result<std::shared_ptr<Promise<std::vector<QuantitySample>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_QuantitySample____ create_Result_std__shared_ptr_Promise_std__vector_QuantitySample____(const std::shared_ptr<Promise<std::vector<QuantitySample>>>& value) noexcept {
@@ -2306,6 +2551,40 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_StateOfMindSample__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse__ = std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>> create_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse__() noexcept {
+    return Promise<StateOfMindSamplesWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<StateOfMindSamplesWithAnchorResponse> wrap_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse__(std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>> promise) noexcept {
+    return PromiseHolder<StateOfMindSamplesWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const StateOfMindSamplesWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const StateOfMindSamplesWithAnchorResponse&)>`.
+   */
+  using Func_void_StateOfMindSamplesWithAnchorResponse = std::function<void(const StateOfMindSamplesWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const StateOfMindSamplesWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_StateOfMindSamplesWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_StateOfMindSamplesWithAnchorResponse_Wrapper(std::function<void(const StateOfMindSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const StateOfMindSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(StateOfMindSamplesWithAnchorResponse result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const StateOfMindSamplesWithAnchorResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_StateOfMindSamplesWithAnchorResponse create_Func_void_StateOfMindSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_StateOfMindSamplesWithAnchorResponse_Wrapper wrap_Func_void_StateOfMindSamplesWithAnchorResponse(Func_void_StateOfMindSamplesWithAnchorResponse value) noexcept {
+    return Func_void_StateOfMindSamplesWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridStateOfMindModuleSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridStateOfMindModuleSpec>`.
@@ -2327,6 +2606,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<StateOfMindSample>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>>
+  using Result_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse___ = Result<std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>>;
+  inline Result_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse___(const std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_StateOfMindSamplesWithAnchorResponse___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>>::withError(error);
+  }
+  
   // pragma MARK: std::vector<WorkoutEvent>
   /**
    * Specialized version of `std::vector<WorkoutEvent>`.
@@ -2753,159 +3041,74 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>
+  // pragma MARK: std::optional<WorkoutActivityType>
   /**
-   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>`.
-   * std::variant cannot be used in Swift because of a Swift bug.
-   * Not even specializing it works. So we create a wrapper struct.
+   * Specialized version of `std::optional<WorkoutActivityType>`.
    */
-  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ {
-    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate> variant;
-    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate> variant): variant(variant) { }
-    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline PredicateWithUUID get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline PredicateWithUUIDs get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-    inline PredicateWithMetadataKey get_2() const noexcept {
-      return std::get<2>(variant);
-    }
-    inline PredicateWithStartAndEnd get_3() const noexcept {
-      return std::get<3>(variant);
-    }
-    inline PredicateFromWorkout get_4() const noexcept {
-      return std::get<4>(variant);
-    }
-    inline WorkoutActivityTypePredicate get_5() const noexcept {
-      return std::get<5>(variant);
-    }
-    inline WorkoutDurationPredicate get_6() const noexcept {
-      return std::get<6>(variant);
-    }
-  };
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithUUID& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithUUIDs& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  using std__optional_WorkoutActivityType_ = std::optional<WorkoutActivityType>;
+  inline std::optional<WorkoutActivityType> create_std__optional_WorkoutActivityType_(const WorkoutActivityType& value) noexcept {
+    return std::optional<WorkoutActivityType>(value);
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithMetadataKey& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  inline bool has_value_std__optional_WorkoutActivityType_(const std::optional<WorkoutActivityType>& optional) noexcept {
+    return optional.has_value();
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithStartAndEnd& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  inline WorkoutActivityType get_std__optional_WorkoutActivityType_(const std::optional<WorkoutActivityType>& optional) noexcept {
+    return *optional;
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateFromWorkout& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  
+  // pragma MARK: std::optional<WorkoutDurationPredicate>
+  /**
+   * Specialized version of `std::optional<WorkoutDurationPredicate>`.
+   */
+  using std__optional_WorkoutDurationPredicate_ = std::optional<WorkoutDurationPredicate>;
+  inline std::optional<WorkoutDurationPredicate> create_std__optional_WorkoutDurationPredicate_(const WorkoutDurationPredicate& value) noexcept {
+    return std::optional<WorkoutDurationPredicate>(value);
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const WorkoutActivityTypePredicate& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  inline bool has_value_std__optional_WorkoutDurationPredicate_(const std::optional<WorkoutDurationPredicate>& optional) noexcept {
+    return optional.has_value();
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const WorkoutDurationPredicate& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  inline WorkoutDurationPredicate get_std__optional_WorkoutDurationPredicate_(const std::optional<WorkoutDurationPredicate>& optional) noexcept {
+    return *optional;
   }
   
-  // pragma MARK: std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>>
+  // pragma MARK: std::vector<FilterForWorkoutsBase>
   /**
-   * Specialized version of `std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>>`.
+   * Specialized version of `std::vector<FilterForWorkoutsBase>`.
    */
-  using std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__ = std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>>;
-  inline std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>> create_std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__(size_t size) noexcept {
-    std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>> vector;
+  using std__vector_FilterForWorkoutsBase_ = std::vector<FilterForWorkoutsBase>;
+  inline std::vector<FilterForWorkoutsBase> create_std__vector_FilterForWorkoutsBase_(size_t size) noexcept {
+    std::vector<FilterForWorkoutsBase> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>
+  // pragma MARK: std::optional<std::vector<FilterForWorkoutsBase>>
   /**
-   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>`.
-   * std::variant cannot be used in Swift because of a Swift bug.
-   * Not even specializing it works. So we create a wrapper struct.
+   * Specialized version of `std::optional<std::vector<FilterForWorkoutsBase>>`.
    */
-  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ {
-    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd> variant;
-    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd> variant): variant(variant) { }
-    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline PredicateWithUUID get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline PredicateWithUUIDs get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-    inline PredicateWithMetadataKey get_2() const noexcept {
-      return std::get<2>(variant);
-    }
-    inline PredicateWithStartAndEnd get_3() const noexcept {
-      return std::get<3>(variant);
-    }
-    inline PredicateFromWorkout get_4() const noexcept {
-      return std::get<4>(variant);
-    }
-    inline WorkoutActivityTypePredicate get_5() const noexcept {
-      return std::get<5>(variant);
-    }
-    inline WorkoutDurationPredicate get_6() const noexcept {
-      return std::get<6>(variant);
-    }
-    inline PredicateForWorkoutsOr get_7() const noexcept {
-      return std::get<7>(variant);
-    }
-    inline PredicateForWorkoutsAnd get_8() const noexcept {
-      return std::get<8>(variant);
-    }
-  };
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithUUID& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithUUIDs& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithMetadataKey& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  using std__optional_std__vector_FilterForWorkoutsBase__ = std::optional<std::vector<FilterForWorkoutsBase>>;
+  inline std::optional<std::vector<FilterForWorkoutsBase>> create_std__optional_std__vector_FilterForWorkoutsBase__(const std::vector<FilterForWorkoutsBase>& value) noexcept {
+    return std::optional<std::vector<FilterForWorkoutsBase>>(value);
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithStartAndEnd& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateFromWorkout& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const WorkoutActivityTypePredicate& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const WorkoutDurationPredicate& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
-  }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateForWorkoutsOr& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  inline bool has_value_std__optional_std__vector_FilterForWorkoutsBase__(const std::optional<std::vector<FilterForWorkoutsBase>>& optional) noexcept {
+    return optional.has_value();
   }
-  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateForWorkoutsAnd& value) noexcept {
-    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  inline std::vector<FilterForWorkoutsBase> get_std__optional_std__vector_FilterForWorkoutsBase__(const std::optional<std::vector<FilterForWorkoutsBase>>& optional) noexcept {
+    return *optional;
   }
   
-  // pragma MARK: std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>
+  // pragma MARK: std::optional<FilterForWorkouts>
   /**
-   * Specialized version of `std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>`.
+   * Specialized version of `std::optional<FilterForWorkouts>`.
    */
-  using std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd__ = std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>;
-  inline std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>> create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd__(const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>& value) noexcept {
-    return std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>(value);
+  using std__optional_FilterForWorkouts_ = std::optional<FilterForWorkouts>;
+  inline std::optional<FilterForWorkouts> create_std__optional_FilterForWorkouts_(const FilterForWorkouts& value) noexcept {
+    return std::optional<FilterForWorkouts>(value);
   }
-  inline bool has_value_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd__(const std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>& optional) noexcept {
+  inline bool has_value_std__optional_FilterForWorkouts_(const std::optional<FilterForWorkouts>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd> get_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd__(const std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>& optional) noexcept {
+  inline FilterForWorkouts get_std__optional_FilterForWorkouts_(const std::optional<FilterForWorkouts>& optional) noexcept {
     return *optional;
   }