react-native-nitro-player 0.0.1

package/nitrogen/generated/ios/NitroPlayerAutolinking.swift

@@ -0,0 +1,55 @@
+///
+/// NitroPlayerAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+public final class NitroPlayerAutolinking {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  /**
+   * Creates an instance of a Swift class that implements `HybridPlayerQueueSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridPlayerQueueSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridPlayerQueue`).
+   */
+  public static func createPlayerQueue() -> bridge.std__shared_ptr_HybridPlayerQueueSpec_ {
+    let hybridObject = HybridPlayerQueue()
+    return { () -> bridge.std__shared_ptr_HybridPlayerQueueSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridTrackPlayerSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridTrackPlayerSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridTrackPlayer`).
+   */
+  public static func createTrackPlayer() -> bridge.std__shared_ptr_HybridTrackPlayerSpec_ {
+    let hybridObject = HybridTrackPlayer()
+    return { () -> bridge.std__shared_ptr_HybridTrackPlayerSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridAudioRoutePickerSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridAudioRoutePickerSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridAudioRoutePicker`).
+   */
+  public static func createAudioRoutePicker() -> bridge.std__shared_ptr_HybridAudioRoutePickerSpec_ {
+    let hybridObject = HybridAudioRoutePicker()
+    return { () -> bridge.std__shared_ptr_HybridAudioRoutePickerSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+}

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

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

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

@@ -0,0 +1,74 @@
+///
+/// HybridAudioRoutePickerSpecSwift.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 "HybridAudioRoutePickerSpec.hpp"
+
+// Forward declaration of `HybridAudioRoutePickerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridAudioRoutePickerSpec_cxx; }
+
+
+
+
+
+#include "NitroPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * The C++ part of HybridAudioRoutePickerSpec_cxx.swift.
+   *
+   * HybridAudioRoutePickerSpecSwift (C++) accesses HybridAudioRoutePickerSpec_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, HybridAudioRoutePickerSpec_cxx can directly inherit from the C++ class HybridAudioRoutePickerSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridAudioRoutePickerSpecSwift: public virtual HybridAudioRoutePickerSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridAudioRoutePickerSpecSwift(const NitroPlayer::HybridAudioRoutePickerSpec_cxx& swiftPart):
+      HybridObject(HybridAudioRoutePickerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroPlayer::HybridAudioRoutePickerSpec_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 showRoutePicker() override {
+      auto __result = _swiftPart.showRoutePicker();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroPlayer::HybridAudioRoutePickerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

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

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

@@ -0,0 +1,167 @@
+///
+/// HybridPlayerQueueSpecSwift.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 "HybridPlayerQueueSpec.hpp"
+
+// Forward declaration of `HybridPlayerQueueSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
+
+// Forward declaration of `Playlist` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct Playlist; }
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `QueueOperation` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
+
+#include <string>
+#include <optional>
+#include <NitroModules/Null.hpp>
+#include "Playlist.hpp"
+#include <variant>
+#include "TrackItem.hpp"
+#include <vector>
+#include "QueueOperation.hpp"
+#include <functional>
+
+#include "NitroPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * The C++ part of HybridPlayerQueueSpec_cxx.swift.
+   *
+   * HybridPlayerQueueSpecSwift (C++) accesses HybridPlayerQueueSpec_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, HybridPlayerQueueSpec_cxx can directly inherit from the C++ class HybridPlayerQueueSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridPlayerQueueSpecSwift: public virtual HybridPlayerQueueSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridPlayerQueueSpecSwift(const NitroPlayer::HybridPlayerQueueSpec_cxx& swiftPart):
+      HybridObject(HybridPlayerQueueSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroPlayer::HybridPlayerQueueSpec_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 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());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void deletePlaylist(const std::string& playlistId) override {
+      auto __result = _swiftPart.deletePlaylist(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    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 {
+      auto __result = _swiftPart.updatePlaylist(playlistId, name, description, artwork);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::variant<nitro::NullType, Playlist> getPlaylist(const std::string& playlistId) override {
+      auto __result = _swiftPart.getPlaylist(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<Playlist> getAllPlaylists() override {
+      auto __result = _swiftPart.getAllPlaylists();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline 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());
+      }
+    }
+    inline 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());
+      }
+    }
+    inline 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());
+      }
+    }
+    inline 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());
+      }
+    }
+    inline void loadPlaylist(const std::string& playlistId) override {
+      auto __result = _swiftPart.loadPlaylist(playlistId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::variant<nitro::NullType, std::string> getCurrentPlaylistId() override {
+      auto __result = _swiftPart.getCurrentPlaylistId();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) override {
+      auto __result = _swiftPart.onPlaylistsChanged(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onPlaylistChanged(const std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>& callback) override {
+      auto __result = _swiftPart.onPlaylistChanged(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroPlayer::HybridPlayerQueueSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

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

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

@@ -0,0 +1,174 @@
+///
+/// HybridTrackPlayerSpecSwift.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 "HybridTrackPlayerSpec.hpp"
+
+// Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
+
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerState; }
+// 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; }
+// Forward declaration of `PlayerConfig` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
+// Forward declaration of `Reason` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class Reason; }
+
+#include <string>
+#include <optional>
+#include "PlayerState.hpp"
+#include <NitroModules/Null.hpp>
+#include "TrackItem.hpp"
+#include <variant>
+#include "TrackPlayerState.hpp"
+#include "PlayerConfig.hpp"
+#include "Reason.hpp"
+#include <functional>
+
+#include "NitroPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * 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 NitroPlayer::HybridTrackPlayerSpec_cxx& swiftPart):
+      HybridObject(HybridTrackPlayerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroPlayer::HybridTrackPlayerSpec_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 play() override {
+      auto __result = _swiftPart.play();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void pause() override {
+      auto __result = _swiftPart.pause();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override {
+      auto __result = _swiftPart.playSong(songId, fromPlaylist);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void skipToNext() override {
+      auto __result = _swiftPart.skipToNext();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void skipToPrevious() override {
+      auto __result = _swiftPart.skipToPrevious();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void seek(double position) override {
+      auto __result = _swiftPart.seek(std::forward<decltype(position)>(position));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    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 void configure(const PlayerConfig& config) override {
+      auto __result = _swiftPart.configure(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override {
+      auto __result = _swiftPart.onChangeTrack(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) override {
+      auto __result = _swiftPart.onPlaybackStateChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) override {
+      auto __result = _swiftPart.onSeek(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) override {
+      auto __result = _swiftPart.onPlaybackProgressChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override {
+      auto __result = _swiftPart.onAndroidAutoConnectionChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline bool isAndroidAutoConnected() override {
+      auto __result = _swiftPart.isAndroidAutoConnected();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroPlayer::HybridTrackPlayerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/ios/swift/Func_void_TrackItem_std__optional_Reason_.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_TrackItem_std__optional_Reason_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ track: TrackItem, _ reason: Reason?) -> 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_TrackItem_std__optional_Reason_ {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ track: TrackItem, _ reason: Reason?) -> Void
+
+  public init(_ closure: @escaping (_ track: TrackItem, _ reason: Reason?) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(track: TrackItem, reason: bridge.std__optional_Reason_) -> Void {
+    self.closure(track, reason.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_TrackItem_std__optional_Reason_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_TrackItem_std__optional_Reason_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_TrackItem_std__optional_Reason_ {
+    return Unmanaged<Func_void_TrackItem_std__optional_Reason_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_TrackPlayerState_std__optional_Reason_.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_TrackPlayerState_std__optional_Reason_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ state: TrackPlayerState, _ reason: Reason?) -> 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_TrackPlayerState_std__optional_Reason_ {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ state: TrackPlayerState, _ reason: Reason?) -> Void
+
+  public init(_ closure: @escaping (_ state: TrackPlayerState, _ reason: Reason?) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(state: Int32, reason: bridge.std__optional_Reason_) -> Void {
+    self.closure(margelo.nitro.nitroplayer.TrackPlayerState(rawValue: state)!, reason.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_TrackPlayerState_std__optional_Reason_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_TrackPlayerState_std__optional_Reason_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_TrackPlayerState_std__optional_Reason_ {
+    return Unmanaged<Func_void_TrackPlayerState_std__optional_Reason_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_bool.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_bool.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ connected: Bool) -> 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_bool {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ connected: Bool) -> Void
+
+  public init(_ closure: @escaping (_ connected: Bool) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(connected: Bool) -> Void {
+    self.closure(connected)
+  }
+
+  /**
+   * 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_bool`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_bool>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_bool {
+    return Unmanaged<Func_void_bool>.fromOpaque(pointer).takeRetainedValue()
+  }
+}