react-native-nitro-player 0.6.1 → 0.7.1-alpha.0

package/nitrogen/generated/ios/swift/HybridEqualizerSpec_cxx.swift

@@ -125,14 +125,21 @@ open class HybridEqualizerSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func setEnabled(enabled: Bool) -> bridge.Result_bool_ {
+  public final func setEnabled(enabled: Bool) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.setEnabled(enabled: enabled)
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
+      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_bool_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
@@ -149,44 +156,65 @@ open class HybridEqualizerSpec_cxx {
   }
   
   @inline(__always)
-  public final func getBands() -> bridge.Result_std__vector_EqualizerBand__ {
+  public final func getBands() -> bridge.Result_std__shared_ptr_Promise_std__vector_EqualizerBand____ {
     do {
       let __result = try self.__implementation.getBands()
-      let __resultCpp = { () -> bridge.std__vector_EqualizerBand_ in
-        var __vector = bridge.create_std__vector_EqualizerBand_(__result.count)
-        for __item in __result {
-          __vector.push_back(__item)
-        }
-        return __vector
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_EqualizerBand___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_EqualizerBand___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_EqualizerBand___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_EqualizerBand_ in
+              var __vector = bridge.create_std__vector_EqualizerBand_(__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__vector_EqualizerBand__(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_EqualizerBand____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__vector_EqualizerBand__(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_EqualizerBand____(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func setBandGain(bandIndex: Double, gainDb: Double) -> bridge.Result_bool_ {
+  public final func setBandGain(bandIndex: Double, gainDb: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.setBandGain(bandIndex: bandIndex, gainDb: gainDb)
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
+      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_bool_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func setAllBandGains(gains: bridge.std__vector_double_) -> bridge.Result_bool_ {
+  public final func setAllBandGains(gains: bridge.std__vector_double_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.setAllBandGains(gains: gains.map({ __item in __item }))
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
+      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_bool_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
@@ -257,14 +285,21 @@ open class HybridEqualizerSpec_cxx {
   }
   
   @inline(__always)
-  public final func applyPreset(presetName: std.string) -> bridge.Result_bool_ {
+  public final func applyPreset(presetName: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.applyPreset(presetName: String(presetName))
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
+      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_bool_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
@@ -288,49 +323,78 @@ open class HybridEqualizerSpec_cxx {
   }
   
   @inline(__always)
-  public final func saveCustomPreset(name: std.string) -> bridge.Result_bool_ {
+  public final func saveCustomPreset(name: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.saveCustomPreset(name: String(name))
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
+      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_bool_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func deleteCustomPreset(name: std.string) -> bridge.Result_bool_ {
+  public final func deleteCustomPreset(name: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.deleteCustomPreset(name: String(name))
-      let __resultCpp = __result
-      return bridge.create_Result_bool_(__resultCpp)
+      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_bool_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getState() -> bridge.Result_EqualizerState_ {
+  public final func getState() -> bridge.Result_std__shared_ptr_Promise_EqualizerState___ {
     do {
       let __result = try self.__implementation.getState()
-      let __resultCpp = __result
-      return bridge.create_Result_EqualizerState_(__resultCpp)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_EqualizerState__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_EqualizerState__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_EqualizerState__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_EqualizerState___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_EqualizerState_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_EqualizerState___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func reset() -> bridge.Result_void_ {
+  public final func reset() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.reset()
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.reset()
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/HybridPlayerQueueSpec.swift

@@ -13,16 +13,16 @@ public protocol HybridPlayerQueueSpec_protocol: HybridObject {
   
 
   // Methods
-  func createPlaylist(name: String, description: String?, artwork: String?) throws -> String
-  func deletePlaylist(playlistId: String) throws -> Void
-  func updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?) throws -> Void
+  func createPlaylist(name: String, description: String?, artwork: String?) throws -> Promise<String>
+  func deletePlaylist(playlistId: String) throws -> Promise<Void>
+  func updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?) throws -> Promise<Void>
   func getPlaylist(playlistId: String) throws -> Variant_NullType_Playlist
   func getAllPlaylists() throws -> [Playlist]
-  func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?) throws -> Void
-  func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws -> Void
-  func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Void
-  func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Void
-  func loadPlaylist(playlistId: String) throws -> Void
+  func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?) throws -> Promise<Void>
+  func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws -> Promise<Void>
+  func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Promise<Void>
+  func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Promise<Void>
+  func loadPlaylist(playlistId: String) throws -> Promise<Void>
   func getCurrentPlaylistId() throws -> Variant_NullType_String
   func onPlaylistsChanged(callback: @escaping (_ playlists: [Playlist], _ operation: QueueOperation?) -> Void) throws -> Void
   func onPlaylistChanged(callback: @escaping (_ playlistId: String, _ playlist: Playlist, _ operation: QueueOperation?) -> Void) throws -> Void

package/nitrogen/generated/ios/swift/HybridPlayerQueueSpec_cxx.swift

@@ -125,7 +125,7 @@ open class HybridPlayerQueueSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func createPlaylist(name: std.string, description: bridge.std__optional_std__string_, artwork: bridge.std__optional_std__string_) -> bridge.Result_std__string_ {
+  public final func createPlaylist(name: std.string, description: bridge.std__optional_std__string_, artwork: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
     do {
       let __result = try self.__implementation.createPlaylist(name: String(name), description: { () -> String? in
         if bridge.has_value_std__optional_std__string_(description) {
@@ -142,29 +142,44 @@ open class HybridPlayerQueueSpec_cxx {
           return nil
         }
       }())
-      let __resultCpp = std.string(__result)
-      return bridge.create_Result_std__string_(__resultCpp)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__string_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func deletePlaylist(playlistId: std.string) -> bridge.Result_void_ {
+  public final func deletePlaylist(playlistId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.deletePlaylist(playlistId: String(playlistId))
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.deletePlaylist(playlistId: String(playlistId))
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func updatePlaylist(playlistId: std.string, name: bridge.std__optional_std__string_, description: bridge.std__optional_std__string_, artwork: bridge.std__optional_std__string_) -> bridge.Result_void_ {
+  public final func updatePlaylist(playlistId: std.string, name: bridge.std__optional_std__string_, description: bridge.std__optional_std__string_, artwork: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.updatePlaylist(playlistId: String(playlistId), name: { () -> String? in
+      let __result = try self.__implementation.updatePlaylist(playlistId: String(playlistId), name: { () -> String? in
         if bridge.has_value_std__optional_std__string_(name) {
           let __unwrapped = bridge.get_std__optional_std__string_(name)
           return String(__unwrapped)
@@ -186,10 +201,18 @@ open class HybridPlayerQueueSpec_cxx {
           return nil
         }
       }())
-      return bridge.create_Result_void_()
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
@@ -231,9 +254,9 @@ open class HybridPlayerQueueSpec_cxx {
   }
   
   @inline(__always)
-  public final func addTrackToPlaylist(playlistId: std.string, track: TrackItem, index: bridge.std__optional_double_) -> bridge.Result_void_ {
+  public final func addTrackToPlaylist(playlistId: std.string, track: TrackItem, index: bridge.std__optional_double_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.addTrackToPlaylist(playlistId: String(playlistId), track: track, index: { () -> Double? in
+      let __result = try self.__implementation.addTrackToPlaylist(playlistId: String(playlistId), track: track, index: { () -> Double? in
         if bridge.has_value_std__optional_double_(index) {
           let __unwrapped = bridge.get_std__optional_double_(index)
           return __unwrapped
@@ -241,17 +264,25 @@ open class HybridPlayerQueueSpec_cxx {
           return nil
         }
       }())
-      return bridge.create_Result_void_()
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func addTracksToPlaylist(playlistId: std.string, tracks: bridge.std__vector_TrackItem_, index: bridge.std__optional_double_) -> bridge.Result_void_ {
+  public final func addTracksToPlaylist(playlistId: std.string, tracks: bridge.std__vector_TrackItem_, index: bridge.std__optional_double_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.addTracksToPlaylist(playlistId: String(playlistId), tracks: tracks.map({ __item in __item }), index: { () -> Double? in
+      let __result = try self.__implementation.addTracksToPlaylist(playlistId: String(playlistId), tracks: tracks.map({ __item in __item }), index: { () -> Double? in
         if bridge.has_value_std__optional_double_(index) {
           let __unwrapped = bridge.get_std__optional_double_(index)
           return __unwrapped
@@ -259,43 +290,75 @@ open class HybridPlayerQueueSpec_cxx {
           return nil
         }
       }())
-      return bridge.create_Result_void_()
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func removeTrackFromPlaylist(playlistId: std.string, trackId: std.string) -> bridge.Result_void_ {
+  public final func removeTrackFromPlaylist(playlistId: std.string, trackId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.removeTrackFromPlaylist(playlistId: String(playlistId), trackId: String(trackId))
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.removeTrackFromPlaylist(playlistId: String(playlistId), trackId: String(trackId))
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func reorderTrackInPlaylist(playlistId: std.string, trackId: std.string, newIndex: Double) -> bridge.Result_void_ {
+  public final func reorderTrackInPlaylist(playlistId: std.string, trackId: std.string, newIndex: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.reorderTrackInPlaylist(playlistId: String(playlistId), trackId: String(trackId), newIndex: newIndex)
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.reorderTrackInPlaylist(playlistId: String(playlistId), trackId: String(trackId), newIndex: newIndex)
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func loadPlaylist(playlistId: std.string) -> bridge.Result_void_ {
+  public final func loadPlaylist(playlistId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.loadPlaylist(playlistId: String(playlistId))
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.loadPlaylist(playlistId: String(playlistId))
+      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_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -13,27 +13,27 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   
 
   // Methods
-  func play() throws -> Void
-  func pause() throws -> Void
+  func play() throws -> Promise<Void>
+  func pause() throws -> Promise<Void>
   func playSong(songId: String, fromPlaylist: String?) throws -> Promise<Void>
-  func skipToNext() throws -> Void
+  func skipToNext() throws -> Promise<Void>
   func skipToIndex(index: Double) throws -> Promise<Bool>
-  func skipToPrevious() throws -> Void
-  func seek(position: Double) throws -> Void
+  func skipToPrevious() throws -> Promise<Void>
+  func seek(position: Double) throws -> Promise<Void>
   func addToUpNext(trackId: String) throws -> Promise<Void>
   func playNext(trackId: String) throws -> Promise<Void>
   func getActualQueue() throws -> Promise<[TrackItem]>
   func getState() throws -> Promise<PlayerState>
-  func setRepeatMode(mode: RepeatMode) throws -> Bool
+  func setRepeatMode(mode: RepeatMode) throws -> Promise<Void>
   func getRepeatMode() throws -> RepeatMode
-  func configure(config: PlayerConfig) throws -> Void
+  func configure(config: PlayerConfig) throws -> Promise<Void>
   func onChangeTrack(callback: @escaping (_ track: TrackItem, _ reason: Reason?) -> Void) throws -> Void
   func onPlaybackStateChange(callback: @escaping (_ state: TrackPlayerState, _ reason: Reason?) -> Void) throws -> Void
   func onSeek(callback: @escaping (_ position: Double, _ totalDuration: Double) -> Void) throws -> Void
   func onPlaybackProgressChange(callback: @escaping (_ position: Double, _ totalDuration: Double, _ isManuallySeeked: Bool?) -> Void) throws -> Void
   func onAndroidAutoConnectionChange(callback: @escaping (_ connected: Bool) -> Void) throws -> Void
   func isAndroidAutoConnected() throws -> Bool
-  func setVolume(volume: Double) throws -> Bool
+  func setVolume(volume: Double) throws -> Promise<Void>
   func updateTracks(tracks: [TrackItem]) throws -> Promise<Void>
   func getTracksById(trackIds: [String]) throws -> Promise<[TrackItem]>
   func getTracksNeedingUrls() throws -> Promise<[TrackItem]>
@@ -42,6 +42,14 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func onTracksNeedUpdate(callback: @escaping (_ tracks: [TrackItem], _ lookahead: Double) -> Void) throws -> Void
   func setPlaybackSpeed(speed: Double) throws -> Promise<Void>
   func getPlaybackSpeed() throws -> Promise<Double>
+  func removeFromPlayNext(trackId: String) throws -> Promise<Bool>
+  func removeFromUpNext(trackId: String) throws -> Promise<Bool>
+  func clearPlayNext() throws -> Promise<Void>
+  func clearUpNext() throws -> Promise<Void>
+  func reorderTemporaryTrack(trackId: String, newIndex: Double) throws -> Promise<Bool>
+  func getPlayNextQueue() throws -> Promise<[TrackItem]>
+  func getUpNextQueue() throws -> Promise<[TrackItem]>
+  func onTemporaryQueueChange(callback: @escaping (_ playNextQueue: [TrackItem], _ upNextQueue: [TrackItem]) -> Void) throws -> Void
 }
 
 public extension HybridTrackPlayerSpec_protocol {