@5stones/react-native-audio-browser 0.1.0

package/nitrogen/generated/ios/swift/HybridAudioBrowserSpec_cxx.swift

@@ -0,0 +1,2352 @@
+///
+/// HybridAudioBrowserSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridAudioBrowserSpec 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 HybridAudioBrowserSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::audiobrowser::bridge::swift`)
+   * from `AudioBrowser-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.audiobrowser.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridAudioBrowserSpec` Swift protocol.
+   */
+  private var __implementation: any HybridAudioBrowserSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridAudioBrowserSpec_
+
+  /**
+   * Create a new `HybridAudioBrowserSpec_cxx` that wraps the given `HybridAudioBrowserSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridAudioBrowserSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridAudioBrowserSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridAudioBrowserSpec() -> any HybridAudioBrowserSpec {
+    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 `HybridAudioBrowserSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridAudioBrowserSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridAudioBrowserSpec_cxx {
+    return Unmanaged<HybridAudioBrowserSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridAudioBrowserSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridAudioBrowserSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridAudioBrowserSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridAudioBrowserSpec_(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
+  }
+
+  /**
+   * 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 path: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.path {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.path = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var tabs: bridge.std__optional_std__vector_Track__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__vector_Track__ in
+        if let __unwrappedValue = self.__implementation.tabs {
+          return bridge.create_std__optional_std__vector_Track__({ () -> bridge.std__vector_Track_ in
+            var __vector = bridge.create_std__vector_Track_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.tabs = { () -> [Track]? in
+        if bridge.has_value_std__optional_std__vector_Track__(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__vector_Track__(newValue)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onPathChanged: bridge.Func_void_std__string {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__string in
+        let __closureWrapper = Func_void_std__string(self.__implementation.onPathChanged)
+        return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPathChanged = { () -> (String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__string(newValue)
+        return { (__path: String) -> Void in
+          __wrappedFunction.call(std.string(__path))
+        }
+      }()
+    }
+  }
+  
+  public final var onContentChanged: bridge.Func_void_std__optional_ResolvedTrack_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__optional_ResolvedTrack_ in
+        let __closureWrapper = Func_void_std__optional_ResolvedTrack_(self.__implementation.onContentChanged)
+        return bridge.create_Func_void_std__optional_ResolvedTrack_(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onContentChanged = { () -> (ResolvedTrack?) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__optional_ResolvedTrack_(newValue)
+        return { (__content: ResolvedTrack?) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__optional_ResolvedTrack_ in
+            if let __unwrappedValue = __content {
+              return bridge.create_std__optional_ResolvedTrack_(__unwrappedValue)
+            } else {
+              return .init()
+            }
+          }())
+        }
+      }()
+    }
+  }
+  
+  public final var onTabsChanged: bridge.Func_void_std__vector_Track_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__vector_Track_ in
+        let __closureWrapper = Func_void_std__vector_Track_(self.__implementation.onTabsChanged)
+        return bridge.create_Func_void_std__vector_Track_(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onTabsChanged = { () -> ([Track]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_Track_(newValue)
+        return { (__tabs: [Track]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_Track_ in
+            var __vector = bridge.create_std__vector_Track_(__tabs.count)
+            for __item in __tabs {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }()
+    }
+  }
+  
+  public final var onNavigationError: bridge.Func_void_NavigationErrorEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_NavigationErrorEvent in
+        let __closureWrapper = Func_void_NavigationErrorEvent(self.__implementation.onNavigationError)
+        return bridge.create_Func_void_NavigationErrorEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onNavigationError = { () -> (NavigationErrorEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_NavigationErrorEvent(newValue)
+        return { (__data: NavigationErrorEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onFormattedNavigationError: bridge.Func_void_std__optional_FormattedNavigationError_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__optional_FormattedNavigationError_ in
+        let __closureWrapper = Func_void_std__optional_FormattedNavigationError_(self.__implementation.onFormattedNavigationError)
+        return bridge.create_Func_void_std__optional_FormattedNavigationError_(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onFormattedNavigationError = { () -> (FormattedNavigationError?) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__optional_FormattedNavigationError_(newValue)
+        return { (__formattedError: FormattedNavigationError?) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__optional_FormattedNavigationError_ in
+            if let __unwrappedValue = __formattedError {
+              return bridge.create_std__optional_FormattedNavigationError_(__unwrappedValue)
+            } else {
+              return .init()
+            }
+          }())
+        }
+      }()
+    }
+  }
+  
+  public final var configuration: NativeBrowserConfiguration {
+    @inline(__always)
+    get {
+      return self.__implementation.configuration
+    }
+    @inline(__always)
+    set {
+      self.__implementation.configuration = newValue
+    }
+  }
+  
+  public final var onChapterMetadata: bridge.Func_void_std__vector_ChapterMetadata_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__vector_ChapterMetadata_ in
+        let __closureWrapper = Func_void_std__vector_ChapterMetadata_(self.__implementation.onChapterMetadata)
+        return bridge.create_Func_void_std__vector_ChapterMetadata_(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onChapterMetadata = { () -> ([ChapterMetadata]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_ChapterMetadata_(newValue)
+        return { (__chapters: [ChapterMetadata]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_ChapterMetadata_ in
+            var __vector = bridge.create_std__vector_ChapterMetadata_(__chapters.count)
+            for __item in __chapters {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }()
+    }
+  }
+  
+  public final var onTrackMetadata: bridge.Func_void_TrackMetadata {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_TrackMetadata in
+        let __closureWrapper = Func_void_TrackMetadata(self.__implementation.onTrackMetadata)
+        return bridge.create_Func_void_TrackMetadata(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onTrackMetadata = { () -> (TrackMetadata) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_TrackMetadata(newValue)
+        return { (__metadata: TrackMetadata) -> Void in
+          __wrappedFunction.call(__metadata)
+        }
+      }()
+    }
+  }
+  
+  public final var onTimedMetadata: bridge.Func_void_TimedMetadata {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_TimedMetadata in
+        let __closureWrapper = Func_void_TimedMetadata(self.__implementation.onTimedMetadata)
+        return bridge.create_Func_void_TimedMetadata(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onTimedMetadata = { () -> (TimedMetadata) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_TimedMetadata(newValue)
+        return { (__metadata: TimedMetadata) -> Void in
+          __wrappedFunction.call(__metadata)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackActiveTrackChanged: bridge.Func_void_PlaybackActiveTrackChangedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_PlaybackActiveTrackChangedEvent in
+        let __closureWrapper = Func_void_PlaybackActiveTrackChangedEvent(self.__implementation.onPlaybackActiveTrackChanged)
+        return bridge.create_Func_void_PlaybackActiveTrackChangedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackActiveTrackChanged = { () -> (PlaybackActiveTrackChangedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PlaybackActiveTrackChangedEvent(newValue)
+        return { (__data: PlaybackActiveTrackChangedEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackError: bridge.Func_void_PlaybackErrorEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_PlaybackErrorEvent in
+        let __closureWrapper = Func_void_PlaybackErrorEvent(self.__implementation.onPlaybackError)
+        return bridge.create_Func_void_PlaybackErrorEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackError = { () -> (PlaybackErrorEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PlaybackErrorEvent(newValue)
+        return { (__data: PlaybackErrorEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackPlayWhenReadyChanged: bridge.Func_void_PlaybackPlayWhenReadyChangedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_PlaybackPlayWhenReadyChangedEvent in
+        let __closureWrapper = Func_void_PlaybackPlayWhenReadyChangedEvent(self.__implementation.onPlaybackPlayWhenReadyChanged)
+        return bridge.create_Func_void_PlaybackPlayWhenReadyChangedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackPlayWhenReadyChanged = { () -> (PlaybackPlayWhenReadyChangedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PlaybackPlayWhenReadyChangedEvent(newValue)
+        return { (__data: PlaybackPlayWhenReadyChangedEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackPlayingState: bridge.Func_void_PlayingState {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_PlayingState in
+        let __closureWrapper = Func_void_PlayingState(self.__implementation.onPlaybackPlayingState)
+        return bridge.create_Func_void_PlayingState(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackPlayingState = { () -> (PlayingState) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PlayingState(newValue)
+        return { (__data: PlayingState) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackProgressUpdated: bridge.Func_void_PlaybackProgressUpdatedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_PlaybackProgressUpdatedEvent in
+        let __closureWrapper = Func_void_PlaybackProgressUpdatedEvent(self.__implementation.onPlaybackProgressUpdated)
+        return bridge.create_Func_void_PlaybackProgressUpdatedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackProgressUpdated = { () -> (PlaybackProgressUpdatedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PlaybackProgressUpdatedEvent(newValue)
+        return { (__data: PlaybackProgressUpdatedEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackQueueEnded: bridge.Func_void_PlaybackQueueEndedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_PlaybackQueueEndedEvent in
+        let __closureWrapper = Func_void_PlaybackQueueEndedEvent(self.__implementation.onPlaybackQueueEnded)
+        return bridge.create_Func_void_PlaybackQueueEndedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackQueueEnded = { () -> (PlaybackQueueEndedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PlaybackQueueEndedEvent(newValue)
+        return { (__data: PlaybackQueueEndedEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackQueueChanged: bridge.Func_void_std__vector_Track_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__vector_Track_ in
+        let __closureWrapper = Func_void_std__vector_Track_(self.__implementation.onPlaybackQueueChanged)
+        return bridge.create_Func_void_std__vector_Track_(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackQueueChanged = { () -> ([Track]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_Track_(newValue)
+        return { (__queue: [Track]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_Track_ in
+            var __vector = bridge.create_std__vector_Track_(__queue.count)
+            for __item in __queue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackRepeatModeChanged: bridge.Func_void_RepeatModeChangedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RepeatModeChangedEvent in
+        let __closureWrapper = Func_void_RepeatModeChangedEvent(self.__implementation.onPlaybackRepeatModeChanged)
+        return bridge.create_Func_void_RepeatModeChangedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackRepeatModeChanged = { () -> (RepeatModeChangedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RepeatModeChangedEvent(newValue)
+        return { (__data: RepeatModeChangedEvent) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackShuffleModeChanged: bridge.Func_void_bool {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_bool in
+        let __closureWrapper = Func_void_bool(self.__implementation.onPlaybackShuffleModeChanged)
+        return bridge.create_Func_void_bool(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackShuffleModeChanged = { () -> (Bool) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_bool(newValue)
+        return { (__enabled: Bool) -> Void in
+          __wrappedFunction.call(__enabled)
+        }
+      }()
+    }
+  }
+  
+  public final var onSleepTimerChanged: bridge.Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ in
+        let __closureWrapper = Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(self.__implementation.onSleepTimerChanged)
+        return bridge.create_Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onSleepTimerChanged = { () -> (SleepTimer?) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(newValue)
+        return { (__data: SleepTimer?) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ in
+            if let __unwrappedValue = __data {
+              return bridge.create_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__({ () -> bridge.std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_ in
+                switch __unwrappedValue {
+                  case .first(let __value):
+                    return bridge.create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(margelo.nitro.NullType.null)
+                  case .second(let __value):
+                    return bridge.create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(__value)
+                  case .third(let __value):
+                    return bridge.create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(__value)
+                }
+              }().variant)
+            } else {
+              return .init()
+            }
+          }())
+        }
+      }()
+    }
+  }
+  
+  public final var onPlaybackChanged: bridge.Func_void_Playback {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_Playback in
+        let __closureWrapper = Func_void_Playback(self.__implementation.onPlaybackChanged)
+        return bridge.create_Func_void_Playback(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPlaybackChanged = { () -> (Playback) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_Playback(newValue)
+        return { (__data: Playback) -> Void in
+          __wrappedFunction.call(__data)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteBookmark: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemoteBookmark)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteBookmark = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteDislike: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemoteDislike)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteDislike = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteJumpBackward: bridge.Func_void_RemoteJumpBackwardEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemoteJumpBackwardEvent in
+        let __closureWrapper = Func_void_RemoteJumpBackwardEvent(self.__implementation.onRemoteJumpBackward)
+        return bridge.create_Func_void_RemoteJumpBackwardEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteJumpBackward = { () -> (RemoteJumpBackwardEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemoteJumpBackwardEvent(newValue)
+        return { (__event: RemoteJumpBackwardEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteJumpForward: bridge.Func_void_RemoteJumpForwardEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemoteJumpForwardEvent in
+        let __closureWrapper = Func_void_RemoteJumpForwardEvent(self.__implementation.onRemoteJumpForward)
+        return bridge.create_Func_void_RemoteJumpForwardEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteJumpForward = { () -> (RemoteJumpForwardEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemoteJumpForwardEvent(newValue)
+        return { (__event: RemoteJumpForwardEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteLike: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemoteLike)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteLike = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteNext: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemoteNext)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteNext = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemotePause: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemotePause)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemotePause = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemotePlay: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemotePlay)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemotePlay = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemotePlayId: bridge.Func_void_RemotePlayIdEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemotePlayIdEvent in
+        let __closureWrapper = Func_void_RemotePlayIdEvent(self.__implementation.onRemotePlayId)
+        return bridge.create_Func_void_RemotePlayIdEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemotePlayId = { () -> (RemotePlayIdEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemotePlayIdEvent(newValue)
+        return { (__event: RemotePlayIdEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemotePlaySearch: bridge.Func_void_RemotePlaySearchEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemotePlaySearchEvent in
+        let __closureWrapper = Func_void_RemotePlaySearchEvent(self.__implementation.onRemotePlaySearch)
+        return bridge.create_Func_void_RemotePlaySearchEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemotePlaySearch = { () -> (RemotePlaySearchEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemotePlaySearchEvent(newValue)
+        return { (__event: RemotePlaySearchEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemotePrevious: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemotePrevious)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemotePrevious = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteSeek: bridge.Func_void_RemoteSeekEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemoteSeekEvent in
+        let __closureWrapper = Func_void_RemoteSeekEvent(self.__implementation.onRemoteSeek)
+        return bridge.create_Func_void_RemoteSeekEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteSeek = { () -> (RemoteSeekEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemoteSeekEvent(newValue)
+        return { (__event: RemoteSeekEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteSetRating: bridge.Func_void_RemoteSetRatingEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemoteSetRatingEvent in
+        let __closureWrapper = Func_void_RemoteSetRatingEvent(self.__implementation.onRemoteSetRating)
+        return bridge.create_Func_void_RemoteSetRatingEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteSetRating = { () -> (RemoteSetRatingEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemoteSetRatingEvent(newValue)
+        return { (__event: RemoteSetRatingEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteSkip: bridge.Func_void_RemoteSkipEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_RemoteSkipEvent in
+        let __closureWrapper = Func_void_RemoteSkipEvent(self.__implementation.onRemoteSkip)
+        return bridge.create_Func_void_RemoteSkipEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteSkip = { () -> (RemoteSkipEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_RemoteSkipEvent(newValue)
+        return { (__event: RemoteSkipEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onRemoteStop: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onRemoteStop)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRemoteStop = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onOptionsChanged: bridge.Func_void_Options {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_Options in
+        let __closureWrapper = Func_void_Options(self.__implementation.onOptionsChanged)
+        return bridge.create_Func_void_Options(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onOptionsChanged = { () -> (Options) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_Options(newValue)
+        return { (__event: Options) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onFavoriteChanged: bridge.Func_void_FavoriteChangedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_FavoriteChangedEvent in
+        let __closureWrapper = Func_void_FavoriteChangedEvent(self.__implementation.onFavoriteChanged)
+        return bridge.create_Func_void_FavoriteChangedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onFavoriteChanged = { () -> (FavoriteChangedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_FavoriteChangedEvent(newValue)
+        return { (__event: FavoriteChangedEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onNowPlayingChanged: bridge.Func_void_NowPlayingMetadata {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_NowPlayingMetadata in
+        let __closureWrapper = Func_void_NowPlayingMetadata(self.__implementation.onNowPlayingChanged)
+        return bridge.create_Func_void_NowPlayingMetadata(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onNowPlayingChanged = { () -> (NowPlayingMetadata) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_NowPlayingMetadata(newValue)
+        return { (__metadata: NowPlayingMetadata) -> Void in
+          __wrappedFunction.call(__metadata)
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteBookmark: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemoteBookmark {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteBookmark = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteDislike: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemoteDislike {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteDislike = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteJumpBackward: bridge.std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______ in
+        if let __unwrappedValue = self.__implementation.handleRemoteJumpBackward {
+          return bridge.create_std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______({ () -> bridge.Func_void_RemoteJumpBackwardEvent in
+            let __closureWrapper = Func_void_RemoteJumpBackwardEvent(__unwrappedValue)
+            return bridge.create_Func_void_RemoteJumpBackwardEvent(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteJumpBackward = { () -> ((_ event: RemoteJumpBackwardEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______(newValue)
+          return { () -> (RemoteJumpBackwardEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RemoteJumpBackwardEvent(__unwrapped)
+            return { (__event: RemoteJumpBackwardEvent) -> Void in
+              __wrappedFunction.call(__event)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteJumpForward: bridge.std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______ in
+        if let __unwrappedValue = self.__implementation.handleRemoteJumpForward {
+          return bridge.create_std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______({ () -> bridge.Func_void_RemoteJumpForwardEvent in
+            let __closureWrapper = Func_void_RemoteJumpForwardEvent(__unwrappedValue)
+            return bridge.create_Func_void_RemoteJumpForwardEvent(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteJumpForward = { () -> ((_ event: RemoteJumpForwardEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______(newValue)
+          return { () -> (RemoteJumpForwardEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RemoteJumpForwardEvent(__unwrapped)
+            return { (__event: RemoteJumpForwardEvent) -> Void in
+              __wrappedFunction.call(__event)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteLike: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemoteLike {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteLike = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteNext: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemoteNext {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteNext = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemotePause: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemotePause {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemotePause = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemotePlay: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemotePlay {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemotePlay = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemotePlayId: bridge.std__optional_std__function_void_const_RemotePlayIdEvent_____event______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RemotePlayIdEvent_____event______ in
+        if let __unwrappedValue = self.__implementation.handleRemotePlayId {
+          return bridge.create_std__optional_std__function_void_const_RemotePlayIdEvent_____event______({ () -> bridge.Func_void_RemotePlayIdEvent in
+            let __closureWrapper = Func_void_RemotePlayIdEvent(__unwrappedValue)
+            return bridge.create_Func_void_RemotePlayIdEvent(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemotePlayId = { () -> ((_ event: RemotePlayIdEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RemotePlayIdEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RemotePlayIdEvent_____event______(newValue)
+          return { () -> (RemotePlayIdEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RemotePlayIdEvent(__unwrapped)
+            return { (__event: RemotePlayIdEvent) -> Void in
+              __wrappedFunction.call(__event)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemotePlaySearch: bridge.std__optional_std__function_void_const_RemotePlaySearchEvent_____event______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RemotePlaySearchEvent_____event______ in
+        if let __unwrappedValue = self.__implementation.handleRemotePlaySearch {
+          return bridge.create_std__optional_std__function_void_const_RemotePlaySearchEvent_____event______({ () -> bridge.Func_void_RemotePlaySearchEvent in
+            let __closureWrapper = Func_void_RemotePlaySearchEvent(__unwrappedValue)
+            return bridge.create_Func_void_RemotePlaySearchEvent(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemotePlaySearch = { () -> ((_ event: RemotePlaySearchEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RemotePlaySearchEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RemotePlaySearchEvent_____event______(newValue)
+          return { () -> (RemotePlaySearchEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RemotePlaySearchEvent(__unwrapped)
+            return { (__event: RemotePlaySearchEvent) -> Void in
+              __wrappedFunction.call(__event)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemotePrevious: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemotePrevious {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemotePrevious = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteSeek: bridge.std__optional_std__function_void_const_RemoteSeekEvent_____event______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RemoteSeekEvent_____event______ in
+        if let __unwrappedValue = self.__implementation.handleRemoteSeek {
+          return bridge.create_std__optional_std__function_void_const_RemoteSeekEvent_____event______({ () -> bridge.Func_void_RemoteSeekEvent in
+            let __closureWrapper = Func_void_RemoteSeekEvent(__unwrappedValue)
+            return bridge.create_Func_void_RemoteSeekEvent(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteSeek = { () -> ((_ event: RemoteSeekEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RemoteSeekEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RemoteSeekEvent_____event______(newValue)
+          return { () -> (RemoteSeekEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RemoteSeekEvent(__unwrapped)
+            return { (__event: RemoteSeekEvent) -> Void in
+              __wrappedFunction.call(__event)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteSkip: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemoteSkip {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteSkip = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var handleRemoteStop: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.handleRemoteStop {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.handleRemoteStop = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onOnlineChanged: bridge.Func_void_bool {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_bool in
+        let __closureWrapper = Func_void_bool(self.__implementation.onOnlineChanged)
+        return bridge.create_Func_void_bool(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onOnlineChanged = { () -> (Bool) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_bool(newValue)
+        return { (__online: Bool) -> Void in
+          __wrappedFunction.call(__online)
+        }
+      }()
+    }
+  }
+  
+  public final var onSystemVolumeChanged: bridge.Func_void_double {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_double in
+        let __closureWrapper = Func_void_double(self.__implementation.onSystemVolumeChanged)
+        return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onSystemVolumeChanged = { () -> (Double) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_double(newValue)
+        return { (__volume: Double) -> Void in
+          __wrappedFunction.call(__volume)
+        }
+      }()
+    }
+  }
+  
+  public final var onIosOutputChanged: bridge.Func_void_IosOutput {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_IosOutput in
+        let __closureWrapper = Func_void_IosOutput(self.__implementation.onIosOutputChanged)
+        return bridge.create_Func_void_IosOutput(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onIosOutputChanged = { () -> (IosOutput) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_IosOutput(newValue)
+        return { (__output: IosOutput) -> Void in
+          __wrappedFunction.call(__output)
+        }
+      }()
+    }
+  }
+  
+  public final var onEqualizerChanged: bridge.Func_void_EqualizerSettings {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_EqualizerSettings in
+        let __closureWrapper = Func_void_EqualizerSettings(self.__implementation.onEqualizerChanged)
+        return bridge.create_Func_void_EqualizerSettings(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onEqualizerChanged = { () -> (EqualizerSettings) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_EqualizerSettings(newValue)
+        return { (__settings: EqualizerSettings) -> Void in
+          __wrappedFunction.call(__settings)
+        }
+      }()
+    }
+  }
+  
+  public final var onBatteryWarningPendingChanged: bridge.Func_void_BatteryWarningPendingChangedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_BatteryWarningPendingChangedEvent in
+        let __closureWrapper = Func_void_BatteryWarningPendingChangedEvent(self.__implementation.onBatteryWarningPendingChanged)
+        return bridge.create_Func_void_BatteryWarningPendingChangedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onBatteryWarningPendingChanged = { () -> (BatteryWarningPendingChangedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_BatteryWarningPendingChangedEvent(newValue)
+        return { (__event: BatteryWarningPendingChangedEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+  
+  public final var onBatteryOptimizationStatusChanged: bridge.Func_void_BatteryOptimizationStatusChangedEvent {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_BatteryOptimizationStatusChangedEvent in
+        let __closureWrapper = Func_void_BatteryOptimizationStatusChangedEvent(self.__implementation.onBatteryOptimizationStatusChanged)
+        return bridge.create_Func_void_BatteryOptimizationStatusChangedEvent(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onBatteryOptimizationStatusChanged = { () -> (BatteryOptimizationStatusChangedEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_BatteryOptimizationStatusChangedEvent(newValue)
+        return { (__event: BatteryOptimizationStatusChangedEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }()
+    }
+  }
+
+  // Methods
+  @inline(__always)
+  public final func navigatePath(path: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.navigatePath(path: String(path))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func navigateTrack(track: Track) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.navigateTrack(track: track)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func onSearch(query: std.string) -> bridge.Result_std__shared_ptr_Promise_std__vector_Track____ {
+    do {
+      let __result = try self.__implementation.onSearch(query: String(query))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_Track___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_Track___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_Track___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_Track_ in
+              var __vector = bridge.create_std__vector_Track_(__result.count)
+              for __item in __result {
+                __vector.push_back(__item)
+              }
+              return __vector
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_Track____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_Track____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getContent() -> bridge.Result_std__optional_ResolvedTrack__ {
+    do {
+      let __result = try self.__implementation.getContent()
+      let __resultCpp = { () -> bridge.std__optional_ResolvedTrack_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_ResolvedTrack_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_ResolvedTrack__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_ResolvedTrack__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getNavigationError() -> bridge.Result_std__optional_NavigationError__ {
+    do {
+      let __result = try self.__implementation.getNavigationError()
+      let __resultCpp = { () -> bridge.std__optional_NavigationError_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_NavigationError_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_NavigationError__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_NavigationError__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getFormattedNavigationError() -> bridge.Result_std__optional_FormattedNavigationError__ {
+    do {
+      let __result = try self.__implementation.getFormattedNavigationError()
+      let __resultCpp = { () -> bridge.std__optional_FormattedNavigationError_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_FormattedNavigationError_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_FormattedNavigationError__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_FormattedNavigationError__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func notifyContentChanged(path: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.notifyContentChanged(path: String(path))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setFavorites(favorites: bridge.std__vector_std__string_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setFavorites(favorites: favorites.map({ __item in String(__item) }))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setupPlayer(options: PartialSetupPlayerOptions) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.setupPlayer(options: options)
+      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 updateOptions(options: NativeUpdateOptions) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.updateOptions(options: options)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getOptions() -> bridge.Result_UpdateOptions_ {
+    do {
+      let __result = try self.__implementation.getOptions()
+      let __resultCpp = __result
+      return bridge.create_Result_UpdateOptions_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_UpdateOptions_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func load(track: Track) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.load(track: track)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func reset() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.reset()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func play() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.play()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func pause() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.pause()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func togglePlayback() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.togglePlayback()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func stop() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.stop()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setPlayWhenReady(playWhenReady: Bool) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setPlayWhenReady(playWhenReady: playWhenReady)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getPlayWhenReady() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.getPlayWhenReady()
+      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 seekTo(position: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.seekTo(position: position)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func seekBy(offset: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.seekBy(offset: offset)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setVolume(level: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setVolume(level: level)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getVolume() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getVolume()
+      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 setRate(rate: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setRate(rate: rate)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getRate() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getRate()
+      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 getProgress() -> bridge.Result_Progress_ {
+    do {
+      let __result = try self.__implementation.getProgress()
+      let __resultCpp = __result
+      return bridge.create_Result_Progress_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_Progress_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getPlayback() -> bridge.Result_Playback_ {
+    do {
+      let __result = try self.__implementation.getPlayback()
+      let __resultCpp = __result
+      return bridge.create_Result_Playback_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_Playback_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getPlayingState() -> bridge.Result_PlayingState_ {
+    do {
+      let __result = try self.__implementation.getPlayingState()
+      let __resultCpp = __result
+      return bridge.create_Result_PlayingState_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_PlayingState_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getRepeatMode() -> bridge.Result_RepeatMode_ {
+    do {
+      let __result = try self.__implementation.getRepeatMode()
+      let __resultCpp = __result
+      return bridge.create_Result_RepeatMode_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_RepeatMode_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setRepeatMode(mode: Int32) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setRepeatMode(mode: margelo.nitro.audiobrowser.RepeatMode(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 getShuffleEnabled() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.getShuffleEnabled()
+      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 setShuffleEnabled(enabled: Bool) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setShuffleEnabled(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 getPlaybackError() -> bridge.Result_std__optional_PlaybackError__ {
+    do {
+      let __result = try self.__implementation.getPlaybackError()
+      let __resultCpp = { () -> bridge.std__optional_PlaybackError_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_PlaybackError_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_PlaybackError__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_PlaybackError__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func retry() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.retry()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getSleepTimer() -> bridge.Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ {
+    do {
+      let __result = try self.__implementation.getSleepTimer()
+      let __resultCpp = { () -> bridge.std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_ in
+        switch __result {
+          case .first(let __value):
+            return bridge.create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(margelo.nitro.NullType.null)
+          case .second(let __value):
+            return bridge.create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(__value)
+          case .third(let __value):
+            return bridge.create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(__value)
+        }
+      }().variant
+      return bridge.create_Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setSleepTimer(seconds: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setSleepTimer(seconds: seconds)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setSleepTimerToEndOfTrack() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setSleepTimerToEndOfTrack()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearSleepTimer() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.clearSleepTimer()
+      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 add(tracks: bridge.std__vector_Track_, insertBeforeIndex: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.add(tracks: tracks.map({ __item in __item }), insertBeforeIndex: insertBeforeIndex.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func move(fromIndex: Double, toIndex: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.move(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 remove(indexes: bridge.std__vector_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.remove(indexes: indexes.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 removeUpcomingTracks() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removeUpcomingTracks()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func skip(index: Double, initialPosition: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.skip(index: index, initialPosition: initialPosition.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func skipToNext(initialPosition: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.skipToNext(initialPosition: initialPosition.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func skipToPrevious(initialPosition: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.skipToPrevious(initialPosition: initialPosition.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setActiveTrackFavorited(favorited: Bool) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setActiveTrackFavorited(favorited: favorited)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func toggleActiveTrackFavorited() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.toggleActiveTrackFavorited()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setQueue(tracks: bridge.std__vector_Track_, startIndex: bridge.std__optional_double_, startPositionMs: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setQueue(tracks: tracks.map({ __item in __item }), startIndex: startIndex.value, startPositionMs: startPositionMs.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getQueue() -> bridge.Result_std__vector_Track__ {
+    do {
+      let __result = try self.__implementation.getQueue()
+      let __resultCpp = { () -> bridge.std__vector_Track_ in
+        var __vector = bridge.create_std__vector_Track_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_Track__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_Track__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getTrack(index: Double) -> bridge.Result_std__optional_Track__ {
+    do {
+      let __result = try self.__implementation.getTrack(index: index)
+      let __resultCpp = { () -> bridge.std__optional_Track_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_Track_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_Track__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_Track__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getActiveTrackIndex() -> bridge.Result_std__optional_double__ {
+    do {
+      let __result = try self.__implementation.getActiveTrackIndex()
+      let __resultCpp = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_double__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_double__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getActiveTrack() -> bridge.Result_std__optional_Track__ {
+    do {
+      let __result = try self.__implementation.getActiveTrack()
+      let __resultCpp = { () -> bridge.std__optional_Track_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_Track_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_Track__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_Track__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func updateNowPlaying(update: bridge.std__optional_NowPlayingUpdate_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.updateNowPlaying(update: update.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getNowPlaying() -> bridge.Result_std__optional_NowPlayingMetadata__ {
+    do {
+      let __result = try self.__implementation.getNowPlaying()
+      let __resultCpp = { () -> bridge.std__optional_NowPlayingMetadata_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_NowPlayingMetadata_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_NowPlayingMetadata__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_NowPlayingMetadata__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getOnline() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.getOnline()
+      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 getSystemVolume() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getSystemVolume()
+      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 setSystemVolume(volume: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setSystemVolume(volume: volume)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getIosOutput() -> bridge.Result_std__optional_IosOutput__ {
+    do {
+      let __result = try self.__implementation.getIosOutput()
+      let __resultCpp = { () -> bridge.std__optional_IosOutput_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_IosOutput_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_IosOutput__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_IosOutput__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func openIosOutputPicker() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.openIosOutputPicker()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getEqualizerSettings() -> bridge.Result_std__optional_EqualizerSettings__ {
+    do {
+      let __result = try self.__implementation.getEqualizerSettings()
+      let __resultCpp = { () -> bridge.std__optional_EqualizerSettings_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_EqualizerSettings_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_EqualizerSettings__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_EqualizerSettings__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setEqualizerEnabled(enabled: Bool) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setEqualizerEnabled(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 setEqualizerPreset(preset: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setEqualizerPreset(preset: String(preset))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setEqualizerLevels(levels: bridge.std__vector_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setEqualizerLevels(levels: levels.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 getBatteryWarningPending() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.getBatteryWarningPending()
+      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 getBatteryOptimizationStatus() -> bridge.Result_BatteryOptimizationStatus_ {
+    do {
+      let __result = try self.__implementation.getBatteryOptimizationStatus()
+      let __resultCpp = __result
+      return bridge.create_Result_BatteryOptimizationStatus_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_BatteryOptimizationStatus_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func dismissBatteryWarning() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.dismissBatteryWarning()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func openBatterySettings() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.openBatterySettings()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+}