react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Umbrella.hpp

@@ -8,42 +8,104 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `CurrentPlayingType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class CurrentPlayingType; }
+// Forward declaration of `DownloadConfig` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadConfig; }
+// Forward declaration of `DownloadErrorReason` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class DownloadErrorReason; }
+// Forward declaration of `DownloadError` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadError; }
+// Forward declaration of `DownloadProgress` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadProgress; }
+// Forward declaration of `DownloadQueueStatus` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadQueueStatus; }
+// Forward declaration of `DownloadState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class DownloadState; }
+// Forward declaration of `DownloadStorageInfo` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadStorageInfo; }
+// Forward declaration of `DownloadTask` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadTask; }
+// Forward declaration of `DownloadedPlaylist` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadedPlaylist; }
+// Forward declaration of `DownloadedTrack` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadedTrack; }
+// Forward declaration of `EqualizerBand` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerBand; }
+// Forward declaration of `EqualizerPreset` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerPreset; }
+// Forward declaration of `EqualizerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerState; }
+// Forward declaration of `GainRange` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct GainRange; }
 // Forward declaration of `HybridAudioRoutePickerSpec` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { class HybridAudioRoutePickerSpec; }
+// Forward declaration of `HybridDownloadManagerSpec` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { class HybridDownloadManagerSpec; }
+// Forward declaration of `HybridEqualizerSpec` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { class HybridEqualizerSpec; }
 // Forward declaration of `HybridPlayerQueueSpec` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { class HybridPlayerQueueSpec; }
 // Forward declaration of `HybridTrackPlayerSpec` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { class HybridTrackPlayerSpec; }
+// Forward declaration of `PlaybackSource` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PlaybackSource; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `Playlist` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct Playlist; }
+// Forward declaration of `PresetType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PresetType; }
 // Forward declaration of `QueueOperation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 // Forward declaration of `RepeatMode` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
+// Forward declaration of `StorageLocation` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 
 // Include C++ defined types
+#include "CurrentPlayingType.hpp"
+#include "DownloadConfig.hpp"
+#include "DownloadError.hpp"
+#include "DownloadErrorReason.hpp"
+#include "DownloadProgress.hpp"
+#include "DownloadQueueStatus.hpp"
+#include "DownloadState.hpp"
+#include "DownloadStorageInfo.hpp"
+#include "DownloadTask.hpp"
+#include "DownloadedPlaylist.hpp"
+#include "DownloadedTrack.hpp"
+#include "EqualizerBand.hpp"
+#include "EqualizerPreset.hpp"
+#include "EqualizerState.hpp"
+#include "GainRange.hpp"
 #include "HybridAudioRoutePickerSpec.hpp"
+#include "HybridDownloadManagerSpec.hpp"
+#include "HybridEqualizerSpec.hpp"
 #include "HybridPlayerQueueSpec.hpp"
 #include "HybridTrackPlayerSpec.hpp"
+#include "PlaybackSource.hpp"
 #include "PlayerConfig.hpp"
 #include "PlayerState.hpp"
 #include "Playlist.hpp"
+#include "PresetType.hpp"
 #include "QueueOperation.hpp"
 #include "Reason.hpp"
 #include "RepeatMode.hpp"
+#include "StorageLocation.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
@@ -65,6 +127,10 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridAudioRoutePickerSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridAudioRoutePickerSpec_cxx; }
+// Forward declaration of `HybridDownloadManagerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridDownloadManagerSpec_cxx; }
+// Forward declaration of `HybridEqualizerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridEqualizerSpec_cxx; }
 // Forward declaration of `HybridPlayerQueueSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
 // Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.

package/nitrogen/generated/ios/NitroPlayerAutolinking.mm

@@ -13,6 +13,8 @@
 #include "HybridPlayerQueueSpecSwift.hpp"
 #include "HybridTrackPlayerSpecSwift.hpp"
 #include "HybridAudioRoutePickerSpecSwift.hpp"
+#include "HybridDownloadManagerSpecSwift.hpp"
+#include "HybridEqualizerSpecSwift.hpp"
 
 @interface NitroPlayerAutolinking : NSObject
 @end
