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

#include "VisionCamera-Swift-Cxx-Bridge.hpp"

// Include C++ implementation defined types
#include "HybridCameraCalibrationDataSpecSwift.hpp"
#include "HybridCameraControllerSpecSwift.hpp"
#include "HybridCameraDepthFrameOutputSpecSwift.hpp"
#include "HybridCameraDeviceFactorySpecSwift.hpp"
#include "HybridCameraDeviceSpecSwift.hpp"
#include "HybridCameraExtensionSpecSwift.hpp"
#include "HybridCameraFactorySpecSwift.hpp"
#include "HybridCameraFrameOutputSpecSwift.hpp"
#include "HybridCameraObjectOutputSpecSwift.hpp"
#include "HybridCameraOutputSpecSwift.hpp"
#include "HybridCameraOutputSynchronizerSpecSwift.hpp"
#include "HybridCameraPhotoOutputSpecSwift.hpp"
#include "HybridCameraPreviewOutputSpecSwift.hpp"
#include "HybridCameraSessionConfigSpecSwift.hpp"
#include "HybridCameraSessionSpecSwift.hpp"
#include "HybridCameraVideoOutputSpecSwift.hpp"
#include "HybridDepthSpecSwift.hpp"
#include "HybridFrameConverterSpecSwift.hpp"
#include "HybridFramePlaneSpecSwift.hpp"
#include "HybridFrameRendererSpecSwift.hpp"
#include "HybridFrameRendererViewSpecSwift.hpp"
#include "HybridFrameSpecSwift.hpp"
#include "HybridGestureControllerSpecSwift.hpp"
#include "HybridLocationSpecSwift.hpp"
#include "HybridMeteringPointSpecSwift.hpp"
#include "HybridNativeThreadFactorySpecSwift.hpp"
#include "HybridNativeThreadSpecSwift.hpp"
#include "HybridOrientationManagerSpecSwift.hpp"
#include "HybridPhotoSpecSwift.hpp"
#include "HybridPreviewViewSpecSwift.hpp"
#include "HybridRecorderSpecSwift.hpp"
#include "HybridScannedCodeSpecSwift.hpp"
#include "HybridScannedFaceSpecSwift.hpp"
#include "HybridScannedObjectSpecSwift.hpp"
#include "HybridTapToFocusGestureControllerSpecSwift.hpp"
#include "HybridZoomGestureControllerSpecSwift.hpp"
#include "VisionCamera-Swift-Cxx-Umbrella.hpp"
#include <NitroImage/NitroImage-Swift-Cxx-Bridge.hpp>
#include <NitroModules/NitroDefines.hpp>

namespace margelo::nitro::camera::bridge::swift {

