react-native-nitro-player 0.7.0 → 0.7.1-alpha.1

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -125,24 +125,40 @@ open class HybridTrackPlayerSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func play() -> bridge.Result_void_ {
+  public final func play() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.play()
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.play()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func pause() -> bridge.Result_void_ {
+  public final func pause() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.pause()
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.pause()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
@@ -173,13 +189,21 @@ open class HybridTrackPlayerSpec_cxx {
   }
   
   @inline(__always)
-  public final func skipToNext() -> bridge.Result_void_ {
+  public final func skipToNext() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.skipToNext()
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.skipToNext()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
@@ -203,24 +227,40 @@ open class HybridTrackPlayerSpec_cxx {
   }
   
   @inline(__always)
-  public final func skipToPrevious() -> bridge.Result_void_ {
+  public final func skipToPrevious() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.skipToPrevious()
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.skipToPrevious()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func seek(position: Double) -> bridge.Result_void_ {
+  public final func seek(position: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.seek(position: position)
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.seek(position: position)
+      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)
     }
   }
   
@@ -307,14 +347,21 @@ open class HybridTrackPlayerSpec_cxx {
   }
   
   @inline(__always)
-  public final func setRepeatMode(mode: Int32) -> bridge.Result_bool_ {
+  public final func setRepeatMode(mode: Int32) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.setRepeatMode(mode: margelo.nitro.nitroplayer.RepeatMode(rawValue: mode)!)
-      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)
     }
   }
   
@@ -331,13 +378,21 @@ open class HybridTrackPlayerSpec_cxx {
   }
   
   @inline(__always)
-  public final func configure(config: PlayerConfig) -> bridge.Result_void_ {
+  public final func configure(config: PlayerConfig) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.configure(config: config)
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.configure(config: config)
+      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)
     }
   }
   
@@ -452,14 +507,21 @@ open class HybridTrackPlayerSpec_cxx {
   }
   
   @inline(__always)
-  public final func setVolume(volume: Double) -> bridge.Result_bool_ {
+  public final func setVolume(volume: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.setVolume(volume: volume)
-      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)
     }
   }
   
