///
/// HybridPlaybackEngineSpec_cxx.swift
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

import NitroModules

/**
 * A class implementation that bridges HybridPlaybackEngineSpec over to C++.
 * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
 *
 * Also, some Swift types need to be bridged with special handling:
 * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
 * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
 * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
 */
open class HybridPlaybackEngineSpec_cxx {
  /**
   * The Swift <> C++ bridge's namespace (`margelo::nitro::aviation::bridge::swift`)
   * from `Aviation-Swift-Cxx-Bridge.hpp`.
   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
   */
  public typealias bridge = margelo.nitro.aviation.bridge.swift

  /**
   * Holds an instance of the `HybridPlaybackEngineSpec` Swift protocol.
   */
  private var __implementation: any HybridPlaybackEngineSpec

  /**
   * Holds a weak pointer to the C++ class that wraps the Swift class.
   */
  private var __cxxPart: bridge.std__weak_ptr_HybridPlaybackEngineSpec_

  /**
   * Create a new `HybridPlaybackEngineSpec_cxx` that wraps the given `HybridPlaybackEngineSpec`.
   * All properties and methods bridge to C++ types.
   */
  public init(_ implementation: any HybridPlaybackEngineSpec) {
    self.__implementation = implementation
    self.__cxxPart = .init()
    /* no base class */
  }

  /**
   * Get the actual `HybridPlaybackEngineSpec` instance this class wraps.
   */
  @inline(__always)
  public func getHybridPlaybackEngineSpec() -> any HybridPlaybackEngineSpec {
    return __implementation
  }

  /**
   * Casts this instance to a retained unsafe raw pointer.
   * This acquires one additional strong reference on the object!
   */
  public func toUnsafe() -> UnsafeMutableRawPointer {
    return Unmanaged.passRetained(self).toOpaque()
  }

  /**
   * Casts an unsafe pointer to a `HybridPlaybackEngineSpec_cxx`.
   * The pointer has to be a retained opaque `Unmanaged<HybridPlaybackEngineSpec_cxx>`.
   * This removes one strong reference from the object!
   */
  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridPlaybackEngineSpec_cxx {
    return Unmanaged<HybridPlaybackEngineSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
  }

  /**
   * Gets (or creates) the C++ part of this Hybrid Object.
   * The C++ part is a `std::shared_ptr<HybridPlaybackEngineSpec>`.
   */
  public func getCxxPart() -> bridge.std__shared_ptr_HybridPlaybackEngineSpec_ {
    let cachedCxxPart = self.__cxxPart.lock()
    if Bool(fromCxx: cachedCxxPart) {
      return cachedCxxPart
    } else {
      let newCxxPart = bridge.create_std__shared_ptr_HybridPlaybackEngineSpec_(self.toUnsafe())
      __cxxPart = bridge.weakify_std__shared_ptr_HybridPlaybackEngineSpec_(newCxxPart)
      return newCxxPart
    }
  }

  

  /**
   * Get the memory size of the Swift class (plus size of any other allocations)
   * so the JS VM can properly track it and garbage-collect the JS object if needed.
   */
  @inline(__always)
  public var memorySize: Int {
    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
  }

  /**
   * Compares this object with the given [other] object for reference equality.
   */
  @inline(__always)
  public func equals(other: HybridPlaybackEngineSpec_cxx) -> Bool {
    return self.__implementation === other.__implementation
  }

  /**
   * Call dispose() on the Swift class.
   * This _may_ be called manually from JS.
   */
  @inline(__always)
  public func dispose() {
    self.__implementation.dispose()
  }

  /**
   * Call toString() on the Swift class.
   */
  @inline(__always)
  public func toString() -> String {
    return self.__implementation.toString()
  }

  // Properties
  public final var engineId: std.string {
    @inline(__always)
    get {
      return std.string(self.__implementation.engineId)
    }
  }
  
  public final var state: Int32 {
    @inline(__always)
    get {
      return self.__implementation.state.rawValue
    }
  }
  
  public final var mediaPosition: MediaPosition {
    @inline(__always)
    get {
      return self.__implementation.mediaPosition
    }
  }
  
