@kingstinct/react-native-healthkit 11.1.0 → 11.1.1

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

@@ -283,6 +283,7 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "WorkoutSample.hpp"
 #include "WorkoutSessionLocationType.hpp"
 #include <NitroModules/AnyMap.hpp>
+#include <NitroModules/FastVectorCopy.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -331,7 +332,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(bool /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper) noexcept;
+  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));
   }
@@ -353,7 +354,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   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* _Nonnull swiftClosureWrapper) noexcept;
+  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));
   }
@@ -393,8 +394,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridSourceProxySpec>`.
    */
   using std__shared_ptr_HybridSourceProxySpec_ = std::shared_ptr<HybridSourceProxySpec>;
-  std::shared_ptr<HybridSourceProxySpec> create_std__shared_ptr_HybridSourceProxySpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridSourceProxySpec_(std__shared_ptr_HybridSourceProxySpec_ cppType) noexcept;
+  std::shared_ptr<HybridSourceProxySpec> create_std__shared_ptr_HybridSourceProxySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridSourceProxySpec_(std__shared_ptr_HybridSourceProxySpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridSourceProxySpec>
   using std__weak_ptr_HybridSourceProxySpec_ = std::weak_ptr<HybridSourceProxySpec>;
@@ -470,7 +471,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<CategorySample>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_CategorySample__Wrapper wrap_Func_void_std__vector_CategorySample_(Func_void_std__vector_CategorySample_ value) noexcept {
     return Func_void_std__vector_CategorySample__Wrapper(std::move(value));
   }
@@ -592,8 +593,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridWorkoutProxySpec>`.
    */
   using std__shared_ptr_HybridWorkoutProxySpec_ = std::shared_ptr<HybridWorkoutProxySpec>;
