@kingstinct/react-native-healthkit 9.0.11 → 10.1.0

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

@@ -84,6 +84,8 @@ namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
 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.
@@ -217,6 +219,7 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "PredicateForWorkoutsOr.hpp"
 #include "PredicateFromWorkout.hpp"
 #include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "PredicateWithStartAndEnd.hpp"
 #include "PredicateWithUUID.hpp"
 #include "PredicateWithUUIDs.hpp"
@@ -442,6 +445,65 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return vector;
   }
   
+  // pragma MARK: std::optional<PredicateWithMetadataOperator>
+  /**
+   * Specialized version of `std::optional<PredicateWithMetadataOperator>`.
+   */
+  using std__optional_PredicateWithMetadataOperator_ = std::optional<PredicateWithMetadataOperator>;
+  inline std::optional<PredicateWithMetadataOperator> create_std__optional_PredicateWithMetadataOperator_(const PredicateWithMetadataOperator& value) {
+    return std::optional<PredicateWithMetadataOperator>(value);
+  }
+  
+  // pragma MARK: std::variant<std::string, double, bool, std::chrono::system_clock::time_point>
+  /**
+   * Wrapper struct for `std::variant<std::string, double, bool, std::chrono::system_clock::time_point>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ {
+    std::variant<std::string, double, bool, std::chrono::system_clock::time_point> variant;
+    std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std::variant<std::string, double, bool, std::chrono::system_clock::time_point> variant): variant(variant) { }
+    operator std::variant<std::string, double, bool, std::chrono::system_clock::time_point>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline std::string get_0() const {
+      return std::get<0>(variant);
+    }
+    inline double get_1() const {
+      return std::get<1>(variant);
+    }
+    inline bool get_2() const {
+      return std::get<2>(variant);
+    }
+    inline std::chrono::system_clock::time_point get_3() const {
+      return std::get<3>(variant);
+    }
+  };
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(const std::string& value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(double value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(bool value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  inline std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std::chrono::system_clock::time_point value) {
+    return std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>
+  /**
+   * Specialized version of `std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>`.
+   */
+  using std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__ = std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>;
+  inline std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>> create_std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__(const std::variant<std::string, double, bool, std::chrono::system_clock::time_point>& value) {
+    return std::optional<std::variant<std::string, double, bool, std::chrono::system_clock::time_point>>(value);
+  }
+  
   // pragma MARK: std::optional<std::chrono::system_clock::time_point>
   /**
    * Specialized version of `std::optional<std::chrono::system_clock::time_point>`.
@@ -2136,38 +2198,38 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>::withError(error);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>`.
    */
-  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
-  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
-    return Promise<std::string>::create();
+  using std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___ = std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>> create_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___() {
+    return Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>::create();
   }
