react-native-queue-player 1.2.0 → 2.0.1

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/Func_void_std__vector_EqualizerBand_.kt

@@ -10,7 +10,6 @@ package com.margelo.nitro.queueplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
-import dalvik.annotation.optimization.FastNative
 
 
 /**
@@ -59,7 +58,6 @@ class Func_void_std__vector_EqualizerBand__cxx: Func_void_std__vector_EqualizerB
   override fun invoke(bands: Array<EqualizerBand>): Unit
     = invoke_cxx(bands)
 
-  @FastNative
   private external fun invoke_cxx(bands: Array<EqualizerBand>): Unit
 }
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/HybridCastManagerSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.queueplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
@@ -157,6 +158,7 @@ abstract class HybridCastManagerSpec: HybridObject() {
   @Keep
   protected open class CxxPart(javaPart: HybridCastManagerSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridCastManagerSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/HybridEqualizerSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.queueplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
@@ -97,6 +98,7 @@ abstract class HybridEqualizerSpec: HybridObject() {
   @Keep
   protected open class CxxPart(javaPart: HybridEqualizerSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridEqualizerSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/HybridTrackPlayerSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.queueplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.HybridObject
@@ -56,7 +57,7 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun getQueue(): Array<TrackItem>
+  abstract fun getQueue(): Promise<Array<TrackItem>>
   
   @DoNotStrip
   @Keep
@@ -212,11 +213,11 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
     return Func_void_java(__result)
   }
   
-  abstract fun onQueueChange(callback: (queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason) -> Unit): () -> Unit
+  abstract fun onQueueChange(callback: (delta: QueueChangeDelta, currentIndex: Double, reason: QueueChangeReason) -> Unit): () -> Unit
   
   @DoNotStrip
   @Keep
-  private fun onQueueChange_cxx(callback: Func_void_std__vector_TrackItem__double_QueueChangeReason): Func_void {
+  private fun onQueueChange_cxx(callback: Func_void_QueueChangeDelta_double_QueueChangeReason): Func_void {
     val __result = onQueueChange(callback)
     return Func_void_java(__result)
   }
@@ -374,7 +375,7 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun getLookaheadCacheStatus(): CacheStatus
+  abstract fun getLookaheadCacheStatus(): Promise<CacheStatus>
   
   @DoNotStrip
   @Keep
@@ -420,6 +421,7 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   @Keep
   protected open class CxxPart(javaPart: HybridTrackPlayerSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridTrackPlayerSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/HybridVisualizerSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.queueplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -51,6 +52,7 @@ abstract class HybridVisualizerSpec: HybridObject() {
   @Keep
   protected open class CxxPart(javaPart: HybridVisualizerSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridVisualizerSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/LookaheadCacheConfig.kt

@@ -23,7 +23,10 @@ data class LookaheadCacheConfig(
   val enabled: Boolean,
   @DoNotStrip
   @Keep
-  val lookaheadCount: Double
+  val lookaheadCount: Double,
+  @DoNotStrip
+  @Keep
+  val allowsCellularAccess: Boolean?
 ) {
   /* primary constructor */
 
@@ -32,12 +35,14 @@ data class LookaheadCacheConfig(
     if (other !is LookaheadCacheConfig) return false
     return Objects.deepEquals(this.enabled, other.enabled)
       && Objects.deepEquals(this.lookaheadCount, other.lookaheadCount)
+      && Objects.deepEquals(this.allowsCellularAccess, other.allowsCellularAccess)
   }
 
   override fun hashCode(): Int {
     return arrayOf<Any?>(
       enabled,
-      lookaheadCount
+      lookaheadCount,
+      allowsCellularAccess
     ).contentDeepHashCode()
   }
 
