react-native-queue-player 1.0.0

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -0,0 +1,749 @@
+///
+/// HybridTrackPlayerSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridTrackPlayerSpec.hpp"
+
+// Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
+namespace QueuePlayer { class HybridTrackPlayerSpec_cxx; }
+
+// Forward declaration of `PlayerConfig` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlayerConfig; }
+// Forward declaration of `AudioContentType` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioContentType; }
+// Forward declaration of `AudioCategoryOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct AudioCategoryOptions; }
+// Forward declaration of `EvictionPolicy` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class EvictionPolicy; }
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct TrackItem; }
+// Forward declaration of `PlaybackMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlaybackMode; }
+// Forward declaration of `PlaybackModeKind` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlaybackModeKind; }
+// Forward declaration of `PitchCorrectionMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PitchCorrectionMode; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class RepeatMode; }
+// Forward declaration of `RemoteControlOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct RemoteControlOptions; }
+// Forward declaration of `RemoteSkipMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class RemoteSkipMode; }
+// Forward declaration of `ShuffleResult` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct ShuffleResult; }
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlayerState; }
+// Forward declaration of `TrackSource` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class TrackSource; }
+// Forward declaration of `BufferState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class BufferState; }
+// Forward declaration of `SkipCapability` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct SkipCapability; }
+// Forward declaration of `SleepTimerState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct SleepTimerState; }
+// Forward declaration of `StateChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class StateChangeReason; }
+// Forward declaration of `TrackChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class TrackChangeReason; }
+// Forward declaration of `PlayerProgress` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlayerProgress; }
+// Forward declaration of `PlaybackError` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlaybackError; }
+// Forward declaration of `PlaybackErrorCode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlaybackErrorCode; }
+// Forward declaration of `BrowseSnapshot` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseSnapshot; }
+// Forward declaration of `BrowseSection` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseSection; }
+// Forward declaration of `SectionIcon` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class SectionIcon; }
+// Forward declaration of `BrowseItem` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseItem; }
+// Forward declaration of `MediaSearchRequest` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct MediaSearchRequest; }
+// Forward declaration of `MediaSearchType` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchType; }
+// Forward declaration of `MediaSearchOrigin` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchOrigin; }
+// Forward declaration of `MediaSearchReference` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchReference; }
+// Forward declaration of `MediaSearchRepeatMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchRepeatMode; }
+// Forward declaration of `MediaSearchReleaseDateRange` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct MediaSearchReleaseDateRange; }
+// Forward declaration of `MediaSearchQueueLocation` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchQueueLocation; }
+// Forward declaration of `VoiceVocabulary` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct VoiceVocabulary; }
+// Forward declaration of `ServiceReadyReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class ServiceReadyReason; }
+// Forward declaration of `LookaheadCacheConfig` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct LookaheadCacheConfig; }
+// Forward declaration of `CacheStatus` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CacheStatus; }
+// Forward declaration of `ReplayGainMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class ReplayGainMode; }
+// Forward declaration of `NowPlayingFormat` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormat; }
+// Forward declaration of `AudioCodec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioCodec; }
+// Forward declaration of `AudioContainer` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioContainer; }
+// Forward declaration of `NowPlayingFormatIosExtras` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormatIosExtras; }
+// Forward declaration of `NowPlayingFormatAndroidExtras` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormatAndroidExtras; }
+
+#include <NitroModules/Promise.hpp>
+#include "PlayerConfig.hpp"
+#include <string>
+#include <unordered_map>
+#include <optional>
+#include "AudioContentType.hpp"
+#include "AudioCategoryOptions.hpp"
+#include "EvictionPolicy.hpp"
+#include "TrackItem.hpp"
+#include <vector>
+#include "PlaybackMode.hpp"
+#include "PlaybackModeKind.hpp"
+#include "PitchCorrectionMode.hpp"
+#include "RepeatMode.hpp"
+#include "RemoteControlOptions.hpp"
+#include "RemoteSkipMode.hpp"
+#include "ShuffleResult.hpp"
+#include "PlayerState.hpp"
+#include "TrackSource.hpp"
+#include "BufferState.hpp"
+#include "SkipCapability.hpp"
+#include "SleepTimerState.hpp"
+#include <functional>
+#include "StateChangeReason.hpp"
+#include "TrackChangeReason.hpp"
+#include "PlayerProgress.hpp"
+#include "PlaybackError.hpp"
+#include "PlaybackErrorCode.hpp"
+#include "BrowseSnapshot.hpp"
+#include "BrowseSection.hpp"
+#include "SectionIcon.hpp"
+#include "BrowseItem.hpp"
+#include "MediaSearchRequest.hpp"
+#include "MediaSearchType.hpp"
+#include "MediaSearchOrigin.hpp"
+#include "MediaSearchReference.hpp"
+#include "MediaSearchRepeatMode.hpp"
+#include "MediaSearchReleaseDateRange.hpp"
+#include "MediaSearchQueueLocation.hpp"
+#include "VoiceVocabulary.hpp"
+#include "ServiceReadyReason.hpp"
+#include "LookaheadCacheConfig.hpp"
+#include "CacheStatus.hpp"
+#include "ReplayGainMode.hpp"
+#include <NitroModules/Null.hpp>
+#include "NowPlayingFormat.hpp"
+#include <variant>
+#include "AudioCodec.hpp"
+#include "AudioContainer.hpp"
+#include "NowPlayingFormatIosExtras.hpp"
+#include "NowPlayingFormatAndroidExtras.hpp"
+
+#include "QueuePlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  /**
+   * The C++ part of HybridTrackPlayerSpec_cxx.swift.
+   *
+   * HybridTrackPlayerSpecSwift (C++) accesses HybridTrackPlayerSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridTrackPlayerSpec_cxx can directly inherit from the C++ class HybridTrackPlayerSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridTrackPlayerSpecSwift: public virtual HybridTrackPlayerSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridTrackPlayerSpecSwift(const QueuePlayer::HybridTrackPlayerSpec_cxx& swiftPart):
+      HybridObject(HybridTrackPlayerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline QueuePlayer::HybridTrackPlayerSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridTrackPlayerSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> configure(const PlayerConfig& config) override {
+      auto __result = _swiftPart.configure(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> destroy() override {
+      auto __result = _swiftPart.destroy();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setQueue(const std::vector<TrackItem>& tracks, std::optional<double> startAtIndex) override {
+      auto __result = _swiftPart.setQueue(tracks, startAtIndex);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> addToQueue(const std::vector<TrackItem>& tracks, std::optional<double> insertBefore) override {
+      auto __result = _swiftPart.addToQueue(tracks, insertBefore);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> removeFromQueue(const std::vector<double>& indices) override {
+      auto __result = _swiftPart.removeFromQueue(indices);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> moveInQueue(double fromIndex, double toIndex) override {
+      auto __result = _swiftPart.moveInQueue(std::forward<decltype(fromIndex)>(fromIndex), std::forward<decltype(toIndex)>(toIndex));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<TrackItem> getQueue() override {
+      auto __result = _swiftPart.getQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearQueue() override {
+      auto __result = _swiftPart.clearQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> play() override {
+      auto __result = _swiftPart.play();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> pause() override {
+      auto __result = _swiftPart.pause();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> stop() override {
+      auto __result = _swiftPart.stop();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> retry() override {
+      auto __result = _swiftPart.retry();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> seekTo(double position) override {
+      auto __result = _swiftPart.seekTo(std::forward<decltype(position)>(position));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> skipToIndex(double index) override {
+      auto __result = _swiftPart.skipToIndex(std::forward<decltype(index)>(index));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> skipToNext() override {
+      auto __result = _swiftPart.skipToNext();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> skipToPrevious() override {
+      auto __result = _swiftPart.skipToPrevious();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setPlaybackMode(const PlaybackMode& mode) override {
+      auto __result = _swiftPart.setPlaybackMode(std::forward<decltype(mode)>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline PlaybackMode getPlaybackMode() override {
+      auto __result = _swiftPart.getPlaybackMode();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setPlaybackSpeed(double rate) override {
+      auto __result = _swiftPart.setPlaybackSpeed(std::forward<decltype(rate)>(rate));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setPitchCorrectionMode(PitchCorrectionMode mode) override {
+      auto __result = _swiftPart.setPitchCorrectionMode(static_cast<int>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setVolume(double volume) override {
+      auto __result = _swiftPart.setVolume(std::forward<decltype(volume)>(volume));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setRepeatMode(RepeatMode mode) override {
+      auto __result = _swiftPart.setRepeatMode(static_cast<int>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setRemoteControls(const RemoteControlOptions& options) override {
+      auto __result = _swiftPart.setRemoteControls(std::forward<decltype(options)>(options));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setSleepTimer(double seconds) override {
+      auto __result = _swiftPart.setSleepTimer(std::forward<decltype(seconds)>(seconds));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setSleepTimerToTrackEnd() override {
+      auto __result = _swiftPart.setSleepTimerToTrackEnd();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearSleepTimer() override {
+      auto __result = _swiftPart.clearSleepTimer();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<ShuffleResult>> shuffleQueue() override {
+      auto __result = _swiftPart.shuffleQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline PlayerState getState() override {
+      auto __result = _swiftPart.getState();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getCurrentTrackIndex() override {
+      auto __result = _swiftPart.getCurrentTrackIndex();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<TrackSource> getCurrentTrackSource() override {
+      auto __result = _swiftPart.getCurrentTrackSource();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getPlaybackSpeed() override {
+      auto __result = _swiftPart.getPlaybackSpeed();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline PitchCorrectionMode getPitchCorrectionMode() override {
+      auto __result = _swiftPart.getPitchCorrectionMode();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getVolume() override {
+      auto __result = _swiftPart.getVolume();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline RemoteControlOptions getRemoteControls() override {
+      auto __result = _swiftPart.getRemoteControls();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline BufferState getBufferState() override {
+      auto __result = _swiftPart.getBufferState();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool getIsSeekable() override {
+      auto __result = _swiftPart.getIsSeekable();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isFullyBuffered() override {
+      auto __result = _swiftPart.isFullyBuffered();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool getCanSkipNext() override {
+      auto __result = _swiftPart.getCanSkipNext();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool getCanSkipPrevious() override {
+      auto __result = _swiftPart.getCanSkipPrevious();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline SkipCapability getSkipCapability() override {
+      auto __result = _swiftPart.getSkipCapability();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline SleepTimerState getSleepTimer() override {
+      auto __result = _swiftPart.getSleepTimer();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onStateChange(const std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>& callback) override {
+      auto __result = _swiftPart.onStateChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onTrackChange(const std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>& callback) override {
+      auto __result = _swiftPart.onTrackChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onProgress(const std::function<void(const PlayerProgress& /* progress */)>& callback) override {
+      auto __result = _swiftPart.onProgress(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onPlaybackMilestone(const std::function<void(double /* milestone */, double /* trackIndex */)>& callback) override {
+      auto __result = _swiftPart.onPlaybackMilestone(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onError(const std::function<void(const PlaybackError& /* error */)>& callback) override {
+      auto __result = _swiftPart.onError(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onQueueEnd(const std::function<void()>& callback) override {
+      auto __result = _swiftPart.onQueueEnd(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onSkipCapabilityChange(const std::function<void(const SkipCapability& /* capability */)>& callback) override {
+      auto __result = _swiftPart.onSkipCapabilityChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onSleepTimerChange(const std::function<void(const SleepTimerState& /* state */)>& callback) override {
+      auto __result = _swiftPart.onSleepTimerChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onBufferStateChange(const std::function<void(BufferState /* state */)>& callback) override {
+      auto __result = _swiftPart.onBufferStateChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onFullyBufferedChange(const std::function<void(bool /* fullyBuffered */)>& callback) override {
+      auto __result = _swiftPart.onFullyBufferedChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setBrowseSnapshot(const BrowseSnapshot& snapshot) override {
+      auto __result = _swiftPart.setBrowseSnapshot(std::forward<decltype(snapshot)>(snapshot));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::function<void()> onBrowseRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>& callback) override {
+      auto __result = _swiftPart.onBrowseRequest(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* query */)>& callback) override {
+      auto __result = _swiftPart.onSearchRequest(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onPlayFromSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>& callback) override {
+      auto __result = _swiftPart.onPlayFromSearchRequest(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onPlayFromIdRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>& callback) override {
+      auto __result = _swiftPart.onPlayFromIdRequest(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void donateVoiceVocabulary(const VoiceVocabulary& vocabulary) override {
+      auto __result = _swiftPart.donateVoiceVocabulary(std::forward<decltype(vocabulary)>(vocabulary));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::function<void()> onCarConnect(const std::function<void()>& callback) override {
+      auto __result = _swiftPart.onCarConnect(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onCarDisconnect(const std::function<void()>& callback) override {
+      auto __result = _swiftPart.onCarDisconnect(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onServiceReady(const std::function<void(ServiceReadyReason /* reason */)>& callback) override {
+      auto __result = _swiftPart.onServiceReady(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setLookaheadCache(const LookaheadCacheConfig& config) override {
+      auto __result = _swiftPart.setLookaheadCache(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline CacheStatus getLookaheadCacheStatus() override {
+      auto __result = _swiftPart.getLookaheadCacheStatus();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearLookaheadCache() override {
+      auto __result = _swiftPart.clearLookaheadCache();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onCacheStatusChange(const std::function<void(const CacheStatus& /* status */)>& callback) override {
+      auto __result = _swiftPart.onCacheStatusChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setReplayGainMode(ReplayGainMode mode) override {
+      auto __result = _swiftPart.setReplayGainMode(static_cast<int>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ReplayGainMode getReplayGainMode() override {
+      auto __result = _swiftPart.getReplayGainMode();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<nitro::NullType, NowPlayingFormat> getNowPlayingFormat() override {
+      auto __result = _swiftPart.getNowPlayingFormat();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onNowPlayingFormatChange(const std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>& callback) override {
+      auto __result = _swiftPart.onNowPlayingFormatChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    QueuePlayer::HybridTrackPlayerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::queueplayer