-  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
-    return PromiseHolder<std::string>(std::move(promise));
+  inline PromiseHolder<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___(std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>> promise) {
+    return PromiseHolder<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::string& /* result */)>
+  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::string&)>`.
+   * Specialized version of `std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>&)>`.
    */
-  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
+  using Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ = std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__string_Wrapper final {
+  class Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
-    inline void call(std::string result) const {
+    explicit Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__Wrapper(std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec> result) const {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
-    return Func_void_std__string_Wrapper(std::move(value));
+  Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ create_Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__Wrapper wrap_Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ value) {
+    return Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::vector<QuantitySampleForSaving>
@@ -2431,13 +2493,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>;
   inline std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>& strong) { return strong; }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
-  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
-    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(const std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>& value) {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>>

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

@@ -86,6 +86,8 @@ namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
 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.
@@ -212,6 +214,7 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "PredicateForWorkoutsOr.hpp"
 #include "PredicateFromWorkout.hpp"
 #include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "PredicateWithStartAndEnd.hpp"
 #include "PredicateWithUUID.hpp"
 #include "PredicateWithUUIDs.hpp"

package/nitrogen/generated/ios/c++/HybridCategoryTypeModuleSpecSwift.hpp

@@ -40,6 +40,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `CategorySamplesWithAnchorResponse` to properly resolve imports.
@@ -70,6 +72,7 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 #include "CategorySamplesWithAnchorResponse.hpp"
 #include "DeletedSample.hpp"

package/nitrogen/generated/ios/c++/HybridCoreModuleSpecSwift.hpp

@@ -46,6 +46,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 
@@ -73,6 +75,7 @@ namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include <chrono>
 #include "HybridWorkoutProxySpec.hpp"
 #include <unordered_map>

package/nitrogen/generated/ios/c++/HybridHeartbeatSeriesModuleSpecSwift.hpp

@@ -40,6 +40,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `HeartbeatSeriesSamplesWithAnchorResponse` to properly resolve imports.
@@ -70,6 +72,7 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 #include "HeartbeatSeriesSamplesWithAnchorResponse.hpp"
 #include "DeletedSample.hpp"

package/nitrogen/generated/ios/c++/HybridQuantityTypeModuleSpecSwift.hpp

@@ -30,6 +30,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `QuantitySample` to properly resolve imports.
@@ -76,6 +78,7 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchorAndUnit; }
 #include "FilterForSamplesOr.hpp"
 #include <vector>
 #include <optional>
+#include "PredicateWithMetadataOperator.hpp"
 #include <memory>
 #include "HybridWorkoutProxySpec.hpp"
 #include "QuantitySample.hpp"

package/nitrogen/generated/ios/c++/HybridStateOfMindModuleSpecSwift.hpp

@@ -46,6 +46,8 @@ namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
 namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
 // Forward declaration of `FilterForSamplesOr` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 
@@ -73,6 +75,7 @@ namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 #include "PredicateFromWorkout.hpp"
 #include "FilterForSamplesAnd.hpp"
 #include "FilterForSamplesOr.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "HybridWorkoutProxySpec.hpp"
 
 #include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"

package/nitrogen/generated/ios/c++/HybridWorkoutsModuleSpecSwift.hpp

@@ -12,6 +12,8 @@
 // Forward declaration of `HybridWorkoutsModuleSpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 
+// Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `WorkoutActivityType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WorkoutActivityType; }
 // Forward declaration of `QuantitySampleForSaving` to properly resolve imports.
@@ -28,8 +30,6 @@ namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
 namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
-// Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
-namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
 // Forward declaration of `DeletedSample` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct DeletedSample; }
 // Forward declaration of `WorkoutQueryOptionsWithAnchor` to properly resolve imports.
@@ -52,6 +52,8 @@ namespace margelo::nitro::healthkit { struct WorkoutDurationPredicate; }
 namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
 // Forward declaration of `PredicateForWorkoutsAnd` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct PredicateForWorkoutsAnd; }
+// Forward declaration of `PredicateWithMetadataOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class PredicateWithMetadataOperator; }
 // Forward declaration of `ComparisonPredicateOperator` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class ComparisonPredicateOperator; }
 // Forward declaration of `WorkoutQueryOptions` to properly resolve imports.
@@ -62,20 +64,20 @@ namespace margelo::nitro::healthkit { struct WorkoutConfiguration; }
 namespace margelo::nitro::healthkit { enum class WorkoutSessionLocationType; }
 
 #include <NitroModules/Promise.hpp>
-#include <string>
+#include <memory>
+#include "HybridWorkoutProxySpec.hpp"
 #include "WorkoutActivityType.hpp"
 #include <vector>
 #include "QuantitySampleForSaving.hpp"
 #include <chrono>
 #include "QuantityTypeIdentifier.hpp"
+#include <string>
 #include <NitroModules/AnyMap.hpp>
 #include <optional>
 #include "SourceRevision.hpp"
-#include <memory>
 #include "HybridSourceProxySpec.hpp"
 #include "WorkoutTotals.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
-#include "HybridWorkoutProxySpec.hpp"
 #include "DeletedSample.hpp"
 #include "WorkoutQueryOptionsWithAnchor.hpp"
 #include <variant>
@@ -88,6 +90,7 @@ namespace margelo::nitro::healthkit { enum class WorkoutSessionLocationType; }
 #include "WorkoutDurationPredicate.hpp"
 #include "PredicateForWorkoutsOr.hpp"
 #include "PredicateForWorkoutsAnd.hpp"
+#include "PredicateWithMetadataOperator.hpp"
 #include "ComparisonPredicateOperator.hpp"
 #include "WorkoutQueryOptions.hpp"
 #include "WorkoutConfiguration.hpp"