@@ -44,6 +46,20 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DownloadManager",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridDownloadManagerSpec> hybridObject = NitroPlayer::NitroPlayerAutolinking::createDownloadManager();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Equalizer",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridEqualizerSpec> hybridObject = NitroPlayer::NitroPlayerAutolinking::createEqualizer();
+      return hybridObject;
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/NitroPlayerAutolinking.swift

@@ -52,4 +52,34 @@ public final class NitroPlayerAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridDownloadManagerSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridDownloadManagerSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridDownloadManager`).
+   */
+  public static func createDownloadManager() -> bridge.std__shared_ptr_HybridDownloadManagerSpec_ {
+    let hybridObject = HybridDownloadManager()
+    return { () -> bridge.std__shared_ptr_HybridDownloadManagerSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridEqualizerSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridEqualizerSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridEqualizer`).
+   */
+  public static func createEqualizer() -> bridge.std__shared_ptr_HybridEqualizerSpec_ {
+    let hybridObject = HybridEqualizer()
+    return { () -> bridge.std__shared_ptr_HybridEqualizerSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
 }

package/nitrogen/generated/ios/c++/HybridDownloadManagerSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridDownloadManagerSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridDownloadManagerSpecSwift.hpp"
+
+namespace margelo::nitro::nitroplayer {
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,386 @@
+///
+/// HybridDownloadManagerSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridDownloadManagerSpec.hpp"
+
+// Forward declaration of `HybridDownloadManagerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridDownloadManagerSpec_cxx; }
+
+// Forward declaration of `DownloadConfig` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadConfig; }
+// Forward declaration of `StorageLocation` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `DownloadTask` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadTask; }
+// Forward declaration of `DownloadState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class DownloadState; }
+// Forward declaration of `DownloadProgress` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadProgress; }
+// Forward declaration of `DownloadError` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadError; }
+// Forward declaration of `DownloadErrorReason` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class DownloadErrorReason; }
+// Forward declaration of `DownloadQueueStatus` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadQueueStatus; }
+// Forward declaration of `DownloadedTrack` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadedTrack; }
+// Forward declaration of `DownloadedPlaylist` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadedPlaylist; }
+// Forward declaration of `Playlist` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct Playlist; }
+// Forward declaration of `DownloadStorageInfo` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadStorageInfo; }
+// Forward declaration of `PlaybackSource` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PlaybackSource; }
+
+#include "DownloadConfig.hpp"
+#include "StorageLocation.hpp"
+#include <optional>
+#include <NitroModules/Null.hpp>
+#include <string>
+#include <variant>
+#include <NitroModules/Promise.hpp>
+#include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <vector>
+#include "DownloadTask.hpp"
+#include "DownloadState.hpp"
+#include "DownloadProgress.hpp"
+#include "DownloadError.hpp"
+#include "DownloadErrorReason.hpp"
+#include "DownloadQueueStatus.hpp"
+#include "DownloadedTrack.hpp"
+#include "DownloadedPlaylist.hpp"
+#include "Playlist.hpp"
+#include "DownloadStorageInfo.hpp"
+#include "PlaybackSource.hpp"
+#include <functional>
+
+#include "NitroPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * The C++ part of HybridDownloadManagerSpec_cxx.swift.
+   *
+   * HybridDownloadManagerSpecSwift (C++) accesses HybridDownloadManagerSpec_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, HybridDownloadManagerSpec_cxx can directly inherit from the C++ class HybridDownloadManagerSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridDownloadManagerSpecSwift: public virtual HybridDownloadManagerSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridDownloadManagerSpecSwift(const NitroPlayer::HybridDownloadManagerSpec_cxx& swiftPart):
+      HybridObject(HybridDownloadManagerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroPlayer::HybridDownloadManagerSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void configure(const DownloadConfig& config) override {
+      auto __result = _swiftPart.configure(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline DownloadConfig getConfig() override {
+      auto __result = _swiftPart.getConfig();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> downloadTrack(const TrackItem& track, const std::optional<std::string>& playlistId) override {
+      auto __result = _swiftPart.downloadTrack(std::forward<decltype(track)>(track), playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<std::string>>> downloadPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks) override {
+      auto __result = _swiftPart.downloadPlaylist(playlistId, tracks);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> pauseDownload(const std::string& downloadId) override {
+      auto __result = _swiftPart.pauseDownload(downloadId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> resumeDownload(const std::string& downloadId) override {
+      auto __result = _swiftPart.resumeDownload(downloadId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> cancelDownload(const std::string& downloadId) override {
+      auto __result = _swiftPart.cancelDownload(downloadId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> retryDownload(const std::string& downloadId) override {
+      auto __result = _swiftPart.retryDownload(downloadId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> pauseAllDownloads() override {
+      auto __result = _swiftPart.pauseAllDownloads();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> resumeAllDownloads() override {
+      auto __result = _swiftPart.resumeAllDownloads();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> cancelAllDownloads() override {
+      auto __result = _swiftPart.cancelAllDownloads();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<nitro::NullType, DownloadTask> getDownloadTask(const std::string& downloadId) override {
+      auto __result = _swiftPart.getDownloadTask(downloadId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<DownloadTask> getActiveDownloads() override {
+      auto __result = _swiftPart.getActiveDownloads();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline DownloadQueueStatus getQueueStatus() override {
+      auto __result = _swiftPart.getQueueStatus();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isDownloading(const std::string& trackId) override {
+      auto __result = _swiftPart.isDownloading(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline DownloadState getDownloadState(const std::string& trackId) override {
+      auto __result = _swiftPart.getDownloadState(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isTrackDownloaded(const std::string& trackId) override {
+      auto __result = _swiftPart.isTrackDownloaded(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isPlaylistDownloaded(const std::string& playlistId) override {
+      auto __result = _swiftPart.isPlaylistDownloaded(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isPlaylistPartiallyDownloaded(const std::string& playlistId) override {
+      auto __result = _swiftPart.isPlaylistPartiallyDownloaded(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<nitro::NullType, DownloadedTrack> getDownloadedTrack(const std::string& trackId) override {
+      auto __result = _swiftPart.getDownloadedTrack(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<DownloadedTrack> getAllDownloadedTracks() override {
+      auto __result = _swiftPart.getAllDownloadedTracks();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<nitro::NullType, DownloadedPlaylist> getDownloadedPlaylist(const std::string& playlistId) override {
+      auto __result = _swiftPart.getDownloadedPlaylist(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<DownloadedPlaylist> getAllDownloadedPlaylists() override {
+      auto __result = _swiftPart.getAllDownloadedPlaylists();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<nitro::NullType, std::string> getLocalPath(const std::string& trackId) override {
+      auto __result = _swiftPart.getLocalPath(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> deleteDownloadedTrack(const std::string& trackId) override {
+      auto __result = _swiftPart.deleteDownloadedTrack(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> deleteDownloadedPlaylist(const std::string& playlistId) override {
+      auto __result = _swiftPart.deleteDownloadedPlaylist(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> deleteAllDownloads() override {
+      auto __result = _swiftPart.deleteAllDownloads();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<DownloadStorageInfo>> getStorageInfo() override {
+      auto __result = _swiftPart.getStorageInfo();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double syncDownloads() override {
+      auto __result = _swiftPart.syncDownloads();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setPlaybackSourcePreference(PlaybackSource preference) override {
+      auto __result = _swiftPart.setPlaybackSourcePreference(static_cast<int>(preference));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline PlaybackSource getPlaybackSourcePreference() override {
+      auto __result = _swiftPart.getPlaybackSourcePreference();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::string getEffectiveUrl(const TrackItem& track) override {
+      auto __result = _swiftPart.getEffectiveUrl(std::forward<decltype(track)>(track));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void onDownloadProgress(const std::function<void(const DownloadProgress& /* progress */)>& callback) override {
+      auto __result = _swiftPart.onDownloadProgress(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onDownloadStateChange(const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& callback) override {
+      auto __result = _swiftPart.onDownloadStateChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onDownloadComplete(const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& callback) override {
+      auto __result = _swiftPart.onDownloadComplete(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroPlayer::HybridDownloadManagerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/ios/c++/HybridEqualizerSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridEqualizerSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridEqualizerSpecSwift.hpp"
+
+namespace margelo::nitro::nitroplayer {
+} // namespace margelo::nitro::nitroplayer