@kingstinct/react-native-healthkit 12.2.0 → 13.0.1

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

@@ -130,6 +130,8 @@ namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
 namespace margelo::nitro::healthkit { struct Quantity; }
 // Forward declaration of `QueryCorrelationSamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryCorrelationSamplesWithAnchorResponse; }
+// Forward declaration of `QueryStatisticsResponseFromSingleSource` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryStatisticsResponseFromSingleSource; }
 // Forward declaration of `QueryStatisticsResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
@@ -280,6 +282,7 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "QuantityTypeIdentifier.hpp"
 #include "QueryCorrelationSamplesWithAnchorResponse.hpp"
 #include "QueryStatisticsResponse.hpp"
+#include "QueryStatisticsResponseFromSingleSource.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
 #include "RelatedCoding.hpp"
 #include "SampleType.hpp"
@@ -329,62 +332,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
  */
 namespace margelo::nitro::healthkit::bridge::swift {
 
-  // pragma MARK: std::shared_ptr<Promise<bool>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<bool>>`.
-   */
-  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
-  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
-    return Promise<bool>::create();
-  }
-  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
-    return PromiseHolder<bool>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(bool /* result */)>
-  /**
-   * Specialized version of `std::function<void(bool)>`.
-   */
-  using Func_void_bool = std::function<void(bool /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_bool_Wrapper final {
-  public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
-    inline void call(bool result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(bool /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
-    return Func_void_bool_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  /**
-   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
-   */
-  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__exception_ptr_Wrapper final {
-  public:
-    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
-    inline void call(std::exception_ptr error) const noexcept {
-      _function->operator()(error);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
-    return Func_void_std__exception_ptr_Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::optional<WeatherCondition>
   /**
    * Specialized version of `std::optional<WeatherCondition>`.
@@ -532,6 +479,92 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<CategorySample>
+  /**
+   * Specialized version of `std::optional<CategorySample>`.
+   */
+  using std__optional_CategorySample_ = std::optional<CategorySample>;
+  inline std::optional<CategorySample> create_std__optional_CategorySample_(const CategorySample& value) noexcept {
+    return std::optional<CategorySample>(value);
+  }
+  inline bool has_value_std__optional_CategorySample_(const std::optional<CategorySample>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CategorySample get_std__optional_CategorySample_(const std::optional<CategorySample>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<CategorySample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<CategorySample>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_CategorySample___ = std::shared_ptr<Promise<std::optional<CategorySample>>>;
+  inline std::shared_ptr<Promise<std::optional<CategorySample>>> create_std__shared_ptr_Promise_std__optional_CategorySample___() noexcept {
+    return Promise<std::optional<CategorySample>>::create();
+  }
+  inline PromiseHolder<std::optional<CategorySample>> wrap_std__shared_ptr_Promise_std__optional_CategorySample___(std::shared_ptr<Promise<std::optional<CategorySample>>> promise) noexcept {
+    return PromiseHolder<std::optional<CategorySample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<CategorySample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<CategorySample>&)>`.
+   */
+  using Func_void_std__optional_CategorySample_ = std::function<void(const std::optional<CategorySample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<CategorySample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_CategorySample__Wrapper final {
+  public:
+    explicit Func_void_std__optional_CategorySample__Wrapper(std::function<void(const std::optional<CategorySample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<CategorySample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<CategorySample> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<CategorySample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_CategorySample_ create_Func_void_std__optional_CategorySample_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_CategorySample__Wrapper wrap_Func_void_std__optional_CategorySample_(Func_void_std__optional_CategorySample_ value) noexcept {
+    return Func_void_std__optional_CategorySample__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::shared_ptr<AnyMap>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<AnyMap>>`.
+   */
+  using std__optional_std__shared_ptr_AnyMap__ = std::optional<std::shared_ptr<AnyMap>>;
+  inline std::optional<std::shared_ptr<AnyMap>> create_std__optional_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
+    return std::optional<std::shared_ptr<AnyMap>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<AnyMap> get_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::vector<CategorySample>
   /**
    * Specialized version of `std::vector<CategorySample>`.
@@ -813,21 +846,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return *optional;
   }
   
-  // pragma MARK: std::optional<std::shared_ptr<AnyMap>>
-  /**
-   * Specialized version of `std::optional<std::shared_ptr<AnyMap>>`.
-   */
-  using std__optional_std__shared_ptr_AnyMap__ = std::optional<std::shared_ptr<AnyMap>>;
-  inline std::optional<std::shared_ptr<AnyMap>> create_std__optional_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
-    return std::optional<std::shared_ptr<AnyMap>>(value);
-  }
-  inline bool has_value_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::shared_ptr<AnyMap> get_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::vector<DeletedSample>
   /**
    * Specialized version of `std::vector<DeletedSample>`.
@@ -885,13 +903,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_HybridCategoryTypeModuleSpec_ = std::weak_ptr<HybridCategoryTypeModuleSpec>;
   inline std__weak_ptr_HybridCategoryTypeModuleSpec_ weakify_std__shared_ptr_HybridCategoryTypeModuleSpec_(const std::shared_ptr<HybridCategoryTypeModuleSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
-  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<CategorySample>>>>
+  using Result_std__shared_ptr_Promise_std__optional_CategorySample____ = Result<std::shared_ptr<Promise<std::optional<CategorySample>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_CategorySample____ create_Result_std__shared_ptr_Promise_std__optional_CategorySample____(const std::shared_ptr<Promise<std::optional<CategorySample>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<CategorySample>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__optional_CategorySample____ create_Result_std__shared_ptr_Promise_std__optional_CategorySample____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<CategorySample>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<CategorySample>>>>
@@ -1184,6 +1202,40 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<WheelchairUse>>>::withError(error);
   }
   
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::vector<IdentifierWithUnit>
   /**
    * Specialized version of `std::vector<IdentifierWithUnit>`.
@@ -1487,6 +1539,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_HybridCoreModuleSpec_ = std::weak_ptr<HybridCoreModuleSpec>;
   inline std__weak_ptr_HybridCoreModuleSpec_ weakify_std__shared_ptr_HybridCoreModuleSpec_(const std::shared_ptr<HybridCoreModuleSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
   // pragma MARK: Result<bool>
   using Result_bool_ = Result<bool>;
   inline Result_bool_ create_Result_bool_(bool value) noexcept {
@@ -1586,6 +1647,95 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>>::withError(error);
   }
   
+  // pragma MARK: std::variant<CategorySample, QuantitySample>
+  /**
+   * Wrapper struct for `std::variant<CategorySample, QuantitySample>`.
+   * 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_CategorySample__QuantitySample_ {
+    std::variant<CategorySample, QuantitySample> variant;
+    std__variant_CategorySample__QuantitySample_(std::variant<CategorySample, QuantitySample> variant): variant(variant) { }
+    operator std::variant<CategorySample, QuantitySample>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline CategorySample get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline QuantitySample get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_CategorySample__QuantitySample_ create_std__variant_CategorySample__QuantitySample_(const CategorySample& value) noexcept {
+    return std__variant_CategorySample__QuantitySample_(value);
+  }
+  inline std__variant_CategorySample__QuantitySample_ create_std__variant_CategorySample__QuantitySample_(const QuantitySample& value) noexcept {
+    return std__variant_CategorySample__QuantitySample_(value);
+  }
+  
+  // pragma MARK: std::vector<std::variant<CategorySample, QuantitySample>>
+  /**
+   * Specialized version of `std::vector<std::variant<CategorySample, QuantitySample>>`.
+   */
+  using std__vector_std__variant_CategorySample__QuantitySample__ = std::vector<std::variant<CategorySample, QuantitySample>>;
+  inline std::vector<std::variant<CategorySample, QuantitySample>> create_std__vector_std__variant_CategorySample__QuantitySample__(size_t size) noexcept {
+    std::vector<std::variant<CategorySample, QuantitySample>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<CorrelationSample>
+  /**
+   * Specialized version of `std::optional<CorrelationSample>`.
+   */
+  using std__optional_CorrelationSample_ = std::optional<CorrelationSample>;
+  inline std::optional<CorrelationSample> create_std__optional_CorrelationSample_(const CorrelationSample& value) noexcept {
+    return std::optional<CorrelationSample>(value);
+  }
+  inline bool has_value_std__optional_CorrelationSample_(const std::optional<CorrelationSample>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CorrelationSample get_std__optional_CorrelationSample_(const std::optional<CorrelationSample>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<CorrelationSample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<CorrelationSample>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_CorrelationSample___ = std::shared_ptr<Promise<std::optional<CorrelationSample>>>;
+  inline std::shared_ptr<Promise<std::optional<CorrelationSample>>> create_std__shared_ptr_Promise_std__optional_CorrelationSample___() noexcept {
+    return Promise<std::optional<CorrelationSample>>::create();
+  }
+  inline PromiseHolder<std::optional<CorrelationSample>> wrap_std__shared_ptr_Promise_std__optional_CorrelationSample___(std::shared_ptr<Promise<std::optional<CorrelationSample>>> promise) noexcept {
+    return PromiseHolder<std::optional<CorrelationSample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<CorrelationSample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<CorrelationSample>&)>`.
+   */
+  using Func_void_std__optional_CorrelationSample_ = std::function<void(const std::optional<CorrelationSample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<CorrelationSample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_CorrelationSample__Wrapper final {
+  public:
+    explicit Func_void_std__optional_CorrelationSample__Wrapper(std::function<void(const std::optional<CorrelationSample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<CorrelationSample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<CorrelationSample> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<CorrelationSample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_CorrelationSample_ create_Func_void_std__optional_CorrelationSample_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_CorrelationSample__Wrapper wrap_Func_void_std__optional_CorrelationSample_(Func_void_std__optional_CorrelationSample_ value) noexcept {
+    return Func_void_std__optional_CorrelationSample__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::optional<SourceRevision>
   /**
    * Specialized version of `std::optional<SourceRevision>`.
@@ -1641,46 +1791,6 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::variant<CategorySample, QuantitySample>
-  /**
-   * Wrapper struct for `std::variant<CategorySample, QuantitySample>`.
-   * 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_CategorySample__QuantitySample_ {
-    std::variant<CategorySample, QuantitySample> variant;
-    std__variant_CategorySample__QuantitySample_(std::variant<CategorySample, QuantitySample> variant): variant(variant) { }
-    operator std::variant<CategorySample, QuantitySample>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline CategorySample get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline QuantitySample get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-  };
-  inline std__variant_CategorySample__QuantitySample_ create_std__variant_CategorySample__QuantitySample_(const CategorySample& value) noexcept {
-    return std__variant_CategorySample__QuantitySample_(value);
-  }
-  inline std__variant_CategorySample__QuantitySample_ create_std__variant_CategorySample__QuantitySample_(const QuantitySample& value) noexcept {
-    return std__variant_CategorySample__QuantitySample_(value);
-  }
-  
-  // pragma MARK: std::vector<std::variant<CategorySample, QuantitySample>>
-  /**
-   * Specialized version of `std::vector<std::variant<CategorySample, QuantitySample>>`.
-   */
-  using std__vector_std__variant_CategorySample__QuantitySample__ = std::vector<std::variant<CategorySample, QuantitySample>>;
-  inline std::vector<std::variant<CategorySample, QuantitySample>> create_std__vector_std__variant_CategorySample__QuantitySample__(size_t size) noexcept {
-    std::vector<std::variant<CategorySample, QuantitySample>> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
   // pragma MARK: std::vector<CorrelationSample>
   /**
    * Specialized version of `std::vector<CorrelationSample>`.
@@ -1772,6 +1882,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
   using std__weak_ptr_HybridCorrelationTypeModuleSpec_ = std::weak_ptr<HybridCorrelationTypeModuleSpec>;
   inline std__weak_ptr_HybridCorrelationTypeModuleSpec_ weakify_std__shared_ptr_HybridCorrelationTypeModuleSpec_(const std::shared_ptr<HybridCorrelationTypeModuleSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<CorrelationSample>>>>
+  using Result_std__shared_ptr_Promise_std__optional_CorrelationSample____ = Result<std::shared_ptr<Promise<std::optional<CorrelationSample>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_CorrelationSample____ create_Result_std__shared_ptr_Promise_std__optional_CorrelationSample____(const std::shared_ptr<Promise<std::optional<CorrelationSample>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<CorrelationSample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_CorrelationSample____ create_Result_std__shared_ptr_Promise_std__optional_CorrelationSample____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<CorrelationSample>>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<CorrelationSample>>>>
   using Result_std__shared_ptr_Promise_std__vector_CorrelationSample____ = Result<std::shared_ptr<Promise<std::vector<CorrelationSample>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_CorrelationSample____ create_Result_std__shared_ptr_Promise_std__vector_CorrelationSample____(const std::shared_ptr<Promise<std::vector<CorrelationSample>>>& value) noexcept {
@@ -2219,6 +2338,55 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<MedicationDoseEventsWithAnchorResponse>>>::withError(error);
   }
   
+  // pragma MARK: std::optional<QuantitySample>
+  /**
+   * Specialized version of `std::optional<QuantitySample>`.
+   */
+  using std__optional_QuantitySample_ = std::optional<QuantitySample>;
+  inline std::optional<QuantitySample> create_std__optional_QuantitySample_(const QuantitySample& value) noexcept {
+    return std::optional<QuantitySample>(value);
+  }
+  inline bool has_value_std__optional_QuantitySample_(const std::optional<QuantitySample>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline QuantitySample get_std__optional_QuantitySample_(const std::optional<QuantitySample>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<QuantitySample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<QuantitySample>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_QuantitySample___ = std::shared_ptr<Promise<std::optional<QuantitySample>>>;
+  inline std::shared_ptr<Promise<std::optional<QuantitySample>>> create_std__shared_ptr_Promise_std__optional_QuantitySample___() noexcept {
+    return Promise<std::optional<QuantitySample>>::create();
+  }
+  inline PromiseHolder<std::optional<QuantitySample>> wrap_std__shared_ptr_Promise_std__optional_QuantitySample___(std::shared_ptr<Promise<std::optional<QuantitySample>>> promise) noexcept {
+    return PromiseHolder<std::optional<QuantitySample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<QuantitySample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<QuantitySample>&)>`.
+   */
+  using Func_void_std__optional_QuantitySample_ = std::function<void(const std::optional<QuantitySample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<QuantitySample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_QuantitySample__Wrapper final {
+  public:
+    explicit Func_void_std__optional_QuantitySample__Wrapper(std::function<void(const std::optional<QuantitySample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<QuantitySample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<QuantitySample> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<QuantitySample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_QuantitySample_ create_Func_void_std__optional_QuantitySample_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_QuantitySample__Wrapper wrap_Func_void_std__optional_QuantitySample_(Func_void_std__optional_QuantitySample_ value) noexcept {
+    return Func_void_std__optional_QuantitySample__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::vector<QuantitySample>
   /**
    * Specialized version of `std::vector<QuantitySample>`.
@@ -2384,6 +2552,51 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::vector<QueryStatisticsResponseFromSingleSource>
+  /**
+   * Specialized version of `std::vector<QueryStatisticsResponseFromSingleSource>`.
+   */
+  using std__vector_QueryStatisticsResponseFromSingleSource_ = std::vector<QueryStatisticsResponseFromSingleSource>;
+  inline std::vector<QueryStatisticsResponseFromSingleSource> create_std__vector_QueryStatisticsResponseFromSingleSource_(size_t size) noexcept {
+    std::vector<QueryStatisticsResponseFromSingleSource> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource___ = std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>;
+  inline std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>> create_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource___() noexcept {
+    return Promise<std::vector<QueryStatisticsResponseFromSingleSource>>::create();
+  }
+  inline PromiseHolder<std::vector<QueryStatisticsResponseFromSingleSource>> wrap_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource___(std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>> promise) noexcept {
+    return PromiseHolder<std::vector<QueryStatisticsResponseFromSingleSource>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>&)>`.
+   */
+  using Func_void_std__vector_QueryStatisticsResponseFromSingleSource_ = std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_QueryStatisticsResponseFromSingleSource__Wrapper final {
+  public:
+    explicit Func_void_std__vector_QueryStatisticsResponseFromSingleSource__Wrapper(std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<QueryStatisticsResponseFromSingleSource> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<QueryStatisticsResponseFromSingleSource>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_QueryStatisticsResponseFromSingleSource_ create_Func_void_std__vector_QueryStatisticsResponseFromSingleSource_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_QueryStatisticsResponseFromSingleSource__Wrapper wrap_Func_void_std__vector_QueryStatisticsResponseFromSingleSource_(Func_void_std__vector_QueryStatisticsResponseFromSingleSource_ value) noexcept {
+    return Func_void_std__vector_QueryStatisticsResponseFromSingleSource__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>
   /**
    * Specialized version of `std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>`.
@@ -2439,6 +2652,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<AggregationStyle>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<QuantitySample>>>>
+  using Result_std__shared_ptr_Promise_std__optional_QuantitySample____ = Result<std::shared_ptr<Promise<std::optional<QuantitySample>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_QuantitySample____ create_Result_std__shared_ptr_Promise_std__optional_QuantitySample____(const std::shared_ptr<Promise<std::optional<QuantitySample>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<QuantitySample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_QuantitySample____ create_Result_std__shared_ptr_Promise_std__optional_QuantitySample____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<QuantitySample>>>>::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 {
@@ -2466,6 +2688,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>>
+  using Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource____ = Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource____ create_Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource____(const std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource____ create_Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponseFromSingleSource____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponseFromSingleSource>>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>>
   using Result_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse___ = Result<std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>>;
   inline Result_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse___(const std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>& value) noexcept {
@@ -2585,6 +2816,55 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_StateOfMindSamplesWithAnchorResponse_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<StateOfMindSample>
+  /**
+   * Specialized version of `std::optional<StateOfMindSample>`.
+   */
+  using std__optional_StateOfMindSample_ = std::optional<StateOfMindSample>;
+  inline std::optional<StateOfMindSample> create_std__optional_StateOfMindSample_(const StateOfMindSample& value) noexcept {
+    return std::optional<StateOfMindSample>(value);
+  }
+  inline bool has_value_std__optional_StateOfMindSample_(const std::optional<StateOfMindSample>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline StateOfMindSample get_std__optional_StateOfMindSample_(const std::optional<StateOfMindSample>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<StateOfMindSample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<StateOfMindSample>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_StateOfMindSample___ = std::shared_ptr<Promise<std::optional<StateOfMindSample>>>;
+  inline std::shared_ptr<Promise<std::optional<StateOfMindSample>>> create_std__shared_ptr_Promise_std__optional_StateOfMindSample___() noexcept {
+    return Promise<std::optional<StateOfMindSample>>::create();
+  }
+  inline PromiseHolder<std::optional<StateOfMindSample>> wrap_std__shared_ptr_Promise_std__optional_StateOfMindSample___(std::shared_ptr<Promise<std::optional<StateOfMindSample>>> promise) noexcept {
+    return PromiseHolder<std::optional<StateOfMindSample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<StateOfMindSample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<StateOfMindSample>&)>`.
+   */
+  using Func_void_std__optional_StateOfMindSample_ = std::function<void(const std::optional<StateOfMindSample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<StateOfMindSample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_StateOfMindSample__Wrapper final {
+  public:
+    explicit Func_void_std__optional_StateOfMindSample__Wrapper(std::function<void(const std::optional<StateOfMindSample>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<StateOfMindSample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<StateOfMindSample> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<StateOfMindSample>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_StateOfMindSample_ create_Func_void_std__optional_StateOfMindSample_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_StateOfMindSample__Wrapper wrap_Func_void_std__optional_StateOfMindSample_(Func_void_std__optional_StateOfMindSample_ value) noexcept {
+    return Func_void_std__optional_StateOfMindSample__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridStateOfMindModuleSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridStateOfMindModuleSpec>`.
@@ -2615,6 +2895,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<StateOfMindSamplesWithAnchorResponse>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<StateOfMindSample>>>>
+  using Result_std__shared_ptr_Promise_std__optional_StateOfMindSample____ = Result<std::shared_ptr<Promise<std::optional<StateOfMindSample>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_StateOfMindSample____ create_Result_std__shared_ptr_Promise_std__optional_StateOfMindSample____(const std::shared_ptr<Promise<std::optional<StateOfMindSample>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<StateOfMindSample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_StateOfMindSample____ create_Result_std__shared_ptr_Promise_std__optional_StateOfMindSample____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<StateOfMindSample>>>>::withError(error);
+  }
+  
   // pragma MARK: std::vector<WorkoutEvent>
   /**
    * Specialized version of `std::vector<WorkoutEvent>`.

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

@@ -146,6 +146,8 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithAnchor; }
 namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrderAndUnit; }
 // Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `QueryStatisticsResponseFromSingleSource` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryStatisticsResponseFromSingleSource; }
 // Forward declaration of `QueryStatisticsResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
@@ -286,6 +288,7 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "QueryOptionsWithSortOrder.hpp"
 #include "QueryOptionsWithSortOrderAndUnit.hpp"
 #include "QueryStatisticsResponse.hpp"
+#include "QueryStatisticsResponseFromSingleSource.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
 #include "RelatedCoding.hpp"
 #include "SampleType.hpp"