///
/// HaptikaPPG-Swift-Cxx-Bridge.hpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#pragma once

// Forward declarations of C++ defined types
// Forward declaration of `FingerContactState` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { enum class FingerContactState; }
// Forward declaration of `HealthMetricType` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { enum class HealthMetricType; }
// Forward declaration of `HybridFrameSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridFrameSpec; }
// Forward declaration of `HybridHaptikaCardiacMirrorSpec` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { class HybridHaptikaCardiacMirrorSpec; }
// Forward declaration of `HybridHaptikaHealthKitSpec` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { class HybridHaptikaHealthKitSpec; }
// Forward declaration of `HybridHaptikaPPGFrameProcessorSpec` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { class HybridHaptikaPPGFrameProcessorSpec; }
// Forward declaration of `NativeAcceptedBeat` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativeAcceptedBeat; }
// Forward declaration of `NativeCardiacMirrorHeartbeat` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativeCardiacMirrorHeartbeat; }
// Forward declaration of `NativeCardiacMirrorPatternInfo` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativeCardiacMirrorPatternInfo; }
// Forward declaration of `NativeHealthKitContext` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativeHealthKitContext; }
// Forward declaration of `NativeHealthMetricSample` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativeHealthMetricSample; }
// Forward declaration of `NativeHeartbeatSeriesSummary` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativeHeartbeatSeriesSummary; }
// Forward declaration of `NativePPGProcessingResult` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct NativePPGProcessingResult; }
// Forward declaration of `PPGFrameUpdate` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { struct PPGFrameUpdate; }
// Forward declaration of `ThermalState` to properly resolve imports.
namespace margelo::nitro::haptika::ppg { enum class ThermalState; }

// Forward declarations of Swift defined types
// Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
namespace VisionCamera { class HybridFrameSpec_cxx; }
// Forward declaration of `HybridHaptikaCardiacMirrorSpec_cxx` to properly resolve imports.
namespace HaptikaPPG { class HybridHaptikaCardiacMirrorSpec_cxx; }
// Forward declaration of `HybridHaptikaHealthKitSpec_cxx` to properly resolve imports.
namespace HaptikaPPG { class HybridHaptikaHealthKitSpec_cxx; }
// Forward declaration of `HybridHaptikaPPGFrameProcessorSpec_cxx` to properly resolve imports.
namespace HaptikaPPG { class HybridHaptikaPPGFrameProcessorSpec_cxx; }