  // pragma MARK: std::shared_ptr<HybridCameraDeviceSpec>
  std::shared_ptr<HybridCameraDeviceSpec> create_std__shared_ptr_HybridCameraDeviceSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraDeviceSpec_cxx swiftPart = VisionCamera::HybridCameraDeviceSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraDeviceSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraDeviceSpec_(std__shared_ptr_HybridCameraDeviceSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraDeviceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraDeviceSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraDeviceSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraDeviceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void()>
  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
      swiftClosure.call();
    };
  }
  
  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
      swiftClosure.call(error);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridMeteringPointSpec>
  std::shared_ptr<HybridMeteringPointSpec> create_std__shared_ptr_HybridMeteringPointSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridMeteringPointSpec_cxx swiftPart = VisionCamera::HybridMeteringPointSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridMeteringPointSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridMeteringPointSpec_(std__shared_ptr_HybridMeteringPointSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridMeteringPointSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridMeteringPointSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridMeteringPointSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridMeteringPointSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraControllerSpec>
  std::shared_ptr<HybridCameraControllerSpec> create_std__shared_ptr_HybridCameraControllerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraControllerSpec_cxx swiftPart = VisionCamera::HybridCameraControllerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraControllerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraControllerSpec_(std__shared_ptr_HybridCameraControllerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraControllerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraControllerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraControllerSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraControllerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(bool /* result */)>
  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_bool::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraSessionSpec>
  std::shared_ptr<HybridCameraSessionSpec> create_std__shared_ptr_HybridCameraSessionSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraSessionSpec_cxx swiftPart = VisionCamera::HybridCameraSessionSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraSessionSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraSessionSpec_(std__shared_ptr_HybridCameraSessionSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraSessionSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraSessionSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraSessionSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraSessionSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridCameraSessionSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridCameraSessionSpec_ create_Func_void_std__shared_ptr_HybridCameraSessionSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridCameraSessionSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridCameraSessionSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraSessionConfigSpec>
  std::shared_ptr<HybridCameraSessionConfigSpec> create_std__shared_ptr_HybridCameraSessionConfigSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraSessionConfigSpec_cxx swiftPart = VisionCamera::HybridCameraSessionConfigSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraSessionConfigSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraSessionConfigSpec_(std__shared_ptr_HybridCameraSessionConfigSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraSessionConfigSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraSessionConfigSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraSessionConfigSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraSessionConfigSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridCameraSessionConfigSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridCameraSessionConfigSpec_ create_Func_void_std__shared_ptr_HybridCameraSessionConfigSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridCameraSessionConfigSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridCameraSessionConfigSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraOutputSpec>
  std::shared_ptr<HybridCameraOutputSpec> create_std__shared_ptr_HybridCameraOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraOutputSpec_cxx swiftPart = VisionCamera::HybridCameraOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraOutputSpec_(std__shared_ptr_HybridCameraOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraDeviceFactorySpec>
  std::shared_ptr<HybridCameraDeviceFactorySpec> create_std__shared_ptr_HybridCameraDeviceFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraDeviceFactorySpec_cxx swiftPart = VisionCamera::HybridCameraDeviceFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraDeviceFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraDeviceFactorySpec_(std__shared_ptr_HybridCameraDeviceFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraDeviceFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraDeviceFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraDeviceFactorySpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraDeviceFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridCameraDeviceFactorySpec>& /* result */)>
  Func_void_std__shared_ptr_HybridCameraDeviceFactorySpec_ create_Func_void_std__shared_ptr_HybridCameraDeviceFactorySpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridCameraDeviceFactorySpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridCameraDeviceFactorySpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraPhotoOutputSpec>
  std::shared_ptr<HybridCameraPhotoOutputSpec> create_std__shared_ptr_HybridCameraPhotoOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraPhotoOutputSpec_cxx swiftPart = VisionCamera::HybridCameraPhotoOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraPhotoOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraPhotoOutputSpec_(std__shared_ptr_HybridCameraPhotoOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraPhotoOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraPhotoOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraPhotoOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraPhotoOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraVideoOutputSpec>
  std::shared_ptr<HybridCameraVideoOutputSpec> create_std__shared_ptr_HybridCameraVideoOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraVideoOutputSpec_cxx swiftPart = VisionCamera::HybridCameraVideoOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraVideoOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraVideoOutputSpec_(std__shared_ptr_HybridCameraVideoOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraVideoOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraVideoOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraVideoOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraVideoOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraFrameOutputSpec>
  std::shared_ptr<HybridCameraFrameOutputSpec> create_std__shared_ptr_HybridCameraFrameOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraFrameOutputSpec_cxx swiftPart = VisionCamera::HybridCameraFrameOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraFrameOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraFrameOutputSpec_(std__shared_ptr_HybridCameraFrameOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraFrameOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraFrameOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraFrameOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraFrameOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraDepthFrameOutputSpec>
  std::shared_ptr<HybridCameraDepthFrameOutputSpec> create_std__shared_ptr_HybridCameraDepthFrameOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraDepthFrameOutputSpec_cxx swiftPart = VisionCamera::HybridCameraDepthFrameOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraDepthFrameOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraDepthFrameOutputSpec_(std__shared_ptr_HybridCameraDepthFrameOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraDepthFrameOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraDepthFrameOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraDepthFrameOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraDepthFrameOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraPreviewOutputSpec>
  std::shared_ptr<HybridCameraPreviewOutputSpec> create_std__shared_ptr_HybridCameraPreviewOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraPreviewOutputSpec_cxx swiftPart = VisionCamera::HybridCameraPreviewOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraPreviewOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraPreviewOutputSpec_(std__shared_ptr_HybridCameraPreviewOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraPreviewOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraPreviewOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraPreviewOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraPreviewOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraObjectOutputSpec>
  std::shared_ptr<HybridCameraObjectOutputSpec> create_std__shared_ptr_HybridCameraObjectOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraObjectOutputSpec_cxx swiftPart = VisionCamera::HybridCameraObjectOutputSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraObjectOutputSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraObjectOutputSpec_(std__shared_ptr_HybridCameraObjectOutputSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraObjectOutputSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraObjectOutputSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraObjectOutputSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraObjectOutputSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraOutputSynchronizerSpec>
  std::shared_ptr<HybridCameraOutputSynchronizerSpec> create_std__shared_ptr_HybridCameraOutputSynchronizerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraOutputSynchronizerSpec_cxx swiftPart = VisionCamera::HybridCameraOutputSynchronizerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraOutputSynchronizerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraOutputSynchronizerSpec_(std__shared_ptr_HybridCameraOutputSynchronizerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSynchronizerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraOutputSynchronizerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraOutputSynchronizerSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraOutputSynchronizerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridGestureControllerSpec>
  std::shared_ptr<HybridGestureControllerSpec> create_std__shared_ptr_HybridGestureControllerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridGestureControllerSpec_cxx swiftPart = VisionCamera::HybridGestureControllerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridGestureControllerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridGestureControllerSpec_(std__shared_ptr_HybridGestureControllerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridGestureControllerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridGestureControllerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridGestureControllerSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridGestureControllerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridZoomGestureControllerSpec>
  std::shared_ptr<HybridZoomGestureControllerSpec> create_std__shared_ptr_HybridZoomGestureControllerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridZoomGestureControllerSpec_cxx swiftPart = VisionCamera::HybridZoomGestureControllerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridZoomGestureControllerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridZoomGestureControllerSpec_(std__shared_ptr_HybridZoomGestureControllerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridZoomGestureControllerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridZoomGestureControllerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridZoomGestureControllerSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridZoomGestureControllerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridTapToFocusGestureControllerSpec>
  std::shared_ptr<HybridTapToFocusGestureControllerSpec> create_std__shared_ptr_HybridTapToFocusGestureControllerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridTapToFocusGestureControllerSpec_cxx swiftPart = VisionCamera::HybridTapToFocusGestureControllerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridTapToFocusGestureControllerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridTapToFocusGestureControllerSpec_(std__shared_ptr_HybridTapToFocusGestureControllerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridTapToFocusGestureControllerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridTapToFocusGestureControllerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridTapToFocusGestureControllerSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridTapToFocusGestureControllerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOrientationManagerSpec>
  std::shared_ptr<HybridOrientationManagerSpec> create_std__shared_ptr_HybridOrientationManagerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridOrientationManagerSpec_cxx swiftPart = VisionCamera::HybridOrientationManagerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridOrientationManagerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOrientationManagerSpec_(std__shared_ptr_HybridOrientationManagerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridOrientationManagerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridOrientationManagerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOrientationManagerSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridOrientationManagerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridFrameRendererSpec>
  std::shared_ptr<HybridFrameRendererSpec> create_std__shared_ptr_HybridFrameRendererSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridFrameRendererSpec_cxx swiftPart = VisionCamera::HybridFrameRendererSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridFrameRendererSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridFrameRendererSpec_(std__shared_ptr_HybridFrameRendererSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridFrameRendererSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridFrameRendererSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridFrameRendererSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridFrameRendererSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraFactorySpec>
  std::shared_ptr<HybridCameraFactorySpec> create_std__shared_ptr_HybridCameraFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraFactorySpec_cxx swiftPart = VisionCamera::HybridCameraFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraFactorySpec_(std__shared_ptr_HybridCameraFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraFactorySpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridFrameSpec>
  std::shared_ptr<HybridFrameSpec> create_std__shared_ptr_HybridFrameSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridFrameSpec_cxx swiftPart = VisionCamera::HybridFrameSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridFrameSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridFrameSpec_(std__shared_ptr_HybridFrameSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridFrameSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridFrameSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridFrameSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridFrameSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridNativeThreadSpec>
  std::shared_ptr<HybridNativeThreadSpec> create_std__shared_ptr_HybridNativeThreadSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridNativeThreadSpec_cxx swiftPart = VisionCamera::HybridNativeThreadSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridNativeThreadSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNativeThreadSpec_(std__shared_ptr_HybridNativeThreadSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridNativeThreadSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridNativeThreadSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNativeThreadSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridNativeThreadSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridNativeThreadFactorySpec>
  std::shared_ptr<HybridNativeThreadFactorySpec> create_std__shared_ptr_HybridNativeThreadFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridNativeThreadFactorySpec_cxx swiftPart = VisionCamera::HybridNativeThreadFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridNativeThreadFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNativeThreadFactorySpec_(std__shared_ptr_HybridNativeThreadFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridNativeThreadFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridNativeThreadFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNativeThreadFactorySpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridNativeThreadFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridCameraDeviceSpec>>& /* newDevices */)>
  Func_void_std__vector_std__shared_ptr_HybridCameraDeviceSpec__ create_Func_void_std__vector_std__shared_ptr_HybridCameraDeviceSpec__(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__vector_std__shared_ptr_HybridCameraDeviceSpec__::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<HybridCameraDeviceSpec>>& newDevices) mutable -> void {
      swiftClosure.call(newDevices);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraExtensionSpec>
  std::shared_ptr<HybridCameraExtensionSpec> create_std__shared_ptr_HybridCameraExtensionSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraExtensionSpec_cxx swiftPart = VisionCamera::HybridCameraExtensionSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraExtensionSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraExtensionSpec_(std__shared_ptr_HybridCameraExtensionSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraExtensionSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraExtensionSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraExtensionSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraExtensionSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridCameraExtensionSpec>>& /* result */)>
  Func_void_std__vector_std__shared_ptr_HybridCameraExtensionSpec__ create_Func_void_std__vector_std__shared_ptr_HybridCameraExtensionSpec__(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__vector_std__shared_ptr_HybridCameraExtensionSpec__::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<HybridCameraExtensionSpec>>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridCameraCalibrationDataSpec>
  std::shared_ptr<HybridCameraCalibrationDataSpec> create_std__shared_ptr_HybridCameraCalibrationDataSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridCameraCalibrationDataSpec_cxx swiftPart = VisionCamera::HybridCameraCalibrationDataSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridCameraCalibrationDataSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridCameraCalibrationDataSpec_(std__shared_ptr_HybridCameraCalibrationDataSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridCameraCalibrationDataSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridCameraCalibrationDataSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridCameraCalibrationDataSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridCameraCalibrationDataSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridDepthSpec>
  std::shared_ptr<HybridDepthSpec> create_std__shared_ptr_HybridDepthSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridDepthSpec_cxx swiftPart = VisionCamera::HybridDepthSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridDepthSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridDepthSpec_(std__shared_ptr_HybridDepthSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridDepthSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridDepthSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridDepthSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridDepthSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridDepthSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridDepthSpec_ create_Func_void_std__shared_ptr_HybridDepthSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridDepthSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridDepthSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridFrameSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridFrameSpec_ create_Func_void_std__shared_ptr_HybridFrameSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridFrameSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridFrameSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridFramePlaneSpec>
  std::shared_ptr<HybridFramePlaneSpec> create_std__shared_ptr_HybridFramePlaneSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridFramePlaneSpec_cxx swiftPart = VisionCamera::HybridFramePlaneSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridFramePlaneSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridFramePlaneSpec_(std__shared_ptr_HybridFramePlaneSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridFramePlaneSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridFramePlaneSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridFramePlaneSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridFramePlaneSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::string& /* result */)>
  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<ArrayBuffer>& result) mutable -> void {
      swiftClosure.call(ArrayBufferHolder(result));
    };
  }
  
  // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridImageSpec>
  std::shared_ptr<margelo::nitro::image::HybridImageSpec> create_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    // Implemented in NitroImage
    return margelo::nitro::image::bridge::swift::create_std__shared_ptr_HybridImageSpec_(swiftUnsafePointer);
  }
  void* NON_NULL get_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(std__shared_ptr_margelo__nitro__image__HybridImageSpec_ cppType) {
    // Implemented in NitroImage
    return margelo::nitro::image::bridge::swift::get_std__shared_ptr_HybridImageSpec_(cppType);
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& /* result */)>
  Func_void_std__shared_ptr_margelo__nitro__image__HybridImageSpec_ create_Func_void_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_margelo__nitro__image__HybridImageSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridPhotoSpec>
  std::shared_ptr<HybridPhotoSpec> create_std__shared_ptr_HybridPhotoSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridPhotoSpec_cxx swiftPart = VisionCamera::HybridPhotoSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridPhotoSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridPhotoSpec_(std__shared_ptr_HybridPhotoSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridPhotoSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridPhotoSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridPhotoSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridPhotoSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridScannedObjectSpec>
  std::shared_ptr<HybridScannedObjectSpec> create_std__shared_ptr_HybridScannedObjectSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridScannedObjectSpec_cxx swiftPart = VisionCamera::HybridScannedObjectSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridScannedObjectSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridScannedObjectSpec_(std__shared_ptr_HybridScannedObjectSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridScannedObjectSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridScannedObjectSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridScannedObjectSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridScannedObjectSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridScannedCodeSpec>
  std::shared_ptr<HybridScannedCodeSpec> create_std__shared_ptr_HybridScannedCodeSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridScannedCodeSpec_cxx swiftPart = VisionCamera::HybridScannedCodeSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridScannedCodeSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridScannedCodeSpec_(std__shared_ptr_HybridScannedCodeSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridScannedCodeSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridScannedCodeSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridScannedCodeSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridScannedCodeSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridScannedFaceSpec>
  std::shared_ptr<HybridScannedFaceSpec> create_std__shared_ptr_HybridScannedFaceSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridScannedFaceSpec_cxx swiftPart = VisionCamera::HybridScannedFaceSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridScannedFaceSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridScannedFaceSpec_(std__shared_ptr_HybridScannedFaceSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridScannedFaceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridScannedFaceSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridScannedFaceSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridScannedFaceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridLocationSpec>
  std::shared_ptr<HybridLocationSpec> create_std__shared_ptr_HybridLocationSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridLocationSpec_cxx swiftPart = VisionCamera::HybridLocationSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridLocationSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridLocationSpec_(std__shared_ptr_HybridLocationSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridLocationSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridLocationSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridLocationSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridLocationSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(CameraOrientation /* orientation */)>
  Func_void_CameraOrientation create_Func_void_CameraOrientation(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_CameraOrientation::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](CameraOrientation orientation) mutable -> void {
      swiftClosure.call(static_cast<int>(orientation));
    };
  }
  
  // pragma MARK: std::function<bool(const std::shared_ptr<HybridDepthSpec>& /* depth */)>
  Func_bool_std__shared_ptr_HybridDepthSpec_ create_Func_bool_std__shared_ptr_HybridDepthSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_bool_std__shared_ptr_HybridDepthSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridDepthSpec>& depth) mutable -> bool {
      auto __result = swiftClosure.call(depth);
      return __result;
    };
  }
  
  // pragma MARK: std::function<void(FrameDroppedReason /* reason */)>
  Func_void_FrameDroppedReason create_Func_void_FrameDroppedReason(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_FrameDroppedReason::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](FrameDroppedReason reason) mutable -> void {
      swiftClosure.call(static_cast<int>(reason));
    };
  }
  
  // pragma MARK: std::function<bool(const std::shared_ptr<HybridFrameSpec>& /* frame */)>
  Func_bool_std__shared_ptr_HybridFrameSpec_ create_Func_bool_std__shared_ptr_HybridFrameSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_bool_std__shared_ptr_HybridFrameSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridFrameSpec>& frame) mutable -> bool {
      auto __result = swiftClosure.call(frame);
      return __result;
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridScannedObjectSpec>>& /* objects */)>
  Func_void_std__vector_std__shared_ptr_HybridScannedObjectSpec__ create_Func_void_std__vector_std__shared_ptr_HybridScannedObjectSpec__(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__vector_std__shared_ptr_HybridScannedObjectSpec__::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<HybridScannedObjectSpec>>& objects) mutable -> void {
      swiftClosure.call(objects);
    };
  }
  
  // pragma MARK: std::function<bool(const std::vector<std::variant<std::shared_ptr<HybridFrameSpec>, std::shared_ptr<HybridDepthSpec>>>& /* frames */)>
  Func_bool_std__vector_std__variant_std__shared_ptr_HybridFrameSpec___std__shared_ptr_HybridDepthSpec___ create_Func_bool_std__vector_std__variant_std__shared_ptr_HybridFrameSpec___std__shared_ptr_HybridDepthSpec___(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_bool_std__vector_std__variant_std__shared_ptr_HybridFrameSpec___std__shared_ptr_HybridDepthSpec___::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::variant<std::shared_ptr<HybridFrameSpec>, std::shared_ptr<HybridDepthSpec>>>& frames) mutable -> bool {
      auto __result = swiftClosure.call(frames);
      return __result;
    };
  }
  
  // pragma MARK: std::function<void(MediaType /* frameType */, FrameDroppedReason /* reason */)>
  Func_void_MediaType_FrameDroppedReason create_Func_void_MediaType_FrameDroppedReason(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_MediaType_FrameDroppedReason::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](MediaType frameType, FrameDroppedReason reason) mutable -> void {
      swiftClosure.call(static_cast<int>(frameType), static_cast<int>(reason));
    };
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridPhotoSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridPhotoSpec_ create_Func_void_std__shared_ptr_HybridPhotoSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridPhotoSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridPhotoSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PhotoFile& /* result */)>
  Func_void_PhotoFile create_Func_void_PhotoFile(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_PhotoFile::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PhotoFile& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridRecorderSpec>
  std::shared_ptr<HybridRecorderSpec> create_std__shared_ptr_HybridRecorderSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridRecorderSpec_cxx swiftPart = VisionCamera::HybridRecorderSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridRecorderSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridRecorderSpec_(std__shared_ptr_HybridRecorderSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridRecorderSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridRecorderSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridRecorderSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridRecorderSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridRecorderSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridRecorderSpec_ create_Func_void_std__shared_ptr_HybridRecorderSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__shared_ptr_HybridRecorderSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridRecorderSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* filePath */, RecordingFinishedReason /* reason */)>
  Func_void_std__string_RecordingFinishedReason create_Func_void_std__string_RecordingFinishedReason(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__string_RecordingFinishedReason::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& filePath, RecordingFinishedReason reason) mutable -> void {
      swiftClosure.call(filePath, static_cast<int>(reason));
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<HybridCameraControllerSpec>>& /* result */)>
  Func_void_std__vector_std__shared_ptr_HybridCameraControllerSpec__ create_Func_void_std__vector_std__shared_ptr_HybridCameraControllerSpec__(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_std__vector_std__shared_ptr_HybridCameraControllerSpec__::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::shared_ptr<HybridCameraControllerSpec>>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(InterruptionReason /* reason */)>
  Func_void_InterruptionReason create_Func_void_InterruptionReason(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = VisionCamera::Func_void_InterruptionReason::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](InterruptionReason reason) mutable -> void {
      swiftClosure.call(static_cast<int>(reason));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridFrameConverterSpec>
  std::shared_ptr<HybridFrameConverterSpec> create_std__shared_ptr_HybridFrameConverterSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridFrameConverterSpec_cxx swiftPart = VisionCamera::HybridFrameConverterSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridFrameConverterSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridFrameConverterSpec_(std__shared_ptr_HybridFrameConverterSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridFrameConverterSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridFrameConverterSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridFrameConverterSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridFrameConverterSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridFrameRendererViewSpec>
  std::shared_ptr<HybridFrameRendererViewSpec> create_std__shared_ptr_HybridFrameRendererViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridFrameRendererViewSpec_cxx swiftPart = VisionCamera::HybridFrameRendererViewSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridFrameRendererViewSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridFrameRendererViewSpec_(std__shared_ptr_HybridFrameRendererViewSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridFrameRendererViewSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridFrameRendererViewSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridFrameRendererViewSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridFrameRendererViewSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridPreviewViewSpec>
  std::shared_ptr<HybridPreviewViewSpec> create_std__shared_ptr_HybridPreviewViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    VisionCamera::HybridPreviewViewSpec_cxx swiftPart = VisionCamera::HybridPreviewViewSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::camera::HybridPreviewViewSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridPreviewViewSpec_(std__shared_ptr_HybridPreviewViewSpec_ cppType) {
    std::shared_ptr<margelo::nitro::camera::HybridPreviewViewSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::HybridPreviewViewSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridPreviewViewSpec\" is not implemented in Swift!");
    }
    #endif
    VisionCamera::HybridPreviewViewSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

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