@@ -635,4 +697,177 @@ open class HybridTrackPlayerSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func removeFromPlayNext(trackId: std.string) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.removeFromPlayNext(trackId: String(trackId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__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_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removeFromUpNext(trackId: std.string) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.removeFromUpNext(trackId: String(trackId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__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_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearPlayNext() -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.clearPlayNext()
+      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 clearUpNext() -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.clearUpNext()
+      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 reorderTemporaryTrack(trackId: std.string, newIndex: Double) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.reorderTemporaryTrack(trackId: String(trackId), newIndex: newIndex)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__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_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getPlayNextQueue() -> bridge.Result_std__shared_ptr_Promise_std__vector_TrackItem____ {
+    do {
+      let __result = try self.__implementation.getPlayNextQueue()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_TrackItem___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_TrackItem___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_TrackItem___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_TrackItem_ in
+              var __vector = bridge.create_std__vector_TrackItem_(__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_TrackItem____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getUpNextQueue() -> bridge.Result_std__shared_ptr_Promise_std__vector_TrackItem____ {
+    do {
+      let __result = try self.__implementation.getUpNextQueue()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_TrackItem___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_TrackItem___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_TrackItem___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_TrackItem_ in
+              var __vector = bridge.create_std__vector_TrackItem_(__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_TrackItem____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func onTemporaryQueueChange(callback: bridge.Func_void_std__vector_TrackItem__std__vector_TrackItem_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.onTemporaryQueueChange(callback: { () -> ([TrackItem], [TrackItem]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_TrackItem__std__vector_TrackItem_(callback)
+        return { (__playNextQueue: [TrackItem], __upNextQueue: [TrackItem]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_TrackItem_ in
+            var __vector = bridge.create_std__vector_TrackItem_(__playNextQueue.count)
+            for __item in __playNextQueue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }(), { () -> bridge.std__vector_TrackItem_ in
+            var __vector = bridge.create_std__vector_TrackItem_(__upNextQueue.count)
+            for __item in __upNextQueue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/shared/c++/HybridAndroidAutoMediaLibrarySpec.hpp

@@ -15,6 +15,7 @@
 
 
 
+#include <NitroModules/Promise.hpp>
 #include <string>
 
 namespace margelo::nitro::nitroplayer {
@@ -48,8 +49,8 @@ namespace margelo::nitro::nitroplayer {
 
     public:
       // Methods
-      virtual void setMediaLibrary(const std::string& libraryJson) = 0;
-      virtual void clearMediaLibrary() = 0;
+      virtual std::shared_ptr<Promise<void>> setMediaLibrary(const std::string& libraryJson) = 0;
+      virtual std::shared_ptr<Promise<void>> clearMediaLibrary() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridAudioDevicesSpec.hpp

@@ -18,6 +18,7 @@ namespace margelo::nitro::nitroplayer { struct TAudioDevice; }
 
 #include "TAudioDevice.hpp"
 #include <vector>
+#include <NitroModules/Promise.hpp>
 
 namespace margelo::nitro::nitroplayer {
 
@@ -51,7 +52,7 @@ namespace margelo::nitro::nitroplayer {
     public:
       // Methods
       virtual std::vector<TAudioDevice> getAudioDevices() = 0;
-      virtual bool setAudioDevice(double deviceId) = 0;
+      virtual std::shared_ptr<Promise<void>> setAudioDevice(double deviceId) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridDownloadManagerSpec.hpp

@@ -102,22 +102,22 @@ namespace margelo::nitro::nitroplayer {
       virtual DownloadQueueStatus getQueueStatus() = 0;
       virtual bool isDownloading(const std::string& trackId) = 0;
       virtual DownloadState getDownloadState(const std::string& trackId) = 0;
-      virtual bool isTrackDownloaded(const std::string& trackId) = 0;
-      virtual bool isPlaylistDownloaded(const std::string& playlistId) = 0;
-      virtual bool isPlaylistPartiallyDownloaded(const std::string& playlistId) = 0;
-      virtual std::variant<nitro::NullType, DownloadedTrack> getDownloadedTrack(const std::string& trackId) = 0;
-      virtual std::vector<DownloadedTrack> getAllDownloadedTracks() = 0;
-      virtual std::variant<nitro::NullType, DownloadedPlaylist> getDownloadedPlaylist(const std::string& playlistId) = 0;
-      virtual std::vector<DownloadedPlaylist> getAllDownloadedPlaylists() = 0;
-      virtual std::variant<nitro::NullType, std::string> getLocalPath(const std::string& trackId) = 0;
+      virtual std::shared_ptr<Promise<bool>> isTrackDownloaded(const std::string& trackId) = 0;
+      virtual std::shared_ptr<Promise<bool>> isPlaylistDownloaded(const std::string& playlistId) = 0;
+      virtual std::shared_ptr<Promise<bool>> isPlaylistPartiallyDownloaded(const std::string& playlistId) = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, DownloadedTrack>>> getDownloadedTrack(const std::string& trackId) = 0;
+      virtual std::shared_ptr<Promise<std::vector<DownloadedTrack>>> getAllDownloadedTracks() = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, DownloadedPlaylist>>> getDownloadedPlaylist(const std::string& playlistId) = 0;
+      virtual std::shared_ptr<Promise<std::vector<DownloadedPlaylist>>> getAllDownloadedPlaylists() = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getLocalPath(const std::string& trackId) = 0;
       virtual std::shared_ptr<Promise<void>> deleteDownloadedTrack(const std::string& trackId) = 0;
       virtual std::shared_ptr<Promise<void>> deleteDownloadedPlaylist(const std::string& playlistId) = 0;
       virtual std::shared_ptr<Promise<void>> deleteAllDownloads() = 0;
       virtual std::shared_ptr<Promise<DownloadStorageInfo>> getStorageInfo() = 0;
-      virtual double syncDownloads() = 0;
+      virtual std::shared_ptr<Promise<double>> syncDownloads() = 0;
       virtual void setPlaybackSourcePreference(PlaybackSource preference) = 0;
       virtual PlaybackSource getPlaybackSourcePreference() = 0;
-      virtual std::string getEffectiveUrl(const TrackItem& track) = 0;
+      virtual std::shared_ptr<Promise<std::string>> getEffectiveUrl(const TrackItem& track) = 0;
       virtual void onDownloadProgress(const std::function<void(const DownloadProgress& /* progress */)>& callback) = 0;
       virtual void onDownloadStateChange(const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& callback) = 0;
       virtual void onDownloadComplete(const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& callback) = 0;

package/nitrogen/generated/shared/c++/HybridEqualizerSpec.hpp

@@ -22,6 +22,7 @@ namespace margelo::nitro::nitroplayer { struct EqualizerPreset; }
 // Forward declaration of `EqualizerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct EqualizerState; }
 
+#include <NitroModules/Promise.hpp>
 #include "EqualizerBand.hpp"
 #include <vector>
 #include "GainRange.hpp"
@@ -64,21 +65,21 @@ namespace margelo::nitro::nitroplayer {
 
     public:
       // Methods
-      virtual bool setEnabled(bool enabled) = 0;
+      virtual std::shared_ptr<Promise<void>> setEnabled(bool enabled) = 0;
       virtual bool isEnabled() = 0;
-      virtual std::vector<EqualizerBand> getBands() = 0;
-      virtual bool setBandGain(double bandIndex, double gainDb) = 0;
-      virtual bool setAllBandGains(const std::vector<double>& gains) = 0;
+      virtual std::shared_ptr<Promise<std::vector<EqualizerBand>>> getBands() = 0;
+      virtual std::shared_ptr<Promise<void>> setBandGain(double bandIndex, double gainDb) = 0;
+      virtual std::shared_ptr<Promise<void>> setAllBandGains(const std::vector<double>& gains) = 0;
       virtual GainRange getBandRange() = 0;
       virtual std::vector<EqualizerPreset> getPresets() = 0;
       virtual std::vector<EqualizerPreset> getBuiltInPresets() = 0;
       virtual std::vector<EqualizerPreset> getCustomPresets() = 0;
-      virtual bool applyPreset(const std::string& presetName) = 0;
+      virtual std::shared_ptr<Promise<void>> applyPreset(const std::string& presetName) = 0;
       virtual std::variant<nitro::NullType, std::string> getCurrentPresetName() = 0;
-      virtual bool saveCustomPreset(const std::string& name) = 0;
-      virtual bool deleteCustomPreset(const std::string& name) = 0;
-      virtual EqualizerState getState() = 0;
-      virtual void reset() = 0;
+      virtual std::shared_ptr<Promise<void>> saveCustomPreset(const std::string& name) = 0;
+      virtual std::shared_ptr<Promise<void>> deleteCustomPreset(const std::string& name) = 0;
+      virtual std::shared_ptr<Promise<EqualizerState>> getState() = 0;
+      virtual std::shared_ptr<Promise<void>> reset() = 0;
       virtual void onEnabledChange(const std::function<void(bool /* enabled */)>& callback) = 0;
       virtual void onBandChange(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& callback) = 0;
       virtual void onPresetChange(const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& callback) = 0;

package/nitrogen/generated/shared/c++/HybridPlayerQueueSpec.hpp

@@ -21,6 +21,7 @@ namespace margelo::nitro::nitroplayer { struct TrackItem; }
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 
 #include <string>
+#include <NitroModules/Promise.hpp>
 #include <optional>
 #include <NitroModules/Null.hpp>
 #include "Playlist.hpp"
@@ -61,16 +62,16 @@ namespace margelo::nitro::nitroplayer {
 
     public:
       // Methods
-      virtual std::string createPlaylist(const std::string& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) = 0;
-      virtual void deletePlaylist(const std::string& playlistId) = 0;
-      virtual void updatePlaylist(const std::string& playlistId, const std::optional<std::string>& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) = 0;
+      virtual std::shared_ptr<Promise<std::string>> createPlaylist(const std::string& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) = 0;
+      virtual std::shared_ptr<Promise<void>> deletePlaylist(const std::string& playlistId) = 0;
+      virtual std::shared_ptr<Promise<void>> updatePlaylist(const std::string& playlistId, const std::optional<std::string>& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) = 0;
       virtual std::variant<nitro::NullType, Playlist> getPlaylist(const std::string& playlistId) = 0;
       virtual std::vector<Playlist> getAllPlaylists() = 0;
-      virtual void addTrackToPlaylist(const std::string& playlistId, const TrackItem& track, std::optional<double> index) = 0;
-      virtual void addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) = 0;
-      virtual void removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) = 0;
-      virtual void reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) = 0;
-      virtual void loadPlaylist(const std::string& playlistId) = 0;
+      virtual std::shared_ptr<Promise<void>> addTrackToPlaylist(const std::string& playlistId, const TrackItem& track, std::optional<double> index) = 0;
+      virtual std::shared_ptr<Promise<void>> addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) = 0;
+      virtual std::shared_ptr<Promise<void>> removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) = 0;
+      virtual std::shared_ptr<Promise<void>> reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) = 0;
+      virtual std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId) = 0;
       virtual std::variant<nitro::NullType, std::string> getCurrentPlaylistId() = 0;
       virtual void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) = 0;
       virtual void onPlaylistChanged(const std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>& callback) = 0;

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp

@@ -43,6 +43,14 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("onTracksNeedUpdate", &HybridTrackPlayerSpec::onTracksNeedUpdate);
       prototype.registerHybridMethod("setPlaybackSpeed", &HybridTrackPlayerSpec::setPlaybackSpeed);
       prototype.registerHybridMethod("getPlaybackSpeed", &HybridTrackPlayerSpec::getPlaybackSpeed);
+      prototype.registerHybridMethod("removeFromPlayNext", &HybridTrackPlayerSpec::removeFromPlayNext);
+      prototype.registerHybridMethod("removeFromUpNext", &HybridTrackPlayerSpec::removeFromUpNext);
+      prototype.registerHybridMethod("clearPlayNext", &HybridTrackPlayerSpec::clearPlayNext);
+      prototype.registerHybridMethod("clearUpNext", &HybridTrackPlayerSpec::clearUpNext);
+      prototype.registerHybridMethod("reorderTemporaryTrack", &HybridTrackPlayerSpec::reorderTemporaryTrack);
+      prototype.registerHybridMethod("getPlayNextQueue", &HybridTrackPlayerSpec::getPlayNextQueue);
+      prototype.registerHybridMethod("getUpNextQueue", &HybridTrackPlayerSpec::getUpNextQueue);
+      prototype.registerHybridMethod("onTemporaryQueueChange", &HybridTrackPlayerSpec::onTemporaryQueueChange);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.hpp

@@ -69,27 +69,27 @@ namespace margelo::nitro::nitroplayer {
 
     public:
       // Methods
-      virtual void play() = 0;
-      virtual void pause() = 0;
+      virtual std::shared_ptr<Promise<void>> play() = 0;
+      virtual std::shared_ptr<Promise<void>> pause() = 0;
       virtual std::shared_ptr<Promise<void>> playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) = 0;
-      virtual void skipToNext() = 0;
+      virtual std::shared_ptr<Promise<void>> skipToNext() = 0;
       virtual std::shared_ptr<Promise<bool>> skipToIndex(double index) = 0;
-      virtual void skipToPrevious() = 0;
-      virtual void seek(double position) = 0;
+      virtual std::shared_ptr<Promise<void>> skipToPrevious() = 0;
+      virtual std::shared_ptr<Promise<void>> seek(double position) = 0;
       virtual std::shared_ptr<Promise<void>> addToUpNext(const std::string& trackId) = 0;
       virtual std::shared_ptr<Promise<void>> playNext(const std::string& trackId) = 0;
       virtual std::shared_ptr<Promise<std::vector<TrackItem>>> getActualQueue() = 0;
       virtual std::shared_ptr<Promise<PlayerState>> getState() = 0;
-      virtual bool setRepeatMode(RepeatMode mode) = 0;
+      virtual std::shared_ptr<Promise<void>> setRepeatMode(RepeatMode mode) = 0;
       virtual RepeatMode getRepeatMode() = 0;
-      virtual void configure(const PlayerConfig& config) = 0;
+      virtual std::shared_ptr<Promise<void>> configure(const PlayerConfig& config) = 0;
       virtual void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) = 0;
       virtual void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) = 0;
       virtual void onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) = 0;
       virtual void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) = 0;
       virtual void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) = 0;
       virtual bool isAndroidAutoConnected() = 0;
-      virtual bool setVolume(double volume) = 0;
+      virtual std::shared_ptr<Promise<void>> setVolume(double volume) = 0;
       virtual std::shared_ptr<Promise<void>> updateTracks(const std::vector<TrackItem>& tracks) = 0;
       virtual std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksById(const std::vector<std::string>& trackIds) = 0;
       virtual std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksNeedingUrls() = 0;
@@ -98,6 +98,14 @@ namespace margelo::nitro::nitroplayer {
       virtual void onTracksNeedUpdate(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& callback) = 0;
       virtual std::shared_ptr<Promise<void>> setPlaybackSpeed(double speed) = 0;
       virtual std::shared_ptr<Promise<double>> getPlaybackSpeed() = 0;
+      virtual std::shared_ptr<Promise<bool>> removeFromPlayNext(const std::string& trackId) = 0;
+      virtual std::shared_ptr<Promise<bool>> removeFromUpNext(const std::string& trackId) = 0;
+      virtual std::shared_ptr<Promise<void>> clearPlayNext() = 0;
+      virtual std::shared_ptr<Promise<void>> clearUpNext() = 0;
+      virtual std::shared_ptr<Promise<bool>> reorderTemporaryTrack(const std::string& trackId, double newIndex) = 0;
+      virtual std::shared_ptr<Promise<std::vector<TrackItem>>> getPlayNextQueue() = 0;
+      virtual std::shared_ptr<Promise<std::vector<TrackItem>>> getUpNextQueue() = 0;
+      virtual void onTemporaryQueueChange(const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& callback) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.7.0",
+  "version": "0.7.1-alpha.1",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",
@@ -57,18 +57,18 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@react-native/eslint-config": "0.82.0",
+    "@react-native/eslint-config": "0.85.0-rc.6",
     "@release-it-plugins/workspaces": "^5.0.3",
     "@release-it/bumper": "^7.0.5",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/react": "^19.1.03",
+    "@types/react": "^19.2.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "nitrogen": "^0.35.2",
     "prettier": "^3.3.3",
-    "react": "19.1.1",
-    "react-native": "0.82.0",
+    "react": "19.2.3",
+    "react-native": "0.85.0-rc.6",
     "react-native-nitro-modules": "^0.35.2",
     "release-it": "^19.0.4",
     "typescript": "^5.8.3"