///
/// One-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 "One-Swift-Cxx-Bridge.hpp"

// Include C++ implementation defined types
#include "HybridDocumentCameraImageSpecSwift.hpp"
#include "HybridDocumentCameraScanSpecSwift.hpp"
#include "HybridNativeCNContactSpecSwift.hpp"
#include "HybridNativeCNContactStoreSpecSwift.hpp"
#include "HybridNativeCNKeyDescriptorSpecSwift.hpp"
#include "HybridOneAdaptiveSpecSwift.hpp"
#include "HybridOneAppIconSpecSwift.hpp"
#include "HybridOneAppInfoSpecSwift.hpp"
#include "HybridOneAppIntentsSpecSwift.hpp"
#include "HybridOneAppTrackingSpecSwift.hpp"
#include "HybridOneAppleAuthSpecSwift.hpp"
#include "HybridOneAudioSpecSwift.hpp"
#include "HybridOneBackgroundTasksSpecSwift.hpp"
#include "HybridOneBarometerSpecSwift.hpp"
#include "HybridOneBatterySpecSwift.hpp"
#include "HybridOneBrightnessSpecSwift.hpp"
#include "HybridOneBrowserSpecSwift.hpp"
#include "HybridOneCalendarSpecSwift.hpp"
#include "HybridOneClipboardSpecSwift.hpp"
#include "HybridOneContactUISpecSwift.hpp"
#include "HybridOneContactsSpecSwift.hpp"
#include "HybridOneDataScannerSpecSwift.hpp"
#include "HybridOneDeviceAttestationSpecSwift.hpp"
#include "HybridOneDeviceSpecSwift.hpp"
#include "HybridOneDocumentCameraSpecSwift.hpp"
#include "HybridOneDocumentPickerSpecSwift.hpp"
#include "HybridOneFetchSpecSwift.hpp"
#include "HybridOneFileSystemSpecSwift.hpp"
#include "HybridOneFontsSpecSwift.hpp"
#include "HybridOneHapticsSpecSwift.hpp"
#include "HybridOneImageManipulatorSpecSwift.hpp"
#include "HybridOneImagePickerSpecSwift.hpp"
#include "HybridOneKeepAwakeSpecSwift.hpp"
#include "HybridOneLaunchScreenSpecSwift.hpp"
#include "HybridOneLightSensorSpecSwift.hpp"
#include "HybridOneLocalAuthenticationSpecSwift.hpp"
#include "HybridOneLocationSpecSwift.hpp"
#include "HybridOneMailComposeSpecSwift.hpp"
#include "HybridOneMapServicesSpecSwift.hpp"
#include "HybridOneMessageComposeSpecSwift.hpp"
#include "HybridOneMotionSpecSwift.hpp"
#include "HybridOneNativeModulesSpecSwift.hpp"
#include "HybridOneNetworkSpecSwift.hpp"
#include "HybridOneNotificationsSpecSwift.hpp"
#include "HybridOnePedometerSpecSwift.hpp"
#include "HybridOnePhotoLibrarySpecSwift.hpp"
#include "HybridOnePrintSpecSwift.hpp"
#include "HybridOneProtectedStoreSpecSwift.hpp"
#include "HybridOnePurchasesSpecSwift.hpp"
#include "HybridOneQuickActionsSpecSwift.hpp"
#include "HybridOneScreenCaptureSpecSwift.hpp"
#include "HybridOneScreenOrientationSpecSwift.hpp"
#include "HybridOneSecureStoreSpecSwift.hpp"
#include "HybridOneShareSpecSwift.hpp"
#include "HybridOneSpeechSpecSwift.hpp"
#include "HybridOneSpeechSynthesisSpecSwift.hpp"
#include "HybridOneStoreReviewSpecSwift.hpp"
#include "HybridOneUpdatesSpecSwift.hpp"
#include "One-Swift-Cxx-Umbrella.hpp"
#include <NitroModules/NitroDefines.hpp>

namespace margelo::nitro::one::bridge::swift {