@@ -49,8 +54,8 @@ data class LookaheadCacheConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(enabled: Boolean, lookaheadCount: Double): LookaheadCacheConfig {
-      return LookaheadCacheConfig(enabled, lookaheadCount)
+    private fun fromCpp(enabled: Boolean, lookaheadCount: Double, allowsCellularAccess: Boolean?): LookaheadCacheConfig {
+      return LookaheadCacheConfig(enabled, lookaheadCount, allowsCellularAccess)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/PlayerConfig.kt

@@ -44,6 +44,9 @@ data class PlayerConfig(
   val audioCategoryOptions: AudioCategoryOptions?,
   @DoNotStrip
   @Keep
+  val voiceVocabularyDonationEnabled: Boolean?,
+  @DoNotStrip
+  @Keep
   val visualizationEnabled: Boolean?,
   @DoNotStrip
   @Keep
@@ -77,6 +80,7 @@ data class PlayerConfig(
       && Objects.deepEquals(this.networkTimeoutMs, other.networkTimeoutMs)
       && Objects.deepEquals(this.audioContentType, other.audioContentType)
       && Objects.deepEquals(this.audioCategoryOptions, other.audioCategoryOptions)
+      && Objects.deepEquals(this.voiceVocabularyDonationEnabled, other.voiceVocabularyDonationEnabled)
       && Objects.deepEquals(this.visualizationEnabled, other.visualizationEnabled)
       && Objects.deepEquals(this.clampSeekToBuffered, other.clampSeekToBuffered)
       && Objects.deepEquals(this.skipToPreviousBehavior, other.skipToPreviousBehavior)
@@ -96,6 +100,7 @@ data class PlayerConfig(
       networkTimeoutMs,
       audioContentType,
       audioCategoryOptions,
+      voiceVocabularyDonationEnabled,
       visualizationEnabled,
       clampSeekToBuffered,
       skipToPreviousBehavior,
@@ -114,8 +119,8 @@ data class PlayerConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(httpHeaders: Map<String, String>?, userAgent: String?, placeholderArtworkUri: String?, autoRetries: Double?, retryBackoffMs: Double?, networkTimeoutMs: Double?, audioContentType: AudioContentType?, audioCategoryOptions: AudioCategoryOptions?, visualizationEnabled: Boolean?, clampSeekToBuffered: Boolean?, skipToPreviousBehavior: SkipToPreviousBehavior?, lookaheadCacheMaxSizeMb: Double?, lookaheadCacheEvictionPolicy: EvictionPolicy?, progressUpdateIntervalMs: Double?, backgroundProgressUpdateIntervalMs: Double?): PlayerConfig {
-      return PlayerConfig(httpHeaders, userAgent, placeholderArtworkUri, autoRetries, retryBackoffMs, networkTimeoutMs, audioContentType, audioCategoryOptions, visualizationEnabled, clampSeekToBuffered, skipToPreviousBehavior, lookaheadCacheMaxSizeMb, lookaheadCacheEvictionPolicy, progressUpdateIntervalMs, backgroundProgressUpdateIntervalMs)
+    private fun fromCpp(httpHeaders: Map<String, String>?, userAgent: String?, placeholderArtworkUri: String?, autoRetries: Double?, retryBackoffMs: Double?, networkTimeoutMs: Double?, audioContentType: AudioContentType?, audioCategoryOptions: AudioCategoryOptions?, voiceVocabularyDonationEnabled: Boolean?, visualizationEnabled: Boolean?, clampSeekToBuffered: Boolean?, skipToPreviousBehavior: SkipToPreviousBehavior?, lookaheadCacheMaxSizeMb: Double?, lookaheadCacheEvictionPolicy: EvictionPolicy?, progressUpdateIntervalMs: Double?, backgroundProgressUpdateIntervalMs: Double?): PlayerConfig {
+      return PlayerConfig(httpHeaders, userAgent, placeholderArtworkUri, autoRetries, retryBackoffMs, networkTimeoutMs, audioContentType, audioCategoryOptions, voiceVocabularyDonationEnabled, visualizationEnabled, clampSeekToBuffered, skipToPreviousBehavior, lookaheadCacheMaxSizeMb, lookaheadCacheEvictionPolicy, progressUpdateIntervalMs, backgroundProgressUpdateIntervalMs)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/QueueChangeDelta.kt

@@ -0,0 +1,86 @@
+///
+/// QueueChangeDelta.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.queueplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "QueueChangeDelta".
+ */
+@DoNotStrip
+@Keep
+data class QueueChangeDelta(
+  @DoNotStrip
+  @Keep
+  val revision: Double,
+  @DoNotStrip
+  @Keep
+  val length: Double,
+  @DoNotStrip
+  @Keep
+  val inserted: Array<TrackItem>,
+  @DoNotStrip
+  @Keep
+  val insertedAt: Double,
+  @DoNotStrip
+  @Keep
+  val removed: DoubleArray,
+  @DoNotStrip
+  @Keep
+  val movedFrom: Double,
+  @DoNotStrip
+  @Keep
+  val movedTo: Double,
+  @DoNotStrip
+  @Keep
+  val order: DoubleArray
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is QueueChangeDelta) return false
+    return Objects.deepEquals(this.revision, other.revision)
+      && Objects.deepEquals(this.length, other.length)
+      && Objects.deepEquals(this.inserted, other.inserted)
+      && Objects.deepEquals(this.insertedAt, other.insertedAt)
+      && Objects.deepEquals(this.removed, other.removed)
+      && Objects.deepEquals(this.movedFrom, other.movedFrom)
+      && Objects.deepEquals(this.movedTo, other.movedTo)
+      && Objects.deepEquals(this.order, other.order)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      revision,
+      length,
+      inserted,
+      insertedAt,
+      removed,
+      movedFrom,
+      movedTo,
+      order
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(revision: Double, length: Double, inserted: Array<TrackItem>, insertedAt: Double, removed: DoubleArray, movedFrom: Double, movedTo: Double, order: DoubleArray): QueueChangeDelta {
+      return QueueChangeDelta(revision, length, inserted, insertedAt, removed, movedFrom, movedTo, order)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/TrackItem.kt

@@ -41,7 +41,19 @@ data class TrackItem(
   val artworkUrl: String?,
   @DoNotStrip
   @Keep
-  val extras: Map<String, String>?
+  val extras: Map<String, String>?,
+  @DoNotStrip
+  @Keep
+  val replayGainTrackGain: Double?,
+  @DoNotStrip
+  @Keep
+  val replayGainTrackPeak: Double?,
+  @DoNotStrip
+  @Keep
+  val replayGainAlbumGain: Double?,
+  @DoNotStrip
+  @Keep
+  val replayGainAlbumPeak: Double?
 ) {
   /* primary constructor */
 
@@ -56,6 +68,10 @@ data class TrackItem(
       && Objects.deepEquals(this.duration, other.duration)
       && Objects.deepEquals(this.artworkUrl, other.artworkUrl)
       && Objects.deepEquals(this.extras, other.extras)
+      && Objects.deepEquals(this.replayGainTrackGain, other.replayGainTrackGain)
+      && Objects.deepEquals(this.replayGainTrackPeak, other.replayGainTrackPeak)
+      && Objects.deepEquals(this.replayGainAlbumGain, other.replayGainAlbumGain)
+      && Objects.deepEquals(this.replayGainAlbumPeak, other.replayGainAlbumPeak)
   }
 
   override fun hashCode(): Int {
@@ -67,7 +83,11 @@ data class TrackItem(
       album,
       duration,
       artworkUrl,
-      extras
+      extras,
+      replayGainTrackGain,
+      replayGainTrackPeak,
+      replayGainAlbumGain,
+      replayGainAlbumPeak
     ).contentDeepHashCode()
   }
 
@@ -79,8 +99,8 @@ data class TrackItem(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(id: String?, url: String, title: String?, artist: String?, album: String?, duration: Double?, artworkUrl: String?, extras: Map<String, String>?): TrackItem {
-      return TrackItem(id, url, title, artist, album, duration, artworkUrl, extras)
+    private fun fromCpp(id: String?, url: String, title: String?, artist: String?, album: String?, duration: Double?, artworkUrl: String?, extras: Map<String, String>?, replayGainTrackGain: Double?, replayGainTrackPeak: Double?, replayGainAlbumGain: Double?, replayGainAlbumPeak: Double?): TrackItem {
+      return TrackItem(id, url, title, artist, album, duration, artworkUrl, extras, replayGainTrackGain, replayGainTrackPeak, replayGainAlbumGain, replayGainAlbumPeak)
     }
   }
 }

package/nitrogen/generated/android/queueplayerOnLoad.cpp

@@ -29,7 +29,7 @@
 #include "JHybridTrackPlayerSpec.hpp"
 #include "JFunc_void_PlayerState_StateChangeReason.hpp"
 #include "JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_.hpp"
-#include "JFunc_void_std__vector_TrackItem__double_QueueChangeReason.hpp"
+#include "JFunc_void_QueueChangeDelta_double_QueueChangeReason.hpp"
 #include "JFunc_void_PlayerProgress.hpp"
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_PlaybackError.hpp"
@@ -107,7 +107,7 @@ void registerAllNatives() {
   margelo::nitro::queueplayer::JHybridTrackPlayerSpec::CxxPart::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_PlayerState_StateChangeReason_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__cxx::registerNatives();
-  margelo::nitro::queueplayer::JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx::registerNatives();
+  margelo::nitro::queueplayer::JFunc_void_QueueChangeDelta_double_QueueChangeReason_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_PlayerProgress_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_double_double_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_PlaybackError_cxx::registerNatives();

package/nitrogen/generated/ios/QueuePlayer-Swift-Cxx-Bridge.cpp

@@ -137,6 +137,14 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* result */)>
+  Func_void_std__vector_TrackItem_ create_Func_void_std__vector_TrackItem_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = QueuePlayer::Func_void_std__vector_TrackItem_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<TrackItem>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const ShuffleResult& /* result */)>
   Func_void_ShuffleResult create_Func_void_ShuffleResult(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = QueuePlayer::Func_void_ShuffleResult::fromUnsafe(swiftClosureWrapper);
@@ -161,11 +169,11 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>
-  Func_void_std__vector_TrackItem__double_QueueChangeReason create_Func_void_std__vector_TrackItem__double_QueueChangeReason(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = QueuePlayer::Func_void_std__vector_TrackItem__double_QueueChangeReason::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<TrackItem>& queue, double currentIndex, QueueChangeReason reason) mutable -> void {
-      swiftClosure.call(queue, currentIndex, static_cast<int>(reason));
+  // pragma MARK: std::function<void(const QueueChangeDelta& /* delta */, double /* currentIndex */, QueueChangeReason /* reason */)>
+  Func_void_QueueChangeDelta_double_QueueChangeReason create_Func_void_QueueChangeDelta_double_QueueChangeReason(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = QueuePlayer::Func_void_QueueChangeDelta_double_QueueChangeReason::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const QueueChangeDelta& delta, double currentIndex, QueueChangeReason reason) mutable -> void {
+      swiftClosure.call(delta, currentIndex, static_cast<int>(reason));
     };
   }
   
@@ -242,14 +250,6 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* result */)>
-  Func_void_std__vector_TrackItem_ create_Func_void_std__vector_TrackItem_(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = QueuePlayer::Func_void_std__vector_TrackItem_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<TrackItem>& result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
   // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>
   Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = QueuePlayer::Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest::fromUnsafe(swiftClosureWrapper);
@@ -284,11 +284,11 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const CacheStatus& /* status */)>
+  // pragma MARK: std::function<void(const CacheStatus& /* result */)>
   Func_void_CacheStatus create_Func_void_CacheStatus(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = QueuePlayer::Func_void_CacheStatus::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const CacheStatus& status) mutable -> void {
-      swiftClosure.call(status);
+    return [swiftClosure = std::move(swiftClosure)](const CacheStatus& result) mutable -> void {
+      swiftClosure.call(result);
     };
   }
   

package/nitrogen/generated/ios/QueuePlayer-Swift-Cxx-Bridge.hpp

@@ -98,6 +98,8 @@ namespace margelo::nitro::queueplayer { struct PlaybackMode; }
 namespace margelo::nitro::queueplayer { struct PlayerProgress; }
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::queueplayer { enum class PlayerState; }
+// Forward declaration of `QueueChangeDelta` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct QueueChangeDelta; }
 // Forward declaration of `QueueChangeReason` to properly resolve imports.
 namespace margelo::nitro::queueplayer { enum class QueueChangeReason; }
 // Forward declaration of `RemoteControlOptions` to properly resolve imports.
@@ -184,6 +186,7 @@ namespace QueuePlayer { class HybridVisualizerSpec_cxx; }
 #include "PlaybackMode.hpp"
 #include "PlayerProgress.hpp"
 #include "PlayerState.hpp"
+#include "QueueChangeDelta.hpp"
 #include "QueueChangeReason.hpp"
 #include "RemoteControlOptions.hpp"
 #include "ReplayGainMode.hpp"
@@ -829,6 +832,40 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return vector;
   }
   
+  // pragma MARK: std::shared_ptr<Promise<std::vector<TrackItem>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<TrackItem>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_TrackItem___ = std::shared_ptr<Promise<std::vector<TrackItem>>>;
+  inline std::shared_ptr<Promise<std::vector<TrackItem>>> create_std__shared_ptr_Promise_std__vector_TrackItem___() noexcept {
+    return Promise<std::vector<TrackItem>>::create();
+  }
+  inline PromiseHolder<std::vector<TrackItem>> wrap_std__shared_ptr_Promise_std__vector_TrackItem___(std::shared_ptr<Promise<std::vector<TrackItem>>> promise) noexcept {
+    return PromiseHolder<std::vector<TrackItem>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<TrackItem>&)>`.
+   */
+  using Func_void_std__vector_TrackItem_ = std::function<void(const std::vector<TrackItem>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<TrackItem>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_TrackItem__Wrapper final {
+  public:
+    explicit Func_void_std__vector_TrackItem__Wrapper(std::function<void(const std::vector<TrackItem>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<TrackItem>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<TrackItem> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<TrackItem>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_TrackItem_ create_Func_void_std__vector_TrackItem_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_TrackItem__Wrapper wrap_Func_void_std__vector_TrackItem_(Func_void_std__vector_TrackItem_ value) noexcept {
+    return Func_void_std__vector_TrackItem__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::optional<TrackItem>
   /**
    * Specialized version of `std::optional<TrackItem>`.
@@ -937,26 +974,26 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>
+  // pragma MARK: std::function<void(const QueueChangeDelta& /* delta */, double /* currentIndex */, QueueChangeReason /* reason */)>
   /**
-   * Specialized version of `std::function<void(const std::vector<TrackItem>&, double, QueueChangeReason)>`.
+   * Specialized version of `std::function<void(const QueueChangeDelta&, double, QueueChangeReason)>`.
    */
-  using Func_void_std__vector_TrackItem__double_QueueChangeReason = std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>;
+  using Func_void_QueueChangeDelta_double_QueueChangeReason = std::function<void(const QueueChangeDelta& /* delta */, double /* currentIndex */, QueueChangeReason /* reason */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::vector<TrackItem>& / * queue * /, double / * currentIndex * /, QueueChangeReason / * reason * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const QueueChangeDelta& / * delta * /, double / * currentIndex * /, QueueChangeReason / * reason * /)>`, this can be used from Swift.
    */
-  class Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper final {
+  class Func_void_QueueChangeDelta_double_QueueChangeReason_Wrapper final {
   public:
-    explicit Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper(std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>&& func): _function(std::make_unique<std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>>(std::move(func))) {}
-    inline void call(std::vector<TrackItem> queue, double currentIndex, int reason) const noexcept {
-      _function->operator()(queue, currentIndex, static_cast<QueueChangeReason>(reason));
+    explicit Func_void_QueueChangeDelta_double_QueueChangeReason_Wrapper(std::function<void(const QueueChangeDelta& /* delta */, double /* currentIndex */, QueueChangeReason /* reason */)>&& func): _function(std::make_unique<std::function<void(const QueueChangeDelta& /* delta */, double /* currentIndex */, QueueChangeReason /* reason */)>>(std::move(func))) {}
+    inline void call(QueueChangeDelta delta, double currentIndex, int reason) const noexcept {
+      _function->operator()(delta, currentIndex, static_cast<QueueChangeReason>(reason));
     }
   private:
-    std::unique_ptr<std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>> _function;
+    std::unique_ptr<std::function<void(const QueueChangeDelta& /* delta */, double /* currentIndex */, QueueChangeReason /* reason */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_TrackItem__double_QueueChangeReason create_Func_void_std__vector_TrackItem__double_QueueChangeReason(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper wrap_Func_void_std__vector_TrackItem__double_QueueChangeReason(Func_void_std__vector_TrackItem__double_QueueChangeReason value) noexcept {
-    return Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper(std::move(value));
+  Func_void_QueueChangeDelta_double_QueueChangeReason create_Func_void_QueueChangeDelta_double_QueueChangeReason(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_QueueChangeDelta_double_QueueChangeReason_Wrapper wrap_Func_void_QueueChangeDelta_double_QueueChangeReason(Func_void_QueueChangeDelta_double_QueueChangeReason value) noexcept {
+    return Func_void_QueueChangeDelta_double_QueueChangeReason_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::function<void(const PlayerProgress& /* progress */)>
@@ -1219,40 +1256,6 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return Func_void_std__shared_ptr_Promise_std__vector_BrowseItem____Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::vector<TrackItem>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::vector<TrackItem>>>`.
-   */
-  using std__shared_ptr_Promise_std__vector_TrackItem___ = std::shared_ptr<Promise<std::vector<TrackItem>>>;
-  inline std::shared_ptr<Promise<std::vector<TrackItem>>> create_std__shared_ptr_Promise_std__vector_TrackItem___() noexcept {
-    return Promise<std::vector<TrackItem>>::create();
-  }
-  inline PromiseHolder<std::vector<TrackItem>> wrap_std__shared_ptr_Promise_std__vector_TrackItem___(std::shared_ptr<Promise<std::vector<TrackItem>>> promise) noexcept {
-    return PromiseHolder<std::vector<TrackItem>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::vector<TrackItem>&)>`.
-   */
-  using Func_void_std__vector_TrackItem_ = std::function<void(const std::vector<TrackItem>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::vector<TrackItem>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__vector_TrackItem__Wrapper final {
-  public:
-    explicit Func_void_std__vector_TrackItem__Wrapper(std::function<void(const std::vector<TrackItem>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<TrackItem>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<TrackItem> result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::vector<TrackItem>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_TrackItem_ create_Func_void_std__vector_TrackItem_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__vector_TrackItem__Wrapper wrap_Func_void_std__vector_TrackItem_(Func_void_std__vector_TrackItem_ value) noexcept {
-    return Func_void_std__vector_TrackItem__Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::optional<MediaSearchType>
   /**
    * Specialized version of `std::optional<MediaSearchType>`.
@@ -1456,22 +1459,34 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return Func_void_ServiceReadyReason_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(const CacheStatus& /* status */)>
+  // pragma MARK: std::shared_ptr<Promise<CacheStatus>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<CacheStatus>>`.
+   */
+  using std__shared_ptr_Promise_CacheStatus__ = std::shared_ptr<Promise<CacheStatus>>;
+  inline std::shared_ptr<Promise<CacheStatus>> create_std__shared_ptr_Promise_CacheStatus__() noexcept {
+    return Promise<CacheStatus>::create();
+  }
+  inline PromiseHolder<CacheStatus> wrap_std__shared_ptr_Promise_CacheStatus__(std::shared_ptr<Promise<CacheStatus>> promise) noexcept {
+    return PromiseHolder<CacheStatus>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const CacheStatus& /* result */)>
   /**
    * Specialized version of `std::function<void(const CacheStatus&)>`.
    */
-  using Func_void_CacheStatus = std::function<void(const CacheStatus& /* status */)>;
+  using Func_void_CacheStatus = std::function<void(const CacheStatus& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const CacheStatus& / * status * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const CacheStatus& / * result * /)>`, this can be used from Swift.
    */
   class Func_void_CacheStatus_Wrapper final {
   public:
-    explicit Func_void_CacheStatus_Wrapper(std::function<void(const CacheStatus& /* status */)>&& func): _function(std::make_unique<std::function<void(const CacheStatus& /* status */)>>(std::move(func))) {}
-    inline void call(CacheStatus status) const noexcept {
-      _function->operator()(status);
+    explicit Func_void_CacheStatus_Wrapper(std::function<void(const CacheStatus& /* result */)>&& func): _function(std::make_unique<std::function<void(const CacheStatus& /* result */)>>(std::move(func))) {}
+    inline void call(CacheStatus result) const noexcept {
+      _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const CacheStatus& /* status */)>> _function;
+    std::unique_ptr<std::function<void(const CacheStatus& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
   Func_void_CacheStatus create_Func_void_CacheStatus(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_CacheStatus_Wrapper wrap_Func_void_CacheStatus(Func_void_CacheStatus value) noexcept {
@@ -1674,13 +1689,13 @@ namespace margelo::nitro::queueplayer::bridge::swift {
   using std__weak_ptr_HybridTrackPlayerSpec_ = std::weak_ptr<HybridTrackPlayerSpec>;
   inline std__weak_ptr_HybridTrackPlayerSpec_ weakify_std__shared_ptr_HybridTrackPlayerSpec_(const std::shared_ptr<HybridTrackPlayerSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<std::vector<TrackItem>>
-  using Result_std__vector_TrackItem__ = Result<std::vector<TrackItem>>;
-  inline Result_std__vector_TrackItem__ create_Result_std__vector_TrackItem__(const std::vector<TrackItem>& value) noexcept {
-    return Result<std::vector<TrackItem>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>
+  using Result_std__shared_ptr_Promise_std__vector_TrackItem____ = Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_TrackItem____ create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(const std::shared_ptr<Promise<std::vector<TrackItem>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>::withValue(value);
   }
-  inline Result_std__vector_TrackItem__ create_Result_std__vector_TrackItem__(const std::exception_ptr& error) noexcept {
-    return Result<std::vector<TrackItem>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__vector_TrackItem____ create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>::withError(error);
   }
   
   // pragma MARK: Result<PlaybackMode>
@@ -1773,13 +1788,13 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return Result<void>::withError(error);
   }
   
-  // pragma MARK: Result<CacheStatus>
-  using Result_CacheStatus_ = Result<CacheStatus>;
-  inline Result_CacheStatus_ create_Result_CacheStatus_(const CacheStatus& value) noexcept {
-    return Result<CacheStatus>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<CacheStatus>>>
+  using Result_std__shared_ptr_Promise_CacheStatus___ = Result<std::shared_ptr<Promise<CacheStatus>>>;
+  inline Result_std__shared_ptr_Promise_CacheStatus___ create_Result_std__shared_ptr_Promise_CacheStatus___(const std::shared_ptr<Promise<CacheStatus>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<CacheStatus>>>::withValue(value);
   }
-  inline Result_CacheStatus_ create_Result_CacheStatus_(const std::exception_ptr& error) noexcept {
-    return Result<CacheStatus>::withError(error);
+  inline Result_std__shared_ptr_Promise_CacheStatus___ create_Result_std__shared_ptr_Promise_CacheStatus___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<CacheStatus>>>::withError(error);
   }
   
   // pragma MARK: Result<ReplayGainMode>