///
/// VisionCameraFaceDetector-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 `CameraPosition` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { enum class CameraPosition; }
// Forward declaration of `Contours` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { struct Contours; }
// Forward declaration of `FaceDetectorOutputResolution` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { enum class FaceDetectorOutputResolution; }
// Forward declaration of `HybridCameraOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraOutputSpec; }
// Forward declaration of `HybridFaceDetectorFactorySpec` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { class HybridFaceDetectorFactorySpec; }
// Forward declaration of `HybridFaceDetectorSpec` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { class HybridFaceDetectorSpec; }
// Forward declaration of `HybridFaceSpec` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { class HybridFaceSpec; }
// Forward declaration of `HybridFrameSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridFrameSpec; }
// Forward declaration of `HybridImageFaceDetectorFactorySpec` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { class HybridImageFaceDetectorFactorySpec; }
// Forward declaration of `HybridImageFaceDetectorSpec` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { class HybridImageFaceDetectorSpec; }
// Forward declaration of `ImageUri` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { struct ImageUri; }
// Forward declaration of `Landmarks` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { struct Landmarks; }
// Forward declaration of `PerformanceMode` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { enum class PerformanceMode; }
// Forward declaration of `Point` to properly resolve imports.
namespace margelo::nitro::camera::facedetector { struct Point; }

// Forward declarations of Swift defined types
// Forward declaration of `HybridCameraOutputSpec_cxx` to properly resolve imports.
namespace VisionCamera { class HybridCameraOutputSpec_cxx; }
// Forward declaration of `HybridFaceDetectorFactorySpec_cxx` to properly resolve imports.
namespace VisionCameraFaceDetector { class HybridFaceDetectorFactorySpec_cxx; }
// Forward declaration of `HybridFaceDetectorSpec_cxx` to properly resolve imports.
namespace VisionCameraFaceDetector { class HybridFaceDetectorSpec_cxx; }
// Forward declaration of `HybridFaceSpec_cxx` to properly resolve imports.
namespace VisionCameraFaceDetector { class HybridFaceSpec_cxx; }
// Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
namespace VisionCamera { class HybridFrameSpec_cxx; }
// Forward declaration of `HybridImageFaceDetectorFactorySpec_cxx` to properly resolve imports.
namespace VisionCameraFaceDetector { class HybridImageFaceDetectorFactorySpec_cxx; }
// Forward declaration of `HybridImageFaceDetectorSpec_cxx` to properly resolve imports.
namespace VisionCameraFaceDetector { class HybridImageFaceDetectorSpec_cxx; }