// Include C++ defined types
#include "FingerContactState.hpp"
#include "HealthMetricType.hpp"
#include "HybridHaptikaCardiacMirrorSpec.hpp"
#include "HybridHaptikaHealthKitSpec.hpp"
#include "HybridHaptikaPPGFrameProcessorSpec.hpp"
#include "NativeAcceptedBeat.hpp"
#include "NativeCardiacMirrorHeartbeat.hpp"
#include "NativeCardiacMirrorPatternInfo.hpp"
#include "NativeHealthKitContext.hpp"
#include "NativeHealthMetricSample.hpp"
#include "NativeHeartbeatSeriesSummary.hpp"
#include "NativePPGProcessingResult.hpp"
#include "PPGFrameUpdate.hpp"
#include "ThermalState.hpp"
#include <NitroModules/Promise.hpp>
#include <NitroModules/PromiseHolder.hpp>
#include <NitroModules/Result.hpp>
#include <VisionCamera/HybridFrameSpec.hpp>
#include <exception>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#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::haptika::ppg::bridge::swift {

  // 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) noexcept {
    return std::optional<double>(value);
  }
  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
    return optional.has_value();
  }
  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<NativeAcceptedBeat>
  /**
   * Specialized version of `std::vector<NativeAcceptedBeat>`.
   */
  using std__vector_NativeAcceptedBeat_ = std::vector<NativeAcceptedBeat>;
  inline std::vector<NativeAcceptedBeat> create_std__vector_NativeAcceptedBeat_(size_t size) noexcept {
    std::vector<NativeAcceptedBeat> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<PPGFrameUpdate>
  /**
   * Specialized version of `std::optional<PPGFrameUpdate>`.
   */
  using std__optional_PPGFrameUpdate_ = std::optional<PPGFrameUpdate>;
  inline std::optional<PPGFrameUpdate> create_std__optional_PPGFrameUpdate_(const PPGFrameUpdate& value) noexcept {
    return std::optional<PPGFrameUpdate>(value);
  }
  inline bool has_value_std__optional_PPGFrameUpdate_(const std::optional<PPGFrameUpdate>& optional) noexcept {
    return optional.has_value();
  }
  inline PPGFrameUpdate get_std__optional_PPGFrameUpdate_(const std::optional<PPGFrameUpdate>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>
  /**
   * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>`.
   */
  using std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>;
  std::shared_ptr<margelo::nitro::camera::HybridFrameSpec> create_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>
  using std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>;
  inline std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& strong) noexcept { return strong; }
  
  // 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) noexcept {
    return std::optional<std::string>(value);
  }
  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
    return optional.has_value();
  }
  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
    return optional.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) noexcept {
    std::vector<std::string> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<HybridHaptikaPPGFrameProcessorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridHaptikaPPGFrameProcessorSpec>`.
   */
  using std__shared_ptr_HybridHaptikaPPGFrameProcessorSpec_ = std::shared_ptr<HybridHaptikaPPGFrameProcessorSpec>;
  std::shared_ptr<HybridHaptikaPPGFrameProcessorSpec> create_std__shared_ptr_HybridHaptikaPPGFrameProcessorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridHaptikaPPGFrameProcessorSpec_(std__shared_ptr_HybridHaptikaPPGFrameProcessorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridHaptikaPPGFrameProcessorSpec>
  using std__weak_ptr_HybridHaptikaPPGFrameProcessorSpec_ = std::weak_ptr<HybridHaptikaPPGFrameProcessorSpec>;
  inline std__weak_ptr_HybridHaptikaPPGFrameProcessorSpec_ weakify_std__shared_ptr_HybridHaptikaPPGFrameProcessorSpec_(const std::shared_ptr<HybridHaptikaPPGFrameProcessorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<void>
  using Result_void_ = Result<void>;
  inline Result_void_ create_Result_void_() noexcept {
    return Result<void>::withValue();
  }
  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
    return Result<void>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<PPGFrameUpdate>>
  using Result_std__optional_PPGFrameUpdate__ = Result<std::optional<PPGFrameUpdate>>;
  inline Result_std__optional_PPGFrameUpdate__ create_Result_std__optional_PPGFrameUpdate__(const std::optional<PPGFrameUpdate>& value) noexcept {
    return Result<std::optional<PPGFrameUpdate>>::withValue(value);
  }
  inline Result_std__optional_PPGFrameUpdate__ create_Result_std__optional_PPGFrameUpdate__(const std::exception_ptr& error) noexcept {
    return Result<std::optional<PPGFrameUpdate>>::withError(error);
  }
  
  // pragma MARK: Result<NativePPGProcessingResult>
  using Result_NativePPGProcessingResult_ = Result<NativePPGProcessingResult>;
  inline Result_NativePPGProcessingResult_ create_Result_NativePPGProcessingResult_(const NativePPGProcessingResult& value) noexcept {
    return Result<NativePPGProcessingResult>::withValue(value);
  }
  inline Result_NativePPGProcessingResult_ create_Result_NativePPGProcessingResult_(const std::exception_ptr& error) noexcept {
    return Result<NativePPGProcessingResult>::withError(error);
  }
  
  // pragma MARK: Result<ThermalState>
  using Result_ThermalState_ = Result<ThermalState>;
  inline Result_ThermalState_ create_Result_ThermalState_(ThermalState value) noexcept {
    return Result<ThermalState>::withValue(std::move(value));
  }
  inline Result_ThermalState_ create_Result_ThermalState_(const std::exception_ptr& error) noexcept {
    return Result<ThermalState>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<bool>>
  /**
   * Specialized version of `std::shared_ptr<Promise<bool>>`.
   */
  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
    return Promise<bool>::create();
  }
  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
    return PromiseHolder<bool>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(bool /* result */)>
  /**
   * Specialized version of `std::function<void(bool)>`.
   */
  using Func_void_bool = std::function<void(bool /* result */)>;
  /**
   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
   */
  class Func_void_bool_Wrapper final {
  public:
    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
    inline void call(bool result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(bool /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
    return Func_void_bool_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
  /**
   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
   */
  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
  /**
   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
   */
  class Func_void_std__exception_ptr_Wrapper final {
  public:
    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
    inline void call(std::exception_ptr error) const noexcept {
      _function->operator()(error);
    }
  private:
    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
    return Func_void_std__exception_ptr_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<NativeHealthMetricSample>
  /**
   * Specialized version of `std::optional<NativeHealthMetricSample>`.
   */
  using std__optional_NativeHealthMetricSample_ = std::optional<NativeHealthMetricSample>;
  inline std::optional<NativeHealthMetricSample> create_std__optional_NativeHealthMetricSample_(const NativeHealthMetricSample& value) noexcept {
    return std::optional<NativeHealthMetricSample>(value);
  }
  inline bool has_value_std__optional_NativeHealthMetricSample_(const std::optional<NativeHealthMetricSample>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeHealthMetricSample get_std__optional_NativeHealthMetricSample_(const std::optional<NativeHealthMetricSample>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<NativeHealthMetricSample>
  /**
   * Specialized version of `std::vector<NativeHealthMetricSample>`.
   */
  using std__vector_NativeHealthMetricSample_ = std::vector<NativeHealthMetricSample>;
  inline std::vector<NativeHealthMetricSample> create_std__vector_NativeHealthMetricSample_(size_t size) noexcept {
    std::vector<NativeHealthMetricSample> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<NativeHealthKitContext>>
  /**
   * Specialized version of `std::shared_ptr<Promise<NativeHealthKitContext>>`.
   */
  using std__shared_ptr_Promise_NativeHealthKitContext__ = std::shared_ptr<Promise<NativeHealthKitContext>>;
  inline std::shared_ptr<Promise<NativeHealthKitContext>> create_std__shared_ptr_Promise_NativeHealthKitContext__() noexcept {
    return Promise<NativeHealthKitContext>::create();
  }
  inline PromiseHolder<NativeHealthKitContext> wrap_std__shared_ptr_Promise_NativeHealthKitContext__(std::shared_ptr<Promise<NativeHealthKitContext>> promise) noexcept {
    return PromiseHolder<NativeHealthKitContext>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const NativeHealthKitContext& /* result */)>
  /**
   * Specialized version of `std::function<void(const NativeHealthKitContext&)>`.
   */
  using Func_void_NativeHealthKitContext = std::function<void(const NativeHealthKitContext& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const NativeHealthKitContext& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_NativeHealthKitContext_Wrapper final {
  public:
    explicit Func_void_NativeHealthKitContext_Wrapper(std::function<void(const NativeHealthKitContext& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativeHealthKitContext& /* result */)>>(std::move(func))) {}
    inline void call(NativeHealthKitContext result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const NativeHealthKitContext& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_NativeHealthKitContext create_Func_void_NativeHealthKitContext(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_NativeHealthKitContext_Wrapper wrap_Func_void_NativeHealthKitContext(Func_void_NativeHealthKitContext value) noexcept {
    return Func_void_NativeHealthKitContext_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<double>
  /**
   * Specialized version of `std::vector<double>`.
   */
  using std__vector_double_ = std::vector<double>;
  inline std::vector<double> create_std__vector_double_(size_t size) noexcept {
    std::vector<double> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<NativeHeartbeatSeriesSummary>
  /**
   * Specialized version of `std::optional<NativeHeartbeatSeriesSummary>`.
   */
  using std__optional_NativeHeartbeatSeriesSummary_ = std::optional<NativeHeartbeatSeriesSummary>;
  inline std::optional<NativeHeartbeatSeriesSummary> create_std__optional_NativeHeartbeatSeriesSummary_(const NativeHeartbeatSeriesSummary& value) noexcept {
    return std::optional<NativeHeartbeatSeriesSummary>(value);
  }
  inline bool has_value_std__optional_NativeHeartbeatSeriesSummary_(const std::optional<NativeHeartbeatSeriesSummary>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeHeartbeatSeriesSummary get_std__optional_NativeHeartbeatSeriesSummary_(const std::optional<NativeHeartbeatSeriesSummary>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>`.
   */
  using std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary___ = std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>;
  inline std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>> create_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary___() noexcept {
    return Promise<std::optional<NativeHeartbeatSeriesSummary>>::create();
  }
  inline PromiseHolder<std::optional<NativeHeartbeatSeriesSummary>> wrap_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary___(std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>> promise) noexcept {
    return PromiseHolder<std::optional<NativeHeartbeatSeriesSummary>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<NativeHeartbeatSeriesSummary>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<NativeHeartbeatSeriesSummary>&)>`.
   */
  using Func_void_std__optional_NativeHeartbeatSeriesSummary_ = std::function<void(const std::optional<NativeHeartbeatSeriesSummary>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<NativeHeartbeatSeriesSummary>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_NativeHeartbeatSeriesSummary__Wrapper final {
  public:
    explicit Func_void_std__optional_NativeHeartbeatSeriesSummary__Wrapper(std::function<void(const std::optional<NativeHeartbeatSeriesSummary>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<NativeHeartbeatSeriesSummary>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<NativeHeartbeatSeriesSummary> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<NativeHeartbeatSeriesSummary>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_NativeHeartbeatSeriesSummary_ create_Func_void_std__optional_NativeHeartbeatSeriesSummary_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_NativeHeartbeatSeriesSummary__Wrapper wrap_Func_void_std__optional_NativeHeartbeatSeriesSummary_(Func_void_std__optional_NativeHeartbeatSeriesSummary_ value) noexcept {
    return Func_void_std__optional_NativeHeartbeatSeriesSummary__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridHaptikaHealthKitSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridHaptikaHealthKitSpec>`.
   */
  using std__shared_ptr_HybridHaptikaHealthKitSpec_ = std::shared_ptr<HybridHaptikaHealthKitSpec>;
  std::shared_ptr<HybridHaptikaHealthKitSpec> create_std__shared_ptr_HybridHaptikaHealthKitSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridHaptikaHealthKitSpec_(std__shared_ptr_HybridHaptikaHealthKitSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridHaptikaHealthKitSpec>
  using std__weak_ptr_HybridHaptikaHealthKitSpec_ = std::weak_ptr<HybridHaptikaHealthKitSpec>;
  inline std__weak_ptr_HybridHaptikaHealthKitSpec_ weakify_std__shared_ptr_HybridHaptikaHealthKitSpec_(const std::shared_ptr<HybridHaptikaHealthKitSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<bool>
  using Result_bool_ = Result<bool>;
  inline Result_bool_ create_Result_bool_(bool value) noexcept {
    return Result<bool>::withValue(std::move(value));
  }
  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
    return Result<bool>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<NativeHealthKitContext>>>
  using Result_std__shared_ptr_Promise_NativeHealthKitContext___ = Result<std::shared_ptr<Promise<NativeHealthKitContext>>>;
  inline Result_std__shared_ptr_Promise_NativeHealthKitContext___ create_Result_std__shared_ptr_Promise_NativeHealthKitContext___(const std::shared_ptr<Promise<NativeHealthKitContext>>& value) noexcept {
    return Result<std::shared_ptr<Promise<NativeHealthKitContext>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_NativeHealthKitContext___ create_Result_std__shared_ptr_Promise_NativeHealthKitContext___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<NativeHealthKitContext>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>>
  using Result_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary____ = Result<std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary____ create_Result_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary____(const std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary____ create_Result_std__shared_ptr_Promise_std__optional_NativeHeartbeatSeriesSummary____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<NativeHeartbeatSeriesSummary>>>>::withError(error);
  }
  
  // pragma MARK: std::optional<NativeCardiacMirrorHeartbeat>
  /**
   * Specialized version of `std::optional<NativeCardiacMirrorHeartbeat>`.
   */
  using std__optional_NativeCardiacMirrorHeartbeat_ = std::optional<NativeCardiacMirrorHeartbeat>;
  inline std::optional<NativeCardiacMirrorHeartbeat> create_std__optional_NativeCardiacMirrorHeartbeat_(const NativeCardiacMirrorHeartbeat& value) noexcept {
    return std::optional<NativeCardiacMirrorHeartbeat>(value);
  }
  inline bool has_value_std__optional_NativeCardiacMirrorHeartbeat_(const std::optional<NativeCardiacMirrorHeartbeat>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeCardiacMirrorHeartbeat get_std__optional_NativeCardiacMirrorHeartbeat_(const std::optional<NativeCardiacMirrorHeartbeat>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridHaptikaCardiacMirrorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridHaptikaCardiacMirrorSpec>`.
   */
  using std__shared_ptr_HybridHaptikaCardiacMirrorSpec_ = std::shared_ptr<HybridHaptikaCardiacMirrorSpec>;
  std::shared_ptr<HybridHaptikaCardiacMirrorSpec> create_std__shared_ptr_HybridHaptikaCardiacMirrorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridHaptikaCardiacMirrorSpec_(std__shared_ptr_HybridHaptikaCardiacMirrorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridHaptikaCardiacMirrorSpec>
  using std__weak_ptr_HybridHaptikaCardiacMirrorSpec_ = std::weak_ptr<HybridHaptikaCardiacMirrorSpec>;
  inline std__weak_ptr_HybridHaptikaCardiacMirrorSpec_ weakify_std__shared_ptr_HybridHaptikaCardiacMirrorSpec_(const std::shared_ptr<HybridHaptikaCardiacMirrorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<NativeCardiacMirrorPatternInfo>
  using Result_NativeCardiacMirrorPatternInfo_ = Result<NativeCardiacMirrorPatternInfo>;
  inline Result_NativeCardiacMirrorPatternInfo_ create_Result_NativeCardiacMirrorPatternInfo_(const NativeCardiacMirrorPatternInfo& value) noexcept {
    return Result<NativeCardiacMirrorPatternInfo>::withValue(value);
  }
  inline Result_NativeCardiacMirrorPatternInfo_ create_Result_NativeCardiacMirrorPatternInfo_(const std::exception_ptr& error) noexcept {
    return Result<NativeCardiacMirrorPatternInfo>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<NativeCardiacMirrorHeartbeat>>
  using Result_std__optional_NativeCardiacMirrorHeartbeat__ = Result<std::optional<NativeCardiacMirrorHeartbeat>>;
  inline Result_std__optional_NativeCardiacMirrorHeartbeat__ create_Result_std__optional_NativeCardiacMirrorHeartbeat__(const std::optional<NativeCardiacMirrorHeartbeat>& value) noexcept {
    return Result<std::optional<NativeCardiacMirrorHeartbeat>>::withValue(value);
  }
  inline Result_std__optional_NativeCardiacMirrorHeartbeat__ create_Result_std__optional_NativeCardiacMirrorHeartbeat__(const std::exception_ptr& error) noexcept {
    return Result<std::optional<NativeCardiacMirrorHeartbeat>>::withError(error);
  }
  
  // pragma MARK: Result<double>
  using Result_double_ = Result<double>;
  inline Result_double_ create_Result_double_(double value) noexcept {
    return Result<double>::withValue(std::move(value));
  }
  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
    return Result<double>::withError(error);
  }

} // namespace margelo::nitro::haptika::ppg::bridge::swift