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

package/ios/playlist/PlaylistManager.swift

@@ -268,9 +268,6 @@ class PlaylistManager {
 
     currentPlaylistId = playlistId
 
-    // Update TrackPlayerCore
-    TrackPlayerCore.shared.loadPlaylist(playlistId: playlistId)
-
     return true
   }
 
@@ -399,9 +396,7 @@ class PlaylistManager {
     let (allPlaylists, currentListeners) = queue.sync {
       (Array(playlists.values), listeners)
     }
-    DispatchQueue.main.async {
-      currentListeners.forEach { $0.1(allPlaylists, operation) }
-    }
+    currentListeners.forEach { $0.1(allPlaylists, operation) }
   }
 
   private func notifyPlaylistChanged(_ playlistId: String, _ operation: QueueOperation?) {
@@ -413,9 +408,7 @@ class PlaylistManager {
 
     guard let (playlist, currentListeners) = result else { return }
 
-    DispatchQueue.main.async {
-      currentListeners.forEach { $0.1(playlist, operation) }
-    }
+    currentListeners.forEach { $0.1(playlist, operation) }
   }
 
   private func scheduleSave() {

package/ios/queue/HybridPlayerQueue.swift

@@ -9,109 +9,112 @@ import NitroModules
 
 final class HybridPlayerQueue: HybridPlayerQueueSpec {
   private let playlistManager = PlaylistManager.shared
+  private let core = TrackPlayerCore.shared
 
-  // Static storage for callbacks to ensure they persist across HybridPlayerQueue instances
-  private static var playlistsChangeCallbacks: [([Playlist], QueueOperation?) -> Void] = []
-  private static var playlistChangeCallbacks: [(String, Playlist, QueueOperation?) -> Void] = []
-  private static var isPlaylistsListenerRegistered = false
-  private static var playlistListenerIds: Set<String> = []
+  // Per-instance listener removers (no static storage)
+  private var playlistsChangeRemover: (() -> Void)?
+  private var playlistChangeRemovers: [() -> Void] = []
 
-  func createPlaylist(name: String, description: String?, artwork: String?) throws -> String {
-    return playlistManager.createPlaylist(name: name, description: description, artwork: artwork)
+  // MARK: - Playlist CRUD
+
+  func createPlaylist(name: String, description: String?, artwork: String?) throws -> Promise<String> {
+    Promise.async { self.playlistManager.createPlaylist(name: name, description: description, artwork: artwork) }
   }
 
-  func deletePlaylist(playlistId: String) throws {
-    _ = playlistManager.deletePlaylist(playlistId: playlistId)
+  func deletePlaylist(playlistId: String) throws -> Promise<Void> {
+    Promise.async { _ = self.playlistManager.deletePlaylist(playlistId: playlistId) }
   }
 
-  func updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?)
-    throws
-  {
-    _ = playlistManager.updatePlaylist(
-      playlistId: playlistId, name: name, description: description, artwork: artwork)
+  func updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?) throws -> Promise<Void> {
+    Promise.async {
+      _ = self.playlistManager.updatePlaylist(
+        playlistId: playlistId, name: name, description: description, artwork: artwork)
+      self.core.updatePlaylist(playlistId: playlistId)
+    }
   }
 
   func getPlaylist(playlistId: String) throws -> Variant_NullType_Playlist {
     if let playlist = playlistManager.getPlaylist(playlistId: playlistId) {
       return Variant_NullType_Playlist.second(playlist.toGeneratedPlaylist())
-    } else {
-      return Variant_NullType_Playlist.first(NullType.null)
     }
+    return Variant_NullType_Playlist.first(NullType.null)
   }
 
   func getAllPlaylists() throws -> [Playlist] {
-    return playlistManager.getAllPlaylists().map { $0.toGeneratedPlaylist() }
+    playlistManager.getAllPlaylists().map { $0.toGeneratedPlaylist() }
   }
 
-  func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?) throws {
-    let insertIndex = index.map { Int($0) }
-    _ = playlistManager.addTrackToPlaylist(playlistId: playlistId, track: track, index: insertIndex)
+  // MARK: - Track mutations
+
+  func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?) throws -> Promise<Void> {
+    Promise.async {
+      _ = self.playlistManager.addTrackToPlaylist(playlistId: playlistId, track: track, index: index.map { Int($0) })
+      self.core.updatePlaylist(playlistId: playlistId)
+    }
   }
 
-  func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws {
-    let insertIndex = index.map { Int($0) }
-    _ = playlistManager.addTracksToPlaylist(
-      playlistId: playlistId, tracks: tracks, index: insertIndex)
+  func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws -> Promise<Void> {
+    Promise.async {
+      _ = self.playlistManager.addTracksToPlaylist(playlistId: playlistId, tracks: tracks, index: index.map { Int($0) })
+      self.core.updatePlaylist(playlistId: playlistId)
+    }
   }
 
-  func removeTrackFromPlaylist(playlistId: String, trackId: String) throws {
-    _ = playlistManager.removeTrackFromPlaylist(playlistId: playlistId, trackId: trackId)
+  func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Promise<Void> {
+    Promise.async {
+      _ = self.playlistManager.removeTrackFromPlaylist(playlistId: playlistId, trackId: trackId)
+      self.core.updatePlaylist(playlistId: playlistId)
+    }
   }
 
-  func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws {
-    _ = playlistManager.reorderTrackInPlaylist(
-      playlistId: playlistId, trackId: trackId, newIndex: Int(newIndex))
+  func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Promise<Void> {
+    Promise.async {
+      _ = self.playlistManager.reorderTrackInPlaylist(
+        playlistId: playlistId, trackId: trackId, newIndex: Int(newIndex))
+      self.core.updatePlaylist(playlistId: playlistId)
+    }
   }
 
-  func loadPlaylist(playlistId: String) throws {
-    _ = playlistManager.loadPlaylist(playlistId: playlistId)
+  // MARK: - Playback control
+
+  func loadPlaylist(playlistId: String) throws -> Promise<Void> {
+    Promise.async {
+      // Update PlaylistManager.currentPlaylistId so getCurrentPlaylistId() returns correctly
+      _ = self.playlistManager.loadPlaylist(playlistId: playlistId)
+      await self.core.loadPlaylist(playlistId: playlistId)
+    }
   }
 
   func getCurrentPlaylistId() throws -> Variant_NullType_String {
-    if let playlistId = playlistManager.getCurrentPlaylistId() {
-      return Variant_NullType_String.second(playlistId)
-    } else {
-      return Variant_NullType_String.first(NullType.null)
+    if let id = playlistManager.getCurrentPlaylistId() {
+      return Variant_NullType_String.second(id)
     }
+    return Variant_NullType_String.first(NullType.null)
   }
 
-  func onPlaylistsChanged(callback: @escaping ([Playlist], QueueOperation?) -> Void) throws {
-    // Store callback in static storage so it persists across HybridPlayerQueue instances
-    HybridPlayerQueue.playlistsChangeCallbacks.removeAll()
-    HybridPlayerQueue.playlistsChangeCallbacks.append(callback)
-
-    // Register a single listener with PlaylistManager that dispatches to all callbacks
-    if !HybridPlayerQueue.isPlaylistsListenerRegistered {
-      HybridPlayerQueue.isPlaylistsListenerRegistered = true
-      _ = playlistManager.addPlaylistsChangeListener { playlists, operation in
-        let generatedPlaylists = playlists.map { $0.toGeneratedPlaylist() }
-        // Call all registered callbacks
-        for cb in HybridPlayerQueue.playlistsChangeCallbacks {
-          cb(generatedPlaylists, operation)
-        }
-      }
+  // MARK: - Events (per-instance listener storage)
+
+  func onPlaylistsChanged(callback: @escaping (_ playlists: [Playlist], _ operation: QueueOperation?) -> Void) throws {
+    let remover = playlistManager.addPlaylistsChangeListener { playlists, operation in
+      callback(playlists.map { $0.toGeneratedPlaylist() }, operation)
     }
+    playlistsChangeRemover = remover
   }
 
-  func onPlaylistChanged(callback: @escaping (String, Playlist, QueueOperation?) -> Void) throws {
-    // Store callback in static storage so it persists across HybridPlayerQueue instances
-    HybridPlayerQueue.playlistChangeCallbacks.removeAll()
-    HybridPlayerQueue.playlistChangeCallbacks.append(callback)
-
-    // Register listeners for all existing playlists (only once per playlist)
+  func onPlaylistChanged(callback: @escaping (_ playlistId: String, _ playlist: Playlist, _ operation: QueueOperation?) -> Void) throws {
     let allPlaylists = playlistManager.getAllPlaylists()
     for playlist in allPlaylists {
-      if !HybridPlayerQueue.playlistListenerIds.contains(playlist.id) {
-        HybridPlayerQueue.playlistListenerIds.insert(playlist.id)
-        _ = playlistManager.addPlaylistChangeListener(playlistId: playlist.id) {
-          updatedPlaylist, operation in
-          let generatedPlaylist = updatedPlaylist.toGeneratedPlaylist()
-          // Call all registered callbacks
-          for cb in HybridPlayerQueue.playlistChangeCallbacks {
-            cb(updatedPlaylist.id, generatedPlaylist, operation)
-          }
-        }
+      let remover = playlistManager.addPlaylistChangeListener(playlistId: playlist.id) { updated, operation in
+        callback(updated.id, updated.toGeneratedPlaylist(), operation)
       }
+      playlistChangeRemovers.append(remover)
     }
   }
+
+  // MARK: - Cleanup
+
+  deinit {
+    playlistsChangeRemover?()
+    playlistChangeRemovers.forEach { $0() }
+  }
 }

package/lib/hooks/useDownloadedTracks.js

@@ -12,21 +12,24 @@ export function useDownloadedTracks() {
     const refresh = useCallback(() => {
         if (!isMounted.current)
             return;
-        try {
-            const tracks = DownloadManager.getAllDownloadedTracks();
-            const playlists = DownloadManager.getAllDownloadedPlaylists();
-            if (isMounted.current) {
-                setDownloadedTracks(tracks);
-                setDownloadedPlaylists(playlists);
-                setIsLoading(false);
+        const run = async () => {
+            try {
+                const tracks = await DownloadManager.getAllDownloadedTracks();
+                const playlists = await DownloadManager.getAllDownloadedPlaylists();
+                if (isMounted.current) {
+                    setDownloadedTracks(tracks);
+                    setDownloadedPlaylists(playlists);
+                    setIsLoading(false);
+                }
             }
-        }
-        catch (error) {
-            console.error('[useDownloadedTracks] Error refreshing:', error);
-            if (isMounted.current) {
-                setIsLoading(false);
+            catch (error) {
+                console.error('[useDownloadedTracks] Error refreshing:', error);
+                if (isMounted.current) {
+                    setIsLoading(false);
+                }
             }
-        }
+        };
+        void run();
     }, []);
     useEffect(() => {
         isMounted.current = true;

package/lib/hooks/useEqualizer.d.ts

@@ -7,13 +7,13 @@ export interface UseEqualizerResult {
     /** Currently applied preset name */
     currentPreset: string | null;
     /** Toggle equalizer on/off */
-    setEnabled: (enabled: boolean) => boolean;
+    setEnabled: (enabled: boolean) => Promise<boolean>;
     /** Set gain for a specific band */
-    setBandGain: (bandIndex: number, gainDb: number) => boolean;
+    setBandGain: (bandIndex: number, gainDb: number) => Promise<boolean>;
     /** Set all band gains at once */
-    setAllBandGains: (gains: number[]) => boolean;
+    setAllBandGains: (gains: number[]) => Promise<boolean>;
     /** Reset to flat response */
-    reset: () => void;
+    reset: () => Promise<void>;
     /** Whether equalizer is loading */
     isLoading: boolean;
     /** Gain range (min/max in dB) */

package/lib/hooks/useEqualizer.js

@@ -2,11 +2,16 @@ import { useEffect, useState, useCallback, useRef } from 'react';
 import { Equalizer } from '../index';
 import { equalizerCallbackManager } from './equalizerCallbackManager';
 const DEFAULT_BANDS = [
-    { index: 0, centerFrequency: 60, gainDb: 0, frequencyLabel: '60 Hz' },
-    { index: 1, centerFrequency: 230, gainDb: 0, frequencyLabel: '230 Hz' },
-    { index: 2, centerFrequency: 910, gainDb: 0, frequencyLabel: '910 Hz' },
-    { index: 3, centerFrequency: 3600, gainDb: 0, frequencyLabel: '3.6 kHz' },
-    { index: 4, centerFrequency: 14000, gainDb: 0, frequencyLabel: '14 kHz' },
+    { index: 0, centerFrequency: 31, gainDb: 0, frequencyLabel: '31 Hz' },
+    { index: 1, centerFrequency: 63, gainDb: 0, frequencyLabel: '63 Hz' },
+    { index: 2, centerFrequency: 125, gainDb: 0, frequencyLabel: '125 Hz' },
+    { index: 3, centerFrequency: 250, gainDb: 0, frequencyLabel: '250 Hz' },
+    { index: 4, centerFrequency: 500, gainDb: 0, frequencyLabel: '500 Hz' },
+    { index: 5, centerFrequency: 1000, gainDb: 0, frequencyLabel: '1 kHz' },
+    { index: 6, centerFrequency: 2000, gainDb: 0, frequencyLabel: '2 kHz' },
+    { index: 7, centerFrequency: 4000, gainDb: 0, frequencyLabel: '4 kHz' },
+    { index: 8, centerFrequency: 8000, gainDb: 0, frequencyLabel: '8 kHz' },
+    { index: 9, centerFrequency: 16000, gainDb: 0, frequencyLabel: '16 kHz' },
 ];
 export function useEqualizer() {
     const [isEnabled, setIsEnabledState] = useState(false);
@@ -20,7 +25,7 @@ export function useEqualizer() {
         isMounted.current = true;
         const loadState = async () => {
             try {
-                const state = Equalizer.getState();
+                const state = await Equalizer.getState();
                 if (isMounted.current) {
                     setIsEnabledState(state.enabled);
                     setBands(state.bands);
@@ -69,42 +74,42 @@ export function useEqualizer() {
         });
         return unsubscribe;
     }, []);
-    const setEnabled = useCallback((enabled) => {
+    const setEnabled = useCallback(async (enabled) => {
         try {
-            return Equalizer.setEnabled(enabled);
+            await Equalizer.setEnabled(enabled);
+            return true;
         }
         catch (error) {
             console.error('[useEqualizer] Error setting enabled:', error);
             return false;
         }
     }, []);
-    const setBandGain = useCallback((bandIndex, gainDb) => {
-        // Optimistic update
+    const setBandGain = useCallback(async (bandIndex, gainDb) => {
         setBands((prevBands) => prevBands.map((b) => (b.index === bandIndex ? { ...b, gainDb } : b)));
         try {
-            return Equalizer.setBandGain(bandIndex, gainDb);
+            await Equalizer.setBandGain(bandIndex, gainDb);
+            return true;
         }
         catch (error) {
             console.error('[useEqualizer] Error setting band gain:', error);
             return false;
         }
     }, []);
-    const setAllBandGains = useCallback((gains) => {
-        // Optimistic update
+    const setAllBandGains = useCallback(async (gains) => {
         setBands((prevBands) => prevBands.map((b, i) => ({ ...b, gainDb: gains[i] ?? b.gainDb })));
         try {
-            return Equalizer.setAllBandGains(gains);
+            await Equalizer.setAllBandGains(gains);
+            return true;
         }
         catch (error) {
             console.error('[useEqualizer] Error setting all band gains:', error);
             return false;
         }
     }, []);
-    const reset = useCallback(() => {
-        // Optimistic update
+    const reset = useCallback(async () => {
         setBands((prevBands) => prevBands.map((b) => ({ ...b, gainDb: 0 })));
         try {
-            Equalizer.reset();
+            await Equalizer.reset();
         }
         catch (error) {
             console.error('[useEqualizer] Error resetting equalizer:', error);

package/lib/hooks/useEqualizerPresets.d.ts

@@ -7,11 +7,11 @@ export interface UseEqualizerPresetsResult {
     /** Custom user presets */
     customPresets: EqualizerPreset[];
     /** Apply a preset by name */
-    applyPreset: (name: string) => boolean;
+    applyPreset: (name: string) => Promise<boolean>;
     /** Save current settings as custom preset */
-    saveCustomPreset: (name: string) => boolean;
+    saveCustomPreset: (name: string) => Promise<boolean>;
     /** Delete a custom preset */
-    deleteCustomPreset: (name: string) => boolean;
+    deleteCustomPreset: (name: string) => Promise<boolean>;
     /** Currently applied preset name */
     currentPreset: string | null;
     /** Whether presets are loading */

package/lib/hooks/useEqualizerPresets.js

@@ -43,39 +43,33 @@ export function useEqualizerPresets() {
         });
         return unsubscribe;
     }, []);
-    const applyPreset = useCallback((name) => {
+    const applyPreset = useCallback(async (name) => {
         try {
-            const success = Equalizer.applyPreset(name);
-            if (success) {
-                setCurrentPreset(name);
-            }
-            return success;
+            await Equalizer.applyPreset(name);
+            setCurrentPreset(name);
+            return true;
         }
         catch (error) {
             console.error('[useEqualizerPresets] Error applying preset:', error);
             return false;
         }
     }, []);
-    const saveCustomPreset = useCallback((name) => {
+    const saveCustomPreset = useCallback(async (name) => {
         try {
-            const success = Equalizer.saveCustomPreset(name);
-            if (success) {
-                refreshPresets();
-            }
-            return success;
+            await Equalizer.saveCustomPreset(name);
+            refreshPresets();
+            return true;
         }
         catch (error) {
             console.error('[useEqualizerPresets] Error saving custom preset:', error);
             return false;
         }
     }, [refreshPresets]);
-    const deleteCustomPreset = useCallback((name) => {
+    const deleteCustomPreset = useCallback(async (name) => {
         try {
-            const success = Equalizer.deleteCustomPreset(name);
-            if (success) {
-                refreshPresets();
-            }
-            return success;
+            await Equalizer.deleteCustomPreset(name);
+            refreshPresets();
+            return true;
         }
         catch (error) {
             console.error('[useEqualizerPresets] Error deleting custom preset:', error);

package/lib/specs/AndroidAutoMediaLibrary.nitro.d.ts

@@ -12,10 +12,10 @@ export interface AndroidAutoMediaLibrary extends HybridObject<{
      *
      * @param libraryJson - JSON string of the MediaLibrary structure
      */
-    setMediaLibrary(libraryJson: string): void;
+    setMediaLibrary(libraryJson: string): Promise<void>;
     /**
      * Clear the Android Auto media library
      * Falls back to showing all playlists
      */
-    clearMediaLibrary(): void;
+    clearMediaLibrary(): Promise<void>;
 }

package/lib/specs/AudioDevices.nitro.d.ts

@@ -18,7 +18,7 @@ export interface AudioDevices extends HybridObject<{
      * Set the audio device
      *
      * @param deviceId - The ID of the audio device
-     * @returns True if the audio device was set successfully, false otherwise
+     * @returns Promise that resolves when the device has been set
      */
-    setAudioDevice(deviceId: number): boolean;
+    setAudioDevice(deviceId: number): Promise<void>;
 }

package/lib/specs/DownloadManager.nitro.d.ts

@@ -74,35 +74,35 @@ export interface DownloadManager extends HybridObject<{
     /**
      * Check if a track is downloaded
      */
-    isTrackDownloaded(trackId: string): boolean;
+    isTrackDownloaded(trackId: string): Promise<boolean>;
     /**
      * Check if a playlist is fully downloaded
      */
-    isPlaylistDownloaded(playlistId: string): boolean;
+    isPlaylistDownloaded(playlistId: string): Promise<boolean>;
     /**
      * Check if a playlist is partially downloaded
      */
-    isPlaylistPartiallyDownloaded(playlistId: string): boolean;
+    isPlaylistPartiallyDownloaded(playlistId: string): Promise<boolean>;
     /**
      * Get downloaded track by track ID
      */
-    getDownloadedTrack(trackId: string): DownloadedTrack | null;
+    getDownloadedTrack(trackId: string): Promise<DownloadedTrack | null>;
     /**
      * Get all downloaded tracks
      */
-    getAllDownloadedTracks(): DownloadedTrack[];
+    getAllDownloadedTracks(): Promise<DownloadedTrack[]>;
     /**
      * Get downloaded playlist by playlist ID
      */
-    getDownloadedPlaylist(playlistId: string): DownloadedPlaylist | null;
+    getDownloadedPlaylist(playlistId: string): Promise<DownloadedPlaylist | null>;
     /**
      * Get all downloaded playlists
      */
-    getAllDownloadedPlaylists(): DownloadedPlaylist[];
+    getAllDownloadedPlaylists(): Promise<DownloadedPlaylist[]>;
     /**
      * Get local file path for a downloaded track
      */
-    getLocalPath(trackId: string): string | null;
+    getLocalPath(trackId: string): Promise<string | null>;
     /**
      * Delete a downloaded track
      */
@@ -124,7 +124,7 @@ export interface DownloadManager extends HybridObject<{
      * Call this to clean up after manual file deletion
      * @returns number of orphaned records that were cleaned up
      */
-    syncDownloads(): number;
+    syncDownloads(): Promise<number>;
     /**
      * Set playback source preference
      */
@@ -136,7 +136,7 @@ export interface DownloadManager extends HybridObject<{
     /**
      * Get the effective URL for a track (local or network based on preference)
      */
-    getEffectiveUrl(track: TrackItem): string;
+    getEffectiveUrl(track: TrackItem): Promise<string>;
     /**
      * Called when download progress updates
      */

package/lib/specs/Equalizer.nitro.d.ts

@@ -5,15 +5,15 @@ export interface Equalizer extends HybridObject<{
     ios: 'swift';
 }> {
     /** Enable or disable the equalizer */
-    setEnabled(enabled: boolean): boolean;
+    setEnabled(enabled: boolean): Promise<void>;
     /** Check if equalizer is currently enabled */
     isEnabled(): boolean;
     /** Get all equalizer bands with current gain values */
-    getBands(): EqualizerBand[];
+    getBands(): Promise<EqualizerBand[]>;
     /** Set gain for a specific band index (-12 to +12 dB) */
-    setBandGain(bandIndex: number, gainDb: number): boolean;
-    /** Set gains for all bands at once (array of 5 values) */
-    setAllBandGains(gains: number[]): boolean;
+    setBandGain(bandIndex: number, gainDb: number): Promise<void>;
+    /** Set gains for all bands at once (array of 10 values) */
+    setAllBandGains(gains: number[]): Promise<void>;
     /** Get the valid gain range for bands */
     getBandRange(): GainRange;
     /** Get all available presets (built-in + custom) */
@@ -23,17 +23,17 @@ export interface Equalizer extends HybridObject<{
     /** Get custom user presets only */
     getCustomPresets(): EqualizerPreset[];
     /** Apply a preset by name */
-    applyPreset(presetName: string): boolean;
+    applyPreset(presetName: string): Promise<void>;
     /** Get currently applied preset name (null if custom values) */
     getCurrentPresetName(): string | null;
     /** Save current settings as a custom preset */
-    saveCustomPreset(name: string): boolean;
+    saveCustomPreset(name: string): Promise<void>;
     /** Delete a custom preset by name */
-    deleteCustomPreset(name: string): boolean;
+    deleteCustomPreset(name: string): Promise<void>;
     /** Get complete equalizer state */
-    getState(): EqualizerState;
+    getState(): Promise<EqualizerState>;
     /** Reset to flat response (all bands at 0 dB) */
-    reset(): void;
+    reset(): Promise<void>;
     /** Called when equalizer enabled state changes */
     onEnabledChange(callback: (enabled: boolean) => void): void;
     /** Called when any band gain changes */

package/lib/specs/TrackPlayer.nitro.d.ts

@@ -4,16 +4,16 @@ export interface PlayerQueue extends HybridObject<{
     android: 'kotlin';
     ios: 'swift';
 }> {
-    createPlaylist(name: string, description?: string, artwork?: string): string;
-    deletePlaylist(playlistId: string): void;
-    updatePlaylist(playlistId: string, name?: string, description?: string, artwork?: string): void;
+    createPlaylist(name: string, description?: string, artwork?: string): Promise<string>;
+    deletePlaylist(playlistId: string): Promise<void>;
+    updatePlaylist(playlistId: string, name?: string, description?: string, artwork?: string): Promise<void>;
     getPlaylist(playlistId: string): Playlist | null;
     getAllPlaylists(): Playlist[];
-    addTrackToPlaylist(playlistId: string, track: TrackItem, index?: number): void;
-    addTracksToPlaylist(playlistId: string, tracks: TrackItem[], index?: number): void;
-    removeTrackFromPlaylist(playlistId: string, trackId: string): void;
-    reorderTrackInPlaylist(playlistId: string, trackId: string, newIndex: number): void;
-    loadPlaylist(playlistId: string): void;
+    addTrackToPlaylist(playlistId: string, track: TrackItem, index?: number): Promise<void>;
+    addTracksToPlaylist(playlistId: string, tracks: TrackItem[], index?: number): Promise<void>;
+    removeTrackFromPlaylist(playlistId: string, trackId: string): Promise<void>;
+    reorderTrackInPlaylist(playlistId: string, trackId: string, newIndex: number): Promise<void>;
+    loadPlaylist(playlistId: string): Promise<void>;
     getCurrentPlaylistId(): string | null;
     onPlaylistsChanged(callback: (playlists: Playlist[], operation?: QueueOperation) => void): void;
     onPlaylistChanged(callback: (playlistId: string, playlist: Playlist, operation?: QueueOperation) => void): void;
@@ -23,27 +23,27 @@ export interface TrackPlayer extends HybridObject<{
     android: 'kotlin';
     ios: 'swift';
 }> {
-    play(): void;
-    pause(): void;
+    play(): Promise<void>;
+    pause(): Promise<void>;
     playSong(songId: string, fromPlaylist?: string): Promise<void>;
-    skipToNext(): void;
+    skipToNext(): Promise<void>;
     skipToIndex(index: number): Promise<boolean>;
-    skipToPrevious(): void;
-    seek(position: number): void;
+    skipToPrevious(): Promise<void>;
+    seek(position: number): Promise<void>;
     addToUpNext(trackId: string): Promise<void>;
     playNext(trackId: string): Promise<void>;
     getActualQueue(): Promise<TrackItem[]>;
     getState(): Promise<PlayerState>;
-    setRepeatMode(mode: RepeatMode): boolean;
+    setRepeatMode(mode: RepeatMode): Promise<void>;
     getRepeatMode(): RepeatMode;
-    configure(config: PlayerConfig): void;
+    configure(config: PlayerConfig): Promise<void>;
     onChangeTrack(callback: (track: TrackItem, reason?: Reason) => void): void;
     onPlaybackStateChange(callback: (state: TrackPlayerState, reason?: Reason) => void): void;
     onSeek(callback: (position: number, totalDuration: number) => void): void;
     onPlaybackProgressChange(callback: (position: number, totalDuration: number, isManuallySeeked?: boolean) => void): void;
     onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
     isAndroidAutoConnected(): boolean;
-    setVolume(volume: number): boolean;
+    setVolume(volume: number): Promise<void>;
     /**
      * Update entire track objects across all playlists
      * Matches by track.id and updates all properties (url, artwork, title, etc.)
@@ -91,4 +91,26 @@ export interface TrackPlayer extends HybridObject<{
      * @returns Promise resolving to playback speed
      */
     getPlaybackSpeed(): Promise<number>;
+    /** Remove a track from the playNext stack by ID. Returns true if found and removed. */
+    removeFromPlayNext(trackId: string): Promise<boolean>;
+    /** Remove a track from the upNext queue by ID. Returns true if found and removed. */
+    removeFromUpNext(trackId: string): Promise<boolean>;
+    /** Clear the entire playNext stack */
+    clearPlayNext(): Promise<void>;
+    /** Clear the entire upNext queue */
+    clearUpNext(): Promise<void>;
+    /**
+     * Reorder a temporary track within the combined virtual queue
+     * (playNextStack + upNextQueue). newIndex is 0-based within that combined list.
+     * Returns true if the track was found and moved.
+     */
+    reorderTemporaryTrack(trackId: string, newIndex: number): Promise<boolean>;
+    /** Get the current playNext stack (LIFO order, index 0 plays first) */
+    getPlayNextQueue(): Promise<TrackItem[]>;
+    /** Get the current upNext queue (FIFO order, index 0 plays first) */
+    getUpNextQueue(): Promise<TrackItem[]>;
+    /**
+     * Register callback that fires whenever the temporary queue (playNext or upNext) changes.
+     */
+    onTemporaryQueueChange(callback: (playNextQueue: TrackItem[], upNextQueue: TrackItem[]) => void): void;
 }