  public final var currentItem: bridge.std__optional_std__shared_ptr_HybridMediaItemSpec__ {
    @inline(__always)
    get {
      return { () -> bridge.std__optional_std__shared_ptr_HybridMediaItemSpec__ in
        if let __unwrappedValue = self.__implementation.currentItem {
          return bridge.create_std__optional_std__shared_ptr_HybridMediaItemSpec__({ () -> bridge.std__shared_ptr_HybridMediaItemSpec_ in
            let __cxxWrapped = __unwrappedValue.getCxxWrapper()
            return __cxxWrapped.getCxxPart()
          }())
        } else {
          return .init()
        }
      }()
    }
  }
  
  public final var currentItemSource: Int32 {
    @inline(__always)
    get {
      return self.__implementation.currentItemSource.rawValue
    }
  }
  
  public final var isLive: Bool {
    @inline(__always)
    get {
      return self.__implementation.isLive
    }
  }
  
  public final var isPlaying: Bool {
    @inline(__always)
    get {
      return self.__implementation.isPlaying
    }
  }
  
  public final var isPaused: Bool {
    @inline(__always)
    get {
      return self.__implementation.isPaused
    }
  }
  
  public final var isLoaded: Bool {
    @inline(__always)
    get {
      return self.__implementation.isLoaded
    }
  }
  
  public final var availableSubtitleTracks: bridge.std__vector_SubtitleTrack_ {
    @inline(__always)
    get {
      return { () -> bridge.std__vector_SubtitleTrack_ in
        var __vector = bridge.create_std__vector_SubtitleTrack_(self.__implementation.availableSubtitleTracks.count)
        for __item in self.__implementation.availableSubtitleTracks {
          __vector.push_back(__item)
        }
        return __vector
      }()
    }
  }
  
  public final var availableAudioTracks: bridge.std__vector_AudioTrack_ {
    @inline(__always)
    get {
      return { () -> bridge.std__vector_AudioTrack_ in
        var __vector = bridge.create_std__vector_AudioTrack_(self.__implementation.availableAudioTracks.count)
        for __item in self.__implementation.availableAudioTracks {
          __vector.push_back(__item)
        }
        return __vector
      }()
    }
  }
  
  public final var volume: Double {
    @inline(__always)
    get {
      return self.__implementation.volume
    }
    @inline(__always)
    set {
      self.__implementation.volume = newValue
    }
  }
  
  public final var rate: Double {
    @inline(__always)
    get {
      return self.__implementation.rate
    }
    @inline(__always)
    set {
      self.__implementation.rate = newValue
    }
  }
  
  public final var muted: Bool {
    @inline(__always)
    get {
      return self.__implementation.muted
    }
    @inline(__always)
    set {
      self.__implementation.muted = newValue
    }
  }
  
  public final var loop: Bool {
    @inline(__always)
    get {
      return self.__implementation.loop
    }
    @inline(__always)
    set {
      self.__implementation.loop = newValue
    }
  }
  
  public final var queueItems: bridge.std__vector_std__shared_ptr_HybridMediaItemSpec__ {
    @inline(__always)
    get {
      return { () -> bridge.std__vector_std__shared_ptr_HybridMediaItemSpec__ in
        var __vector = bridge.create_std__vector_std__shared_ptr_HybridMediaItemSpec__(self.__implementation.queueItems.count)
        for __item in self.__implementation.queueItems {
          __vector.push_back({ () -> bridge.std__shared_ptr_HybridMediaItemSpec_ in
            let __cxxWrapped = __item.getCxxWrapper()
            return __cxxWrapped.getCxxPart()
          }())
        }
        return __vector
      }()
    }
  }
  
  public final var queueIndex: Double {
    @inline(__always)
    get {
      return self.__implementation.queueIndex
    }
  }
  
  public final var queueCount: Double {
    @inline(__always)
    get {
      return self.__implementation.queueCount
    }
  }
  
  public final var repeatMode: Int32 {
    @inline(__always)
    get {
      return self.__implementation.repeatMode.rawValue
    }
    @inline(__always)
    set {
      self.__implementation.repeatMode = margelo.nitro.aviation.RepeatMode(rawValue: newValue)!
    }
  }
  