@@ -132,7 +135,7 @@ namespace margelo::nitro::healthkit {
 
   public:
     // Methods
-    inline std::shared_ptr<Promise<std::string>> saveWorkoutSample(WorkoutActivityType workoutActivityType, const std::vector<QuantitySampleForSaving>& quantities, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const WorkoutTotals& totals, const std::shared_ptr<AnyMap>& metadata) override {
+    inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>> saveWorkoutSample(WorkoutActivityType workoutActivityType, const std::vector<QuantitySampleForSaving>& quantities, std::chrono::system_clock::time_point startDate, std::chrono::system_clock::time_point endDate, const WorkoutTotals& totals, const std::shared_ptr<AnyMap>& metadata) override {
       auto __result = _swiftPart.saveWorkoutSample(static_cast<int>(workoutActivityType), quantities, startDate, endDate, totals, metadata);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/CorrelationSample.swift

@@ -18,8 +18,8 @@ public extension CorrelationSample {
   /**
    * Create a new instance of `CorrelationSample`.
    */
-  init(correlationType: CorrelationTypeIdentifier, objects: [CorrelationObject], metadata: AnyMap, startDate: Date, endDate: Date) {
-    self.init(correlationType, { () -> bridge.std__vector_std__variant_CategorySample__QuantitySample__ in
+  init(uuid: String, correlationType: CorrelationTypeIdentifier, objects: [CorrelationObject], metadata: AnyMap, startDate: Date, endDate: Date) {
+    self.init(std.string(uuid), correlationType, { () -> bridge.std__vector_std__variant_CategorySample__QuantitySample__ in
       var __vector = bridge.create_std__vector_std__variant_CategorySample__QuantitySample__(objects.count)
       for __item in objects {
         __vector.push_back({ () -> bridge.std__variant_CategorySample__QuantitySample_ in
@@ -35,6 +35,17 @@ public extension CorrelationSample {
     }(), metadata.cppPart, startDate.toCpp(), endDate.toCpp())
   }
 
+  var uuid: String {
+    @inline(__always)
+    get {
+      return String(self.__uuid)
+    }
+    @inline(__always)
+    set {
+      self.__uuid = std.string(newValue)
+    }
+  }
+  
   var correlationType: CorrelationTypeIdentifier {
     @inline(__always)
     get {

package/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_.swift

@@ -0,0 +1,50 @@
+///
+/// Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: (any HybridWorkoutProxySpec)) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ {
+  public typealias bridge = margelo.nitro.healthkit.bridge.swift
+
+  private let closure: (_ value: (any HybridWorkoutProxySpec)) -> Void
+
+  public init(_ closure: @escaping (_ value: (any HybridWorkoutProxySpec)) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_) -> Void {
+    self.closure({ () -> HybridWorkoutProxySpec in
+      let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(value)
+      let __instance = HybridWorkoutProxySpec_cxx.fromUnsafe(__unsafePointer)
+      return __instance.getHybridWorkoutProxySpec()
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ {
+    return Unmanaged<Func_void_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridWorkoutsModuleSpec.swift

@@ -14,7 +14,7 @@ public protocol HybridWorkoutsModuleSpec_protocol: HybridObject {
   
 
   // Methods
-  func saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: [QuantitySampleForSaving], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMap) throws -> Promise<String>
+  func saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: [QuantitySampleForSaving], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMap) throws -> Promise<(any HybridWorkoutProxySpec)>
   func queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor) throws -> Promise<QueryWorkoutSamplesWithAnchorResponse>
   func queryWorkoutSamples(options: WorkoutQueryOptions) throws -> Promise<[(any HybridWorkoutProxySpec)]>
   func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) throws -> Promise<Bool>

package/nitrogen/generated/ios/swift/HybridWorkoutsModuleSpec_cxx.swift

@@ -101,21 +101,24 @@ public class HybridWorkoutsModuleSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func saveWorkoutSample(workoutActivityType: Int32, quantities: bridge.std__vector_QuantitySampleForSaving_, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, totals: WorkoutTotals, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+  public final func saveWorkoutSample(workoutActivityType: Int32, quantities: bridge.std__vector_QuantitySampleForSaving_, startDate: margelo.nitro.chrono_time, endDate: margelo.nitro.chrono_time, totals: WorkoutTotals, metadata: margelo.nitro.SharedAnyMap) -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ {
     do {
       let __result = try self.__implementation.saveWorkoutSample(workoutActivityType: margelo.nitro.healthkit.WorkoutActivityType(rawValue: workoutActivityType)!, quantities: quantities.map({ __item in __item }), startDate: Date(fromChrono: startDate), endDate: Date(fromChrono: endDate), totals: totals, metadata: AnyMap(withCppPart: metadata))
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ in
+              let __cxxWrapped = __result.getCxxWrapper()
+              return __cxxWrapped.getCxxPart()
+            }()) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/PredicateWithMetadataKey.swift

@@ -18,8 +18,31 @@ public extension PredicateWithMetadataKey {
   /**
    * Create a new instance of `PredicateWithMetadataKey`.
    */
-  init(withMetadataKey: String) {
-    self.init(std.string(withMetadataKey))
+  init(withMetadataKey: String, operatorType: PredicateWithMetadataOperator?, value: Variant_String_Double_Bool_Date?) {
+    self.init(std.string(withMetadataKey), { () -> bridge.std__optional_PredicateWithMetadataOperator_ in
+      if let __unwrappedValue = operatorType {
+        return bridge.create_std__optional_PredicateWithMetadataOperator_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__ in
+      if let __unwrappedValue = value {
+        return bridge.create_std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__({ () -> bridge.std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std.string(__value))
+            case .second(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+            case .third(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+            case .fourth(let __value):
+              return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value.toCpp())
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }())
   }
 
   var withMetadataKey: String {
@@ -32,4 +55,73 @@ public extension PredicateWithMetadataKey {
       self.__withMetadataKey = std.string(newValue)
     }
   }
+  
+  var operatorType: PredicateWithMetadataOperator? {
+    @inline(__always)
+    get {
+      return self.__operatorType.value
+    }
+    @inline(__always)
+    set {
+      self.__operatorType = { () -> bridge.std__optional_PredicateWithMetadataOperator_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_PredicateWithMetadataOperator_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var value: Variant_String_Double_Bool_Date? {
+    @inline(__always)
+    get {
+      return { () -> Variant_String_Double_Bool_Date? in
+        if let __unwrapped = self.__value.value {
+          return { () -> Variant_String_Double_Bool_Date in
+            let __variant = bridge.std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__unwrapped)
+            switch __variant.index() {
+              case 0:
+                let __actual = __variant.get_0()
+                return .first(String(__actual))
+              case 1:
+                let __actual = __variant.get_1()
+                return .second(__actual)
+              case 2:
+                let __actual = __variant.get_2()
+                return .third(__actual)
+              case 3:
+                let __actual = __variant.get_3()
+                return .fourth(Date(fromChrono: __actual))
+              default:
+                fatalError("Variant can never have index \(__variant.index())!")
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__value = { () -> bridge.std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__variant_std__string__double__bool__std__chrono__system_clock__time_point__({ () -> bridge.std__variant_std__string__double__bool__std__chrono__system_clock__time_point_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(std.string(__value))
+              case .second(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+              case .third(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value)
+              case .fourth(let __value):
+                return bridge.create_std__variant_std__string__double__bool__std__chrono__system_clock__time_point_(__value.toCpp())
+            }
+          }().variant)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

package/nitrogen/generated/ios/swift/PredicateWithMetadataOperator.swift

@@ -0,0 +1,48 @@
+///
+/// PredicateWithMetadataOperator.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `PredicateWithMetadataOperator`, backed by a C++ enum.
+ */
+public typealias PredicateWithMetadataOperator = margelo.nitro.healthkit.PredicateWithMetadataOperator
+
+public extension PredicateWithMetadataOperator {
+  /**
+   * Get a PredicateWithMetadataOperator for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "equalTo":
+        self = .equalto
+      case "notEqualTo":
+        self = .notequalto
+      case "greaterThan":
+        self = .greaterthan
+      case "lessThan":
+        self = .lessthan
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this PredicateWithMetadataOperator represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .equalto:
+        return "equalTo"
+      case .notequalto:
+        return "notEqualTo"
+      case .greaterthan:
+        return "greaterThan"
+      case .lessthan:
+        return "lessThan"
+    }
+  }
+}