-  std::shared_ptr<HybridWorkoutProxySpec> create_std__shared_ptr_HybridWorkoutProxySpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridWorkoutProxySpec_(std__shared_ptr_HybridWorkoutProxySpec_ cppType) noexcept;
+  std::shared_ptr<HybridWorkoutProxySpec> create_std__shared_ptr_HybridWorkoutProxySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridWorkoutProxySpec_(std__shared_ptr_HybridWorkoutProxySpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridWorkoutProxySpec>
   using std__weak_ptr_HybridWorkoutProxySpec_ = std::weak_ptr<HybridWorkoutProxySpec>;
@@ -816,7 +817,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_CategorySamplesWithAnchorResponse_Wrapper wrap_Func_void_CategorySamplesWithAnchorResponse(Func_void_CategorySamplesWithAnchorResponse value) noexcept {
     return Func_void_CategorySamplesWithAnchorResponse_Wrapper(std::move(value));
   }
@@ -826,8 +827,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridCategoryTypeModuleSpec>`.
    */
   using std__shared_ptr_HybridCategoryTypeModuleSpec_ = std::shared_ptr<HybridCategoryTypeModuleSpec>;
-  std::shared_ptr<HybridCategoryTypeModuleSpec> create_std__shared_ptr_HybridCategoryTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridCategoryTypeModuleSpec_(std__shared_ptr_HybridCategoryTypeModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridCategoryTypeModuleSpec> create_std__shared_ptr_HybridCategoryTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCategoryTypeModuleSpec_(std__shared_ptr_HybridCategoryTypeModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridCategoryTypeModuleSpec>
   using std__weak_ptr_HybridCategoryTypeModuleSpec_ = std::weak_ptr<HybridCategoryTypeModuleSpec>;
@@ -889,7 +890,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(BloodType /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_BloodType create_Func_void_BloodType(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_BloodType create_Func_void_BloodType(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_BloodType_Wrapper wrap_Func_void_BloodType(Func_void_BloodType value) noexcept {
     return Func_void_BloodType_Wrapper(std::move(value));
   }
@@ -923,7 +924,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(std::optional<std::chrono::system_clock::time_point> /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_std__chrono__system_clock__time_point_ create_Func_void_std__optional_std__chrono__system_clock__time_point_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__optional_std__chrono__system_clock__time_point_ create_Func_void_std__optional_std__chrono__system_clock__time_point_(void* NON_NULL swiftClosureWrapper) noexcept;
   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) noexcept {
     return Func_void_std__optional_std__chrono__system_clock__time_point__Wrapper(std::move(value));
   }
@@ -957,7 +958,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(BiologicalSex /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_BiologicalSex_Wrapper wrap_Func_void_BiologicalSex(Func_void_BiologicalSex value) noexcept {
     return Func_void_BiologicalSex_Wrapper(std::move(value));
   }
@@ -991,7 +992,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(FitzpatrickSkinType /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_FitzpatrickSkinType_Wrapper wrap_Func_void_FitzpatrickSkinType(Func_void_FitzpatrickSkinType value) noexcept {
     return Func_void_FitzpatrickSkinType_Wrapper(std::move(value));
   }
@@ -1025,7 +1026,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(WheelchairUse /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_WheelchairUse_Wrapper wrap_Func_void_WheelchairUse(Func_void_WheelchairUse value) noexcept {
     return Func_void_WheelchairUse_Wrapper(std::move(value));
   }
@@ -1035,8 +1036,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridCharacteristicTypeModuleSpec>`.
    */
   using std__shared_ptr_HybridCharacteristicTypeModuleSpec_ = std::shared_ptr<HybridCharacteristicTypeModuleSpec>;
-  std::shared_ptr<HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(std__shared_ptr_HybridCharacteristicTypeModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCharacteristicTypeModuleSpec_(std__shared_ptr_HybridCharacteristicTypeModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridCharacteristicTypeModuleSpec>
   using std__weak_ptr_HybridCharacteristicTypeModuleSpec_ = std::weak_ptr<HybridCharacteristicTypeModuleSpec>;
@@ -1172,7 +1173,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_IdentifierWithUnit__Wrapper wrap_Func_void_std__vector_IdentifierWithUnit_(Func_void_std__vector_IdentifierWithUnit_ value) noexcept {
     return Func_void_std__vector_IdentifierWithUnit__Wrapper(std::move(value));
   }
@@ -1182,10 +1183,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::vector<QuantityTypeIdentifier>`.
    */
   using std__vector_QuantityTypeIdentifier_ = std::vector<QuantityTypeIdentifier>;
-  inline std::vector<QuantityTypeIdentifier> create_std__vector_QuantityTypeIdentifier_(size_t size) noexcept {
-    std::vector<QuantityTypeIdentifier> vector;
-    vector.reserve(size);
-    return vector;
+  inline std::vector<QuantityTypeIdentifier> copy_std__vector_QuantityTypeIdentifier_(const QuantityTypeIdentifier* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<QuantityTypeIdentifier>(data, size);
+  }
+  inline const QuantityTypeIdentifier* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_QuantityTypeIdentifier_(const std::vector<QuantityTypeIdentifier>& vector) noexcept {
+    return vector.data();
   }
   
   // pragma MARK: std::vector<std::shared_ptr<HybridSourceProxySpec>>
@@ -1228,7 +1230,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<std::shared_ptr<HybridSourceProxySpec>>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__(Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec__ value) noexcept {
     return Func_void_std__vector_std__shared_ptr_HybridSourceProxySpec___Wrapper(std::move(value));
   }
@@ -1250,7 +1252,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const OnChangeCallbackArgs& /* args */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_OnChangeCallbackArgs_Wrapper wrap_Func_void_OnChangeCallbackArgs(Func_void_OnChangeCallbackArgs value) noexcept {
     return Func_void_OnChangeCallbackArgs_Wrapper(std::move(value));
   }
@@ -1284,7 +1286,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(double /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
     return Func_void_double_Wrapper(std::move(value));
   }
@@ -1318,7 +1320,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(AuthorizationRequestStatus /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_AuthorizationRequestStatus_Wrapper wrap_Func_void_AuthorizationRequestStatus(Func_void_AuthorizationRequestStatus value) noexcept {
     return Func_void_AuthorizationRequestStatus_Wrapper(std::move(value));
   }
@@ -1328,10 +1330,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::vector<SampleTypeIdentifierWriteable>`.
    */
   using std__vector_SampleTypeIdentifierWriteable_ = std::vector<SampleTypeIdentifierWriteable>;
-  inline std::vector<SampleTypeIdentifierWriteable> create_std__vector_SampleTypeIdentifierWriteable_(size_t size) noexcept {
-    std::vector<SampleTypeIdentifierWriteable> vector;
-    vector.reserve(size);
-    return vector;
+  inline std::vector<SampleTypeIdentifierWriteable> copy_std__vector_SampleTypeIdentifierWriteable_(const SampleTypeIdentifierWriteable* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<SampleTypeIdentifierWriteable>(data, size);
+  }
+  inline const SampleTypeIdentifierWriteable* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_SampleTypeIdentifierWriteable_(const std::vector<SampleTypeIdentifierWriteable>& vector) noexcept {
+    return vector.data();
   }
   
   // pragma MARK: std::vector<ObjectTypeIdentifier>
@@ -1339,10 +1342,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::vector<ObjectTypeIdentifier>`.
    */
   using std__vector_ObjectTypeIdentifier_ = std::vector<ObjectTypeIdentifier>;
-  inline std::vector<ObjectTypeIdentifier> create_std__vector_ObjectTypeIdentifier_(size_t size) noexcept {
-    std::vector<ObjectTypeIdentifier> vector;
-    vector.reserve(size);
-    return vector;
+  inline std::vector<ObjectTypeIdentifier> copy_std__vector_ObjectTypeIdentifier_(const ObjectTypeIdentifier* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<ObjectTypeIdentifier>(data, size);
+  }
+  inline const ObjectTypeIdentifier* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_ObjectTypeIdentifier_(const std::vector<ObjectTypeIdentifier>& vector) noexcept {
+    return vector.data();
   }
   
   // pragma MARK: std::unordered_map<std::string, bool>
@@ -1399,7 +1403,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__unordered_map_std__string__bool_ create_Func_void_std__unordered_map_std__string__bool_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__unordered_map_std__string__bool_ create_Func_void_std__unordered_map_std__string__bool_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__unordered_map_std__string__bool__Wrapper wrap_Func_void_std__unordered_map_std__string__bool_(Func_void_std__unordered_map_std__string__bool_ value) noexcept {
     return Func_void_std__unordered_map_std__string__bool__Wrapper(std::move(value));
   }
@@ -1409,8 +1413,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridCoreModuleSpec>`.
    */
   using std__shared_ptr_HybridCoreModuleSpec_ = std::shared_ptr<HybridCoreModuleSpec>;
-  std::shared_ptr<HybridCoreModuleSpec> create_std__shared_ptr_HybridCoreModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridCoreModuleSpec_(std__shared_ptr_HybridCoreModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridCoreModuleSpec> create_std__shared_ptr_HybridCoreModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCoreModuleSpec_(std__shared_ptr_HybridCoreModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridCoreModuleSpec>
   using std__weak_ptr_HybridCoreModuleSpec_ = std::weak_ptr<HybridCoreModuleSpec>;
@@ -1626,7 +1630,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<CorrelationSample>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_CorrelationSample__Wrapper wrap_Func_void_std__vector_CorrelationSample_(Func_void_std__vector_CorrelationSample_ value) noexcept {
     return Func_void_std__vector_CorrelationSample__Wrapper(std::move(value));
   }
@@ -1636,8 +1640,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridCorrelationTypeModuleSpec>`.
    */
   using std__shared_ptr_HybridCorrelationTypeModuleSpec_ = std::shared_ptr<HybridCorrelationTypeModuleSpec>;
-  std::shared_ptr<HybridCorrelationTypeModuleSpec> create_std__shared_ptr_HybridCorrelationTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridCorrelationTypeModuleSpec_(std__shared_ptr_HybridCorrelationTypeModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridCorrelationTypeModuleSpec> create_std__shared_ptr_HybridCorrelationTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCorrelationTypeModuleSpec_(std__shared_ptr_HybridCorrelationTypeModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridCorrelationTypeModuleSpec>
   using std__weak_ptr_HybridCorrelationTypeModuleSpec_ = std::weak_ptr<HybridCorrelationTypeModuleSpec>;
@@ -1718,7 +1722,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<ElectrocardiogramSample>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_ElectrocardiogramSample_ create_Func_void_std__vector_ElectrocardiogramSample_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_ElectrocardiogramSample_ create_Func_void_std__vector_ElectrocardiogramSample_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_ElectrocardiogramSample__Wrapper wrap_Func_void_std__vector_ElectrocardiogramSample_(Func_void_std__vector_ElectrocardiogramSample_ value) noexcept {
     return Func_void_std__vector_ElectrocardiogramSample__Wrapper(std::move(value));
   }
@@ -1767,7 +1771,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const ElectrocardiogramSamplesWithAnchorResponse& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_ElectrocardiogramSamplesWithAnchorResponse create_Func_void_ElectrocardiogramSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_ElectrocardiogramSamplesWithAnchorResponse create_Func_void_ElectrocardiogramSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_ElectrocardiogramSamplesWithAnchorResponse_Wrapper wrap_Func_void_ElectrocardiogramSamplesWithAnchorResponse(Func_void_ElectrocardiogramSamplesWithAnchorResponse value) noexcept {
     return Func_void_ElectrocardiogramSamplesWithAnchorResponse_Wrapper(std::move(value));
   }
@@ -1777,8 +1781,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridElectrocardiogramModuleSpec>`.
    */
   using std__shared_ptr_HybridElectrocardiogramModuleSpec_ = std::shared_ptr<HybridElectrocardiogramModuleSpec>;
-  std::shared_ptr<HybridElectrocardiogramModuleSpec> create_std__shared_ptr_HybridElectrocardiogramModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridElectrocardiogramModuleSpec_(std__shared_ptr_HybridElectrocardiogramModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridElectrocardiogramModuleSpec> create_std__shared_ptr_HybridElectrocardiogramModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridElectrocardiogramModuleSpec_(std__shared_ptr_HybridElectrocardiogramModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridElectrocardiogramModuleSpec>
   using std__weak_ptr_HybridElectrocardiogramModuleSpec_ = std::weak_ptr<HybridElectrocardiogramModuleSpec>;
@@ -1853,7 +1857,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_HeartbeatSeriesSample__Wrapper wrap_Func_void_std__vector_HeartbeatSeriesSample_(Func_void_std__vector_HeartbeatSeriesSample_ value) noexcept {
     return Func_void_std__vector_HeartbeatSeriesSample__Wrapper(std::move(value));
   }
@@ -1887,7 +1891,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper wrap_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(Func_void_HeartbeatSeriesSamplesWithAnchorResponse value) noexcept {
     return Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper(std::move(value));
   }
@@ -1897,8 +1901,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridHeartbeatSeriesModuleSpec>`.
    */
   using std__shared_ptr_HybridHeartbeatSeriesModuleSpec_ = std::shared_ptr<HybridHeartbeatSeriesModuleSpec>;
-  std::shared_ptr<HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_HybridHeartbeatSeriesModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_HybridHeartbeatSeriesModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridHeartbeatSeriesModuleSpec>
   using std__weak_ptr_HybridHeartbeatSeriesModuleSpec_ = std::weak_ptr<HybridHeartbeatSeriesModuleSpec>;
@@ -1962,7 +1966,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<QuantitySample>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_QuantitySample__Wrapper wrap_Func_void_std__vector_QuantitySample_(Func_void_std__vector_QuantitySample_ value) noexcept {
     return Func_void_std__vector_QuantitySample__Wrapper(std::move(value));
   }
@@ -2041,7 +2045,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const QueryStatisticsResponse& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_QueryStatisticsResponse_Wrapper wrap_Func_void_QueryStatisticsResponse(Func_void_QueryStatisticsResponse value) noexcept {
     return Func_void_QueryStatisticsResponse_Wrapper(std::move(value));
   }
@@ -2051,10 +2055,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::vector<StatisticsOptions>`.
    */
   using std__vector_StatisticsOptions_ = std::vector<StatisticsOptions>;
-  inline std::vector<StatisticsOptions> create_std__vector_StatisticsOptions_(size_t size) noexcept {
-    std::vector<StatisticsOptions> vector;
-    vector.reserve(size);
-    return vector;
+  inline std::vector<StatisticsOptions> copy_std__vector_StatisticsOptions_(const StatisticsOptions* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<StatisticsOptions>(data, size);
+  }
+  inline const StatisticsOptions* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_StatisticsOptions_(const std::vector<StatisticsOptions>& vector) noexcept {
+    return vector.data();
   }
   
   // pragma MARK: std::optional<StatisticsQueryOptions>
@@ -2112,7 +2117,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_QueryStatisticsResponse__Wrapper wrap_Func_void_std__vector_QueryStatisticsResponse_(Func_void_std__vector_QueryStatisticsResponse_ value) noexcept {
     return Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::move(value));
   }
@@ -2146,7 +2151,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_QuantitySamplesWithAnchorResponse_Wrapper wrap_Func_void_QuantitySamplesWithAnchorResponse(Func_void_QuantitySamplesWithAnchorResponse value) noexcept {
     return Func_void_QuantitySamplesWithAnchorResponse_Wrapper(std::move(value));
   }
@@ -2156,8 +2161,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridQuantityTypeModuleSpec>`.
    */
   using std__shared_ptr_HybridQuantityTypeModuleSpec_ = std::shared_ptr<HybridQuantityTypeModuleSpec>;
-  std::shared_ptr<HybridQuantityTypeModuleSpec> create_std__shared_ptr_HybridQuantityTypeModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridQuantityTypeModuleSpec_(std__shared_ptr_HybridQuantityTypeModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridQuantityTypeModuleSpec> create_std__shared_ptr_HybridQuantityTypeModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridQuantityTypeModuleSpec_(std__shared_ptr_HybridQuantityTypeModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridQuantityTypeModuleSpec>
   using std__weak_ptr_HybridQuantityTypeModuleSpec_ = std::weak_ptr<HybridQuantityTypeModuleSpec>;
@@ -2213,10 +2218,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::vector<StateOfMindAssociation>`.
    */
   using std__vector_StateOfMindAssociation_ = std::vector<StateOfMindAssociation>;
-  inline std::vector<StateOfMindAssociation> create_std__vector_StateOfMindAssociation_(size_t size) noexcept {
-    std::vector<StateOfMindAssociation> vector;
-    vector.reserve(size);
-    return vector;
+  inline std::vector<StateOfMindAssociation> copy_std__vector_StateOfMindAssociation_(const StateOfMindAssociation* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<StateOfMindAssociation>(data, size);
+  }
+  inline const StateOfMindAssociation* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_StateOfMindAssociation_(const std::vector<StateOfMindAssociation>& vector) noexcept {
+    return vector.data();
   }
   
   // pragma MARK: std::vector<StateOfMindLabel>
@@ -2224,10 +2230,11 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::vector<StateOfMindLabel>`.
    */
   using std__vector_StateOfMindLabel_ = std::vector<StateOfMindLabel>;
-  inline std::vector<StateOfMindLabel> create_std__vector_StateOfMindLabel_(size_t size) noexcept {
-    std::vector<StateOfMindLabel> vector;
-    vector.reserve(size);
-    return vector;
+  inline std::vector<StateOfMindLabel> copy_std__vector_StateOfMindLabel_(const StateOfMindLabel* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<StateOfMindLabel>(data, size);
+  }
+  inline const StateOfMindLabel* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_StateOfMindLabel_(const std::vector<StateOfMindLabel>& vector) noexcept {
+    return vector.data();
   }
   
   // pragma MARK: std::vector<StateOfMindSample>
@@ -2270,7 +2277,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<StateOfMindSample>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_StateOfMindSample__Wrapper wrap_Func_void_std__vector_StateOfMindSample_(Func_void_std__vector_StateOfMindSample_ value) noexcept {
     return Func_void_std__vector_StateOfMindSample__Wrapper(std::move(value));
   }
@@ -2280,8 +2287,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridStateOfMindModuleSpec>`.
    */
   using std__shared_ptr_HybridStateOfMindModuleSpec_ = std::shared_ptr<HybridStateOfMindModuleSpec>;
-  std::shared_ptr<HybridStateOfMindModuleSpec> create_std__shared_ptr_HybridStateOfMindModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridStateOfMindModuleSpec_(std__shared_ptr_HybridStateOfMindModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridStateOfMindModuleSpec> create_std__shared_ptr_HybridStateOfMindModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridStateOfMindModuleSpec_(std__shared_ptr_HybridStateOfMindModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridStateOfMindModuleSpec>
   using std__weak_ptr_HybridStateOfMindModuleSpec_ = std::weak_ptr<HybridStateOfMindModuleSpec>;
@@ -2403,7 +2410,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::optional<WorkoutPlan>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__optional_WorkoutPlan__Wrapper wrap_Func_void_std__optional_WorkoutPlan_(Func_void_std__optional_WorkoutPlan_ value) noexcept {
     return Func_void_std__optional_WorkoutPlan__Wrapper(std::move(value));
   }
@@ -2459,7 +2466,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<WorkoutRoute>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_WorkoutRoute__Wrapper wrap_Func_void_std__vector_WorkoutRoute_(Func_void_std__vector_WorkoutRoute_ value) noexcept {
     return Func_void_std__vector_WorkoutRoute__Wrapper(std::move(value));
   }
@@ -2508,7 +2515,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::optional<QueryStatisticsResponse>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_QueryStatisticsResponse_ create_Func_void_std__optional_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__optional_QueryStatisticsResponse_ create_Func_void_std__optional_QueryStatisticsResponse_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__optional_QueryStatisticsResponse__Wrapper wrap_Func_void_std__optional_QueryStatisticsResponse_(Func_void_std__optional_QueryStatisticsResponse_ value) noexcept {
     return Func_void_std__optional_QueryStatisticsResponse__Wrapper(std::move(value));
   }
@@ -2567,7 +2574,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::unordered_map<std::string, QueryStatisticsResponse>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__unordered_map_std__string__QueryStatisticsResponse_ create_Func_void_std__unordered_map_std__string__QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__unordered_map_std__string__QueryStatisticsResponse_ create_Func_void_std__unordered_map_std__string__QueryStatisticsResponse_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__unordered_map_std__string__QueryStatisticsResponse__Wrapper wrap_Func_void_std__unordered_map_std__string__QueryStatisticsResponse_(Func_void_std__unordered_map_std__string__QueryStatisticsResponse_ value) noexcept {
     return Func_void_std__unordered_map_std__string__QueryStatisticsResponse__Wrapper(std::move(value));
   }
@@ -2646,7 +2653,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::shared_ptr<HybridWorkoutProxySpec>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__shared_ptr_HybridWorkoutProxySpec_ create_Func_void_std__shared_ptr_HybridWorkoutProxySpec_(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__shared_ptr_HybridWorkoutProxySpec_ create_Func_void_std__shared_ptr_HybridWorkoutProxySpec_(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__shared_ptr_HybridWorkoutProxySpec__Wrapper wrap_Func_void_std__shared_ptr_HybridWorkoutProxySpec_(Func_void_std__shared_ptr_HybridWorkoutProxySpec_ value) noexcept {
     return Func_void_std__shared_ptr_HybridWorkoutProxySpec__Wrapper(std::move(value));
   }
@@ -2702,7 +2709,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper wrap_Func_void_QueryWorkoutSamplesWithAnchorResponse(Func_void_QueryWorkoutSamplesWithAnchorResponse value) noexcept {
     return Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::move(value));
   }
@@ -2892,7 +2899,7 @@ namespace margelo::nitro::healthkit::bridge::swift {
   private:
     std::unique_ptr<std::function<void(const std::vector<std::shared_ptr<HybridWorkoutProxySpec>>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__(void* _Nonnull swiftClosureWrapper) noexcept;
+  Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__ create_Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__(Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec__ value) noexcept {
     return Func_void_std__vector_std__shared_ptr_HybridWorkoutProxySpec___Wrapper(std::move(value));
   }
@@ -2917,8 +2924,8 @@ namespace margelo::nitro::healthkit::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridWorkoutsModuleSpec>`.
    */
   using std__shared_ptr_HybridWorkoutsModuleSpec_ = std::shared_ptr<HybridWorkoutsModuleSpec>;
-  std::shared_ptr<HybridWorkoutsModuleSpec> create_std__shared_ptr_HybridWorkoutsModuleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
-  void* _Nonnull get_std__shared_ptr_HybridWorkoutsModuleSpec_(std__shared_ptr_HybridWorkoutsModuleSpec_ cppType) noexcept;
+  std::shared_ptr<HybridWorkoutsModuleSpec> create_std__shared_ptr_HybridWorkoutsModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridWorkoutsModuleSpec_(std__shared_ptr_HybridWorkoutsModuleSpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridWorkoutsModuleSpec>
   using std__weak_ptr_HybridWorkoutsModuleSpec_ = std::weak_ptr<HybridWorkoutsModuleSpec>;

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

@@ -136,7 +136,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>> queryCategorySamplesWithAnchor(CategoryTypeIdentifier identifier, const QueryOptionsWithAnchor& options) override {
-      auto __result = _swiftPart.queryCategorySamplesWithAnchor(static_cast<int>(identifier), options);
+      auto __result = _swiftPart.queryCategorySamplesWithAnchor(static_cast<int>(identifier), std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

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

@@ -137,7 +137,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<ElectrocardiogramSamplesWithAnchorResponse>> queryElectrocardiogramSamplesWithAnchor(const ECGQueryOptionsWithAnchor& options) override {
-      auto __result = _swiftPart.queryElectrocardiogramSamplesWithAnchor(options);
+      auto __result = _swiftPart.queryElectrocardiogramSamplesWithAnchor(std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

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

@@ -128,7 +128,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>> queryHeartbeatSeriesSamplesWithAnchor(const QueryOptionsWithAnchor& options) override {
-      auto __result = _swiftPart.queryHeartbeatSeriesSamplesWithAnchor(options);
+      auto __result = _swiftPart.queryHeartbeatSeriesSamplesWithAnchor(std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

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

@@ -178,7 +178,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>> queryStatisticsCollectionForQuantity(QuantityTypeIdentifier identifier, const std::vector<StatisticsOptions>& statistics, const std::string& anchorDate, const IntervalComponents& intervalComponents, const std::optional<StatisticsQueryOptions>& options) override {
-      auto __result = _swiftPart.queryStatisticsCollectionForQuantity(static_cast<int>(identifier), statistics, anchorDate, intervalComponents, options);
+      auto __result = _swiftPart.queryStatisticsCollectionForQuantity(static_cast<int>(identifier), statistics, anchorDate, std::forward<decltype(intervalComponents)>(intervalComponents), options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -186,7 +186,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>> queryQuantitySamplesWithAnchor(QuantityTypeIdentifier identifier, const QueryOptionsWithAnchorAndUnit& options) override {
-      auto __result = _swiftPart.queryQuantitySamplesWithAnchor(static_cast<int>(identifier), options);
+      auto __result = _swiftPart.queryQuantitySamplesWithAnchor(static_cast<int>(identifier), std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

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

@@ -138,8 +138,7 @@ namespace margelo::nitro::healthkit {
       return static_cast<WorkoutActivityType>(__result);
     }
     inline Quantity getDuration() noexcept override {
-      auto __result = _swiftPart.getDuration();
-      return __result;
+      return _swiftPart.getDuration();
     }
     inline std::chrono::system_clock::time_point getStartDate() noexcept override {
       auto __result = _swiftPart.getStartDate();

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

@@ -138,7 +138,7 @@ namespace margelo::nitro::healthkit {
   public:
     // Methods
     inline std::shared_ptr<Promise<std::shared_ptr<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);
+      auto __result = _swiftPart.saveWorkoutSample(static_cast<int>(workoutActivityType), quantities, startDate, endDate, std::forward<decltype(totals)>(totals), metadata);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -146,7 +146,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>> queryWorkoutSamplesWithAnchor(const WorkoutQueryOptionsWithAnchor& options) override {
-      auto __result = _swiftPart.queryWorkoutSamplesWithAnchor(options);
+      auto __result = _swiftPart.queryWorkoutSamplesWithAnchor(std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -154,7 +154,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridWorkoutProxySpec>>>> queryWorkoutSamples(const WorkoutQueryOptions& options) override {
-      auto __result = _swiftPart.queryWorkoutSamples(options);
+      auto __result = _swiftPart.queryWorkoutSamples(std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -162,7 +162,7 @@ namespace margelo::nitro::healthkit {
       return __value;
     }
     inline std::shared_ptr<Promise<bool>> startWatchAppWithWorkoutConfiguration(const WorkoutConfiguration& workoutConfiguration) override {
-      auto __result = _swiftPart.startWatchAppWithWorkoutConfiguration(workoutConfiguration);
+      auto __result = _swiftPart.startWatchAppWithWorkoutConfiguration(std::forward<decltype(workoutConfiguration)>(workoutConfiguration));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }