@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

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

@@ -0,0 +1,2570 @@
+///
+/// ReactNativeHealthkit-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
+// Forward declaration of `AuthorizationRequestStatus` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class AuthorizationRequestStatus; }
+// Forward declaration of `AuthorizationStatus` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class AuthorizationStatus; }
+// Forward declaration of `BiologicalSex` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class BiologicalSex; }
+// Forward declaration of `BloodType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class BloodType; }
+// Forward declaration of `CategorySampleForSaving` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySampleForSaving; }
+// Forward declaration of `CategorySample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySample; }
+// Forward declaration of `CategorySamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CategorySamplesWithAnchorResponse; }
+// Forward declaration of `CategoryTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class CategoryTypeIdentifier; }
+// Forward declaration of `ComparisonPredicateOperator` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class ComparisonPredicateOperator; }
+// Forward declaration of `CorrelationSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct CorrelationSample; }
+// Forward declaration of `CorrelationTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class CorrelationTypeIdentifier; }
+// Forward declaration of `DeletedSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct DeletedSample; }
+// Forward declaration of `Device` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Device; }
+// Forward declaration of `FilterForSamplesAnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesAnd; }
+// Forward declaration of `FilterForSamplesOr` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct FilterForSamplesOr; }
+// Forward declaration of `FitzpatrickSkinType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class FitzpatrickSkinType; }
+// Forward declaration of `HeartbeatSeriesSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct HeartbeatSeriesSample; }
+// Forward declaration of `HeartbeatSeriesSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct HeartbeatSeriesSamplesWithAnchorResponse; }
+// Forward declaration of `Heartbeat` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Heartbeat; }
+// Forward declaration of `HybridCategoryTypeModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridCategoryTypeModuleSpec; }
+// Forward declaration of `HybridCharacteristicTypeModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridCharacteristicTypeModuleSpec; }
+// Forward declaration of `HybridCoreModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridCoreModuleSpec; }
+// Forward declaration of `HybridCorrelationTypeModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridCorrelationTypeModuleSpec; }
+// Forward declaration of `HybridHeartbeatSeriesModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridHeartbeatSeriesModuleSpec; }
+// Forward declaration of `HybridQuantityTypeModuleSpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridQuantityTypeModuleSpec; }
+// Forward declaration of `HybridSourceProxySpec` to properly resolve imports.
+namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
+// Forward declaration of `HybridStateOfMindModuleSpec` to properly resolve imports.
+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.
+namespace margelo::nitro::healthkit { struct IdentifierWithUnit; }
+// Forward declaration of `LocationForSaving` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct LocationForSaving; }
+// Forward declaration of `ObjectTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class ObjectTypeIdentifier; }
+// Forward declaration of `OnChangeCallbackArgs` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct OnChangeCallbackArgs; }
+// Forward declaration of `PredicateForWorkoutsAnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateForWorkoutsAnd; }
+// Forward declaration of `PredicateForWorkoutsOr` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateForWorkoutsOr; }
+// Forward declaration of `PredicateFromWorkout` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateFromWorkout; }
+// Forward declaration of `PredicateWithMetadataKey` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithMetadataKey; }
+// Forward declaration of `PredicateWithStartAndEnd` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithStartAndEnd; }
+// Forward declaration of `PredicateWithUUID` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithUUID; }
+// Forward declaration of `PredicateWithUUIDs` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct PredicateWithUUIDs; }
+// Forward declaration of `QuantityDateInterval` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantityDateInterval; }
+// Forward declaration of `QuantitySampleForSaving` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantitySampleForSaving; }
+// Forward declaration of `QuantitySample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantitySample; }
+// Forward declaration of `QuantitySamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QuantitySamplesWithAnchorResponse; }
+// Forward declaration of `QuantityTypeIdentifier` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class QuantityTypeIdentifier; }
+// Forward declaration of `Quantity` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Quantity; }
+// Forward declaration of `QueryOptionsWithSortOrderAndUnit` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrderAndUnit; }
+// Forward declaration of `QueryOptionsWithSortOrder` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
+// Forward declaration of `QueryStatisticsResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
+// Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
+// Forward declaration of `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.
+namespace margelo::nitro::healthkit { enum class SampleTypeIdentifier; }
+// Forward declaration of `SourceRevision` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct SourceRevision; }
+// Forward declaration of `Source` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct Source; }
+// Forward declaration of `StateOfMindAssociation` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindAssociation; }
+// Forward declaration of `StateOfMindKind` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindKind; }
+// Forward declaration of `StateOfMindLabel` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindLabel; }
+// Forward declaration of `StateOfMindSample` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StateOfMindSample; }
+// Forward declaration of `StateOfMindValenceClassification` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StateOfMindValenceClassification; }
+// Forward declaration of `StatisticsOptions` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class StatisticsOptions; }
+// Forward declaration of `StatisticsQueryOptions` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct StatisticsQueryOptions; }
+// Forward declaration of `WheelchairUse` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WheelchairUse; }
+// Forward declaration of `WorkoutActivityTypePredicate` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutActivityTypePredicate; }
+// Forward declaration of `WorkoutActivityType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WorkoutActivityType; }
+// Forward declaration of `WorkoutActivity` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutActivity; }
+// Forward declaration of `WorkoutDurationPredicate` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutDurationPredicate; }
+// Forward declaration of `WorkoutEventType` to properly resolve imports.
+namespace margelo::nitro::healthkit { enum class WorkoutEventType; }
+// Forward declaration of `WorkoutEvent` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutEvent; }
+// Forward declaration of `WorkoutPlan` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutPlan; }
+// Forward declaration of `WorkoutRouteLocation` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutRouteLocation; }
+// Forward declaration of `WorkoutRoute` to properly resolve imports.
+namespace margelo::nitro::healthkit { struct WorkoutRoute; }
+// Forward declaration of `WorkoutSample` to properly resolve imports.
+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.
+namespace ReactNativeHealthkit { class HybridCategoryTypeModuleSpec_cxx; }
+// Forward declaration of `HybridCharacteristicTypeModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridCharacteristicTypeModuleSpec_cxx; }
+// Forward declaration of `HybridCoreModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridCoreModuleSpec_cxx; }
+// Forward declaration of `HybridCorrelationTypeModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridCorrelationTypeModuleSpec_cxx; }
+// Forward declaration of `HybridHeartbeatSeriesModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridHeartbeatSeriesModuleSpec_cxx; }
+// Forward declaration of `HybridQuantityTypeModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridQuantityTypeModuleSpec_cxx; }
+// Forward declaration of `HybridSourceProxySpec_cxx` to properly resolve imports.
+namespace ReactNativeHealthkit { class HybridSourceProxySpec_cxx; }
+// Forward declaration of `HybridStateOfMindModuleSpec_cxx` to properly resolve imports.
+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; }
+
+// Include C++ defined types
+#include "AuthorizationRequestStatus.hpp"
+#include "AuthorizationStatus.hpp"
+#include "BiologicalSex.hpp"
+#include "BloodType.hpp"
+#include "CategorySample.hpp"
+#include "CategorySampleForSaving.hpp"
+#include "CategorySamplesWithAnchorResponse.hpp"
+#include "CategoryTypeIdentifier.hpp"
+#include "ComparisonPredicateOperator.hpp"
+#include "CorrelationSample.hpp"
+#include "CorrelationTypeIdentifier.hpp"
+#include "DeletedSample.hpp"
+#include "Device.hpp"
+#include "FilterForSamplesAnd.hpp"
+#include "FilterForSamplesOr.hpp"
+#include "FitzpatrickSkinType.hpp"
+#include "Heartbeat.hpp"
+#include "HeartbeatSeriesSample.hpp"
+#include "HeartbeatSeriesSamplesWithAnchorResponse.hpp"
+#include "HybridCategoryTypeModuleSpec.hpp"
+#include "HybridCharacteristicTypeModuleSpec.hpp"
+#include "HybridCoreModuleSpec.hpp"
+#include "HybridCorrelationTypeModuleSpec.hpp"
+#include "HybridHeartbeatSeriesModuleSpec.hpp"
+#include "HybridQuantityTypeModuleSpec.hpp"
+#include "HybridSourceProxySpec.hpp"
+#include "HybridStateOfMindModuleSpec.hpp"
+#include "HybridWorkoutProxySpec.hpp"
+#include "HybridWorkoutSessionModuleSpec.hpp"
+#include "HybridWorkoutsModuleSpec.hpp"
+#include "IdentifierWithUnit.hpp"
+#include "LocationForSaving.hpp"
+#include "ObjectTypeIdentifier.hpp"
+#include "OnChangeCallbackArgs.hpp"
+#include "PredicateForWorkoutsAnd.hpp"
+#include "PredicateForWorkoutsOr.hpp"
+#include "PredicateFromWorkout.hpp"
+#include "PredicateWithMetadataKey.hpp"
+#include "PredicateWithStartAndEnd.hpp"
+#include "PredicateWithUUID.hpp"
+#include "PredicateWithUUIDs.hpp"
+#include "Quantity.hpp"
+#include "QuantityDateInterval.hpp"
+#include "QuantitySample.hpp"
+#include "QuantitySampleForSaving.hpp"
+#include "QuantitySamplesWithAnchorResponse.hpp"
+#include "QuantityTypeIdentifier.hpp"
+#include "QueryOptionsWithSortOrder.hpp"
+#include "QueryOptionsWithSortOrderAndUnit.hpp"
+#include "QueryStatisticsResponse.hpp"
+#include "QueryWorkoutSamplesWithAnchorResponse.hpp"
+#include "RemoteSessionSharableData.hpp"
+#include "SampleTypeIdentifier.hpp"
+#include "SampleTypeIdentifierWriteable.hpp"
+#include "Source.hpp"
+#include "SourceRevision.hpp"
+#include "StateOfMindAssociation.hpp"
+#include "StateOfMindKind.hpp"
+#include "StateOfMindLabel.hpp"
+#include "StateOfMindSample.hpp"
+#include "StateOfMindValenceClassification.hpp"
+#include "StatisticsOptions.hpp"
+#include "StatisticsQueryOptions.hpp"
+#include "WheelchairUse.hpp"
+#include "WorkoutActivity.hpp"
+#include "WorkoutActivityType.hpp"
+#include "WorkoutActivityTypePredicate.hpp"
+#include "WorkoutDurationPredicate.hpp"
+#include "WorkoutEvent.hpp"
+#include "WorkoutEventType.hpp"
+#include "WorkoutPlan.hpp"
+#include "WorkoutRoute.hpp"
+#include "WorkoutRouteLocation.hpp"
+#include "WorkoutSample.hpp"
+#include "WorkoutSessionLocationType.hpp"
+#include "WorkoutSessionState.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <chrono>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+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__() {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) {
+    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_shared<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(bool /* result */)>> _function;
+  };
+  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) {
+    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_shared<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const {
+      _function->operator()(error);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  };
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
+    return std::optional<std::string>(value);
+  }
+  
+  // pragma MARK: std::optional<Device>
+  /**
+   * Specialized version of `std::optional<Device>`.
+   */
+  using std__optional_Device_ = std::optional<Device>;
+  inline std::optional<Device> create_std__optional_Device_(const Device& value) {
+    return std::optional<Device>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_(std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>& strong) { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>`.
+   */
+  using std__optional_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ = std::optional<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>;
+  inline std::optional<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>> create_std__optional_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__(const std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>& value) {
+    return std::optional<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>(value);
+  }
+  
+  // pragma MARK: std::optional<SourceRevision>
+  /**
+   * Specialized version of `std::optional<SourceRevision>`.
+   */
+  using std__optional_SourceRevision_ = std::optional<SourceRevision>;
+  inline std::optional<SourceRevision> create_std__optional_SourceRevision_(const SourceRevision& value) {
+    return std::optional<SourceRevision>(value);
+  }
+  
+  // pragma MARK: std::vector<CategorySample>
+  /**
+   * Specialized version of `std::vector<CategorySample>`.
+   */
+  using std__vector_CategorySample_ = std::vector<CategorySample>;
+  inline std::vector<CategorySample> create_std__vector_CategorySample_(size_t size) {
+    std::vector<CategorySample> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<CategorySample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<CategorySample>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_CategorySample___ = std::shared_ptr<Promise<std::vector<CategorySample>>>;
+  inline std::shared_ptr<Promise<std::vector<CategorySample>>> create_std__shared_ptr_Promise_std__vector_CategorySample___() {
+    return Promise<std::vector<CategorySample>>::create();
+  }
+  inline PromiseHolder<std::vector<CategorySample>> wrap_std__shared_ptr_Promise_std__vector_CategorySample___(std::shared_ptr<Promise<std::vector<CategorySample>>> promise) {
+    return PromiseHolder<std::vector<CategorySample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<CategorySample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<CategorySample>&)>`.
+   */
+  using Func_void_std__vector_CategorySample_ = std::function<void(const std::vector<CategorySample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<CategorySample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_CategorySample__Wrapper final {
+  public:
+    explicit Func_void_std__vector_CategorySample__Wrapper(std::function<void(const std::vector<CategorySample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<CategorySample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<CategorySample> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<CategorySample>& /* result */)>> _function;
+  };
+  Func_void_std__vector_CategorySample_ create_Func_void_std__vector_CategorySample_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_CategorySample__Wrapper wrap_Func_void_std__vector_CategorySample_(Func_void_std__vector_CategorySample_ value) {
+    return Func_void_std__vector_CategorySample__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) {
+    return std::optional<bool>(value);
+  }
+  
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::chrono::system_clock::time_point>
+  /**
+   * Specialized version of `std::optional<std::chrono::system_clock::time_point>`.
+   */
+  using std__optional_std__chrono__system_clock__time_point_ = std::optional<std::chrono::system_clock::time_point>;
+  inline std::optional<std::chrono::system_clock::time_point> create_std__optional_std__chrono__system_clock__time_point_(const std::chrono::system_clock::time_point& value) {
+    return std::optional<std::chrono::system_clock::time_point>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>& strong) { return strong; }
+  
+  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>
+  /**
+   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ {
+    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout> variant;
+    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout> variant): variant(variant) { }
+    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline PredicateWithUUID get_0() const {
+      return std::get<0>(variant);
+    }
+    inline PredicateWithUUIDs get_1() const {
+      return std::get<1>(variant);
+    }
+    inline PredicateWithMetadataKey get_2() const {
+      return std::get<2>(variant);
+    }
+    inline PredicateWithStartAndEnd get_3() const {
+      return std::get<3>(variant);
+    }
+    inline PredicateFromWorkout get_4() const {
+      return std::get<4>(variant);
+    }
+  };
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithUUID& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithUUIDs& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithMetadataKey& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateWithStartAndEnd& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(const PredicateFromWorkout& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout_(value);
+  }
+  
+  // pragma MARK: std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>
+  /**
+   * Specialized version of `std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>`.
+   */
+  using std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__ = std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>;
+  inline std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> create_std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__(size_t size) {
+    std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>
+  /**
+   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ {
+    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr> variant;
+    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr> variant): variant(variant) { }
+    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline PredicateWithUUID get_0() const {
+      return std::get<0>(variant);
+    }
+    inline PredicateWithUUIDs get_1() const {
+      return std::get<1>(variant);
+    }
+    inline PredicateWithMetadataKey get_2() const {
+      return std::get<2>(variant);
+    }
+    inline PredicateWithStartAndEnd get_3() const {
+      return std::get<3>(variant);
+    }
+    inline PredicateFromWorkout get_4() const {
+      return std::get<4>(variant);
+    }
+    inline FilterForSamplesAnd get_5() const {
+      return std::get<5>(variant);
+    }
+    inline FilterForSamplesOr get_6() const {
+      return std::get<6>(variant);
+    }
+  };
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithUUID& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithUUIDs& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithMetadataKey& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateWithStartAndEnd& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const PredicateFromWorkout& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const FilterForSamplesAnd& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(const FilterForSamplesOr& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>
+  /**
+   * Specialized version of `std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>`.
+   */
+  using std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__ = std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>;
+  inline std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>> create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__FilterForSamplesAnd__FilterForSamplesOr__(const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>& value) {
+    return std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, FilterForSamplesAnd, FilterForSamplesOr>>(value);
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) {
+    return std::optional<double>(value);
+  }
+  
+  // pragma MARK: std::optional<QueryOptionsWithSortOrder>
+  /**
+   * Specialized version of `std::optional<QueryOptionsWithSortOrder>`.
+   */
+  using std__optional_QueryOptionsWithSortOrder_ = std::optional<QueryOptionsWithSortOrder>;
+  inline std::optional<QueryOptionsWithSortOrder> create_std__optional_QueryOptionsWithSortOrder_(const QueryOptionsWithSortOrder& value) {
+    return std::optional<QueryOptionsWithSortOrder>(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) {
+    return std::optional<std::shared_ptr<AnyMap>>(value);
+  }
+  
+  // pragma MARK: std::vector<DeletedSample>
+  /**
+   * Specialized version of `std::vector<DeletedSample>`.
+   */
+  using std__vector_DeletedSample_ = std::vector<DeletedSample>;
+  inline std::vector<DeletedSample> create_std__vector_DeletedSample_(size_t size) {
+    std::vector<DeletedSample> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_CategorySamplesWithAnchorResponse__ = std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>> create_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse__() {
+    return Promise<CategorySamplesWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<CategorySamplesWithAnchorResponse> wrap_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse__(std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>> promise) {
+    return PromiseHolder<CategorySamplesWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const CategorySamplesWithAnchorResponse&)>`.
+   */
+  using Func_void_CategorySamplesWithAnchorResponse = std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CategorySamplesWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_CategorySamplesWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_CategorySamplesWithAnchorResponse_Wrapper(std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(CategorySamplesWithAnchorResponse result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const CategorySamplesWithAnchorResponse& /* result */)>> _function;
+  };
+  Func_void_CategorySamplesWithAnchorResponse create_Func_void_CategorySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_CategorySamplesWithAnchorResponse_Wrapper wrap_Func_void_CategorySamplesWithAnchorResponse(Func_void_CategorySamplesWithAnchorResponse value) {
+    return Func_void_CategorySamplesWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridCategoryTypeModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridCategoryTypeModuleSpec>& strong) { 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) {
+    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) {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<CategorySample>>>>
+  using Result_std__shared_ptr_Promise_std__vector_CategorySample____ = Result<std::shared_ptr<Promise<std::vector<CategorySample>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_CategorySample____ create_Result_std__shared_ptr_Promise_std__vector_CategorySample____(const std::shared_ptr<Promise<std::vector<CategorySample>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<CategorySample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_CategorySample____ create_Result_std__shared_ptr_Promise_std__vector_CategorySample____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<CategorySample>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>>
+  using Result_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse___ = Result<std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>>;
+  inline Result_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse___(const std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>& value) {
+    return Result<std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_CategorySamplesWithAnchorResponse___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<CategorySamplesWithAnchorResponse>>>::withError(error);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<BloodType>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<BloodType>>`.
+   */
+  using std__shared_ptr_Promise_BloodType__ = std::shared_ptr<Promise<BloodType>>;
+  inline std::shared_ptr<Promise<BloodType>> create_std__shared_ptr_Promise_BloodType__() {
+    return Promise<BloodType>::create();
+  }
+  inline PromiseHolder<BloodType> wrap_std__shared_ptr_Promise_BloodType__(std::shared_ptr<Promise<BloodType>> promise) {
+    return PromiseHolder<BloodType>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(BloodType /* result */)>
+  /**
+   * Specialized version of `std::function<void(BloodType)>`.
+   */
+  using Func_void_BloodType = std::function<void(BloodType /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(BloodType / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_BloodType_Wrapper final {
+  public:
+    explicit Func_void_BloodType_Wrapper(std::function<void(BloodType /* result */)>&& func): _function(std::make_shared<std::function<void(BloodType /* result */)>>(std::move(func))) {}
+    inline void call(int result) const {
+      _function->operator()(static_cast<BloodType>(result));
+    }
+  private:
+    std::shared_ptr<std::function<void(BloodType /* result */)>> _function;
+  };
+  Func_void_BloodType create_Func_void_BloodType(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_BloodType_Wrapper wrap_Func_void_BloodType(Func_void_BloodType value) {
+    return Func_void_BloodType_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::chrono::system_clock::time_point>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<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();
+  }
+  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));
+  }
+  
+  // pragma MARK: std::function<void(std::chrono::system_clock::time_point /* result */)>
+  /**
+   * Specialized version of `std::function<void(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 */)>;
+  /**
+   * Wrapper class for a `std::function<void(std::chrono::system_clock::time_point / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_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 {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(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));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<BiologicalSex>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<BiologicalSex>>`.
+   */
+  using std__shared_ptr_Promise_BiologicalSex__ = std::shared_ptr<Promise<BiologicalSex>>;
+  inline std::shared_ptr<Promise<BiologicalSex>> create_std__shared_ptr_Promise_BiologicalSex__() {
+    return Promise<BiologicalSex>::create();
+  }
+  inline PromiseHolder<BiologicalSex> wrap_std__shared_ptr_Promise_BiologicalSex__(std::shared_ptr<Promise<BiologicalSex>> promise) {
+    return PromiseHolder<BiologicalSex>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(BiologicalSex /* result */)>
+  /**
+   * Specialized version of `std::function<void(BiologicalSex)>`.
+   */
+  using Func_void_BiologicalSex = std::function<void(BiologicalSex /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(BiologicalSex / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_BiologicalSex_Wrapper final {
+  public:
+    explicit Func_void_BiologicalSex_Wrapper(std::function<void(BiologicalSex /* result */)>&& func): _function(std::make_shared<std::function<void(BiologicalSex /* result */)>>(std::move(func))) {}
+    inline void call(int result) const {
+      _function->operator()(static_cast<BiologicalSex>(result));
+    }
+  private:
+    std::shared_ptr<std::function<void(BiologicalSex /* result */)>> _function;
+  };
+  Func_void_BiologicalSex create_Func_void_BiologicalSex(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_BiologicalSex_Wrapper wrap_Func_void_BiologicalSex(Func_void_BiologicalSex value) {
+    return Func_void_BiologicalSex_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FitzpatrickSkinType>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FitzpatrickSkinType>>`.
+   */
+  using std__shared_ptr_Promise_FitzpatrickSkinType__ = std::shared_ptr<Promise<FitzpatrickSkinType>>;
+  inline std::shared_ptr<Promise<FitzpatrickSkinType>> create_std__shared_ptr_Promise_FitzpatrickSkinType__() {
+    return Promise<FitzpatrickSkinType>::create();
+  }
+  inline PromiseHolder<FitzpatrickSkinType> wrap_std__shared_ptr_Promise_FitzpatrickSkinType__(std::shared_ptr<Promise<FitzpatrickSkinType>> promise) {
+    return PromiseHolder<FitzpatrickSkinType>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(FitzpatrickSkinType /* result */)>
+  /**
+   * Specialized version of `std::function<void(FitzpatrickSkinType)>`.
+   */
+  using Func_void_FitzpatrickSkinType = std::function<void(FitzpatrickSkinType /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(FitzpatrickSkinType / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FitzpatrickSkinType_Wrapper final {
+  public:
+    explicit Func_void_FitzpatrickSkinType_Wrapper(std::function<void(FitzpatrickSkinType /* result */)>&& func): _function(std::make_shared<std::function<void(FitzpatrickSkinType /* result */)>>(std::move(func))) {}
+    inline void call(int result) const {
+      _function->operator()(static_cast<FitzpatrickSkinType>(result));
+    }
+  private:
+    std::shared_ptr<std::function<void(FitzpatrickSkinType /* result */)>> _function;
+  };
+  Func_void_FitzpatrickSkinType create_Func_void_FitzpatrickSkinType(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_FitzpatrickSkinType_Wrapper wrap_Func_void_FitzpatrickSkinType(Func_void_FitzpatrickSkinType value) {
+    return Func_void_FitzpatrickSkinType_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<WheelchairUse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<WheelchairUse>>`.
+   */
+  using std__shared_ptr_Promise_WheelchairUse__ = std::shared_ptr<Promise<WheelchairUse>>;
+  inline std::shared_ptr<Promise<WheelchairUse>> create_std__shared_ptr_Promise_WheelchairUse__() {
+    return Promise<WheelchairUse>::create();
+  }
+  inline PromiseHolder<WheelchairUse> wrap_std__shared_ptr_Promise_WheelchairUse__(std::shared_ptr<Promise<WheelchairUse>> promise) {
+    return PromiseHolder<WheelchairUse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(WheelchairUse /* result */)>
+  /**
+   * Specialized version of `std::function<void(WheelchairUse)>`.
+   */
+  using Func_void_WheelchairUse = std::function<void(WheelchairUse /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(WheelchairUse / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_WheelchairUse_Wrapper final {
+  public:
+    explicit Func_void_WheelchairUse_Wrapper(std::function<void(WheelchairUse /* result */)>&& func): _function(std::make_shared<std::function<void(WheelchairUse /* result */)>>(std::move(func))) {}
+    inline void call(int result) const {
+      _function->operator()(static_cast<WheelchairUse>(result));
+    }
+  private:
+    std::shared_ptr<std::function<void(WheelchairUse /* result */)>> _function;
+  };
+  Func_void_WheelchairUse create_Func_void_WheelchairUse(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_WheelchairUse_Wrapper wrap_Func_void_WheelchairUse(Func_void_WheelchairUse value) {
+    return Func_void_WheelchairUse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridCharacteristicTypeModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridCharacteristicTypeModuleSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<BloodType>
+  using Result_BloodType_ = Result<BloodType>;
+  inline Result_BloodType_ create_Result_BloodType_(BloodType value) {
+    return Result<BloodType>::withValue(std::move(value));
+  }
+  inline Result_BloodType_ create_Result_BloodType_(const std::exception_ptr& error) {
+    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));
+  }
+  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);
+  }
+  
+  // pragma MARK: Result<BiologicalSex>
+  using Result_BiologicalSex_ = Result<BiologicalSex>;
+  inline Result_BiologicalSex_ create_Result_BiologicalSex_(BiologicalSex value) {
+    return Result<BiologicalSex>::withValue(std::move(value));
+  }
+  inline Result_BiologicalSex_ create_Result_BiologicalSex_(const std::exception_ptr& error) {
+    return Result<BiologicalSex>::withError(error);
+  }
+  
+  // pragma MARK: Result<FitzpatrickSkinType>
+  using Result_FitzpatrickSkinType_ = Result<FitzpatrickSkinType>;
+  inline Result_FitzpatrickSkinType_ create_Result_FitzpatrickSkinType_(FitzpatrickSkinType value) {
+    return Result<FitzpatrickSkinType>::withValue(std::move(value));
+  }
+  inline Result_FitzpatrickSkinType_ create_Result_FitzpatrickSkinType_(const std::exception_ptr& error) {
+    return Result<FitzpatrickSkinType>::withError(error);
+  }
+  
+  // pragma MARK: Result<WheelchairUse>
+  using Result_WheelchairUse_ = Result<WheelchairUse>;
+  inline Result_WheelchairUse_ create_Result_WheelchairUse_(WheelchairUse value) {
+    return Result<WheelchairUse>::withValue(std::move(value));
+  }
+  inline Result_WheelchairUse_ create_Result_WheelchairUse_(const std::exception_ptr& error) {
+    return Result<WheelchairUse>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<BloodType>>>
+  using Result_std__shared_ptr_Promise_BloodType___ = Result<std::shared_ptr<Promise<BloodType>>>;
+  inline Result_std__shared_ptr_Promise_BloodType___ create_Result_std__shared_ptr_Promise_BloodType___(const std::shared_ptr<Promise<BloodType>>& value) {
+    return Result<std::shared_ptr<Promise<BloodType>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_BloodType___ create_Result_std__shared_ptr_Promise_BloodType___(const std::exception_ptr& error) {
+    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);
+  }
+  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);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<BiologicalSex>>>
+  using Result_std__shared_ptr_Promise_BiologicalSex___ = Result<std::shared_ptr<Promise<BiologicalSex>>>;
+  inline Result_std__shared_ptr_Promise_BiologicalSex___ create_Result_std__shared_ptr_Promise_BiologicalSex___(const std::shared_ptr<Promise<BiologicalSex>>& value) {
+    return Result<std::shared_ptr<Promise<BiologicalSex>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_BiologicalSex___ create_Result_std__shared_ptr_Promise_BiologicalSex___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<BiologicalSex>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FitzpatrickSkinType>>>
+  using Result_std__shared_ptr_Promise_FitzpatrickSkinType___ = Result<std::shared_ptr<Promise<FitzpatrickSkinType>>>;
+  inline Result_std__shared_ptr_Promise_FitzpatrickSkinType___ create_Result_std__shared_ptr_Promise_FitzpatrickSkinType___(const std::shared_ptr<Promise<FitzpatrickSkinType>>& value) {
+    return Result<std::shared_ptr<Promise<FitzpatrickSkinType>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FitzpatrickSkinType___ create_Result_std__shared_ptr_Promise_FitzpatrickSkinType___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<FitzpatrickSkinType>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<WheelchairUse>>>
+  using Result_std__shared_ptr_Promise_WheelchairUse___ = Result<std::shared_ptr<Promise<WheelchairUse>>>;
+  inline Result_std__shared_ptr_Promise_WheelchairUse___ create_Result_std__shared_ptr_Promise_WheelchairUse___(const std::shared_ptr<Promise<WheelchairUse>>& value) {
+    return Result<std::shared_ptr<Promise<WheelchairUse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_WheelchairUse___ create_Result_std__shared_ptr_Promise_WheelchairUse___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<WheelchairUse>>>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<IdentifierWithUnit>
+  /**
+   * Specialized version of `std::vector<IdentifierWithUnit>`.
+   */
+  using std__vector_IdentifierWithUnit_ = std::vector<IdentifierWithUnit>;
+  inline std::vector<IdentifierWithUnit> create_std__vector_IdentifierWithUnit_(size_t size) {
+    std::vector<IdentifierWithUnit> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_IdentifierWithUnit___ = std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>;
+  inline std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>> create_std__shared_ptr_Promise_std__vector_IdentifierWithUnit___() {
+    return Promise<std::vector<IdentifierWithUnit>>::create();
+  }
+  inline PromiseHolder<std::vector<IdentifierWithUnit>> wrap_std__shared_ptr_Promise_std__vector_IdentifierWithUnit___(std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>> promise) {
+    return PromiseHolder<std::vector<IdentifierWithUnit>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<IdentifierWithUnit>&)>`.
+   */
+  using Func_void_std__vector_IdentifierWithUnit_ = std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<IdentifierWithUnit>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_IdentifierWithUnit__Wrapper final {
+  public:
+    explicit Func_void_std__vector_IdentifierWithUnit__Wrapper(std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<IdentifierWithUnit> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<IdentifierWithUnit>& /* result */)>> _function;
+  };
+  Func_void_std__vector_IdentifierWithUnit_ create_Func_void_std__vector_IdentifierWithUnit_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_IdentifierWithUnit__Wrapper wrap_Func_void_std__vector_IdentifierWithUnit_(Func_void_std__vector_IdentifierWithUnit_ value) {
+    return Func_void_std__vector_IdentifierWithUnit__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<QuantityTypeIdentifier>
+  /**
+   * Specialized version of `std::vector<QuantityTypeIdentifier>`.
+   */
+  using std__vector_QuantityTypeIdentifier_ = std::vector<QuantityTypeIdentifier>;
+  inline std::vector<QuantityTypeIdentifier> create_std__vector_QuantityTypeIdentifier_(size_t size) {
+    std::vector<QuantityTypeIdentifier> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>
+  /**
+   * Specialized version of `std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>`.
+   */
+  using std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ = std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>;
+  inline std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>> create_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__(size_t size) {
+    std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec____ = std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>;
+  inline std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>> create_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec____() {
+    return Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>::create();
+  }
+  inline PromiseHolder<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>> wrap_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec____(std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>> promise) {
+    return PromiseHolder<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>&)>`.
+   */
+  using Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ = std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper final {
+  public:
+    explicit Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>& /* result */)>> _function;
+  };
+  Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ create_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__(Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec__ value) {
+    return Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const OnChangeCallbackArgs& /* args */)>
+  /**
+   * Specialized version of `std::function<void(const OnChangeCallbackArgs&)>`.
+   */
+  using Func_void_OnChangeCallbackArgs = std::function<void(const OnChangeCallbackArgs& /* args */)>;
+  /**
+   * Wrapper class for a `std::function<void(const OnChangeCallbackArgs& / * args * /)>`, this can be used from Swift.
+   */
+  class Func_void_OnChangeCallbackArgs_Wrapper final {
+  public:
+    explicit Func_void_OnChangeCallbackArgs_Wrapper(std::function<void(const OnChangeCallbackArgs& /* args */)>&& func): _function(std::make_shared<std::function<void(const OnChangeCallbackArgs& /* args */)>>(std::move(func))) {}
+    inline void call(OnChangeCallbackArgs args) const {
+      _function->operator()(args);
+    }
+  private:
+    std::shared_ptr<std::function<void(const OnChangeCallbackArgs& /* args */)>> _function;
+  };
+  Func_void_OnChangeCallbackArgs create_Func_void_OnChangeCallbackArgs(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_OnChangeCallbackArgs_Wrapper wrap_Func_void_OnChangeCallbackArgs(Func_void_OnChangeCallbackArgs value) {
+    return Func_void_OnChangeCallbackArgs_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<double>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<double>>`.
+   */
+  using std__shared_ptr_Promise_double__ = std::shared_ptr<Promise<double>>;
+  inline std::shared_ptr<Promise<double>> create_std__shared_ptr_Promise_double__() {
+    return Promise<double>::create();
+  }
+  inline PromiseHolder<double> wrap_std__shared_ptr_Promise_double__(std::shared_ptr<Promise<double>> promise) {
+    return PromiseHolder<double>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(double /* result */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_shared<std::function<void(double /* result */)>>(std::move(func))) {}
+    inline void call(double result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(double /* result */)>> _function;
+  };
+  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<AuthorizationRequestStatus>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<AuthorizationRequestStatus>>`.
+   */
+  using std__shared_ptr_Promise_AuthorizationRequestStatus__ = std::shared_ptr<Promise<AuthorizationRequestStatus>>;
+  inline std::shared_ptr<Promise<AuthorizationRequestStatus>> create_std__shared_ptr_Promise_AuthorizationRequestStatus__() {
+    return Promise<AuthorizationRequestStatus>::create();
+  }
+  inline PromiseHolder<AuthorizationRequestStatus> wrap_std__shared_ptr_Promise_AuthorizationRequestStatus__(std::shared_ptr<Promise<AuthorizationRequestStatus>> promise) {
+    return PromiseHolder<AuthorizationRequestStatus>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(AuthorizationRequestStatus /* result */)>
+  /**
+   * Specialized version of `std::function<void(AuthorizationRequestStatus)>`.
+   */
+  using Func_void_AuthorizationRequestStatus = std::function<void(AuthorizationRequestStatus /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(AuthorizationRequestStatus / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_AuthorizationRequestStatus_Wrapper final {
+  public:
+    explicit Func_void_AuthorizationRequestStatus_Wrapper(std::function<void(AuthorizationRequestStatus /* result */)>&& func): _function(std::make_shared<std::function<void(AuthorizationRequestStatus /* result */)>>(std::move(func))) {}
+    inline void call(int result) const {
+      _function->operator()(static_cast<AuthorizationRequestStatus>(result));
+    }
+  private:
+    std::shared_ptr<std::function<void(AuthorizationRequestStatus /* result */)>> _function;
+  };
+  Func_void_AuthorizationRequestStatus create_Func_void_AuthorizationRequestStatus(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_AuthorizationRequestStatus_Wrapper wrap_Func_void_AuthorizationRequestStatus(Func_void_AuthorizationRequestStatus value) {
+    return Func_void_AuthorizationRequestStatus_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<SampleTypeIdentifierWriteable>
+  /**
+   * Specialized version of `std::vector<SampleTypeIdentifierWriteable>`.
+   */
+  using std__vector_SampleTypeIdentifierWriteable_ = std::vector<SampleTypeIdentifierWriteable>;
+  inline std::vector<SampleTypeIdentifierWriteable> create_std__vector_SampleTypeIdentifierWriteable_(size_t size) {
+    std::vector<SampleTypeIdentifierWriteable> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<ObjectTypeIdentifier>
+  /**
+   * Specialized version of `std::vector<ObjectTypeIdentifier>`.
+   */
+  using std__vector_ObjectTypeIdentifier_ = std::vector<ObjectTypeIdentifier>;
+  inline std::vector<ObjectTypeIdentifier> create_std__vector_ObjectTypeIdentifier_(size_t size) {
+    std::vector<ObjectTypeIdentifier> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::unordered_map<std::string, bool>
+  /**
+   * Specialized version of `std::unordered_map<std::string, bool>`.
+   */
+  using std__unordered_map_std__string__bool_ = std::unordered_map<std::string, bool>;
+  inline std::unordered_map<std::string, bool> create_std__unordered_map_std__string__bool_(size_t size) {
+    std::unordered_map<std::string, bool> map;
+    map.reserve(size);
+    return map;
+  }
+  inline std::vector<std::string> get_std__unordered_map_std__string__bool__keys(const std__unordered_map_std__string__bool_& map) {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+  inline void emplace_std__unordered_map_std__string__bool_(std__unordered_map_std__string__bool_& map, const std::string& key, const bool& value) {
+    map.emplace(key, value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>`.
+   */
+  using std__shared_ptr_Promise_std__unordered_map_std__string__bool___ = std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>;
+  inline std::shared_ptr<Promise<std::unordered_map<std::string, bool>>> create_std__shared_ptr_Promise_std__unordered_map_std__string__bool___() {
+    return Promise<std::unordered_map<std::string, bool>>::create();
+  }
+  inline PromiseHolder<std::unordered_map<std::string, bool>> wrap_std__shared_ptr_Promise_std__unordered_map_std__string__bool___(std::shared_ptr<Promise<std::unordered_map<std::string, bool>>> promise) {
+    return PromiseHolder<std::unordered_map<std::string, bool>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::unordered_map<std::string, bool>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::unordered_map<std::string, bool>&)>`.
+   */
+  using Func_void_std__unordered_map_std__string__bool_ = std::function<void(const std::unordered_map<std::string, bool>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::unordered_map<std::string, bool>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__unordered_map_std__string__bool__Wrapper final {
+  public:
+    explicit Func_void_std__unordered_map_std__string__bool__Wrapper(std::function<void(const std::unordered_map<std::string, bool>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>>(std::move(func))) {}
+    inline void call(std::unordered_map<std::string, bool> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::unordered_map<std::string, bool>& /* result */)>> _function;
+  };
+  Func_void_std__unordered_map_std__string__bool_ create_Func_void_std__unordered_map_std__string__bool_(void* _Nonnull swiftClosureWrapper);
+  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) {
+    return Func_void_std__unordered_map_std__string__bool__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridCoreModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridCoreModuleSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) {
+    return Result<bool>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>>
+  using Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____ = Result<std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____ create_Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____(const std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____ create_Result_std__shared_ptr_Promise_std__vector_IdentifierWithUnit____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<IdentifierWithUnit>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>>
+  using Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_____ = Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_____ create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_____(const std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_____ create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridSourceProxySpec_____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridSourceProxySpec>>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: Result<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) {
+    return Result<double>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
+  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) {
+    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<double>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<AuthorizationStatus>
+  using Result_AuthorizationStatus_ = Result<AuthorizationStatus>;
+  inline Result_AuthorizationStatus_ create_Result_AuthorizationStatus_(AuthorizationStatus value) {
+    return Result<AuthorizationStatus>::withValue(std::move(value));
+  }
+  inline Result_AuthorizationStatus_ create_Result_AuthorizationStatus_(const std::exception_ptr& error) {
+    return Result<AuthorizationStatus>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<AuthorizationRequestStatus>>>
+  using Result_std__shared_ptr_Promise_AuthorizationRequestStatus___ = Result<std::shared_ptr<Promise<AuthorizationRequestStatus>>>;
+  inline Result_std__shared_ptr_Promise_AuthorizationRequestStatus___ create_Result_std__shared_ptr_Promise_AuthorizationRequestStatus___(const std::shared_ptr<Promise<AuthorizationRequestStatus>>& value) {
+    return Result<std::shared_ptr<Promise<AuthorizationRequestStatus>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_AuthorizationRequestStatus___ create_Result_std__shared_ptr_Promise_AuthorizationRequestStatus___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<AuthorizationRequestStatus>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::unordered_map<std::string, bool>>
+  using Result_std__unordered_map_std__string__bool__ = Result<std::unordered_map<std::string, bool>>;
+  inline Result_std__unordered_map_std__string__bool__ create_Result_std__unordered_map_std__string__bool__(const std::unordered_map<std::string, bool>& value) {
+    return Result<std::unordered_map<std::string, bool>>::withValue(value);
+  }
+  inline Result_std__unordered_map_std__string__bool__ create_Result_std__unordered_map_std__string__bool__(const std::exception_ptr& error) {
+    return Result<std::unordered_map<std::string, bool>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>>
+  using Result_std__shared_ptr_Promise_std__unordered_map_std__string__bool____ = Result<std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>>;
+  inline Result_std__shared_ptr_Promise_std__unordered_map_std__string__bool____ create_Result_std__shared_ptr_Promise_std__unordered_map_std__string__bool____(const std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>& value) {
+    return Result<std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__unordered_map_std__string__bool____ create_Result_std__shared_ptr_Promise_std__unordered_map_std__string__bool____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::unordered_map<std::string, bool>>>>::withError(error);
+  }
+  
+  // pragma MARK: std::variant<CategorySampleForSaving, QuantitySampleForSaving>
+  /**
+   * Wrapper struct for `std::variant<CategorySampleForSaving, QuantitySampleForSaving>`.
+   * 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_CategorySampleForSaving__QuantitySampleForSaving_ {
+    std::variant<CategorySampleForSaving, QuantitySampleForSaving> variant;
+    std__variant_CategorySampleForSaving__QuantitySampleForSaving_(std::variant<CategorySampleForSaving, QuantitySampleForSaving> variant): variant(variant) { }
+    operator std::variant<CategorySampleForSaving, QuantitySampleForSaving>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline CategorySampleForSaving get_0() const {
+      return std::get<0>(variant);
+    }
+    inline QuantitySampleForSaving get_1() const {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_CategorySampleForSaving__QuantitySampleForSaving_ create_std__variant_CategorySampleForSaving__QuantitySampleForSaving_(const CategorySampleForSaving& value) {
+    return std__variant_CategorySampleForSaving__QuantitySampleForSaving_(value);
+  }
+  inline std__variant_CategorySampleForSaving__QuantitySampleForSaving_ create_std__variant_CategorySampleForSaving__QuantitySampleForSaving_(const QuantitySampleForSaving& value) {
+    return std__variant_CategorySampleForSaving__QuantitySampleForSaving_(value);
+  }
+  
+  // pragma MARK: std::vector<std::variant<CategorySampleForSaving, QuantitySampleForSaving>>
+  /**
+   * Specialized version of `std::vector<std::variant<CategorySampleForSaving, QuantitySampleForSaving>>`.
+   */
+  using std__vector_std__variant_CategorySampleForSaving__QuantitySampleForSaving__ = std::vector<std::variant<CategorySampleForSaving, QuantitySampleForSaving>>;
+  inline std::vector<std::variant<CategorySampleForSaving, QuantitySampleForSaving>> create_std__vector_std__variant_CategorySampleForSaving__QuantitySampleForSaving__(size_t size) {
+    std::vector<std::variant<CategorySampleForSaving, QuantitySampleForSaving>> vector;
+    vector.reserve(size);
+    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 {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline CategorySample get_0() const {
+      return std::get<0>(variant);
+    }
+    inline QuantitySample get_1() const {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_CategorySample__QuantitySample_ create_std__variant_CategorySample__QuantitySample_(const CategorySample& value) {
+    return std__variant_CategorySample__QuantitySample_(value);
+  }
+  inline std__variant_CategorySample__QuantitySample_ create_std__variant_CategorySample__QuantitySample_(const QuantitySample& value) {
+    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) {
+    std::vector<std::variant<CategorySample, QuantitySample>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<CorrelationSample>
+  /**
+   * Specialized version of `std::vector<CorrelationSample>`.
+   */
+  using std__vector_CorrelationSample_ = std::vector<CorrelationSample>;
+  inline std::vector<CorrelationSample> create_std__vector_CorrelationSample_(size_t size) {
+    std::vector<CorrelationSample> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<CorrelationSample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<CorrelationSample>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_CorrelationSample___ = std::shared_ptr<Promise<std::vector<CorrelationSample>>>;
+  inline std::shared_ptr<Promise<std::vector<CorrelationSample>>> create_std__shared_ptr_Promise_std__vector_CorrelationSample___() {
+    return Promise<std::vector<CorrelationSample>>::create();
+  }
+  inline PromiseHolder<std::vector<CorrelationSample>> wrap_std__shared_ptr_Promise_std__vector_CorrelationSample___(std::shared_ptr<Promise<std::vector<CorrelationSample>>> promise) {
+    return PromiseHolder<std::vector<CorrelationSample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<CorrelationSample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<CorrelationSample>&)>`.
+   */
+  using Func_void_std__vector_CorrelationSample_ = std::function<void(const std::vector<CorrelationSample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<CorrelationSample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_CorrelationSample__Wrapper final {
+  public:
+    explicit Func_void_std__vector_CorrelationSample__Wrapper(std::function<void(const std::vector<CorrelationSample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<CorrelationSample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<CorrelationSample> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<CorrelationSample>& /* result */)>> _function;
+  };
+  Func_void_std__vector_CorrelationSample_ create_Func_void_std__vector_CorrelationSample_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_CorrelationSample__Wrapper wrap_Func_void_std__vector_CorrelationSample_(Func_void_std__vector_CorrelationSample_ value) {
+    return Func_void_std__vector_CorrelationSample__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridCorrelationTypeModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridCorrelationTypeModuleSpec>& strong) { return strong; }
+  
+  // 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) {
+    return Result<std::shared_ptr<Promise<std::vector<CorrelationSample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_CorrelationSample____ create_Result_std__shared_ptr_Promise_std__vector_CorrelationSample____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<CorrelationSample>>>>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<Heartbeat>
+  /**
+   * Specialized version of `std::vector<Heartbeat>`.
+   */
+  using std__vector_Heartbeat_ = std::vector<Heartbeat>;
+  inline std::vector<Heartbeat> create_std__vector_Heartbeat_(size_t size) {
+    std::vector<Heartbeat> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<HeartbeatSeriesSample>
+  /**
+   * Specialized version of `std::vector<HeartbeatSeriesSample>`.
+   */
+  using std__vector_HeartbeatSeriesSample_ = std::vector<HeartbeatSeriesSample>;
+  inline std::vector<HeartbeatSeriesSample> create_std__vector_HeartbeatSeriesSample_(size_t size) {
+    std::vector<HeartbeatSeriesSample> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample___ = std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>;
+  inline std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>> create_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample___() {
+    return Promise<std::vector<HeartbeatSeriesSample>>::create();
+  }
+  inline PromiseHolder<std::vector<HeartbeatSeriesSample>> wrap_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample___(std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>> promise) {
+    return PromiseHolder<std::vector<HeartbeatSeriesSample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<HeartbeatSeriesSample>&)>`.
+   */
+  using Func_void_std__vector_HeartbeatSeriesSample_ = std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<HeartbeatSeriesSample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_HeartbeatSeriesSample__Wrapper final {
+  public:
+    explicit Func_void_std__vector_HeartbeatSeriesSample__Wrapper(std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<HeartbeatSeriesSample> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<HeartbeatSeriesSample>& /* result */)>> _function;
+  };
+  Func_void_std__vector_HeartbeatSeriesSample_ create_Func_void_std__vector_HeartbeatSeriesSample_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_HeartbeatSeriesSample__Wrapper wrap_Func_void_std__vector_HeartbeatSeriesSample_(Func_void_std__vector_HeartbeatSeriesSample_ value) {
+    return Func_void_std__vector_HeartbeatSeriesSample__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse__ = std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>> create_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse__() {
+    return Promise<HeartbeatSeriesSamplesWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<HeartbeatSeriesSamplesWithAnchorResponse> wrap_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse__(std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>> promise) {
+    return PromiseHolder<HeartbeatSeriesSamplesWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse&)>`.
+   */
+  using Func_void_HeartbeatSeriesSamplesWithAnchorResponse = std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper(std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(HeartbeatSeriesSamplesWithAnchorResponse result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const HeartbeatSeriesSamplesWithAnchorResponse& /* result */)>> _function;
+  };
+  Func_void_HeartbeatSeriesSamplesWithAnchorResponse create_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper wrap_Func_void_HeartbeatSeriesSamplesWithAnchorResponse(Func_void_HeartbeatSeriesSamplesWithAnchorResponse value) {
+    return Func_void_HeartbeatSeriesSamplesWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridHeartbeatSeriesModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridHeartbeatSeriesModuleSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>>
+  using Result_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample____ = Result<std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample____ create_Result_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample____(const std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample____ create_Result_std__shared_ptr_Promise_std__vector_HeartbeatSeriesSample____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<HeartbeatSeriesSample>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>>
+  using Result_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse___ = Result<std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>>;
+  inline Result_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse___(const std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>& value) {
+    return Result<std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_HeartbeatSeriesSamplesWithAnchorResponse___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<HeartbeatSeriesSamplesWithAnchorResponse>>>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<QuantitySample>
+  /**
+   * Specialized version of `std::vector<QuantitySample>`.
+   */
+  using std__vector_QuantitySample_ = std::vector<QuantitySample>;
+  inline std::vector<QuantitySample> create_std__vector_QuantitySample_(size_t size) {
+    std::vector<QuantitySample> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<QuantitySample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<QuantitySample>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_QuantitySample___ = std::shared_ptr<Promise<std::vector<QuantitySample>>>;
+  inline std::shared_ptr<Promise<std::vector<QuantitySample>>> create_std__shared_ptr_Promise_std__vector_QuantitySample___() {
+    return Promise<std::vector<QuantitySample>>::create();
+  }
+  inline PromiseHolder<std::vector<QuantitySample>> wrap_std__shared_ptr_Promise_std__vector_QuantitySample___(std::shared_ptr<Promise<std::vector<QuantitySample>>> promise) {
+    return PromiseHolder<std::vector<QuantitySample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<QuantitySample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<QuantitySample>&)>`.
+   */
+  using Func_void_std__vector_QuantitySample_ = std::function<void(const std::vector<QuantitySample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<QuantitySample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_QuantitySample__Wrapper final {
+  public:
+    explicit Func_void_std__vector_QuantitySample__Wrapper(std::function<void(const std::vector<QuantitySample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<QuantitySample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<QuantitySample> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<QuantitySample>& /* result */)>> _function;
+  };
+  Func_void_std__vector_QuantitySample_ create_Func_void_std__vector_QuantitySample_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_QuantitySample__Wrapper wrap_Func_void_std__vector_QuantitySample_(Func_void_std__vector_QuantitySample_ value) {
+    return Func_void_std__vector_QuantitySample__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<QueryOptionsWithSortOrderAndUnit>
+  /**
+   * Specialized version of `std::optional<QueryOptionsWithSortOrderAndUnit>`.
+   */
+  using std__optional_QueryOptionsWithSortOrderAndUnit_ = std::optional<QueryOptionsWithSortOrderAndUnit>;
+  inline std::optional<QueryOptionsWithSortOrderAndUnit> create_std__optional_QueryOptionsWithSortOrderAndUnit_(const QueryOptionsWithSortOrderAndUnit& value) {
+    return std::optional<QueryOptionsWithSortOrderAndUnit>(value);
+  }
+  
+  // pragma MARK: std::optional<Quantity>
+  /**
+   * Specialized version of `std::optional<Quantity>`.
+   */
+  using std__optional_Quantity_ = std::optional<Quantity>;
+  inline std::optional<Quantity> create_std__optional_Quantity_(const Quantity& value) {
+    return std::optional<Quantity>(value);
+  }
+  
+  // pragma MARK: std::optional<QuantityDateInterval>
+  /**
+   * Specialized version of `std::optional<QuantityDateInterval>`.
+   */
+  using std__optional_QuantityDateInterval_ = std::optional<QuantityDateInterval>;
+  inline std::optional<QuantityDateInterval> create_std__optional_QuantityDateInterval_(const QuantityDateInterval& value) {
+    return std::optional<QuantityDateInterval>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<QueryStatisticsResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<QueryStatisticsResponse>>`.
+   */
+  using std__shared_ptr_Promise_QueryStatisticsResponse__ = std::shared_ptr<Promise<QueryStatisticsResponse>>;
+  inline std::shared_ptr<Promise<QueryStatisticsResponse>> create_std__shared_ptr_Promise_QueryStatisticsResponse__() {
+    return Promise<QueryStatisticsResponse>::create();
+  }
+  inline PromiseHolder<QueryStatisticsResponse> wrap_std__shared_ptr_Promise_QueryStatisticsResponse__(std::shared_ptr<Promise<QueryStatisticsResponse>> promise) {
+    return PromiseHolder<QueryStatisticsResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const QueryStatisticsResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const QueryStatisticsResponse&)>`.
+   */
+  using Func_void_QueryStatisticsResponse = std::function<void(const QueryStatisticsResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const QueryStatisticsResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_QueryStatisticsResponse_Wrapper final {
+  public:
+    explicit Func_void_QueryStatisticsResponse_Wrapper(std::function<void(const QueryStatisticsResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const QueryStatisticsResponse& /* result */)>>(std::move(func))) {}
+    inline void call(QueryStatisticsResponse result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const QueryStatisticsResponse& /* result */)>> _function;
+  };
+  Func_void_QueryStatisticsResponse create_Func_void_QueryStatisticsResponse(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_QueryStatisticsResponse_Wrapper wrap_Func_void_QueryStatisticsResponse(Func_void_QueryStatisticsResponse value) {
+    return Func_void_QueryStatisticsResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<StatisticsOptions>
+  /**
+   * Specialized version of `std::vector<StatisticsOptions>`.
+   */
+  using std__vector_StatisticsOptions_ = std::vector<StatisticsOptions>;
+  inline std::vector<StatisticsOptions> create_std__vector_StatisticsOptions_(size_t size) {
+    std::vector<StatisticsOptions> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>
+  /**
+   * Specialized version of `std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>`.
+   */
+  using std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__ = std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>;
+  inline std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>> create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__(const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>& value) {
+    return std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout>>(value);
+  }
+  
+  // pragma MARK: std::optional<StatisticsQueryOptions>
+  /**
+   * Specialized version of `std::optional<StatisticsQueryOptions>`.
+   */
+  using std__optional_StatisticsQueryOptions_ = std::optional<StatisticsQueryOptions>;
+  inline std::optional<StatisticsQueryOptions> create_std__optional_StatisticsQueryOptions_(const StatisticsQueryOptions& value) {
+    return std::optional<StatisticsQueryOptions>(value);
+  }
+  
+  // pragma MARK: std::vector<QueryStatisticsResponse>
+  /**
+   * Specialized version of `std::vector<QueryStatisticsResponse>`.
+   */
+  using std__vector_QueryStatisticsResponse_ = std::vector<QueryStatisticsResponse>;
+  inline std::vector<QueryStatisticsResponse> create_std__vector_QueryStatisticsResponse_(size_t size) {
+    std::vector<QueryStatisticsResponse> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_QueryStatisticsResponse___ = std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>;
+  inline std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>> create_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse___() {
+    return Promise<std::vector<QueryStatisticsResponse>>::create();
+  }
+  inline PromiseHolder<std::vector<QueryStatisticsResponse>> wrap_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse___(std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>> promise) {
+    return PromiseHolder<std::vector<QueryStatisticsResponse>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<QueryStatisticsResponse>&)>`.
+   */
+  using Func_void_std__vector_QueryStatisticsResponse_ = std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<QueryStatisticsResponse>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_QueryStatisticsResponse__Wrapper final {
+  public:
+    explicit Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<QueryStatisticsResponse> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<QueryStatisticsResponse>& /* result */)>> _function;
+  };
+  Func_void_std__vector_QueryStatisticsResponse_ create_Func_void_std__vector_QueryStatisticsResponse_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_QueryStatisticsResponse__Wrapper wrap_Func_void_std__vector_QueryStatisticsResponse_(Func_void_std__vector_QueryStatisticsResponse_ value) {
+    return Func_void_std__vector_QueryStatisticsResponse__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse__ = std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>> create_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse__() {
+    return Promise<QuantitySamplesWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<QuantitySamplesWithAnchorResponse> wrap_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse__(std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>> promise) {
+    return PromiseHolder<QuantitySamplesWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const QuantitySamplesWithAnchorResponse&)>`.
+   */
+  using Func_void_QuantitySamplesWithAnchorResponse = std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const QuantitySamplesWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_QuantitySamplesWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_QuantitySamplesWithAnchorResponse_Wrapper(std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(QuantitySamplesWithAnchorResponse result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const QuantitySamplesWithAnchorResponse& /* result */)>> _function;
+  };
+  Func_void_QuantitySamplesWithAnchorResponse create_Func_void_QuantitySamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_QuantitySamplesWithAnchorResponse_Wrapper wrap_Func_void_QuantitySamplesWithAnchorResponse(Func_void_QuantitySamplesWithAnchorResponse value) {
+    return Func_void_QuantitySamplesWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridQuantityTypeModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridQuantityTypeModuleSpec>& strong) { return strong; }
+  
+  // 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) {
+    return Result<std::shared_ptr<Promise<std::vector<QuantitySample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_QuantitySample____ create_Result_std__shared_ptr_Promise_std__vector_QuantitySample____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<QuantitySample>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<QueryStatisticsResponse>>>
+  using Result_std__shared_ptr_Promise_QueryStatisticsResponse___ = Result<std::shared_ptr<Promise<QueryStatisticsResponse>>>;
+  inline Result_std__shared_ptr_Promise_QueryStatisticsResponse___ create_Result_std__shared_ptr_Promise_QueryStatisticsResponse___(const std::shared_ptr<Promise<QueryStatisticsResponse>>& value) {
+    return Result<std::shared_ptr<Promise<QueryStatisticsResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_QueryStatisticsResponse___ create_Result_std__shared_ptr_Promise_QueryStatisticsResponse___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<QueryStatisticsResponse>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>>
+  using Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse____ = Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse____ create_Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse____(const std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse____ create_Result_std__shared_ptr_Promise_std__vector_QueryStatisticsResponse____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<QueryStatisticsResponse>>>>::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) {
+    return Result<std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_QuantitySamplesWithAnchorResponse___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<QuantitySamplesWithAnchorResponse>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<Source>
+  using Result_Source_ = Result<Source>;
+  inline Result_Source_ create_Result_Source_(const Source& value) {
+    return Result<Source>::withValue(value);
+  }
+  inline Result_Source_ create_Result_Source_(const std::exception_ptr& error) {
+    return Result<Source>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<StateOfMindAssociation>
+  /**
+   * Specialized version of `std::vector<StateOfMindAssociation>`.
+   */
+  using std__vector_StateOfMindAssociation_ = std::vector<StateOfMindAssociation>;
+  inline std::vector<StateOfMindAssociation> create_std__vector_StateOfMindAssociation_(size_t size) {
+    std::vector<StateOfMindAssociation> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<StateOfMindLabel>
+  /**
+   * Specialized version of `std::vector<StateOfMindLabel>`.
+   */
+  using std__vector_StateOfMindLabel_ = std::vector<StateOfMindLabel>;
+  inline std::vector<StateOfMindLabel> create_std__vector_StateOfMindLabel_(size_t size) {
+    std::vector<StateOfMindLabel> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<StateOfMindSample>
+  /**
+   * Specialized version of `std::vector<StateOfMindSample>`.
+   */
+  using std__vector_StateOfMindSample_ = std::vector<StateOfMindSample>;
+  inline std::vector<StateOfMindSample> create_std__vector_StateOfMindSample_(size_t size) {
+    std::vector<StateOfMindSample> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<StateOfMindSample>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<StateOfMindSample>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_StateOfMindSample___ = std::shared_ptr<Promise<std::vector<StateOfMindSample>>>;
+  inline std::shared_ptr<Promise<std::vector<StateOfMindSample>>> create_std__shared_ptr_Promise_std__vector_StateOfMindSample___() {
+    return Promise<std::vector<StateOfMindSample>>::create();
+  }
+  inline PromiseHolder<std::vector<StateOfMindSample>> wrap_std__shared_ptr_Promise_std__vector_StateOfMindSample___(std::shared_ptr<Promise<std::vector<StateOfMindSample>>> promise) {
+    return PromiseHolder<std::vector<StateOfMindSample>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<StateOfMindSample>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<StateOfMindSample>&)>`.
+   */
+  using Func_void_std__vector_StateOfMindSample_ = std::function<void(const std::vector<StateOfMindSample>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<StateOfMindSample>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_StateOfMindSample__Wrapper final {
+  public:
+    explicit Func_void_std__vector_StateOfMindSample__Wrapper(std::function<void(const std::vector<StateOfMindSample>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<StateOfMindSample>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<StateOfMindSample> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<StateOfMindSample>& /* result */)>> _function;
+  };
+  Func_void_std__vector_StateOfMindSample_ create_Func_void_std__vector_StateOfMindSample_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_StateOfMindSample__Wrapper wrap_Func_void_std__vector_StateOfMindSample_(Func_void_std__vector_StateOfMindSample_ value) {
+    return Func_void_std__vector_StateOfMindSample__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridStateOfMindModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridStateOfMindModuleSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<StateOfMindSample>>>>
+  using Result_std__shared_ptr_Promise_std__vector_StateOfMindSample____ = Result<std::shared_ptr<Promise<std::vector<StateOfMindSample>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_StateOfMindSample____ create_Result_std__shared_ptr_Promise_std__vector_StateOfMindSample____(const std::shared_ptr<Promise<std::vector<StateOfMindSample>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<StateOfMindSample>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_StateOfMindSample____ create_Result_std__shared_ptr_Promise_std__vector_StateOfMindSample____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<StateOfMindSample>>>>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<WorkoutEvent>
+  /**
+   * Specialized version of `std::vector<WorkoutEvent>`.
+   */
+  using std__vector_WorkoutEvent_ = std::vector<WorkoutEvent>;
+  inline std::vector<WorkoutEvent> create_std__vector_WorkoutEvent_(size_t size) {
+    std::vector<WorkoutEvent> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<WorkoutEvent>>
+  /**
+   * Specialized version of `std::optional<std::vector<WorkoutEvent>>`.
+   */
+  using std__optional_std__vector_WorkoutEvent__ = std::optional<std::vector<WorkoutEvent>>;
+  inline std::optional<std::vector<WorkoutEvent>> create_std__optional_std__vector_WorkoutEvent__(const std::vector<WorkoutEvent>& value) {
+    return std::optional<std::vector<WorkoutEvent>>(value);
+  }
+  
+  // pragma MARK: std::vector<WorkoutActivity>
+  /**
+   * Specialized version of `std::vector<WorkoutActivity>`.
+   */
+  using std__vector_WorkoutActivity_ = std::vector<WorkoutActivity>;
+  inline std::vector<WorkoutActivity> create_std__vector_WorkoutActivity_(size_t size) {
+    std::vector<WorkoutActivity> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<WorkoutActivity>>
+  /**
+   * Specialized version of `std::optional<std::vector<WorkoutActivity>>`.
+   */
+  using std__optional_std__vector_WorkoutActivity__ = std::optional<std::vector<WorkoutActivity>>;
+  inline std::optional<std::vector<WorkoutActivity>> create_std__optional_std__vector_WorkoutActivity__(const std::vector<WorkoutActivity>& value) {
+    return std::optional<std::vector<WorkoutActivity>>(value);
+  }
+  
+  // pragma MARK: std::vector<LocationForSaving>
+  /**
+   * Specialized version of `std::vector<LocationForSaving>`.
+   */
+  using std__vector_LocationForSaving_ = std::vector<LocationForSaving>;
+  inline std::vector<LocationForSaving> create_std__vector_LocationForSaving_(size_t size) {
+    std::vector<LocationForSaving> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<WorkoutPlan>
+  /**
+   * Specialized version of `std::optional<WorkoutPlan>`.
+   */
+  using std__optional_WorkoutPlan_ = std::optional<WorkoutPlan>;
+  inline std::optional<WorkoutPlan> create_std__optional_WorkoutPlan_(const WorkoutPlan& value) {
+    return std::optional<WorkoutPlan>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<WorkoutPlan>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<WorkoutPlan>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_WorkoutPlan___ = std::shared_ptr<Promise<std::optional<WorkoutPlan>>>;
+  inline std::shared_ptr<Promise<std::optional<WorkoutPlan>>> create_std__shared_ptr_Promise_std__optional_WorkoutPlan___() {
+    return Promise<std::optional<WorkoutPlan>>::create();
+  }
+  inline PromiseHolder<std::optional<WorkoutPlan>> wrap_std__shared_ptr_Promise_std__optional_WorkoutPlan___(std::shared_ptr<Promise<std::optional<WorkoutPlan>>> promise) {
+    return PromiseHolder<std::optional<WorkoutPlan>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<WorkoutPlan>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<WorkoutPlan>&)>`.
+   */
+  using Func_void_std__optional_WorkoutPlan_ = std::function<void(const std::optional<WorkoutPlan>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<WorkoutPlan>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_WorkoutPlan__Wrapper final {
+  public:
+    explicit Func_void_std__optional_WorkoutPlan__Wrapper(std::function<void(const std::optional<WorkoutPlan>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::optional<WorkoutPlan>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<WorkoutPlan> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::optional<WorkoutPlan>& /* result */)>> _function;
+  };
+  Func_void_std__optional_WorkoutPlan_ create_Func_void_std__optional_WorkoutPlan_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__optional_WorkoutPlan__Wrapper wrap_Func_void_std__optional_WorkoutPlan_(Func_void_std__optional_WorkoutPlan_ value) {
+    return Func_void_std__optional_WorkoutPlan__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<WorkoutRouteLocation>
+  /**
+   * Specialized version of `std::vector<WorkoutRouteLocation>`.
+   */
+  using std__vector_WorkoutRouteLocation_ = std::vector<WorkoutRouteLocation>;
+  inline std::vector<WorkoutRouteLocation> create_std__vector_WorkoutRouteLocation_(size_t size) {
+    std::vector<WorkoutRouteLocation> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<WorkoutRoute>
+  /**
+   * Specialized version of `std::vector<WorkoutRoute>`.
+   */
+  using std__vector_WorkoutRoute_ = std::vector<WorkoutRoute>;
+  inline std::vector<WorkoutRoute> create_std__vector_WorkoutRoute_(size_t size) {
+    std::vector<WorkoutRoute> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<WorkoutRoute>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<WorkoutRoute>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_WorkoutRoute___ = std::shared_ptr<Promise<std::vector<WorkoutRoute>>>;
+  inline std::shared_ptr<Promise<std::vector<WorkoutRoute>>> create_std__shared_ptr_Promise_std__vector_WorkoutRoute___() {
+    return Promise<std::vector<WorkoutRoute>>::create();
+  }
+  inline PromiseHolder<std::vector<WorkoutRoute>> wrap_std__shared_ptr_Promise_std__vector_WorkoutRoute___(std::shared_ptr<Promise<std::vector<WorkoutRoute>>> promise) {
+    return PromiseHolder<std::vector<WorkoutRoute>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<WorkoutRoute>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<WorkoutRoute>&)>`.
+   */
+  using Func_void_std__vector_WorkoutRoute_ = std::function<void(const std::vector<WorkoutRoute>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<WorkoutRoute>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_WorkoutRoute__Wrapper final {
+  public:
+    explicit Func_void_std__vector_WorkoutRoute__Wrapper(std::function<void(const std::vector<WorkoutRoute>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<WorkoutRoute>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<WorkoutRoute> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<WorkoutRoute>& /* result */)>> _function;
+  };
+  Func_void_std__vector_WorkoutRoute_ create_Func_void_std__vector_WorkoutRoute_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_WorkoutRoute__Wrapper wrap_Func_void_std__vector_WorkoutRoute_(Func_void_std__vector_WorkoutRoute_ value) {
+    return Func_void_std__vector_WorkoutRoute__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: Result<WorkoutSample>
+  using Result_WorkoutSample_ = Result<WorkoutSample>;
+  inline Result_WorkoutSample_ create_Result_WorkoutSample_(const WorkoutSample& value) {
+    return Result<WorkoutSample>::withValue(value);
+  }
+  inline Result_WorkoutSample_ create_Result_WorkoutSample_(const std::exception_ptr& error) {
+    return Result<WorkoutSample>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<WorkoutPlan>>>>
+  using Result_std__shared_ptr_Promise_std__optional_WorkoutPlan____ = Result<std::shared_ptr<Promise<std::optional<WorkoutPlan>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_WorkoutPlan____ create_Result_std__shared_ptr_Promise_std__optional_WorkoutPlan____(const std::shared_ptr<Promise<std::optional<WorkoutPlan>>>& value) {
+    return Result<std::shared_ptr<Promise<std::optional<WorkoutPlan>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_WorkoutPlan____ create_Result_std__shared_ptr_Promise_std__optional_WorkoutPlan____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::optional<WorkoutPlan>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>
+  using Result_std__shared_ptr_Promise_std__vector_WorkoutRoute____ = Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_WorkoutRoute____ create_Result_std__shared_ptr_Promise_std__vector_WorkoutRoute____(const std::shared_ptr<Promise<std::vector<WorkoutRoute>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_WorkoutRoute____ create_Result_std__shared_ptr_Promise_std__vector_WorkoutRoute____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>::withError(error);
+  }
+  
+  // 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::function<void(const std::string& /* errorMessage */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* errorMessage */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * errorMessage * /)>`, 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);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::string& /* errorMessage */)>> _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>`.
+   */
+  using std__vector_QuantitySampleForSaving_ = std::vector<QuantitySampleForSaving>;
+  inline std::vector<QuantitySampleForSaving> create_std__vector_QuantitySampleForSaving_(size_t size) {
+    std::vector<QuantitySampleForSaving> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>
+  /**
+   * Specialized version of `std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>`.
+   */
+  using std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ = std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>;
+  inline std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>> create_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__(size_t size) {
+    std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>`.
+   */
+  using std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse__ = std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>;
+  inline std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>> create_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse__() {
+    return Promise<QueryWorkoutSamplesWithAnchorResponse>::create();
+  }
+  inline PromiseHolder<QueryWorkoutSamplesWithAnchorResponse> wrap_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse__(std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>> promise) {
+    return PromiseHolder<QueryWorkoutSamplesWithAnchorResponse>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const QueryWorkoutSamplesWithAnchorResponse&)>`.
+   */
+  using Func_void_QueryWorkoutSamplesWithAnchorResponse = std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const QueryWorkoutSamplesWithAnchorResponse& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper final {
+  public:
+    explicit Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>>(std::move(func))) {}
+    inline void call(QueryWorkoutSamplesWithAnchorResponse result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>> _function;
+  };
+  Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper wrap_Func_void_QueryWorkoutSamplesWithAnchorResponse(Func_void_QueryWorkoutSamplesWithAnchorResponse value) {
+    return Func_void_QueryWorkoutSamplesWithAnchorResponse_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>
+  /**
+   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ {
+    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate> variant;
+    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate> variant): variant(variant) { }
+    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline PredicateWithUUID get_0() const {
+      return std::get<0>(variant);
+    }
+    inline PredicateWithUUIDs get_1() const {
+      return std::get<1>(variant);
+    }
+    inline PredicateWithMetadataKey get_2() const {
+      return std::get<2>(variant);
+    }
+    inline PredicateWithStartAndEnd get_3() const {
+      return std::get<3>(variant);
+    }
+    inline PredicateFromWorkout get_4() const {
+      return std::get<4>(variant);
+    }
+    inline WorkoutActivityTypePredicate get_5() const {
+      return std::get<5>(variant);
+    }
+    inline WorkoutDurationPredicate get_6() const {
+      return std::get<6>(variant);
+    }
+  };
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithUUID& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithUUIDs& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithMetadataKey& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateWithStartAndEnd& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const PredicateFromWorkout& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const WorkoutActivityTypePredicate& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(const WorkoutDurationPredicate& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate_(value);
+  }
+  
+  // pragma MARK: std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>>
+  /**
+   * Specialized version of `std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>>`.
+   */
+  using std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__ = std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>>;
+  inline std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>> create_std__vector_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__(size_t size) {
+    std::vector<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>
+  /**
+   * Wrapper struct for `std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ {
+    std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd> variant;
+    std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd> variant): variant(variant) { }
+    operator std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>() const {
+      return variant;
+    }
+    inline size_t index() const {
+      return variant.index();
+    }
+    inline PredicateWithUUID get_0() const {
+      return std::get<0>(variant);
+    }
+    inline PredicateWithUUIDs get_1() const {
+      return std::get<1>(variant);
+    }
+    inline PredicateWithMetadataKey get_2() const {
+      return std::get<2>(variant);
+    }
+    inline PredicateWithStartAndEnd get_3() const {
+      return std::get<3>(variant);
+    }
+    inline PredicateFromWorkout get_4() const {
+      return std::get<4>(variant);
+    }
+    inline WorkoutActivityTypePredicate get_5() const {
+      return std::get<5>(variant);
+    }
+    inline WorkoutDurationPredicate get_6() const {
+      return std::get<6>(variant);
+    }
+    inline PredicateForWorkoutsOr get_7() const {
+      return std::get<7>(variant);
+    }
+    inline PredicateForWorkoutsAnd get_8() const {
+      return std::get<8>(variant);
+    }
+  };
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithUUID& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithUUIDs& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithMetadataKey& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateWithStartAndEnd& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateFromWorkout& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const WorkoutActivityTypePredicate& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const WorkoutDurationPredicate& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateForWorkoutsOr& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  inline std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_ create_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(const PredicateForWorkoutsAnd& value) {
+    return std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>
+  /**
+   * Specialized version of `std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>`.
+   */
+  using std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd__ = std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>;
+  inline std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>> create_std__optional_std__variant_PredicateWithUUID__PredicateWithUUIDs__PredicateWithMetadataKey__PredicateWithStartAndEnd__PredicateFromWorkout__WorkoutActivityTypePredicate__WorkoutDurationPredicate__PredicateForWorkoutsOr__PredicateForWorkoutsAnd__(const std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>& value) {
+    return std::optional<std::variant<PredicateWithUUID, PredicateWithUUIDs, PredicateWithMetadataKey, PredicateWithStartAndEnd, PredicateFromWorkout, WorkoutActivityTypePredicate, WorkoutDurationPredicate, PredicateForWorkoutsOr, PredicateForWorkoutsAnd>>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____ = std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>;
+  inline std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>> create_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____() {
+    return Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>::create();
+  }
+  inline PromiseHolder<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>> wrap_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec____(std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>> promise) {
+    return PromiseHolder<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>&)>`.
+   */
+  using Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ = std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper final {
+  public:
+    explicit Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>& /* result */)>> _function;
+  };
+  Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ create_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__(Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec__ value) {
+    return Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>;
+  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>
+  using std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>;
+  inline std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutsModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>>
+  using Result_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse___ = Result<std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>>;
+  inline Result_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse___(const std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>& value) {
+    return Result<std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse___ create_Result_std__shared_ptr_Promise_QueryWorkoutSamplesWithAnchorResponse___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<QueryWorkoutSamplesWithAnchorResponse>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>>
+  using Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____ = Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____ create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____(const std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____ create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec_____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutProxySpec>>>>>::withError(error);
+  }
+
+} // namespace margelo::nitro::healthkit::bridge::swift