react-native-nitro-player 0.6.1 → 0.7.1-alpha.0

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

@@ -240,7 +240,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool isTrackDownloaded(const std::string& trackId) override {
+    inline std::shared_ptr<Promise<bool>> isTrackDownloaded(const std::string& trackId) override {
       auto __result = _swiftPart.isTrackDownloaded(trackId);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -248,7 +248,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool isPlaylistDownloaded(const std::string& playlistId) override {
+    inline std::shared_ptr<Promise<bool>> isPlaylistDownloaded(const std::string& playlistId) override {
       auto __result = _swiftPart.isPlaylistDownloaded(playlistId);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -256,7 +256,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool isPlaylistPartiallyDownloaded(const std::string& playlistId) override {
+    inline std::shared_ptr<Promise<bool>> isPlaylistPartiallyDownloaded(const std::string& playlistId) override {
       auto __result = _swiftPart.isPlaylistPartiallyDownloaded(playlistId);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -264,7 +264,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<nitro::NullType, DownloadedTrack> getDownloadedTrack(const std::string& trackId) override {
+    inline std::shared_ptr<Promise<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());
@@ -272,7 +272,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::vector<DownloadedTrack> getAllDownloadedTracks() override {
+    inline std::shared_ptr<Promise<std::vector<DownloadedTrack>>> getAllDownloadedTracks() override {
       auto __result = _swiftPart.getAllDownloadedTracks();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -280,7 +280,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<nitro::NullType, DownloadedPlaylist> getDownloadedPlaylist(const std::string& playlistId) override {
+    inline std::shared_ptr<Promise<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());
@@ -288,7 +288,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::vector<DownloadedPlaylist> getAllDownloadedPlaylists() override {
+    inline std::shared_ptr<Promise<std::vector<DownloadedPlaylist>>> getAllDownloadedPlaylists() override {
       auto __result = _swiftPart.getAllDownloadedPlaylists();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -296,7 +296,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<nitro::NullType, std::string> getLocalPath(const std::string& trackId) override {
+    inline std::shared_ptr<Promise<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());
@@ -336,7 +336,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline double syncDownloads() override {
+    inline std::shared_ptr<Promise<double>> syncDownloads() override {
       auto __result = _swiftPart.syncDownloads();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -358,7 +358,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::string getEffectiveUrl(const TrackItem& track) override {
+    inline std::shared_ptr<Promise<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());

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

@@ -23,6 +23,7 @@ namespace margelo::nitro::nitroplayer { enum class PresetType; }
 // Forward declaration of `EqualizerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct EqualizerState; }
 
+#include <NitroModules/Promise.hpp>
 #include "EqualizerBand.hpp"
 #include <vector>
 #include <string>
@@ -85,7 +86,7 @@ namespace margelo::nitro::nitroplayer {
 
   public:
     // Methods
-    inline bool setEnabled(bool enabled) override {
+    inline std::shared_ptr<Promise<void>> setEnabled(bool enabled) override {
       auto __result = _swiftPart.setEnabled(std::forward<decltype(enabled)>(enabled));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -101,7 +102,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::vector<EqualizerBand> getBands() override {
+    inline std::shared_ptr<Promise<std::vector<EqualizerBand>>> getBands() override {
       auto __result = _swiftPart.getBands();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -109,7 +110,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool setBandGain(double bandIndex, double gainDb) override {
+    inline std::shared_ptr<Promise<void>> setBandGain(double bandIndex, double gainDb) override {
       auto __result = _swiftPart.setBandGain(std::forward<decltype(bandIndex)>(bandIndex), std::forward<decltype(gainDb)>(gainDb));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -117,7 +118,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool setAllBandGains(const std::vector<double>& gains) override {
+    inline std::shared_ptr<Promise<void>> setAllBandGains(const std::vector<double>& gains) override {
       auto __result = _swiftPart.setAllBandGains(gains);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -157,7 +158,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool applyPreset(const std::string& presetName) override {
+    inline std::shared_ptr<Promise<void>> applyPreset(const std::string& presetName) override {
       auto __result = _swiftPart.applyPreset(presetName);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -173,7 +174,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool saveCustomPreset(const std::string& name) override {
+    inline std::shared_ptr<Promise<void>> saveCustomPreset(const std::string& name) override {
       auto __result = _swiftPart.saveCustomPreset(name);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -181,7 +182,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool deleteCustomPreset(const std::string& name) override {
+    inline std::shared_ptr<Promise<void>> deleteCustomPreset(const std::string& name) override {
       auto __result = _swiftPart.deleteCustomPreset(name);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -189,7 +190,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline EqualizerState getState() override {
+    inline std::shared_ptr<Promise<EqualizerState>> getState() override {
       auto __result = _swiftPart.getState();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -197,11 +198,13 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void reset() override {
+    inline std::shared_ptr<Promise<void>> reset() override {
       auto __result = _swiftPart.reset();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void onEnabledChange(const std::function<void(bool /* enabled */)>& callback) override {
       auto __result = _swiftPart.onEnabledChange(callback);

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

@@ -20,6 +20,7 @@ namespace margelo::nitro::nitroplayer { struct TrackItem; }
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 
 #include <string>
+#include <NitroModules/Promise.hpp>
 #include <optional>
 #include <NitroModules/Null.hpp>
 #include "Playlist.hpp"
@@ -80,7 +81,7 @@ namespace margelo::nitro::nitroplayer {
 
   public:
     // Methods
-    inline std::string createPlaylist(const std::string& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) override {
+    inline std::shared_ptr<Promise<std::string>> createPlaylist(const std::string& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) override {
       auto __result = _swiftPart.createPlaylist(name, description, artwork);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -88,17 +89,21 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void deletePlaylist(const std::string& playlistId) override {
+    inline std::shared_ptr<Promise<void>> deletePlaylist(const std::string& playlistId) override {
       auto __result = _swiftPart.deletePlaylist(playlistId);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline void updatePlaylist(const std::string& playlistId, const std::optional<std::string>& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) override {
+    inline std::shared_ptr<Promise<void>> updatePlaylist(const std::string& playlistId, const std::optional<std::string>& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) override {
       auto __result = _swiftPart.updatePlaylist(playlistId, name, description, artwork);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::variant<nitro::NullType, Playlist> getPlaylist(const std::string& playlistId) override {
       auto __result = _swiftPart.getPlaylist(playlistId);
@@ -116,35 +121,45 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void addTrackToPlaylist(const std::string& playlistId, const TrackItem& track, std::optional<double> index) override {
+    inline std::shared_ptr<Promise<void>> addTrackToPlaylist(const std::string& playlistId, const TrackItem& track, std::optional<double> index) override {
       auto __result = _swiftPart.addTrackToPlaylist(playlistId, std::forward<decltype(track)>(track), index);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline void addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) override {
+    inline std::shared_ptr<Promise<void>> addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) override {
       auto __result = _swiftPart.addTracksToPlaylist(playlistId, tracks, index);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline void removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) override {
+    inline std::shared_ptr<Promise<void>> removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) override {
       auto __result = _swiftPart.removeTrackFromPlaylist(playlistId, trackId);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline void reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) override {
+    inline std::shared_ptr<Promise<void>> reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) override {
       auto __result = _swiftPart.reorderTrackInPlaylist(playlistId, trackId, std::forward<decltype(newIndex)>(newIndex));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline void loadPlaylist(const std::string& playlistId) override {
+    inline std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId) override {
       auto __result = _swiftPart.loadPlaylist(playlistId);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::variant<nitro::NullType, std::string> getCurrentPlaylistId() override {
       auto __result = _swiftPart.getCurrentPlaylistId();

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

@@ -93,17 +93,21 @@ namespace margelo::nitro::nitroplayer {
 
   public:
     // Methods
-    inline void play() override {
+    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 void pause() override {
+    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>> playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override {
       auto __result = _swiftPart.playSong(songId, fromPlaylist);
@@ -113,11 +117,13 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void skipToNext() override {
+    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<bool>> skipToIndex(double index) override {
       auto __result = _swiftPart.skipToIndex(std::forward<decltype(index)>(index));
@@ -127,17 +133,21 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void skipToPrevious() override {
+    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 void seek(double position) override {
+    inline std::shared_ptr<Promise<void>> seek(double position) override {
       auto __result = _swiftPart.seek(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>> addToUpNext(const std::string& trackId) override {
       auto __result = _swiftPart.addToUpNext(trackId);
@@ -171,7 +181,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool setRepeatMode(RepeatMode mode) override {
+    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());
@@ -187,11 +197,13 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void configure(const PlayerConfig& config) override {
+    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 void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override {
       auto __result = _swiftPart.onChangeTrack(callback);
@@ -231,7 +243,7 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline bool setVolume(double volume) override {
+    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());
@@ -301,6 +313,68 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<bool>> removeFromPlayNext(const std::string& trackId) override {
+      auto __result = _swiftPart.removeFromPlayNext(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> removeFromUpNext(const std::string& trackId) override {
+      auto __result = _swiftPart.removeFromUpNext(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearPlayNext() override {
+      auto __result = _swiftPart.clearPlayNext();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearUpNext() override {
+      auto __result = _swiftPart.clearUpNext();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> reorderTemporaryTrack(const std::string& trackId, double newIndex) override {
+      auto __result = _swiftPart.reorderTemporaryTrack(trackId, std::forward<decltype(newIndex)>(newIndex));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<TrackItem>>> getPlayNextQueue() override {
+      auto __result = _swiftPart.getPlayNextQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<TrackItem>>> getUpNextQueue() override {
+      auto __result = _swiftPart.getUpNextQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void onTemporaryQueueChange(const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& callback) override {
+      auto __result = _swiftPart.onTemporaryQueueChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     NitroPlayer::HybridTrackPlayerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void_EqualizerState.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_EqualizerState.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: EqualizerState) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_EqualizerState {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ value: EqualizerState) -> Void
+
+  public init(_ closure: @escaping (_ value: EqualizerState) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: EqualizerState) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_EqualizerState`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_EqualizerState>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_EqualizerState {
+    return Unmanaged<Func_void_EqualizerState>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__variant_nitro__NullType__DownloadedPlaylist_.swift

@@ -0,0 +1,58 @@
+///
+/// Func_void_std__variant_nitro__NullType__DownloadedPlaylist_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Variant_NullType_DownloadedPlaylist) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__variant_nitro__NullType__DownloadedPlaylist_ {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ value: Variant_NullType_DownloadedPlaylist) -> Void
+
+  public init(_ closure: @escaping (_ value: Variant_NullType_DownloadedPlaylist) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__variant_nitro__NullType__DownloadedPlaylist_) -> Void {
+    self.closure({ () -> Variant_NullType_DownloadedPlaylist in
+      let __variant = value
+      switch __variant.index() {
+        case 0:
+          let __actual = __variant.get_0()
+          return .first(NullType.null)
+        case 1:
+          let __actual = __variant.get_1()
+          return .second(__actual)
+        default:
+          fatalError("Variant can never have index \(__variant.index())!")
+      }
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__variant_nitro__NullType__DownloadedPlaylist_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_nitro__NullType__DownloadedPlaylist_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_nitro__NullType__DownloadedPlaylist_ {
+    return Unmanaged<Func_void_std__variant_nitro__NullType__DownloadedPlaylist_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__variant_nitro__NullType__DownloadedTrack_.swift

@@ -0,0 +1,58 @@
+///
+/// Func_void_std__variant_nitro__NullType__DownloadedTrack_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Variant_NullType_DownloadedTrack) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__variant_nitro__NullType__DownloadedTrack_ {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ value: Variant_NullType_DownloadedTrack) -> Void
+
+  public init(_ closure: @escaping (_ value: Variant_NullType_DownloadedTrack) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__variant_nitro__NullType__DownloadedTrack_) -> Void {
+    self.closure({ () -> Variant_NullType_DownloadedTrack in
+      let __variant = value
+      switch __variant.index() {
+        case 0:
+          let __actual = __variant.get_0()
+          return .first(NullType.null)
+        case 1:
+          let __actual = __variant.get_1()
+          return .second(__actual)
+        default:
+          fatalError("Variant can never have index \(__variant.index())!")
+      }
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__variant_nitro__NullType__DownloadedTrack_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_nitro__NullType__DownloadedTrack_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_nitro__NullType__DownloadedTrack_ {
+    return Unmanaged<Func_void_std__variant_nitro__NullType__DownloadedTrack_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__variant_nitro__NullType__std__string_.swift

@@ -0,0 +1,58 @@
+///
+/// Func_void_std__variant_nitro__NullType__std__string_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Variant_NullType_String) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__variant_nitro__NullType__std__string_ {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ value: Variant_NullType_String) -> Void
+
+  public init(_ closure: @escaping (_ value: Variant_NullType_String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__variant_nitro__NullType__std__string_) -> Void {
+    self.closure({ () -> Variant_NullType_String in
+      let __variant = value
+      switch __variant.index() {
+        case 0:
+          let __actual = __variant.get_0()
+          return .first(NullType.null)
+        case 1:
+          let __actual = __variant.get_1()
+          return .second(String(__actual))
+        default:
+          fatalError("Variant can never have index \(__variant.index())!")
+      }
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__variant_nitro__NullType__std__string_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_nitro__NullType__std__string_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_nitro__NullType__std__string_ {
+    return Unmanaged<Func_void_std__variant_nitro__NullType__std__string_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}