  // pragma MARK: std::function<void(const SizeClass& /* result */)>
  Func_void_SizeClass create_Func_void_SizeClass(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_SizeClass::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const SizeClass& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // 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 = One::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::function<void(const std::optional<HingeState>& /* result */)>
  Func_void_std__optional_HingeState_ create_Func_void_std__optional_HingeState_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__optional_HingeState_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<HingeState>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void()>
  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
      swiftClosure.call();
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAdaptiveSpec>
  std::shared_ptr<HybridOneAdaptiveSpec> create_std__shared_ptr_HybridOneAdaptiveSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAdaptiveSpec_cxx swiftPart = One::HybridOneAdaptiveSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAdaptiveSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAdaptiveSpec_(std__shared_ptr_HybridOneAdaptiveSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAdaptiveSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAdaptiveSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAdaptiveSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAdaptiveSpec_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 = One::Func_void_bool::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::optional<std::string>& /* result */)>
  Func_void_std__optional_std__string_ create_Func_void_std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__optional_std__string_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<std::string>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppIconSpec>
  std::shared_ptr<HybridOneAppIconSpec> create_std__shared_ptr_HybridOneAppIconSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAppIconSpec_cxx swiftPart = One::HybridOneAppIconSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAppIconSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAppIconSpec_(std__shared_ptr_HybridOneAppIconSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAppIconSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAppIconSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAppIconSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAppIconSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppInfoSpec>
  std::shared_ptr<HybridOneAppInfoSpec> create_std__shared_ptr_HybridOneAppInfoSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAppInfoSpec_cxx swiftPart = One::HybridOneAppInfoSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAppInfoSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAppInfoSpec_(std__shared_ptr_HybridOneAppInfoSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAppInfoSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAppInfoSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAppInfoSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAppInfoSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const AppIntentInvocation& /* invocation */)>
  Func_void_AppIntentInvocation create_Func_void_AppIntentInvocation(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AppIntentInvocation::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AppIntentInvocation& invocation) mutable -> void {
      swiftClosure.call(invocation);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppIntentsSpec>
  std::shared_ptr<HybridOneAppIntentsSpec> create_std__shared_ptr_HybridOneAppIntentsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAppIntentsSpec_cxx swiftPart = One::HybridOneAppIntentsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAppIntentsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAppIntentsSpec_(std__shared_ptr_HybridOneAppIntentsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAppIntentsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAppIntentsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAppIntentsSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAppIntentsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const AppleAuthResult& /* result */)>
  Func_void_AppleAuthResult create_Func_void_AppleAuthResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AppleAuthResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AppleAuthResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(AppleCredentialState /* result */)>
  Func_void_AppleCredentialState create_Func_void_AppleCredentialState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AppleCredentialState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](AppleCredentialState result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppleAuthSpec>
  std::shared_ptr<HybridOneAppleAuthSpec> create_std__shared_ptr_HybridOneAppleAuthSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAppleAuthSpec_cxx swiftPart = One::HybridOneAppleAuthSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAppleAuthSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAppleAuthSpec_(std__shared_ptr_HybridOneAppleAuthSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAppleAuthSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAppleAuthSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAppleAuthSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAppleAuthSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(AppTrackingPermissionStatus /* result */)>
  Func_void_AppTrackingPermissionStatus create_Func_void_AppTrackingPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AppTrackingPermissionStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](AppTrackingPermissionStatus result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppTrackingSpec>
  std::shared_ptr<HybridOneAppTrackingSpec> create_std__shared_ptr_HybridOneAppTrackingSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAppTrackingSpec_cxx swiftPart = One::HybridOneAppTrackingSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAppTrackingSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAppTrackingSpec_(std__shared_ptr_HybridOneAppTrackingSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAppTrackingSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAppTrackingSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAppTrackingSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAppTrackingSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(AudioRecordingPermission /* result */)>
  Func_void_AudioRecordingPermission create_Func_void_AudioRecordingPermission(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AudioRecordingPermission::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](AudioRecordingPermission result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const AudioPlaybackStatus& /* result */)>
  Func_void_AudioPlaybackStatus create_Func_void_AudioPlaybackStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AudioPlaybackStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AudioPlaybackStatus& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const AudioRecordingStatus& /* result */)>
  Func_void_AudioRecordingStatus create_Func_void_AudioRecordingStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AudioRecordingStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AudioRecordingStatus& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const AudioRecordingResult& /* result */)>
  Func_void_AudioRecordingResult create_Func_void_AudioRecordingResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AudioRecordingResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AudioRecordingResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const AudioInterruptionEvent& /* event */)>
  Func_void_AudioInterruptionEvent create_Func_void_AudioInterruptionEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AudioInterruptionEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AudioInterruptionEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::function<void(const AudioRemoteCommandEvent& /* event */)>
  Func_void_AudioRemoteCommandEvent create_Func_void_AudioRemoteCommandEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_AudioRemoteCommandEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AudioRemoteCommandEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAudioSpec>
  std::shared_ptr<HybridOneAudioSpec> create_std__shared_ptr_HybridOneAudioSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneAudioSpec_cxx swiftPart = One::HybridOneAudioSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneAudioSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneAudioSpec_(std__shared_ptr_HybridOneAudioSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneAudioSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneAudioSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneAudioSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneAudioSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::vector<PendingBackgroundTask>& /* result */)>
  Func_void_std__vector_PendingBackgroundTask_ create_Func_void_std__vector_PendingBackgroundTask_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_PendingBackgroundTask_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<PendingBackgroundTask>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const BackgroundTaskInvocation& /* invocation */)>
  Func_void_BackgroundTaskInvocation create_Func_void_BackgroundTaskInvocation(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BackgroundTaskInvocation::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BackgroundTaskInvocation& invocation) mutable -> void {
      swiftClosure.call(invocation);
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* executionId */)>
  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& executionId) mutable -> void {
      swiftClosure.call(executionId);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBackgroundTasksSpec>
  std::shared_ptr<HybridOneBackgroundTasksSpec> create_std__shared_ptr_HybridOneBackgroundTasksSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneBackgroundTasksSpec_cxx swiftPart = One::HybridOneBackgroundTasksSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneBackgroundTasksSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneBackgroundTasksSpec_(std__shared_ptr_HybridOneBackgroundTasksSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneBackgroundTasksSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneBackgroundTasksSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneBackgroundTasksSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneBackgroundTasksSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const BarometerMeasurement& /* event */)>
  Func_void_BarometerMeasurement create_Func_void_BarometerMeasurement(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BarometerMeasurement::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BarometerMeasurement& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBarometerSpec>
  std::shared_ptr<HybridOneBarometerSpec> create_std__shared_ptr_HybridOneBarometerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneBarometerSpec_cxx swiftPart = One::HybridOneBarometerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneBarometerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneBarometerSpec_(std__shared_ptr_HybridOneBarometerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneBarometerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneBarometerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneBarometerSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneBarometerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(double /* result */)>
  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_double::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(BatteryState /* result */)>
  Func_void_BatteryState create_Func_void_BatteryState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BatteryState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](BatteryState result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const BatteryPowerState& /* result */)>
  Func_void_BatteryPowerState create_Func_void_BatteryPowerState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BatteryPowerState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BatteryPowerState& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const BatteryLevelEvent& /* event */)>
  Func_void_BatteryLevelEvent create_Func_void_BatteryLevelEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BatteryLevelEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BatteryLevelEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::function<void(const BatteryStateEvent& /* event */)>
  Func_void_BatteryStateEvent create_Func_void_BatteryStateEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BatteryStateEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BatteryStateEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::function<void(const BatteryPowerModeEvent& /* event */)>
  Func_void_BatteryPowerModeEvent create_Func_void_BatteryPowerModeEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BatteryPowerModeEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BatteryPowerModeEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBatterySpec>
  std::shared_ptr<HybridOneBatterySpec> create_std__shared_ptr_HybridOneBatterySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneBatterySpec_cxx swiftPart = One::HybridOneBatterySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneBatterySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneBatterySpec_(std__shared_ptr_HybridOneBatterySpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneBatterySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneBatterySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneBatterySpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneBatterySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(BrightnessMode /* result */)>
  Func_void_BrightnessMode create_Func_void_BrightnessMode(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BrightnessMode::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](BrightnessMode result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const BrightnessPermissionResponse& /* result */)>
  Func_void_BrightnessPermissionResponse create_Func_void_BrightnessPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BrightnessPermissionResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BrightnessPermissionResponse& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const BrightnessEvent& /* event */)>
  Func_void_BrightnessEvent create_Func_void_BrightnessEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BrightnessEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BrightnessEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBrightnessSpec>
  std::shared_ptr<HybridOneBrightnessSpec> create_std__shared_ptr_HybridOneBrightnessSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneBrightnessSpec_cxx swiftPart = One::HybridOneBrightnessSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneBrightnessSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneBrightnessSpec_(std__shared_ptr_HybridOneBrightnessSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneBrightnessSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneBrightnessSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneBrightnessSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneBrightnessSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const BrowserResult& /* result */)>
  Func_void_BrowserResult create_Func_void_BrowserResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BrowserResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BrowserResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const BrowserAuthResult& /* result */)>
  Func_void_BrowserAuthResult create_Func_void_BrowserAuthResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_BrowserAuthResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const BrowserAuthResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBrowserSpec>
  std::shared_ptr<HybridOneBrowserSpec> create_std__shared_ptr_HybridOneBrowserSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneBrowserSpec_cxx swiftPart = One::HybridOneBrowserSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneBrowserSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneBrowserSpec_(std__shared_ptr_HybridOneBrowserSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneBrowserSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneBrowserSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneBrowserSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneBrowserSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(CalendarPermissionStatus /* result */)>
  Func_void_CalendarPermissionStatus create_Func_void_CalendarPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_CalendarPermissionStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](CalendarPermissionStatus result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<CalendarEvent>& /* result */)>
  Func_void_std__vector_CalendarEvent_ create_Func_void_std__vector_CalendarEvent_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_CalendarEvent_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<CalendarEvent>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const CalendarEvent& /* result */)>
  Func_void_CalendarEvent create_Func_void_CalendarEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_CalendarEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const CalendarEvent& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<ReminderInfo>& /* result */)>
  Func_void_std__vector_ReminderInfo_ create_Func_void_std__vector_ReminderInfo_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_ReminderInfo_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<ReminderInfo>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneCalendarSpec>
  std::shared_ptr<HybridOneCalendarSpec> create_std__shared_ptr_HybridOneCalendarSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneCalendarSpec_cxx swiftPart = One::HybridOneCalendarSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneCalendarSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneCalendarSpec_(std__shared_ptr_HybridOneCalendarSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneCalendarSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneCalendarSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneCalendarSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneCalendarSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::optional<ClipboardImageResult>& /* result */)>
  Func_void_std__optional_ClipboardImageResult_ create_Func_void_std__optional_ClipboardImageResult_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__optional_ClipboardImageResult_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<ClipboardImageResult>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<std::string>& /* contentTypes */)>
  Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_std__string_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::string>& contentTypes) mutable -> void {
      swiftClosure.call(contentTypes);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneClipboardSpec>
  std::shared_ptr<HybridOneClipboardSpec> create_std__shared_ptr_HybridOneClipboardSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneClipboardSpec_cxx swiftPart = One::HybridOneClipboardSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneClipboardSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneClipboardSpec_(std__shared_ptr_HybridOneClipboardSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneClipboardSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneClipboardSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneClipboardSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneClipboardSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(ContactsPermissionStatus /* result */)>
  Func_void_ContactsPermissionStatus create_Func_void_ContactsPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ContactsPermissionStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](ContactsPermissionStatus result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const std::optional<ContactInfo>& /* result */)>
  Func_void_std__optional_ContactInfo_ create_Func_void_std__optional_ContactInfo_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__optional_ContactInfo_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<ContactInfo>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<ContactInfo>& /* result */)>
  Func_void_std__vector_ContactInfo_ create_Func_void_std__vector_ContactInfo_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_ContactInfo_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<ContactInfo>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const ContactInfo& /* result */)>
  Func_void_ContactInfo create_Func_void_ContactInfo(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ContactInfo::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const ContactInfo& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneContactsSpec>
  std::shared_ptr<HybridOneContactsSpec> create_std__shared_ptr_HybridOneContactsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneContactsSpec_cxx swiftPart = One::HybridOneContactsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneContactsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneContactsSpec_(std__shared_ptr_HybridOneContactsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneContactsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneContactsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneContactsSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneContactsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::shared_ptr<HybridNativeCNContactSpec>
  std::shared_ptr<HybridNativeCNContactSpec> create_std__shared_ptr_HybridNativeCNContactSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridNativeCNContactSpec_cxx swiftPart = One::HybridNativeCNContactSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridNativeCNContactSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNativeCNContactSpec_(std__shared_ptr_HybridNativeCNContactSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridNativeCNContactSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridNativeCNContactSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNativeCNContactSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridNativeCNContactSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::shared_ptr<HybridNativeCNKeyDescriptorSpec>
  std::shared_ptr<HybridNativeCNKeyDescriptorSpec> create_std__shared_ptr_HybridNativeCNKeyDescriptorSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridNativeCNKeyDescriptorSpec_cxx swiftPart = One::HybridNativeCNKeyDescriptorSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridNativeCNKeyDescriptorSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNativeCNKeyDescriptorSpec_(std__shared_ptr_HybridNativeCNKeyDescriptorSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridNativeCNKeyDescriptorSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridNativeCNKeyDescriptorSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNativeCNKeyDescriptorSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridNativeCNKeyDescriptorSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridNativeCNContactSpec_ create_Func_void_std__shared_ptr_HybridNativeCNContactSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__shared_ptr_HybridNativeCNContactSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridNativeCNContactSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }

  // pragma MARK: std::shared_ptr<HybridNativeCNContactStoreSpec>
  std::shared_ptr<HybridNativeCNContactStoreSpec> create_std__shared_ptr_HybridNativeCNContactStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridNativeCNContactStoreSpec_cxx swiftPart = One::HybridNativeCNContactStoreSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridNativeCNContactStoreSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNativeCNContactStoreSpec_(std__shared_ptr_HybridNativeCNContactStoreSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridNativeCNContactStoreSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridNativeCNContactStoreSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNativeCNContactStoreSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridNativeCNContactStoreSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& /* contact */)>
  Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__ create_Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& contact) mutable -> void {
      swiftClosure.call(contact);
    };
  }

  // pragma MARK: std::shared_ptr<HybridOneContactUISpec>
  std::shared_ptr<HybridOneContactUISpec> create_std__shared_ptr_HybridOneContactUISpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneContactUISpec_cxx swiftPart = One::HybridOneContactUISpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneContactUISpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneContactUISpec_(std__shared_ptr_HybridOneContactUISpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneContactUISpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneContactUISpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneContactUISpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneContactUISpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const DataScannerRecognizedItem& /* item */)>
  Func_void_DataScannerRecognizedItem create_Func_void_DataScannerRecognizedItem(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_DataScannerRecognizedItem::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const DataScannerRecognizedItem& item) mutable -> void {
      swiftClosure.call(item);
    };
  }

  // pragma MARK: std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */, const std::vector<DataScannerRecognizedItem>& /* allItems */)>
  Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_ create_Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<DataScannerRecognizedItem>& items, const std::vector<DataScannerRecognizedItem>& allItems) mutable -> void {
      swiftClosure.call(items, allItems);
    };
  }

  // pragma MARK: std::function<void(DataScannerScanningUnavailable /* error */)>
  Func_void_DataScannerScanningUnavailable create_Func_void_DataScannerScanningUnavailable(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_DataScannerScanningUnavailable::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](DataScannerScanningUnavailable error) mutable -> void {
      swiftClosure.call(static_cast<int>(error));
    };
  }

  // pragma MARK: std::shared_ptr<HybridDocumentCameraImageSpec>
  std::shared_ptr<HybridDocumentCameraImageSpec> create_std__shared_ptr_HybridDocumentCameraImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridDocumentCameraImageSpec_cxx swiftPart = One::HybridDocumentCameraImageSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridDocumentCameraImageSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridDocumentCameraImageSpec_(std__shared_ptr_HybridDocumentCameraImageSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridDocumentCameraImageSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridDocumentCameraImageSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridDocumentCameraImageSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridDocumentCameraImageSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_ create_Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridDocumentCameraImageSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }

  // pragma MARK: std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */)>
  Func_void_std__vector_DataScannerRecognizedItem_ create_Func_void_std__vector_DataScannerRecognizedItem_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_DataScannerRecognizedItem_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<DataScannerRecognizedItem>& items) mutable -> void {
      swiftClosure.call(items);
    };
  }

  // pragma MARK: std::shared_ptr<HybridOneDataScannerSpec>
  std::shared_ptr<HybridOneDataScannerSpec> create_std__shared_ptr_HybridOneDataScannerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneDataScannerSpec_cxx swiftPart = One::HybridOneDataScannerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneDataScannerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneDataScannerSpec_(std__shared_ptr_HybridOneDataScannerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneDataScannerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneDataScannerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneDataScannerSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneDataScannerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(const DeviceInfo& /* result */)>
  Func_void_DeviceInfo create_Func_void_DeviceInfo(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_DeviceInfo::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const DeviceInfo& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const LocalizationInfo& /* result */)>
  Func_void_LocalizationInfo create_Func_void_LocalizationInfo(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_LocalizationInfo::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const LocalizationInfo& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDeviceSpec>
  std::shared_ptr<HybridOneDeviceSpec> create_std__shared_ptr_HybridOneDeviceSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneDeviceSpec_cxx swiftPart = One::HybridOneDeviceSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneDeviceSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneDeviceSpec_(std__shared_ptr_HybridOneDeviceSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneDeviceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneDeviceSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneDeviceSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneDeviceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDeviceAttestationSpec>
  std::shared_ptr<HybridOneDeviceAttestationSpec> create_std__shared_ptr_HybridOneDeviceAttestationSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneDeviceAttestationSpec_cxx swiftPart = One::HybridOneDeviceAttestationSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneDeviceAttestationSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneDeviceAttestationSpec_(std__shared_ptr_HybridOneDeviceAttestationSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneDeviceAttestationSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneDeviceAttestationSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneDeviceAttestationSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneDeviceAttestationSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::shared_ptr<HybridDocumentCameraScanSpec>
  std::shared_ptr<HybridDocumentCameraScanSpec> create_std__shared_ptr_HybridDocumentCameraScanSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridDocumentCameraScanSpec_cxx swiftPart = One::HybridDocumentCameraScanSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridDocumentCameraScanSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridDocumentCameraScanSpec_(std__shared_ptr_HybridDocumentCameraScanSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridDocumentCameraScanSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridDocumentCameraScanSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridDocumentCameraScanSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridDocumentCameraScanSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& /* scan */)>
  Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_ create_Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridDocumentCameraScanSpec>& scan) mutable -> void {
      swiftClosure.call(scan);
    };
  }

  // pragma MARK: std::function<void(const DocumentCameraError& /* error */)>
  Func_void_DocumentCameraError create_Func_void_DocumentCameraError(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_DocumentCameraError::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const DocumentCameraError& error) mutable -> void {
      swiftClosure.call(error);
    };
  }

  // pragma MARK: std::shared_ptr<HybridOneDocumentCameraSpec>
  std::shared_ptr<HybridOneDocumentCameraSpec> create_std__shared_ptr_HybridOneDocumentCameraSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneDocumentCameraSpec_cxx swiftPart = One::HybridOneDocumentCameraSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneDocumentCameraSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneDocumentCameraSpec_(std__shared_ptr_HybridOneDocumentCameraSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneDocumentCameraSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneDocumentCameraSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneDocumentCameraSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneDocumentCameraSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const DocumentPickerNativeResult& /* result */)>
  Func_void_DocumentPickerNativeResult create_Func_void_DocumentPickerNativeResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_DocumentPickerNativeResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const DocumentPickerNativeResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDocumentPickerSpec>
  std::shared_ptr<HybridOneDocumentPickerSpec> create_std__shared_ptr_HybridOneDocumentPickerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneDocumentPickerSpec_cxx swiftPart = One::HybridOneDocumentPickerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneDocumentPickerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneDocumentPickerSpec_(std__shared_ptr_HybridOneDocumentPickerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneDocumentPickerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneDocumentPickerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneDocumentPickerSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneDocumentPickerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const FetchNativeResponse& /* response */)>
  Func_void_FetchNativeResponse create_Func_void_FetchNativeResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_FetchNativeResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const FetchNativeResponse& response) mutable -> void {
      swiftClosure.call(response);
    };
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* chunk */)>
  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<ArrayBuffer>& chunk) mutable -> void {
      swiftClosure.call(ArrayBufferHolder(chunk));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneFetchSpec>
  std::shared_ptr<HybridOneFetchSpec> create_std__shared_ptr_HybridOneFetchSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneFetchSpec_cxx swiftPart = One::HybridOneFetchSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneFetchSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneFetchSpec_(std__shared_ptr_HybridOneFetchSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneFetchSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneFetchSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneFetchSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneFetchSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const FileInfo& /* result */)>
  Func_void_FileInfo create_Func_void_FileInfo(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_FileInfo::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const FileInfo& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<FileEntry>& /* result */)>
  Func_void_std__vector_FileEntry_ create_Func_void_std__vector_FileEntry_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_FileEntry_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<FileEntry>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneFileSystemSpec>
  std::shared_ptr<HybridOneFileSystemSpec> create_std__shared_ptr_HybridOneFileSystemSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneFileSystemSpec_cxx swiftPart = One::HybridOneFileSystemSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneFileSystemSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneFileSystemSpec_(std__shared_ptr_HybridOneFileSystemSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneFileSystemSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneFileSystemSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneFileSystemSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneFileSystemSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneFontsSpec>
  std::shared_ptr<HybridOneFontsSpec> create_std__shared_ptr_HybridOneFontsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneFontsSpec_cxx swiftPart = One::HybridOneFontsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneFontsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneFontsSpec_(std__shared_ptr_HybridOneFontsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneFontsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneFontsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneFontsSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneFontsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneHapticsSpec>
  std::shared_ptr<HybridOneHapticsSpec> create_std__shared_ptr_HybridOneHapticsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneHapticsSpec_cxx swiftPart = One::HybridOneHapticsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneHapticsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneHapticsSpec_(std__shared_ptr_HybridOneHapticsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneHapticsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneHapticsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneHapticsSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneHapticsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const ImageTransformResult& /* result */)>
  Func_void_ImageTransformResult create_Func_void_ImageTransformResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ImageTransformResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const ImageTransformResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneImageManipulatorSpec>
  std::shared_ptr<HybridOneImageManipulatorSpec> create_std__shared_ptr_HybridOneImageManipulatorSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneImageManipulatorSpec_cxx swiftPart = One::HybridOneImageManipulatorSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneImageManipulatorSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneImageManipulatorSpec_(std__shared_ptr_HybridOneImageManipulatorSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneImageManipulatorSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneImageManipulatorSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneImageManipulatorSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneImageManipulatorSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const ImagePickerNativeResult& /* result */)>
  Func_void_ImagePickerNativeResult create_Func_void_ImagePickerNativeResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ImagePickerNativeResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const ImagePickerNativeResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const CameraPermissionResponse& /* result */)>
  Func_void_CameraPermissionResponse create_Func_void_CameraPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_CameraPermissionResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const CameraPermissionResponse& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneImagePickerSpec>
  std::shared_ptr<HybridOneImagePickerSpec> create_std__shared_ptr_HybridOneImagePickerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneImagePickerSpec_cxx swiftPart = One::HybridOneImagePickerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneImagePickerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneImagePickerSpec_(std__shared_ptr_HybridOneImagePickerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneImagePickerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneImagePickerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneImagePickerSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneImagePickerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneKeepAwakeSpec>
  std::shared_ptr<HybridOneKeepAwakeSpec> create_std__shared_ptr_HybridOneKeepAwakeSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneKeepAwakeSpec_cxx swiftPart = One::HybridOneKeepAwakeSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneKeepAwakeSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneKeepAwakeSpec_(std__shared_ptr_HybridOneKeepAwakeSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneKeepAwakeSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneKeepAwakeSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneKeepAwakeSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneKeepAwakeSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneLaunchScreenSpec>
  std::shared_ptr<HybridOneLaunchScreenSpec> create_std__shared_ptr_HybridOneLaunchScreenSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneLaunchScreenSpec_cxx swiftPart = One::HybridOneLaunchScreenSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneLaunchScreenSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneLaunchScreenSpec_(std__shared_ptr_HybridOneLaunchScreenSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneLaunchScreenSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneLaunchScreenSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneLaunchScreenSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneLaunchScreenSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const LightSensorMeasurement& /* event */)>
  Func_void_LightSensorMeasurement create_Func_void_LightSensorMeasurement(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_LightSensorMeasurement::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const LightSensorMeasurement& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneLightSensorSpec>
  std::shared_ptr<HybridOneLightSensorSpec> create_std__shared_ptr_HybridOneLightSensorSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneLightSensorSpec_cxx swiftPart = One::HybridOneLightSensorSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneLightSensorSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneLightSensorSpec_(std__shared_ptr_HybridOneLightSensorSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneLightSensorSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneLightSensorSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneLightSensorSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneLightSensorSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneLocalAuthenticationSpec>
  std::shared_ptr<HybridOneLocalAuthenticationSpec> create_std__shared_ptr_HybridOneLocalAuthenticationSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneLocalAuthenticationSpec_cxx swiftPart = One::HybridOneLocalAuthenticationSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneLocalAuthenticationSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneLocalAuthenticationSpec_(std__shared_ptr_HybridOneLocalAuthenticationSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneLocalAuthenticationSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneLocalAuthenticationSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneLocalAuthenticationSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneLocalAuthenticationSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(LocationPermissionStatus /* result */)>
  Func_void_LocationPermissionStatus create_Func_void_LocationPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_LocationPermissionStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](LocationPermissionStatus result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const LocationPosition& /* result */)>
  Func_void_LocationPosition create_Func_void_LocationPosition(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_LocationPosition::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const LocationPosition& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* code */, const std::string& /* message */)>
  Func_void_std__string_std__string create_Func_void_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__string_std__string::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& code, const std::string& message) mutable -> void {
      swiftClosure.call(code, message);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<LocationPlace>& /* result */)>
  Func_void_std__vector_LocationPlace_ create_Func_void_std__vector_LocationPlace_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_LocationPlace_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<LocationPlace>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(RegionState /* result */)>
  Func_void_RegionState create_Func_void_RegionState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_RegionState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](RegionState result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const LocationRegion& /* region */)>
  Func_void_LocationRegion create_Func_void_LocationRegion(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_LocationRegion::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const LocationRegion& region) mutable -> void {
      swiftClosure.call(region);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneLocationSpec>
  std::shared_ptr<HybridOneLocationSpec> create_std__shared_ptr_HybridOneLocationSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneLocationSpec_cxx swiftPart = One::HybridOneLocationSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneLocationSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneLocationSpec_(std__shared_ptr_HybridOneLocationSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneLocationSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneLocationSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneLocationSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneLocationSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::vector<MapPlace>& /* result */)>
  Func_void_std__vector_MapPlace_ create_Func_void_std__vector_MapPlace_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_MapPlace_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<MapPlace>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<MapSuggestion>& /* result */)>
  Func_void_std__vector_MapSuggestion_ create_Func_void_std__vector_MapSuggestion_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_MapSuggestion_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<MapSuggestion>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const MapPlace& /* result */)>
  Func_void_MapPlace create_Func_void_MapPlace(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_MapPlace::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const MapPlace& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const MapRoute& /* result */)>
  Func_void_MapRoute create_Func_void_MapRoute(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_MapRoute::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const MapRoute& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneMapServicesSpec>
  std::shared_ptr<HybridOneMapServicesSpec> create_std__shared_ptr_HybridOneMapServicesSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneMapServicesSpec_cxx swiftPart = One::HybridOneMapServicesSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneMapServicesSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneMapServicesSpec_(std__shared_ptr_HybridOneMapServicesSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneMapServicesSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneMapServicesSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneMapServicesSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneMapServicesSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(MailComposeResult /* result */, const std::optional<DocumentCameraError>& /* error */)>
  Func_void_MailComposeResult_std__optional_DocumentCameraError_ create_Func_void_MailComposeResult_std__optional_DocumentCameraError_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_MailComposeResult_std__optional_DocumentCameraError_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](MailComposeResult result, const std::optional<DocumentCameraError>& error) mutable -> void {
      swiftClosure.call(static_cast<int>(result), error);
    };
  }

  // pragma MARK: std::shared_ptr<HybridOneMailComposeSpec>
  std::shared_ptr<HybridOneMailComposeSpec> create_std__shared_ptr_HybridOneMailComposeSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneMailComposeSpec_cxx swiftPart = One::HybridOneMailComposeSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneMailComposeSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneMailComposeSpec_(std__shared_ptr_HybridOneMailComposeSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneMailComposeSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneMailComposeSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneMailComposeSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneMailComposeSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(MessageComposeResult /* result */)>
  Func_void_MessageComposeResult create_Func_void_MessageComposeResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_MessageComposeResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](MessageComposeResult result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }

  // pragma MARK: std::shared_ptr<HybridOneMessageComposeSpec>
  std::shared_ptr<HybridOneMessageComposeSpec> create_std__shared_ptr_HybridOneMessageComposeSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneMessageComposeSpec_cxx swiftPart = One::HybridOneMessageComposeSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneMessageComposeSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneMessageComposeSpec_(std__shared_ptr_HybridOneMessageComposeSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneMessageComposeSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneMessageComposeSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneMessageComposeSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneMessageComposeSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

  // pragma MARK: std::function<void(const MotionReading& /* reading */)>
  Func_void_MotionReading create_Func_void_MotionReading(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_MotionReading::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const MotionReading& reading) mutable -> void {
      swiftClosure.call(reading);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneMotionSpec>
  std::shared_ptr<HybridOneMotionSpec> create_std__shared_ptr_HybridOneMotionSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneMotionSpec_cxx swiftPart = One::HybridOneMotionSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneMotionSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneMotionSpec_(std__shared_ptr_HybridOneMotionSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneMotionSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneMotionSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneMotionSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneMotionSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneNativeModulesSpec>
  std::shared_ptr<HybridOneNativeModulesSpec> create_std__shared_ptr_HybridOneNativeModulesSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneNativeModulesSpec_cxx swiftPart = One::HybridOneNativeModulesSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneNativeModulesSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneNativeModulesSpec_(std__shared_ptr_HybridOneNativeModulesSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneNativeModulesSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneNativeModulesSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneNativeModulesSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneNativeModulesSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const NetworkState& /* result */)>
  Func_void_NetworkState create_Func_void_NetworkState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_NetworkState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const NetworkState& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneNetworkSpec>
  std::shared_ptr<HybridOneNetworkSpec> create_std__shared_ptr_HybridOneNetworkSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneNetworkSpec_cxx swiftPart = One::HybridOneNetworkSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneNetworkSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneNetworkSpec_(std__shared_ptr_HybridOneNetworkSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneNetworkSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneNetworkSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneNetworkSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneNetworkSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const NativePermissionResponse& /* result */)>
  Func_void_NativePermissionResponse create_Func_void_NativePermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_NativePermissionResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const NativePermissionResponse& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const NativeNotificationCategory& /* result */)>
  Func_void_NativeNotificationCategory create_Func_void_NativeNotificationCategory(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_NativeNotificationCategory::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const NativeNotificationCategory& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeNotificationCategory>& /* result */)>
  Func_void_std__vector_NativeNotificationCategory_ create_Func_void_std__vector_NativeNotificationCategory_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_NativeNotificationCategory_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeNotificationCategory>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::optional<NativeChannel>& /* result */)>
  Func_void_std__optional_NativeChannel_ create_Func_void_std__optional_NativeChannel_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__optional_NativeChannel_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<NativeChannel>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeChannel>& /* result */)>
  Func_void_std__vector_NativeChannel_ create_Func_void_std__vector_NativeChannel_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_NativeChannel_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeChannel>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeNotificationRequest>& /* result */)>
  Func_void_std__vector_NativeNotificationRequest_ create_Func_void_std__vector_NativeNotificationRequest_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_NativeNotificationRequest_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeNotificationRequest>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeNotification>& /* result */)>
  Func_void_std__vector_NativeNotification_ create_Func_void_std__vector_NativeNotification_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_NativeNotification_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeNotification>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const NativePushToken& /* result */)>
  Func_void_NativePushToken create_Func_void_NativePushToken(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_NativePushToken::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const NativePushToken& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* requestId */, const NativeNotification& /* notification */)>
  Func_void_std__string_NativeNotification create_Func_void_std__string_NativeNotification(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__string_NativeNotification::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& requestId, const NativeNotification& notification) mutable -> void {
      swiftClosure.call(requestId, notification);
    };
  }
  
  // pragma MARK: std::function<void(const NativeNotificationResponse& /* response */)>
  Func_void_NativeNotificationResponse create_Func_void_NativeNotificationResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_NativeNotificationResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const NativeNotificationResponse& response) mutable -> void {
      swiftClosure.call(response);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneNotificationsSpec>
  std::shared_ptr<HybridOneNotificationsSpec> create_std__shared_ptr_HybridOneNotificationsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneNotificationsSpec_cxx swiftPart = One::HybridOneNotificationsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneNotificationsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneNotificationsSpec_(std__shared_ptr_HybridOneNotificationsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneNotificationsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneNotificationsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneNotificationsSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneNotificationsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const PedometerResult& /* result */)>
  Func_void_PedometerResult create_Func_void_PedometerResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PedometerResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PedometerResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PedometerPermissionResponse& /* result */)>
  Func_void_PedometerPermissionResponse create_Func_void_PedometerPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PedometerPermissionResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PedometerPermissionResponse& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePedometerSpec>
  std::shared_ptr<HybridOnePedometerSpec> create_std__shared_ptr_HybridOnePedometerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOnePedometerSpec_cxx swiftPart = One::HybridOnePedometerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOnePedometerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOnePedometerSpec_(std__shared_ptr_HybridOnePedometerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOnePedometerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOnePedometerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOnePedometerSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOnePedometerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(PhotoLibraryPermissionStatus /* result */)>
  Func_void_PhotoLibraryPermissionStatus create_Func_void_PhotoLibraryPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PhotoLibraryPermissionStatus::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](PhotoLibraryPermissionStatus result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAssetPage& /* result */)>
  Func_void_PhotoLibraryAssetPage create_Func_void_PhotoLibraryAssetPage(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PhotoLibraryAssetPage::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PhotoLibraryAssetPage& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAsset& /* result */)>
  Func_void_PhotoLibraryAsset create_Func_void_PhotoLibraryAsset(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PhotoLibraryAsset::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PhotoLibraryAsset& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAlbumPage& /* result */)>
  Func_void_PhotoLibraryAlbumPage create_Func_void_PhotoLibraryAlbumPage(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PhotoLibraryAlbumPage::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PhotoLibraryAlbumPage& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAlbum& /* result */)>
  Func_void_PhotoLibraryAlbum create_Func_void_PhotoLibraryAlbum(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PhotoLibraryAlbum::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PhotoLibraryAlbum& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePhotoLibrarySpec>
  std::shared_ptr<HybridOnePhotoLibrarySpec> create_std__shared_ptr_HybridOnePhotoLibrarySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOnePhotoLibrarySpec_cxx swiftPart = One::HybridOnePhotoLibrarySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOnePhotoLibrarySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOnePhotoLibrarySpec_(std__shared_ptr_HybridOnePhotoLibrarySpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOnePhotoLibrarySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOnePhotoLibrarySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOnePhotoLibrarySpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOnePhotoLibrarySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const PrintResult& /* result */)>
  Func_void_PrintResult create_Func_void_PrintResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PrintResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PrintResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePrintSpec>
  std::shared_ptr<HybridOnePrintSpec> create_std__shared_ptr_HybridOnePrintSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOnePrintSpec_cxx swiftPart = One::HybridOnePrintSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOnePrintSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOnePrintSpec_(std__shared_ptr_HybridOnePrintSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOnePrintSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOnePrintSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOnePrintSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOnePrintSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneProtectedStoreSpec>
  std::shared_ptr<HybridOneProtectedStoreSpec> create_std__shared_ptr_HybridOneProtectedStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneProtectedStoreSpec_cxx swiftPart = One::HybridOneProtectedStoreSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneProtectedStoreSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneProtectedStoreSpec_(std__shared_ptr_HybridOneProtectedStoreSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneProtectedStoreSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneProtectedStoreSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneProtectedStoreSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneProtectedStoreSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::vector<PurchaseProduct>& /* result */)>
  Func_void_std__vector_PurchaseProduct_ create_Func_void_std__vector_PurchaseProduct_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_PurchaseProduct_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<PurchaseProduct>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PurchaseResult& /* result */)>
  Func_void_PurchaseResult create_Func_void_PurchaseResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PurchaseResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PurchaseResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<PurchaseTransaction>& /* result */)>
  Func_void_std__vector_PurchaseTransaction_ create_Func_void_std__vector_PurchaseTransaction_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_PurchaseTransaction_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<PurchaseTransaction>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const PurchaseUpdate& /* update */)>
  Func_void_PurchaseUpdate create_Func_void_PurchaseUpdate(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_PurchaseUpdate::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PurchaseUpdate& update) mutable -> void {
      swiftClosure.call(update);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePurchasesSpec>
  std::shared_ptr<HybridOnePurchasesSpec> create_std__shared_ptr_HybridOnePurchasesSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOnePurchasesSpec_cxx swiftPart = One::HybridOnePurchasesSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOnePurchasesSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOnePurchasesSpec_(std__shared_ptr_HybridOnePurchasesSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOnePurchasesSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOnePurchasesSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOnePurchasesSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOnePurchasesSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::vector<QuickActionItem>& /* result */)>
  Func_void_std__vector_QuickActionItem_ create_Func_void_std__vector_QuickActionItem_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_QuickActionItem_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<QuickActionItem>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneQuickActionsSpec>
  std::shared_ptr<HybridOneQuickActionsSpec> create_std__shared_ptr_HybridOneQuickActionsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneQuickActionsSpec_cxx swiftPart = One::HybridOneQuickActionsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneQuickActionsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneQuickActionsSpec_(std__shared_ptr_HybridOneQuickActionsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneQuickActionsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneQuickActionsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneQuickActionsSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneQuickActionsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(ScreenCaptureState /* result */)>
  Func_void_ScreenCaptureState create_Func_void_ScreenCaptureState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ScreenCaptureState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](ScreenCaptureState result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::function<void(const ScreenCaptureResult& /* result */)>
  Func_void_ScreenCaptureResult create_Func_void_ScreenCaptureResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ScreenCaptureResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const ScreenCaptureResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneScreenCaptureSpec>
  std::shared_ptr<HybridOneScreenCaptureSpec> create_std__shared_ptr_HybridOneScreenCaptureSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneScreenCaptureSpec_cxx swiftPart = One::HybridOneScreenCaptureSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneScreenCaptureSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneScreenCaptureSpec_(std__shared_ptr_HybridOneScreenCaptureSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneScreenCaptureSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneScreenCaptureSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneScreenCaptureSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneScreenCaptureSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(ScreenOrientationValue /* result */)>
  Func_void_ScreenOrientationValue create_Func_void_ScreenOrientationValue(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ScreenOrientationValue::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](ScreenOrientationValue result) mutable -> void {
      swiftClosure.call(static_cast<int>(result));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneScreenOrientationSpec>
  std::shared_ptr<HybridOneScreenOrientationSpec> create_std__shared_ptr_HybridOneScreenOrientationSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneScreenOrientationSpec_cxx swiftPart = One::HybridOneScreenOrientationSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneScreenOrientationSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneScreenOrientationSpec_(std__shared_ptr_HybridOneScreenOrientationSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneScreenOrientationSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneScreenOrientationSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneScreenOrientationSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneScreenOrientationSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneSecureStoreSpec>
  std::shared_ptr<HybridOneSecureStoreSpec> create_std__shared_ptr_HybridOneSecureStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneSecureStoreSpec_cxx swiftPart = One::HybridOneSecureStoreSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneSecureStoreSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneSecureStoreSpec_(std__shared_ptr_HybridOneSecureStoreSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneSecureStoreSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneSecureStoreSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneSecureStoreSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneSecureStoreSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const ShareResult& /* result */)>
  Func_void_ShareResult create_Func_void_ShareResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_ShareResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const ShareResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneShareSpec>
  std::shared_ptr<HybridOneShareSpec> create_std__shared_ptr_HybridOneShareSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneShareSpec_cxx swiftPart = One::HybridOneShareSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneShareSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneShareSpec_(std__shared_ptr_HybridOneShareSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneShareSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneShareSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneShareSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneShareSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const SpeechPermissionResponse& /* result */)>
  Func_void_SpeechPermissionResponse create_Func_void_SpeechPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_SpeechPermissionResponse::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const SpeechPermissionResponse& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const SpeechEvent& /* event */)>
  Func_void_SpeechEvent create_Func_void_SpeechEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_SpeechEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const SpeechEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneSpeechSpec>
  std::shared_ptr<HybridOneSpeechSpec> create_std__shared_ptr_HybridOneSpeechSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneSpeechSpec_cxx swiftPart = One::HybridOneSpeechSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneSpeechSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneSpeechSpec_(std__shared_ptr_HybridOneSpeechSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneSpeechSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneSpeechSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneSpeechSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneSpeechSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const SpeechSynthesisEvent& /* event */)>
  Func_void_SpeechSynthesisEvent create_Func_void_SpeechSynthesisEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_SpeechSynthesisEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const SpeechSynthesisEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::function<void(const std::vector<SpeechSynthesisVoice>& /* result */)>
  Func_void_std__vector_SpeechSynthesisVoice_ create_Func_void_std__vector_SpeechSynthesisVoice_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_std__vector_SpeechSynthesisVoice_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::vector<SpeechSynthesisVoice>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneSpeechSynthesisSpec>
  std::shared_ptr<HybridOneSpeechSynthesisSpec> create_std__shared_ptr_HybridOneSpeechSynthesisSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneSpeechSynthesisSpec_cxx swiftPart = One::HybridOneSpeechSynthesisSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneSpeechSynthesisSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneSpeechSynthesisSpec_(std__shared_ptr_HybridOneSpeechSynthesisSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneSpeechSynthesisSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneSpeechSynthesisSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneSpeechSynthesisSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneSpeechSynthesisSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneStoreReviewSpec>
  std::shared_ptr<HybridOneStoreReviewSpec> create_std__shared_ptr_HybridOneStoreReviewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneStoreReviewSpec_cxx swiftPart = One::HybridOneStoreReviewSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneStoreReviewSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneStoreReviewSpec_(std__shared_ptr_HybridOneStoreReviewSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneStoreReviewSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneStoreReviewSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneStoreReviewSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneStoreReviewSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const OneUpdatesCheckResult& /* result */)>
  Func_void_OneUpdatesCheckResult create_Func_void_OneUpdatesCheckResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_OneUpdatesCheckResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const OneUpdatesCheckResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const OneUpdatesFetchResult& /* result */)>
  Func_void_OneUpdatesFetchResult create_Func_void_OneUpdatesFetchResult(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = One::Func_void_OneUpdatesFetchResult::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const OneUpdatesFetchResult& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridOneUpdatesSpec>
  std::shared_ptr<HybridOneUpdatesSpec> create_std__shared_ptr_HybridOneUpdatesSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    One::HybridOneUpdatesSpec_cxx swiftPart = One::HybridOneUpdatesSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::one::HybridOneUpdatesSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridOneUpdatesSpec_(std__shared_ptr_HybridOneUpdatesSpec_ cppType) {
    std::shared_ptr<margelo::nitro::one::HybridOneUpdatesSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneUpdatesSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridOneUpdatesSpec\" is not implemented in Swift!");
    }
    #endif
    One::HybridOneUpdatesSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

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