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

// Include C++ implementation defined types
#include "Aviation-Swift-Cxx-Umbrella.hpp"
#include "HybridAdsControllerSpecSwift.hpp"
#include "HybridAirPlayButtonSpecSwift.hpp"
#include "HybridAudioSessionFactorySpecSwift.hpp"
#include "HybridAudioSessionSpecSwift.hpp"
#include "HybridMediaItemFactorySpecSwift.hpp"
#include "HybridMediaItemSpecSwift.hpp"
#include "HybridPlaybackEngineFactorySpecSwift.hpp"
#include "HybridPlaybackEngineSpecSwift.hpp"
#include "HybridVideoViewSpecSwift.hpp"
#include <NitroModules/NitroDefines.hpp>

namespace margelo::nitro::aviation::bridge::swift {

  // pragma MARK: std::function<void()>
  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
      swiftClosure.call();
    };
  }
  
  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::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 AdBreakInfo& /* info */)>
  Func_void_AdBreakInfo create_Func_void_AdBreakInfo(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_AdBreakInfo::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AdBreakInfo& info) mutable -> void {
      swiftClosure.call(info);
    };
  }
  
  // pragma MARK: std::function<void(const AdInfo& /* info */)>
  Func_void_AdInfo create_Func_void_AdInfo(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_AdInfo::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AdInfo& info) mutable -> void {
      swiftClosure.call(info);
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* error */)>
  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& error) mutable -> void {
      swiftClosure.call(error);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridAdsControllerSpec>
  std::shared_ptr<HybridAdsControllerSpec> create_std__shared_ptr_HybridAdsControllerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridAdsControllerSpec_cxx swiftPart = Aviation::HybridAdsControllerSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridAdsControllerSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridAdsControllerSpec_(std__shared_ptr_HybridAdsControllerSpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridAdsControllerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridAdsControllerSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridAdsControllerSpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridAdsControllerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridAirPlayButtonSpec>
  std::shared_ptr<HybridAirPlayButtonSpec> create_std__shared_ptr_HybridAirPlayButtonSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridAirPlayButtonSpec_cxx swiftPart = Aviation::HybridAirPlayButtonSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridAirPlayButtonSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridAirPlayButtonSpec_(std__shared_ptr_HybridAirPlayButtonSpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridAirPlayButtonSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridAirPlayButtonSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridAirPlayButtonSpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridAirPlayButtonSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(bool /* began */, bool /* shouldResume */)>
  Func_void_bool_bool create_Func_void_bool_bool(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_bool_bool::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](bool began, bool shouldResume) mutable -> void {
      swiftClosure.call(began, shouldResume);
    };
  }
  
  // pragma MARK: std::function<void(const AudioRouteChangeEvent& /* event */)>
  Func_void_AudioRouteChangeEvent create_Func_void_AudioRouteChangeEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_AudioRouteChangeEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AudioRouteChangeEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridAudioSessionSpec>
  std::shared_ptr<HybridAudioSessionSpec> create_std__shared_ptr_HybridAudioSessionSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridAudioSessionSpec_cxx swiftPart = Aviation::HybridAudioSessionSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridAudioSessionSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridAudioSessionSpec_(std__shared_ptr_HybridAudioSessionSpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridAudioSessionSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridAudioSessionSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridAudioSessionSpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridAudioSessionSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridAudioSessionFactorySpec>
  std::shared_ptr<HybridAudioSessionFactorySpec> create_std__shared_ptr_HybridAudioSessionFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridAudioSessionFactorySpec_cxx swiftPart = Aviation::HybridAudioSessionFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridAudioSessionFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridAudioSessionFactorySpec_(std__shared_ptr_HybridAudioSessionFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridAudioSessionFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridAudioSessionFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridAudioSessionFactorySpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridAudioSessionFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridMediaItemSpec>
  std::shared_ptr<HybridMediaItemSpec> create_std__shared_ptr_HybridMediaItemSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridMediaItemSpec_cxx swiftPart = Aviation::HybridMediaItemSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridMediaItemSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridMediaItemSpec_(std__shared_ptr_HybridMediaItemSpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridMediaItemSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridMediaItemSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridMediaItemSpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridMediaItemSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridMediaItemFactorySpec>
  std::shared_ptr<HybridMediaItemFactorySpec> create_std__shared_ptr_HybridMediaItemFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridMediaItemFactorySpec_cxx swiftPart = Aviation::HybridMediaItemFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridMediaItemFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridMediaItemFactorySpec_(std__shared_ptr_HybridMediaItemFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridMediaItemFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridMediaItemFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridMediaItemFactorySpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridMediaItemFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(PlaybackState /* state */)>
  Func_void_PlaybackState create_Func_void_PlaybackState(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_PlaybackState::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](PlaybackState state) mutable -> void {
      swiftClosure.call(static_cast<int>(state));
    };
  }
  
  // pragma MARK: std::function<void(const MediaPosition& /* position */)>
  Func_void_MediaPosition create_Func_void_MediaPosition(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_MediaPosition::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const MediaPosition& position) mutable -> void {
      swiftClosure.call(position);
    };
  }
  
  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridMediaItemSpec>>& /* item */, ItemSource /* source */)>
  Func_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource create_Func_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::optional<std::shared_ptr<HybridMediaItemSpec>>& item, ItemSource source) mutable -> void {
      swiftClosure.call(item, static_cast<int>(source));
    };
  }
  
  // pragma MARK: std::function<void(const RemoteCommandEvent& /* event */)>
  Func_void_RemoteCommandEvent create_Func_void_RemoteCommandEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_RemoteCommandEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const RemoteCommandEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* message */, const std::string& /* code */)>
  Func_void_std__string_std__string create_Func_void_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_std__string_std__string::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& message, const std::string& code) mutable -> void {
      swiftClosure.call(message, code);
    };
  }
  
  // pragma MARK: std::function<void(const PlaybackMetricEvent& /* event */)>
  Func_void_PlaybackMetricEvent create_Func_void_PlaybackMetricEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_PlaybackMetricEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const PlaybackMetricEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::function<void(const AvailableTracks& /* tracks */)>
  Func_void_AvailableTracks create_Func_void_AvailableTracks(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_AvailableTracks::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const AvailableTracks& tracks) mutable -> void {
      swiftClosure.call(tracks);
    };
  }
  
  // pragma MARK: std::function<void(const DomainEvent& /* event */)>
  Func_void_DomainEvent create_Func_void_DomainEvent(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = Aviation::Func_void_DomainEvent::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const DomainEvent& event) mutable -> void {
      swiftClosure.call(event);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridPlaybackEngineSpec>
  std::shared_ptr<HybridPlaybackEngineSpec> create_std__shared_ptr_HybridPlaybackEngineSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridPlaybackEngineSpec_cxx swiftPart = Aviation::HybridPlaybackEngineSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridPlaybackEngineSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridPlaybackEngineSpec_(std__shared_ptr_HybridPlaybackEngineSpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridPlaybackEngineSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridPlaybackEngineSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridPlaybackEngineSpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridPlaybackEngineSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridPlaybackEngineFactorySpec>
  std::shared_ptr<HybridPlaybackEngineFactorySpec> create_std__shared_ptr_HybridPlaybackEngineFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridPlaybackEngineFactorySpec_cxx swiftPart = Aviation::HybridPlaybackEngineFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridPlaybackEngineFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridPlaybackEngineFactorySpec_(std__shared_ptr_HybridPlaybackEngineFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridPlaybackEngineFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridPlaybackEngineFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridPlaybackEngineFactorySpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridPlaybackEngineFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridVideoViewSpec>
  std::shared_ptr<HybridVideoViewSpec> create_std__shared_ptr_HybridVideoViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    Aviation::HybridVideoViewSpec_cxx swiftPart = Aviation::HybridVideoViewSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::aviation::HybridVideoViewSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridVideoViewSpec_(std__shared_ptr_HybridVideoViewSpec_ cppType) {
    std::shared_ptr<margelo::nitro::aviation::HybridVideoViewSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::aviation::HybridVideoViewSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridVideoViewSpec\" is not implemented in Swift!");
    }
    #endif
    Aviation::HybridVideoViewSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

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