// Include C++ defined types
#include "CameraPosition.hpp"
#include "Contours.hpp"
#include "FaceDetectorOutputResolution.hpp"
#include "HybridFaceDetectorFactorySpec.hpp"
#include "HybridFaceDetectorSpec.hpp"
#include "HybridFaceSpec.hpp"
#include "HybridImageFaceDetectorFactorySpec.hpp"
#include "HybridImageFaceDetectorSpec.hpp"
#include "ImageUri.hpp"
#include "Landmarks.hpp"
#include "PerformanceMode.hpp"
#include "Point.hpp"
#include <NitroModules/Result.hpp>
#include <VisionCamera/HybridCameraOutputSpec.hpp>
#include <VisionCamera/HybridFrameSpec.hpp>
#include <exception>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#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::camera::facedetector::bridge::swift {

  // pragma MARK: std::optional<Point>
  /**
   * Specialized version of `std::optional<Point>`.
   */
  using std__optional_Point_ = std::optional<Point>;
  inline std::optional<Point> create_std__optional_Point_(const Point& value) noexcept {
    return std::optional<Point>(value);
  }
  inline bool has_value_std__optional_Point_(const std::optional<Point>& optional) noexcept {
    return optional.has_value();
  }
  inline Point get_std__optional_Point_(const std::optional<Point>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<Landmarks>
  /**
   * Specialized version of `std::optional<Landmarks>`.
   */
  using std__optional_Landmarks_ = std::optional<Landmarks>;
  inline std::optional<Landmarks> create_std__optional_Landmarks_(const Landmarks& value) noexcept {
    return std::optional<Landmarks>(value);
  }
  inline bool has_value_std__optional_Landmarks_(const std::optional<Landmarks>& optional) noexcept {
    return optional.has_value();
  }
  inline Landmarks get_std__optional_Landmarks_(const std::optional<Landmarks>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<Point>
  /**
   * Specialized version of `std::vector<Point>`.
   */
  using std__vector_Point_ = std::vector<Point>;
  inline std::vector<Point> create_std__vector_Point_(size_t size) noexcept {
    std::vector<Point> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<Point>>
  /**
   * Specialized version of `std::optional<std::vector<Point>>`.
   */
  using std__optional_std__vector_Point__ = std::optional<std::vector<Point>>;
  inline std::optional<std::vector<Point>> create_std__optional_std__vector_Point__(const std::vector<Point>& value) noexcept {
    return std::optional<std::vector<Point>>(value);
  }
  inline bool has_value_std__optional_std__vector_Point__(const std::optional<std::vector<Point>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<Point> get_std__optional_std__vector_Point__(const std::optional<std::vector<Point>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<Contours>
  /**
   * Specialized version of `std::optional<Contours>`.
   */
  using std__optional_Contours_ = std::optional<Contours>;
  inline std::optional<Contours> create_std__optional_Contours_(const Contours& value) noexcept {
    return std::optional<Contours>(value);
  }
  inline bool has_value_std__optional_Contours_(const std::optional<Contours>& optional) noexcept {
    return optional.has_value();
  }
  inline Contours get_std__optional_Contours_(const std::optional<Contours>& optional) noexcept {
    return optional.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) 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::shared_ptr<HybridFaceSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridFaceSpec>`.
   */
  using std__shared_ptr_HybridFaceSpec_ = std::shared_ptr<HybridFaceSpec>;
  std::shared_ptr<HybridFaceSpec> create_std__shared_ptr_HybridFaceSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridFaceSpec_(std__shared_ptr_HybridFaceSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridFaceSpec>
  using std__weak_ptr_HybridFaceSpec_ = std::weak_ptr<HybridFaceSpec>;
  inline std__weak_ptr_HybridFaceSpec_ weakify_std__shared_ptr_HybridFaceSpec_(const std::shared_ptr<HybridFaceSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::vector<std::shared_ptr<HybridFaceSpec>>
  /**
   * Specialized version of `std::vector<std::shared_ptr<HybridFaceSpec>>`.
   */
  using std__vector_std__shared_ptr_HybridFaceSpec__ = std::vector<std::shared_ptr<HybridFaceSpec>>;
  inline std::vector<std::shared_ptr<HybridFaceSpec>> create_std__vector_std__shared_ptr_HybridFaceSpec__(size_t size) noexcept {
    std::vector<std::shared_ptr<HybridFaceSpec>> vector;
    vector.reserve(size);
    return vector;
  }
  
  // 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::shared_ptr<HybridFaceDetectorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridFaceDetectorSpec>`.
   */
  using std__shared_ptr_HybridFaceDetectorSpec_ = std::shared_ptr<HybridFaceDetectorSpec>;
  std::shared_ptr<HybridFaceDetectorSpec> create_std__shared_ptr_HybridFaceDetectorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridFaceDetectorSpec_(std__shared_ptr_HybridFaceDetectorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridFaceDetectorSpec>
  using std__weak_ptr_HybridFaceDetectorSpec_ = std::weak_ptr<HybridFaceDetectorSpec>;
  inline std__weak_ptr_HybridFaceDetectorSpec_ weakify_std__shared_ptr_HybridFaceDetectorSpec_(const std::shared_ptr<HybridFaceDetectorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::vector<std::shared_ptr<HybridFaceSpec>>>
  using Result_std__vector_std__shared_ptr_HybridFaceSpec___ = Result<std::vector<std::shared_ptr<HybridFaceSpec>>>;
  inline Result_std__vector_std__shared_ptr_HybridFaceSpec___ create_Result_std__vector_std__shared_ptr_HybridFaceSpec___(const std::vector<std::shared_ptr<HybridFaceSpec>>& value) noexcept {
    return Result<std::vector<std::shared_ptr<HybridFaceSpec>>>::withValue(value);
  }
  inline Result_std__vector_std__shared_ptr_HybridFaceSpec___ create_Result_std__vector_std__shared_ptr_HybridFaceSpec___(const std::exception_ptr& error) noexcept {
    return Result<std::vector<std::shared_ptr<HybridFaceSpec>>>::withError(error);
  }
  
  // pragma MARK: std::optional<CameraPosition>
  /**
   * Specialized version of `std::optional<CameraPosition>`.
   */
  using std__optional_CameraPosition_ = std::optional<CameraPosition>;
  inline std::optional<CameraPosition> create_std__optional_CameraPosition_(const CameraPosition& value) noexcept {
    return std::optional<CameraPosition>(value);
  }
  inline bool has_value_std__optional_CameraPosition_(const std::optional<CameraPosition>& optional) noexcept {
    return optional.has_value();
  }
  inline CameraPosition get_std__optional_CameraPosition_(const std::optional<CameraPosition>& optional) noexcept {
    return optional.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) noexcept {
    return std::optional<bool>(value);
  }
  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
    return optional.has_value();
  }
  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<PerformanceMode>
  /**
   * Specialized version of `std::optional<PerformanceMode>`.
   */
  using std__optional_PerformanceMode_ = std::optional<PerformanceMode>;
  inline std::optional<PerformanceMode> create_std__optional_PerformanceMode_(const PerformanceMode& value) noexcept {
    return std::optional<PerformanceMode>(value);
  }
  inline bool has_value_std__optional_PerformanceMode_(const std::optional<PerformanceMode>& optional) noexcept {
    return optional.has_value();
  }
  inline PerformanceMode get_std__optional_PerformanceMode_(const std::optional<PerformanceMode>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>
  /**
   * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>`.
   */
  using std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ = std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>;
  std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec> create_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<margelo::nitro::camera::HybridCameraOutputSpec>
  using std__weak_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ = std::weak_ptr<margelo::nitro::camera::HybridCameraOutputSpec>;
  inline std__weak_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(const std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::optional<FaceDetectorOutputResolution>
  /**
   * Specialized version of `std::optional<FaceDetectorOutputResolution>`.
   */
  using std__optional_FaceDetectorOutputResolution_ = std::optional<FaceDetectorOutputResolution>;
  inline std::optional<FaceDetectorOutputResolution> create_std__optional_FaceDetectorOutputResolution_(const FaceDetectorOutputResolution& value) noexcept {
    return std::optional<FaceDetectorOutputResolution>(value);
  }
  inline bool has_value_std__optional_FaceDetectorOutputResolution_(const std::optional<FaceDetectorOutputResolution>& optional) noexcept {
    return optional.has_value();
  }
  inline FaceDetectorOutputResolution get_std__optional_FaceDetectorOutputResolution_(const std::optional<FaceDetectorOutputResolution>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>& /* faces */)>
  /**
   * Specialized version of `std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>&)>`.
   */
  using Func_void_std__vector_std__shared_ptr_HybridFaceSpec__ = std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>& /* faces */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>& / * faces * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_std__shared_ptr_HybridFaceSpec___Wrapper final {
  public:
    explicit Func_void_std__vector_std__shared_ptr_HybridFaceSpec___Wrapper(std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>& /* faces */)>&& func): _function(std::make_unique<std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>& /* faces */)>>(std::move(func))) {}
    inline void call(std::vector<std::shared_ptr<HybridFaceSpec>> faces) const noexcept {
      _function->operator()(faces);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<std::shared_ptr<HybridFaceSpec>>& /* faces */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_std__shared_ptr_HybridFaceSpec__ create_Func_void_std__vector_std__shared_ptr_HybridFaceSpec__(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_std__shared_ptr_HybridFaceSpec___Wrapper wrap_Func_void_std__vector_std__shared_ptr_HybridFaceSpec__(Func_void_std__vector_std__shared_ptr_HybridFaceSpec__ value) noexcept {
    return Func_void_std__vector_std__shared_ptr_HybridFaceSpec___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::shared_ptr<HybridFaceDetectorFactorySpec>
  /**
   * Specialized version of `std::shared_ptr<HybridFaceDetectorFactorySpec>`.
   */
  using std__shared_ptr_HybridFaceDetectorFactorySpec_ = std::shared_ptr<HybridFaceDetectorFactorySpec>;
  std::shared_ptr<HybridFaceDetectorFactorySpec> create_std__shared_ptr_HybridFaceDetectorFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridFaceDetectorFactorySpec_(std__shared_ptr_HybridFaceDetectorFactorySpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridFaceDetectorFactorySpec>
  using std__weak_ptr_HybridFaceDetectorFactorySpec_ = std::weak_ptr<HybridFaceDetectorFactorySpec>;
  inline std__weak_ptr_HybridFaceDetectorFactorySpec_ weakify_std__shared_ptr_HybridFaceDetectorFactorySpec_(const std::shared_ptr<HybridFaceDetectorFactorySpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<HybridFaceDetectorSpec>>
  using Result_std__shared_ptr_HybridFaceDetectorSpec__ = Result<std::shared_ptr<HybridFaceDetectorSpec>>;
  inline Result_std__shared_ptr_HybridFaceDetectorSpec__ create_Result_std__shared_ptr_HybridFaceDetectorSpec__(const std::shared_ptr<HybridFaceDetectorSpec>& value) noexcept {
    return Result<std::shared_ptr<HybridFaceDetectorSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_HybridFaceDetectorSpec__ create_Result_std__shared_ptr_HybridFaceDetectorSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<HybridFaceDetectorSpec>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>
  using Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__ = Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>;
  inline Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__ create_Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__(const std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>& value) noexcept {
    return Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__ create_Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>::withError(error);
  }
  
  // pragma MARK: std::variant<std::string, double, ImageUri>
  /**
   * Wrapper struct for `std::variant<std::string, double, ImageUri>`.
   * 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_std__string__double__ImageUri_ final {
    std::variant<std::string, double, ImageUri> variant;
    std__variant_std__string__double__ImageUri_(std::variant<std::string, double, ImageUri> variant): variant(variant) { }
    operator std::variant<std::string, double, ImageUri>() const noexcept {
      return variant;
    }
    inline size_t index() const noexcept {
      return variant.index();
    }
    inline std::string get_0() const noexcept {
      return std::get<0>(variant);
    }
    inline double get_1() const noexcept {
      return std::get<1>(variant);
    }
    inline ImageUri get_2() const noexcept {
      return std::get<2>(variant);
    }
  };
  inline std__variant_std__string__double__ImageUri_ create_std__variant_std__string__double__ImageUri_(const std::string& value) noexcept {
    return std__variant_std__string__double__ImageUri_(value);
  }
  inline std__variant_std__string__double__ImageUri_ create_std__variant_std__string__double__ImageUri_(double value) noexcept {
    return std__variant_std__string__double__ImageUri_(value);
  }
  inline std__variant_std__string__double__ImageUri_ create_std__variant_std__string__double__ImageUri_(const ImageUri& value) noexcept {
    return std__variant_std__string__double__ImageUri_(value);
  }
  
  // pragma MARK: std::shared_ptr<HybridImageFaceDetectorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridImageFaceDetectorSpec>`.
   */
  using std__shared_ptr_HybridImageFaceDetectorSpec_ = std::shared_ptr<HybridImageFaceDetectorSpec>;
  std::shared_ptr<HybridImageFaceDetectorSpec> create_std__shared_ptr_HybridImageFaceDetectorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridImageFaceDetectorSpec_(std__shared_ptr_HybridImageFaceDetectorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridImageFaceDetectorSpec>
  using std__weak_ptr_HybridImageFaceDetectorSpec_ = std::weak_ptr<HybridImageFaceDetectorSpec>;
  inline std__weak_ptr_HybridImageFaceDetectorSpec_ weakify_std__shared_ptr_HybridImageFaceDetectorSpec_(const std::shared_ptr<HybridImageFaceDetectorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<HybridImageFaceDetectorFactorySpec>
  /**
   * Specialized version of `std::shared_ptr<HybridImageFaceDetectorFactorySpec>`.
   */
  using std__shared_ptr_HybridImageFaceDetectorFactorySpec_ = std::shared_ptr<HybridImageFaceDetectorFactorySpec>;
  std::shared_ptr<HybridImageFaceDetectorFactorySpec> create_std__shared_ptr_HybridImageFaceDetectorFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridImageFaceDetectorFactorySpec_(std__shared_ptr_HybridImageFaceDetectorFactorySpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridImageFaceDetectorFactorySpec>
  using std__weak_ptr_HybridImageFaceDetectorFactorySpec_ = std::weak_ptr<HybridImageFaceDetectorFactorySpec>;
  inline std__weak_ptr_HybridImageFaceDetectorFactorySpec_ weakify_std__shared_ptr_HybridImageFaceDetectorFactorySpec_(const std::shared_ptr<HybridImageFaceDetectorFactorySpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<HybridImageFaceDetectorSpec>>
  using Result_std__shared_ptr_HybridImageFaceDetectorSpec__ = Result<std::shared_ptr<HybridImageFaceDetectorSpec>>;
  inline Result_std__shared_ptr_HybridImageFaceDetectorSpec__ create_Result_std__shared_ptr_HybridImageFaceDetectorSpec__(const std::shared_ptr<HybridImageFaceDetectorSpec>& value) noexcept {
    return Result<std::shared_ptr<HybridImageFaceDetectorSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_HybridImageFaceDetectorSpec__ create_Result_std__shared_ptr_HybridImageFaceDetectorSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<HybridImageFaceDetectorSpec>>::withError(error);
  }

} // namespace margelo::nitro::camera::facedetector::bridge::swift