  public final var shuffleEnabled: Bool {
    @inline(__always)
    get {
      return self.__implementation.shuffleEnabled
    }
    @inline(__always)
    set {
      self.__implementation.shuffleEnabled = newValue
    }
  }

  // Methods
  @inline(__always)
  public final func load(item: bridge.std__shared_ptr_HybridMediaItemSpec_) -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.load(item: { () -> any HybridMediaItemSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridMediaItemSpec_(item)
        let __instance = HybridMediaItemSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridMediaItemSpec()
      }())
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func loadAndPlay(item: bridge.std__shared_ptr_HybridMediaItemSpec_) -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.loadAndPlay(item: { () -> any HybridMediaItemSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridMediaItemSpec_(item)
        let __instance = HybridMediaItemSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridMediaItemSpec()
      }())
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func play() -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.play()
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func pause() -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.pause()
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func stop() -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.stop()
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func seekTo(positionMs: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.seekTo(positionMs: positionMs)
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func release() -> bridge.Result_void_ {
    do {
      try self.__implementation.release()
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func activateDefaultDecoder() -> bridge.Result_void_ {
    do {
      try self.__implementation.activateDefaultDecoder()
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setQueue(items: bridge.std__vector_std__shared_ptr_HybridMediaItemSpec__) -> bridge.Result_void_ {
    do {
      try self.__implementation.setQueue(items: items.map({ __item in { () -> any HybridMediaItemSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridMediaItemSpec_(__item)
        let __instance = HybridMediaItemSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridMediaItemSpec()
      }() }))
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func addToQueue(item: bridge.std__shared_ptr_HybridMediaItemSpec_) -> bridge.Result_void_ {
    do {
      try self.__implementation.addToQueue(item: { () -> any HybridMediaItemSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridMediaItemSpec_(item)
        let __instance = HybridMediaItemSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridMediaItemSpec()
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func insertInQueue(item: bridge.std__shared_ptr_HybridMediaItemSpec_, afterIndex: Double) -> bridge.Result_void_ {
    do {
      try self.__implementation.insertInQueue(item: { () -> any HybridMediaItemSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridMediaItemSpec_(item)
        let __instance = HybridMediaItemSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridMediaItemSpec()
      }(), afterIndex: afterIndex)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func removeFromQueue(index: Double) -> bridge.Result_void_ {
    do {
      try self.__implementation.removeFromQueue(index: index)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func moveInQueue(fromIndex: Double, toIndex: Double) -> bridge.Result_void_ {
    do {
      try self.__implementation.moveInQueue(fromIndex: fromIndex, toIndex: toIndex)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func clearQueue() -> bridge.Result_void_ {
    do {
      try self.__implementation.clearQueue()
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func skipToNext() -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.skipToNext()
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func skipToPrevious() -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.skipToPrevious()
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func skipToIndex(index: Double, autoPlay: Bool) -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.skipToIndex(index: index, autoPlay: autoPlay)
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setEnabledCommands(commands: bridge.std__vector_RemoteCommand_) -> bridge.Result_void_ {
    do {
      try self.__implementation.setEnabledCommands(commands: commands.map({ __item in __item }))
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setCompactCommands(commands: bridge.std__vector_RemoteCommand_) -> bridge.Result_void_ {
    do {
      try self.__implementation.setCompactCommands(commands: commands.map({ __item in __item }))
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setSkipIntervalMs(intervalMs: Double) -> bridge.Result_void_ {
    do {
      try self.__implementation.setSkipIntervalMs(intervalMs: intervalMs)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func updateNowPlaying(info: NowPlayingInfo) -> bridge.Result_void_ {
    do {
      try self.__implementation.updateNowPlaying(info: info)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func overrideRemoteCommand(command: Int32) -> bridge.Result_void_ {
    do {
      try self.__implementation.overrideRemoteCommand(command: margelo.nitro.aviation.RemoteCommand(rawValue: command)!)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func clearRemoteCommandOverride(command: Int32) -> bridge.Result_void_ {
    do {
      try self.__implementation.clearRemoteCommandOverride(command: margelo.nitro.aviation.RemoteCommand(rawValue: command)!)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setAudioSession(session: bridge.std__shared_ptr_HybridAudioSessionSpec_) -> bridge.Result_void_ {
    do {
      try self.__implementation.setAudioSession(session: { () -> any HybridAudioSessionSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridAudioSessionSpec_(session)
        let __instance = HybridAudioSessionSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridAudioSessionSpec()
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func clearCallbacks() -> bridge.Result_void_ {
    do {
      try self.__implementation.clearCallbacks()
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onStateChange(callback: bridge.Func_void_PlaybackState) -> bridge.Result_void_ {
    do {
      try self.__implementation.onStateChange(callback: { () -> (PlaybackState) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_PlaybackState(callback)
        return { (__state: PlaybackState) -> Void in
          __wrappedFunction.call(__state.rawValue)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onMediaPositionChange(callback: bridge.Func_void_MediaPosition) -> bridge.Result_void_ {
    do {
      try self.__implementation.onMediaPositionChange(callback: { () -> (MediaPosition) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_MediaPosition(callback)
        return { (__position: MediaPosition) -> Void in
          __wrappedFunction.call(__position)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onCurrentItemChange(callback: bridge.Func_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource) -> bridge.Result_void_ {
    do {
      try self.__implementation.onCurrentItemChange(callback: { () -> ((any HybridMediaItemSpec)?, ItemSource) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource(callback)
        return { (__item: (any HybridMediaItemSpec)?, __source: ItemSource) -> Void in
          __wrappedFunction.call({ () -> bridge.std__optional_std__shared_ptr_HybridMediaItemSpec__ in
            if let __unwrappedValue = __item {
              return bridge.create_std__optional_std__shared_ptr_HybridMediaItemSpec__({ () -> bridge.std__shared_ptr_HybridMediaItemSpec_ in
                let __cxxWrapped = __unwrappedValue.getCxxWrapper()
                return __cxxWrapped.getCxxPart()
              }())
            } else {
              return .init()
            }
          }(), __source.rawValue)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onRemoteCommand(callback: bridge.Func_void_RemoteCommandEvent) -> bridge.Result_void_ {
    do {
      try self.__implementation.onRemoteCommand(callback: { () -> (RemoteCommandEvent) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_RemoteCommandEvent(callback)
        return { (__event: RemoteCommandEvent) -> Void in
          __wrappedFunction.call(__event)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onError(callback: bridge.Func_void_std__string_std__string) -> bridge.Result_void_ {
    do {
      try self.__implementation.onError(callback: { () -> (String, String) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_std__string_std__string(callback)
        return { (__message: String, __code: String) -> Void in
          __wrappedFunction.call(std.string(__message), std.string(__code))
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onPlaybackEnded(callback: bridge.Func_void) -> bridge.Result_void_ {
    do {
      try self.__implementation.onPlaybackEnded(callback: { () -> () -> Void in
        let __wrappedFunction = bridge.wrap_Func_void(callback)
        return { () -> Void in
          __wrappedFunction.call()
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onQueueEnd(callback: bridge.Func_void) -> bridge.Result_void_ {
    do {
      try self.__implementation.onQueueEnd(callback: { () -> () -> Void in
        let __wrappedFunction = bridge.wrap_Func_void(callback)
        return { () -> Void in
          __wrappedFunction.call()
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onQueueChange(callback: bridge.Func_void) -> bridge.Result_void_ {
    do {
      try self.__implementation.onQueueChange(callback: { () -> () -> Void in
        let __wrappedFunction = bridge.wrap_Func_void(callback)
        return { () -> Void in
          __wrappedFunction.call()
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onPlaybackMetric(callback: bridge.Func_void_PlaybackMetricEvent) -> bridge.Result_void_ {
    do {
      try self.__implementation.onPlaybackMetric(callback: { () -> (PlaybackMetricEvent) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_PlaybackMetricEvent(callback)
        return { (__event: PlaybackMetricEvent) -> Void in
          __wrappedFunction.call(__event)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onTracksAvailable(callback: bridge.Func_void_AvailableTracks) -> bridge.Result_void_ {
    do {
      try self.__implementation.onTracksAvailable(callback: { () -> (AvailableTracks) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_AvailableTracks(callback)
        return { (__tracks: AvailableTracks) -> Void in
          __wrappedFunction.call(__tracks)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func onDomainEvent(callback: bridge.Func_void_DomainEvent) -> bridge.Result_void_ {
    do {
      try self.__implementation.onDomainEvent(callback: { () -> (DomainEvent) -> Void in
        let __wrappedFunction = bridge.wrap_Func_void_DomainEvent(callback)
        return { (__event: DomainEvent) -> Void in
          __wrappedFunction.call(__event)
        }
      }())
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setInterruptionMode(mode: Int32) -> bridge.Result_void_ {
    do {
      try self.__implementation.setInterruptionMode(mode: margelo.nitro.aviation.AviationInterruptionMode(rawValue: mode)!)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setBecomingNoisyBehavior(behavior: Int32) -> bridge.Result_void_ {
    do {
      try self.__implementation.setBecomingNoisyBehavior(behavior: margelo.nitro.aviation.BecomingNoisyBehavior(rawValue: behavior)!)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func selectVideoTrack(selection: VideoTrackSelection) -> bridge.Result_void_ {
    do {
      try self.__implementation.selectVideoTrack(selection: selection)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func selectSubtitleTrack(selection: SubtitleTrackSelection) -> bridge.Result_void_ {
    do {
      try self.__implementation.selectSubtitleTrack(selection: selection)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func selectAudioTrack(selection: AudioTrackSelection) -> bridge.Result_void_ {
    do {
      try self.__implementation.selectAudioTrack(selection: selection)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func clearCache() -> bridge.Result_std__shared_ptr_Promise_void___ {
    do {
      let __result = try self.__implementation.clearCache()
      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
        let __promise = bridge.create_std__shared_ptr_Promise_void__()
        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
        __result
          .then({ __result in __promiseHolder.resolve() })
          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
        return __promise
      }()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func getCacheSize() -> bridge.Result_double_ {
    do {
      let __result = try self.__implementation.getCacheSize()
      let __resultCpp = __result
      return bridge.create_Result_double_(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_double_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func isCached(uri: std.string) -> bridge.Result_bool_ {
    do {
      let __result = try self.__implementation.isCached(uri: String(uri))
      let __resultCpp = __result
      return bridge.create_Result_bool_(__resultCpp)
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_bool_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setCacheEnabled(enabled: Bool) -> bridge.Result_void_ {
    do {
      try self.__implementation.setCacheEnabled(enabled: enabled)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func preload(items: bridge.std__vector_std__shared_ptr_HybridMediaItemSpec__) -> bridge.Result_void_ {
    do {
      try self.__implementation.preload(items: items.map({ __item in { () -> any HybridMediaItemSpec in
        let __unsafePointer = bridge.get_std__shared_ptr_HybridMediaItemSpec_(__item)
        let __instance = HybridMediaItemSpec_cxx.fromUnsafe(__unsafePointer)
        return __instance.getHybridMediaItemSpec()
      }() }))
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setPreloadConfig(config: PreloadConfig) -> bridge.Result_void_ {
    do {
      try self.__implementation.setPreloadConfig(config: config)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setBufferConfig(config: BufferConfig) -> bridge.Result_void_ {
    do {
      try self.__implementation.setBufferConfig(config: config)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setCacheMaxSize(sizeBytes: Double) -> bridge.Result_void_ {
    do {
      try self.__implementation.setCacheMaxSize(sizeBytes: sizeBytes)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
  
  @inline(__always)
  public final func setPreloadEnabled(enabled: Bool) -> bridge.Result_void_ {
    do {
      try self.__implementation.setPreloadEnabled(enabled: enabled)
      return bridge.create_Result_void_()
    } catch (let __error) {
      let __exceptionPtr = __error.toCpp()
      return bridge.create_Result_void_(__exceptionPtr)
    }
  }
}