@kingstinct/react-native-healthkit 9.0.6 → 9.0.8

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

@@ -66,8 +66,6 @@ namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
 namespace margelo::nitro::healthkit { class HybridStateOfMindModuleSpec; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
-// Forward declaration of `HybridWorkoutSessionModuleSpec` to properly resolve imports.
-namespace margelo::nitro::healthkit { class HybridWorkoutSessionModuleSpec; }
 // Forward declaration of `HybridWorkoutsModuleSpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutsModuleSpec; }
 // Forward declaration of `IdentifierWithUnit` to properly resolve imports.
@@ -112,8 +110,6 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
-// Forward declaration of `RemoteSessionSharableData` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct RemoteSessionSharableData; }
 // Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
 // Forward declaration of `SampleTypeIdentifier` to properly resolve imports.
@@ -160,8 +156,6 @@ namespace margelo::nitro::healthkit { struct WorkoutRoute; }
 namespace margelo::nitro::healthkit { struct WorkoutSample; }
 // Forward declaration of `WorkoutSessionLocationType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WorkoutSessionLocationType; }
-// Forward declaration of `WorkoutSessionState` to properly resolve imports.
-namespace margelo::nitro::healthkit { enum class WorkoutSessionState; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridCategoryTypeModuleSpec_cxx` to properly resolve imports.
@@ -182,8 +176,6 @@ namespace ReactNativeHealthkit { class HybridSourceProxySpec_cxx; }
 namespace ReactNativeHealthkit { class HybridStateOfMindModuleSpec_cxx; }
 // Forward declaration of `HybridWorkoutProxySpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutProxySpec_cxx; }
-// Forward declaration of `HybridWorkoutSessionModuleSpec_cxx` to properly resolve imports.
-namespace ReactNativeHealthkit { class HybridWorkoutSessionModuleSpec_cxx; }
 // Forward declaration of `HybridWorkoutsModuleSpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 
@@ -216,7 +208,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "HybridSourceProxySpec.hpp"
 #include "HybridStateOfMindModuleSpec.hpp"
 #include "HybridWorkoutProxySpec.hpp"
-#include "HybridWorkoutSessionModuleSpec.hpp"
 #include "HybridWorkoutsModuleSpec.hpp"
 #include "IdentifierWithUnit.hpp"
 #include "LocationForSaving.hpp"
@@ -239,7 +230,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "QueryOptionsWithSortOrderAndUnit.hpp"
 #include "QueryStatisticsResponse.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
-#include "RemoteSessionSharableData.hpp"
 #include "SampleTypeIdentifier.hpp"
 #include "SampleTypeIdentifierWriteable.hpp"
 #include "Source.hpp"
@@ -263,7 +253,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "WorkoutRouteLocation.hpp"
 #include "WorkoutSample.hpp"
 #include "WorkoutSessionLocationType.hpp"
-#include "WorkoutSessionState.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -745,38 +734,38 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_BloodType_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::chrono::system_clock::time_point>>
+  // pragma MARK: std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::chrono::system_clock::time_point>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>`.
    */
-  using std__shared_ptr_Promise_std__chrono__system_clock__time_point__ = std::shared_ptr<Promise<std::chrono::system_clock::time_point>>;
-  inline std::shared_ptr<Promise<std::chrono::system_clock::time_point>> create_std__shared_ptr_Promise_std__chrono__system_clock__time_point__() {
-    return Promise<std::chrono::system_clock::time_point>::create();
+  using std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point___ = std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>;
+  inline std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>> create_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point___() {
+    return Promise<std::optional<std::chrono::system_clock::time_point>>::create();
   }
-  inline PromiseHolder<std::chrono::system_clock::time_point> wrap_std__shared_ptr_Promise_std__chrono__system_clock__time_point__(std::shared_ptr<Promise<std::chrono::system_clock::time_point>> promise) {
-    return PromiseHolder<std::chrono::system_clock::time_point>(std::move(promise));
+  inline PromiseHolder<std::optional<std::chrono::system_clock::time_point>> wrap_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point___(std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>> promise) {
+    return PromiseHolder<std::optional<std::chrono::system_clock::time_point>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(std::chrono::system_clock::time_point /* result */)>
+  // pragma MARK: std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>
   /**
-   * Specialized version of `std::function<void(std::chrono::system_clock::time_point)>`.
+   * Specialized version of `std::function<void(std::optional<std::chrono::system_clock::time_point>)>`.
    */
-  using Func_void_std__chrono__system_clock__time_point = std::function<void(std::chrono::system_clock::time_point /* result */)>;
+  using Func_void_std__optional_std__chrono__system_clock__time_point_ = std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(std::chrono::system_clock::time_point / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(std::optional<std::chrono::system_clock::time_point> / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__chrono__system_clock__time_point_Wrapper final {
+  class Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper final {
   public:
-    explicit Func_void_std__chrono__system_clock__time_point_Wrapper(std::function<void(std::chrono::system_clock::time_point /* result */)>&& func): _function(std::make_shared<std::function<void(std::chrono::system_clock::time_point /* result */)>>(std::move(func))) {}
-    inline void call(std::chrono::system_clock::time_point result) const {
+    explicit Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper(std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>&& func): _function(std::make_shared<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<std::chrono::system_clock::time_point> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(std::chrono::system_clock::time_point /* result */)>> _function;
+    std::shared_ptr<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>> _function;
   };
-  Func_void_std__chrono__system_clock__time_point create_Func_void_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__chrono__system_clock__time_point_Wrapper wrap_Func_void_std__chrono__system_clock__time_point(Func_void_std__chrono__system_clock__time_point value) {
-    return Func_void_std__chrono__system_clock__time_point_Wrapper(std::move(value));
+  Func_void_std__optional_std__chrono__system_clock__time_point_ create_Func_void_std__optional_std__chrono__system_clock__time_point_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper wrap_Func_void_std__optional_std__chrono__system_clock__time_point_(Func_void_std__optional_std__chrono__system_clock__time_point_ value) {
+    return Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::shared_ptr<Promise<BiologicalSex>>
@@ -902,13 +891,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<BloodType>::withError(error);
   }
   
-  // pragma MARK: Result<std::chrono::system_clock::time_point>
-  using Result_std__chrono__system_clock__time_point_ = Result<std::chrono::system_clock::time_point>;
-  inline Result_std__chrono__system_clock__time_point_ create_Result_std__chrono__system_clock__time_point_(std::chrono::system_clock::time_point value) {
-    return Result<std::chrono::system_clock::time_point>::withValue(std::move(value));
+  // pragma MARK: Result<std::optional<std::chrono::system_clock::time_point>>
+  using Result_std__optional_std__chrono__system_clock__time_point__ = Result<std::optional<std::chrono::system_clock::time_point>>;
+  inline Result_std__optional_std__chrono__system_clock__time_point__ create_Result_std__optional_std__chrono__system_clock__time_point__(std::optional<std::chrono::system_clock::time_point> value) {
+    return Result<std::optional<std::chrono::system_clock::time_point>>::withValue(std::move(value));
   }
-  inline Result_std__chrono__system_clock__time_point_ create_Result_std__chrono__system_clock__time_point_(const std::exception_ptr& error) {
-    return Result<std::chrono::system_clock::time_point>::withError(error);
+  inline Result_std__optional_std__chrono__system_clock__time_point__ create_Result_std__optional_std__chrono__system_clock__time_point__(const std::exception_ptr& error) {
+    return Result<std::optional<std::chrono::system_clock::time_point>>::withError(error);
   }
   
   // pragma MARK: Result<BiologicalSex>
@@ -947,13 +936,13 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<BloodType>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::chrono::system_clock::time_point>>>
-  using Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___ = Result<std::shared_ptr<Promise<std::chrono::system_clock::time_point>>>;
-  inline Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___ create_Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___(const std::shared_ptr<Promise<std::chrono::system_clock::time_point>>& value) {
-    return Result<std::shared_ptr<Promise<std::chrono::system_clock::time_point>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>>
+  using Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____ = Result<std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____ create_Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____(const std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>& value) {
+    return Result<std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___ create_Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::chrono::system_clock::time_point>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____ create_Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<BiologicalSex>>>
@@ -2147,138 +2136,40 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>::withError(error);
   }
   
-  // pragma MARK: std::optional<WorkoutSessionLocationType>
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
   /**
-   * Specialized version of `std::optional<WorkoutSessionLocationType>`.
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
    */
-  using std__optional_WorkoutSessionLocationType_ = std::optional<WorkoutSessionLocationType>;
-  inline std::optional<WorkoutSessionLocationType> create_std__optional_WorkoutSessionLocationType_(const WorkoutSessionLocationType& value) {
-    return std::optional<WorkoutSessionLocationType>(value);
+  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();
+  }
+  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));
   }
   
-  // pragma MARK: std::function<void(const std::string& /* errorMessage */)>
+  // pragma MARK: std::function<void(const std::string& /* result */)>
   /**
    * Specialized version of `std::function<void(const std::string&)>`.
    */
-  using Func_void_std__string = std::function<void(const std::string& /* errorMessage */)>;
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::string& / * errorMessage * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
    */
   class Func_void_std__string_Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* errorMessage */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* errorMessage */)>>(std::move(func))) {}
-    inline void call(std::string errorMessage) const {
-      _function->operator()(errorMessage);
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const {
+      _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::string& /* errorMessage */)>> _function;
+    std::shared_ptr<std::function<void(const std::string& /* result */)>> _function;
   };
   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));
   }
   
-  // pragma MARK: std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>
-  /**
-   * Specialized version of `std::function<void(WorkoutSessionState, WorkoutSessionState, std::chrono::system_clock::time_point)>`.
-   */
-  using Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point = std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>;
-  /**
-   * Wrapper class for a `std::function<void(WorkoutSessionState / * toState * /, WorkoutSessionState / * fromState * /, std::chrono::system_clock::time_point / * date * /)>`, this can be used from Swift.
-   */
-  class Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper final {
-  public:
-    explicit Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper(std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>&& func): _function(std::make_shared<std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>>(std::move(func))) {}
-    inline void call(int toState, int fromState, std::chrono::system_clock::time_point date) const {
-      _function->operator()(static_cast<WorkoutSessionState>(toState), static_cast<WorkoutSessionState>(fromState), date);
-    }
-  private:
-    std::shared_ptr<std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>> _function;
-  };
-  Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point create_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper wrap_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point value) {
-    return Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::vector<RemoteSessionSharableData>
-  /**
-   * Specialized version of `std::vector<RemoteSessionSharableData>`.
-   */
-  using std__vector_RemoteSessionSharableData_ = std::vector<RemoteSessionSharableData>;
-  inline std::vector<RemoteSessionSharableData> create_std__vector_RemoteSessionSharableData_(size_t size) {
-    std::vector<RemoteSessionSharableData> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>
-  /**
-   * Specialized version of `std::function<void(const std::vector<RemoteSessionSharableData>&)>`.
-   */
-  using Func_void_std__vector_RemoteSessionSharableData_ = std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::vector<RemoteSessionSharableData>& / * data * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__vector_RemoteSessionSharableData__Wrapper final {
-  public:
-    explicit Func_void_std__vector_RemoteSessionSharableData__Wrapper(std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>&& func): _function(std::make_shared<std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>>(std::move(func))) {}
-    inline void call(std::vector<RemoteSessionSharableData> data) const {
-      _function->operator()(data);
-    }
-  private:
-    std::shared_ptr<std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>> _function;
-  };
-  Func_void_std__vector_RemoteSessionSharableData_ create_Func_void_std__vector_RemoteSessionSharableData_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_RemoteSessionSharableData__Wrapper wrap_Func_void_std__vector_RemoteSessionSharableData_(Func_void_std__vector_RemoteSessionSharableData_ value) {
-    return Func_void_std__vector_RemoteSessionSharableData__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::function<void(WorkoutEventType /* type */)>
-  /**
-   * Specialized version of `std::function<void(WorkoutEventType)>`.
-   */
-  using Func_void_WorkoutEventType = std::function<void(WorkoutEventType /* type */)>;
-  /**
-   * Wrapper class for a `std::function<void(WorkoutEventType / * type * /)>`, this can be used from Swift.
-   */
-  class Func_void_WorkoutEventType_Wrapper final {
-  public:
-    explicit Func_void_WorkoutEventType_Wrapper(std::function<void(WorkoutEventType /* type */)>&& func): _function(std::make_shared<std::function<void(WorkoutEventType /* type */)>>(std::move(func))) {}
-    inline void call(int type) const {
-      _function->operator()(static_cast<WorkoutEventType>(type));
-    }
-  private:
-    std::shared_ptr<std::function<void(WorkoutEventType /* type */)>> _function;
-  };
-  Func_void_WorkoutEventType create_Func_void_WorkoutEventType(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_WorkoutEventType_Wrapper wrap_Func_void_WorkoutEventType(Func_void_WorkoutEventType value) {
-    return Func_void_WorkoutEventType_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>;
-  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
-  using std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>;
-  inline std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>& strong) { return strong; }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::string>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
-   */
-  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();
-  }
-  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));
-  }
-  
   // pragma MARK: std::vector<QuantitySampleForSaving>
   /**
    * Specialized version of `std::vector<QuantitySampleForSaving>`.
@@ -2519,6 +2410,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<WorkoutSessionLocationType>
+  /**
+   * Specialized version of `std::optional<WorkoutSessionLocationType>`.
+   */
+  using std__optional_WorkoutSessionLocationType_ = std::optional<WorkoutSessionLocationType>;
+  inline std::optional<WorkoutSessionLocationType> create_std__optional_WorkoutSessionLocationType_(const WorkoutSessionLocationType& value) {
+    return std::optional<WorkoutSessionLocationType>(value);
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>`.

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

@@ -66,8 +66,6 @@ namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
 namespace margelo::nitro::healthkit { class HybridStateOfMindModuleSpec; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
-// Forward declaration of `HybridWorkoutSessionModuleSpec` to properly resolve imports.
-namespace margelo::nitro::healthkit { class HybridWorkoutSessionModuleSpec; }
 // Forward declaration of `HybridWorkoutsModuleSpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutsModuleSpec; }
 // Forward declaration of `IdentifierWithUnit` to properly resolve imports.
@@ -118,8 +116,6 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
-// Forward declaration of `RemoteSessionSharableData` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct RemoteSessionSharableData; }
 // Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
 // Forward declaration of `SampleTypeIdentifier` to properly resolve imports.
@@ -174,10 +170,6 @@ namespace margelo::nitro::healthkit { struct WorkoutRoute; }
 namespace margelo::nitro::healthkit { struct WorkoutSample; }
 // Forward declaration of `WorkoutSessionLocationType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WorkoutSessionLocationType; }
-// Forward declaration of `WorkoutSessionMirroringStartHandlerOptions` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct WorkoutSessionMirroringStartHandlerOptions; }
-// Forward declaration of `WorkoutSessionState` to properly resolve imports.
-namespace margelo::nitro::healthkit { enum class WorkoutSessionState; }
 // Forward declaration of `WorkoutTotals` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 
@@ -210,7 +202,6 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "HybridSourceProxySpec.hpp"
 #include "HybridStateOfMindModuleSpec.hpp"
 #include "HybridWorkoutProxySpec.hpp"
-#include "HybridWorkoutSessionModuleSpec.hpp"
 #include "HybridWorkoutsModuleSpec.hpp"
 #include "IdentifierWithUnit.hpp"
 #include "IntervalComponents.hpp"
@@ -236,7 +227,6 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "QueryOptionsWithSortOrderAndUnit.hpp"
 #include "QueryStatisticsResponse.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
-#include "RemoteSessionSharableData.hpp"
 #include "SampleTypeIdentifier.hpp"
 #include "SampleTypeIdentifierWriteable.hpp"
 #include "Source.hpp"
@@ -264,8 +254,6 @@ namespace margelo::nitro::healthkit { struct WorkoutTotals; }
 #include "WorkoutRouteLocation.hpp"
 #include "WorkoutSample.hpp"
 #include "WorkoutSessionLocationType.hpp"
-#include "WorkoutSessionMirroringStartHandlerOptions.hpp"
-#include "WorkoutSessionState.hpp"
 #include "WorkoutTotals.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Promise.hpp>
@@ -308,8 +296,6 @@ namespace ReactNativeHealthkit { class HybridSourceProxySpec_cxx; }
 namespace ReactNativeHealthkit { class HybridStateOfMindModuleSpec_cxx; }
 // Forward declaration of `HybridWorkoutProxySpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutProxySpec_cxx; }
-// Forward declaration of `HybridWorkoutSessionModuleSpec_cxx` to properly resolve imports.
-namespace ReactNativeHealthkit { class HybridWorkoutSessionModuleSpec_cxx; }
 // Forward declaration of `HybridWorkoutsModuleSpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 

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

@@ -22,6 +22,7 @@ namespace margelo::nitro::healthkit { enum class FitzpatrickSkinType; }
 namespace margelo::nitro::healthkit { enum class WheelchairUse; }
 
 #include "BloodType.hpp"
+#include <optional>
 #include <chrono>
 #include "BiologicalSex.hpp"
 #include "FitzpatrickSkinType.hpp"
@@ -75,7 +76,7 @@ namespace margelo::nitro::healthkit {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::chrono::system_clock::time_point getDateOfBirth() override {
+    inline std::optional<std::chrono::system_clock::time_point> getDateOfBirth() override {
       auto __result = _swiftPart.getDateOfBirth();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -115,7 +116,7 @@ namespace margelo::nitro::healthkit {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<std::chrono::system_clock::time_point>> getDateOfBirthAsync() override {
+    inline std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>> getDateOfBirthAsync() override {
       auto __result = _swiftPart.getDateOfBirthAsync();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/Func_void_std__optional_std__chrono__system_clock__time_point_.swift

@@ -0,0 +1,52 @@
+///
+/// Func_void_std__optional_std__chrono__system_clock__time_point_.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: Date?) -> 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__optional_std__chrono__system_clock__time_point_ {
+  public typealias bridge = margelo.nitro.healthkit.bridge.swift
+
+  private let closure: (_ value: Date?) -> Void
+
+  public init(_ closure: @escaping (_ value: Date?) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__optional_std__chrono__system_clock__time_point_) -> Void {
+    self.closure({ () -> Date? in
+      if let __unwrapped = value.value {
+        return Date(fromChrono: __unwrapped)
+      } else {
+        return nil
+      }
+    }())
+  }
+
+  /**
+   * 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__optional_std__chrono__system_clock__time_point_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__optional_std__chrono__system_clock__time_point_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__optional_std__chrono__system_clock__time_point_ {
+    return Unmanaged<Func_void_std__optional_std__chrono__system_clock__time_point_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridCharacteristicTypeModuleSpec.swift

@@ -15,12 +15,12 @@ public protocol HybridCharacteristicTypeModuleSpec_protocol: HybridObject {
 
   // Methods
   func getBloodType() throws -> BloodType
-  func getDateOfBirth() throws -> Date
+  func getDateOfBirth() throws -> Date?
   func getBiologicalSex() throws -> BiologicalSex
   func getFitzpatrickSkinType() throws -> FitzpatrickSkinType
   func getWheelchairUse() throws -> WheelchairUse
   func getBloodTypeAsync() throws -> Promise<BloodType>
-  func getDateOfBirthAsync() throws -> Promise<Date>
+  func getDateOfBirthAsync() throws -> Promise<Date?>
   func getBiologicalSexAsync() throws -> Promise<BiologicalSex>
   func getFitzpatrickSkinTypeAsync() throws -> Promise<FitzpatrickSkinType>
   func getWheelchairUseAsync() throws -> Promise<WheelchairUse>

package/nitrogen/generated/ios/swift/HybridCharacteristicTypeModuleSpec_cxx.swift

@@ -113,14 +113,20 @@ public class HybridCharacteristicTypeModuleSpec_cxx {
   }
   
   @inline(__always)
-  public final func getDateOfBirth() -> bridge.Result_std__chrono__system_clock__time_point_ {
+  public final func getDateOfBirth() -> bridge.Result_std__optional_std__chrono__system_clock__time_point__ {
     do {
       let __result = try self.__implementation.getDateOfBirth()
-      let __resultCpp = __result.toCpp()
-      return bridge.create_Result_std__chrono__system_clock__time_point_(__resultCpp)
+      let __resultCpp = { () -> bridge.std__optional_std__chrono__system_clock__time_point_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__chrono__system_clock__time_point_(__unwrappedValue.toCpp())
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__chrono__system_clock__time_point__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__chrono__system_clock__time_point_(__exceptionPtr)
+      return bridge.create_Result_std__optional_std__chrono__system_clock__time_point__(__exceptionPtr)
     }
   }
   
@@ -180,21 +186,27 @@ public class HybridCharacteristicTypeModuleSpec_cxx {
   }
   
   @inline(__always)
-  public final func getDateOfBirthAsync() -> bridge.Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___ {
+  public final func getDateOfBirthAsync() -> bridge.Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____ {
     do {
       let __result = try self.__implementation.getDateOfBirthAsync()
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__chrono__system_clock__time_point__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__chrono__system_clock__time_point__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__chrono__system_clock__time_point__(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point___(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve(__result.toCpp()) })
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__optional_std__chrono__system_clock__time_point_ in
+              if let __unwrappedValue = __result {
+                return bridge.create_std__optional_std__chrono__system_clock__time_point_(__unwrappedValue.toCpp())
+              } else {
+                return .init()
+              }
+            }()) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__chrono__system_clock__time_point___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_std__chrono__system_clock__time_point____(__exceptionPtr)
     }
   }
   

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

@@ -23,6 +23,7 @@ namespace margelo::nitro::healthkit { enum class FitzpatrickSkinType; }
 namespace margelo::nitro::healthkit { enum class WheelchairUse; }
 
 #include "BloodType.hpp"
+#include <optional>
 #include <chrono>
 #include "BiologicalSex.hpp"
 #include "FitzpatrickSkinType.hpp"
@@ -61,12 +62,12 @@ namespace margelo::nitro::healthkit {
     public:
       // Methods
       virtual BloodType getBloodType() = 0;
-      virtual std::chrono::system_clock::time_point getDateOfBirth() = 0;
+      virtual std::optional<std::chrono::system_clock::time_point> getDateOfBirth() = 0;
       virtual BiologicalSex getBiologicalSex() = 0;
       virtual FitzpatrickSkinType getFitzpatrickSkinType() = 0;
       virtual WheelchairUse getWheelchairUse() = 0;
       virtual std::shared_ptr<Promise<BloodType>> getBloodTypeAsync() = 0;
-      virtual std::shared_ptr<Promise<std::chrono::system_clock::time_point>> getDateOfBirthAsync() = 0;
+      virtual std::shared_ptr<Promise<std::optional<std::chrono::system_clock::time_point>>> getDateOfBirthAsync() = 0;
       virtual std::shared_ptr<Promise<BiologicalSex>> getBiologicalSexAsync() = 0;
       virtual std::shared_ptr<Promise<FitzpatrickSkinType>> getFitzpatrickSkinTypeAsync() = 0;
       virtual std::shared_ptr<Promise<WheelchairUse>> getWheelchairUseAsync() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingstinct/react-native-healthkit",
-  "version": "9.0.6",
+  "version": "9.0.8",
   "description": "React Native bindings for HealthKit",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -92,7 +92,7 @@
     "@types/react": "~19.0.14",
     "nitro-codegen": "^0.26.2",
     "react": "19.0.0",
-    "react-native": "^0.79.3",
+    "react-native": "*",
     "react-native-nitro-modules": "^0.26.2",
     "typescript": "~5.8.3"
   },