react-native-nitro-player 0.0.1

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

@@ -0,0 +1,531 @@
+///
+/// NitroPlayer-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `HybridAudioRoutePickerSpec` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { class HybridAudioRoutePickerSpec; }
+// 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 `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 `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 `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 declarations of Swift defined types
+// Forward declaration of `HybridAudioRoutePickerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridAudioRoutePickerSpec_cxx; }
+// Forward declaration of `HybridPlayerQueueSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
+// Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
+
+// Include C++ defined types
+#include "HybridAudioRoutePickerSpec.hpp"
+#include "HybridPlayerQueueSpec.hpp"
+#include "HybridTrackPlayerSpec.hpp"
+#include "PlayerState.hpp"
+#include "Playlist.hpp"
+#include "QueueOperation.hpp"
+#include "Reason.hpp"
+#include "TrackItem.hpp"
+#include "TrackPlayerState.hpp"
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::nitroplayer::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<HybridAudioRoutePickerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridAudioRoutePickerSpec>`.
+   */
+  using std__shared_ptr_HybridAudioRoutePickerSpec_ = std::shared_ptr<HybridAudioRoutePickerSpec>;
+  std::shared_ptr<HybridAudioRoutePickerSpec> create_std__shared_ptr_HybridAudioRoutePickerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridAudioRoutePickerSpec_(std__shared_ptr_HybridAudioRoutePickerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridAudioRoutePickerSpec>
+  using std__weak_ptr_HybridAudioRoutePickerSpec_ = std::weak_ptr<HybridAudioRoutePickerSpec>;
+  inline std__weak_ptr_HybridAudioRoutePickerSpec_ weakify_std__shared_ptr_HybridAudioRoutePickerSpec_(const std::shared_ptr<HybridAudioRoutePickerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::string>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::string>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__std__string_ {
+    std::variant<nitro::NullType, std::string> variant;
+    std__variant_nitro__NullType__std__string_(std::variant<nitro::NullType, std::string> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::string>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::string>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::string>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__string__ = std::optional<std::variant<nitro::NullType, std::string>>;
+  inline std::optional<std::variant<nitro::NullType, std::string>> create_std__optional_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::string> get_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<TrackItem>
+  /**
+   * Specialized version of `std::vector<TrackItem>`.
+   */
+  using std__vector_TrackItem_ = std::vector<TrackItem>;
+  inline std::vector<TrackItem> create_std__vector_TrackItem_(size_t size) noexcept {
+    std::vector<TrackItem> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, Playlist>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, Playlist>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__Playlist_ {
+    std::variant<nitro::NullType, Playlist> variant;
+    std__variant_nitro__NullType__Playlist_(std::variant<nitro::NullType, Playlist> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, Playlist>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline Playlist get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__Playlist_ create_std__variant_nitro__NullType__Playlist_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__Playlist_(value);
+  }
+  inline std__variant_nitro__NullType__Playlist_ create_std__variant_nitro__NullType__Playlist_(const Playlist& value) noexcept {
+    return std__variant_nitro__NullType__Playlist_(value);
+  }
+  
+  // pragma MARK: std::vector<Playlist>
+  /**
+   * Specialized version of `std::vector<Playlist>`.
+   */
+  using std__vector_Playlist_ = std::vector<Playlist>;
+  inline std::vector<Playlist> create_std__vector_Playlist_(size_t size) noexcept {
+    std::vector<Playlist> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<QueueOperation>
+  /**
+   * Specialized version of `std::optional<QueueOperation>`.
+   */
+  using std__optional_QueueOperation_ = std::optional<QueueOperation>;
+  inline std::optional<QueueOperation> create_std__optional_QueueOperation_(const QueueOperation& value) noexcept {
+    return std::optional<QueueOperation>(value);
+  }
+  inline bool has_value_std__optional_QueueOperation_(const std::optional<QueueOperation>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline QueueOperation get_std__optional_QueueOperation_(const std::optional<QueueOperation>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<Playlist>&, std::optional<QueueOperation>)>`.
+   */
+  using Func_void_std__vector_Playlist__std__optional_QueueOperation_ = std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<Playlist>& / * playlists * /, std::optional<QueueOperation> / * operation * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_Playlist__std__optional_QueueOperation__Wrapper final {
+  public:
+    explicit Func_void_std__vector_Playlist__std__optional_QueueOperation__Wrapper(std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>&& func): _function(std::make_unique<std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>>(std::move(func))) {}
+    inline void call(std::vector<Playlist> playlists, std::optional<QueueOperation> operation) const noexcept {
+      _function->operator()(playlists, operation);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_Playlist__std__optional_QueueOperation_ create_Func_void_std__vector_Playlist__std__optional_QueueOperation_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_Playlist__std__optional_QueueOperation__Wrapper wrap_Func_void_std__vector_Playlist__std__optional_QueueOperation_(Func_void_std__vector_Playlist__std__optional_QueueOperation_ value) noexcept {
+    return Func_void_std__vector_Playlist__std__optional_QueueOperation__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&, const Playlist&, std::optional<QueueOperation>)>`.
+   */
+  using Func_void_std__string_Playlist_std__optional_QueueOperation_ = std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * playlistId * /, const Playlist& / * playlist * /, std::optional<QueueOperation> / * operation * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Playlist_std__optional_QueueOperation__Wrapper final {
+  public:
+    explicit Func_void_std__string_Playlist_std__optional_QueueOperation__Wrapper(std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>>(std::move(func))) {}
+    inline void call(std::string playlistId, Playlist playlist, std::optional<QueueOperation> operation) const noexcept {
+      _function->operator()(playlistId, playlist, operation);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string_Playlist_std__optional_QueueOperation_ create_Func_void_std__string_Playlist_std__optional_QueueOperation_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Playlist_std__optional_QueueOperation__Wrapper wrap_Func_void_std__string_Playlist_std__optional_QueueOperation_(Func_void_std__string_Playlist_std__optional_QueueOperation_ value) noexcept {
+    return Func_void_std__string_Playlist_std__optional_QueueOperation__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPlayerQueueSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridPlayerQueueSpec>`.
+   */
+  using std__shared_ptr_HybridPlayerQueueSpec_ = std::shared_ptr<HybridPlayerQueueSpec>;
+  std::shared_ptr<HybridPlayerQueueSpec> create_std__shared_ptr_HybridPlayerQueueSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridPlayerQueueSpec_(std__shared_ptr_HybridPlayerQueueSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridPlayerQueueSpec>
+  using std__weak_ptr_HybridPlayerQueueSpec_ = std::weak_ptr<HybridPlayerQueueSpec>;
+  inline std__weak_ptr_HybridPlayerQueueSpec_ weakify_std__shared_ptr_HybridPlayerQueueSpec_(const std::shared_ptr<HybridPlayerQueueSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, Playlist>>
+  using Result_std__variant_nitro__NullType__Playlist__ = Result<std::variant<nitro::NullType, Playlist>>;
+  inline Result_std__variant_nitro__NullType__Playlist__ create_Result_std__variant_nitro__NullType__Playlist__(const std::variant<nitro::NullType, Playlist>& value) noexcept {
+    return Result<std::variant<nitro::NullType, Playlist>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__Playlist__ create_Result_std__variant_nitro__NullType__Playlist__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, Playlist>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<Playlist>>
+  using Result_std__vector_Playlist__ = Result<std::vector<Playlist>>;
+  inline Result_std__vector_Playlist__ create_Result_std__vector_Playlist__(const std::vector<Playlist>& value) noexcept {
+    return Result<std::vector<Playlist>>::withValue(value);
+  }
+  inline Result_std__vector_Playlist__ create_Result_std__vector_Playlist__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<Playlist>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, std::string>>
+  using Result_std__variant_nitro__NullType__std__string__ = Result<std::variant<nitro::NullType, std::string>>;
+  inline Result_std__variant_nitro__NullType__std__string__ create_Result_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return Result<std::variant<nitro::NullType, std::string>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__std__string__ create_Result_std__variant_nitro__NullType__std__string__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, std::string>>::withError(error);
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, TrackItem>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, TrackItem>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__TrackItem_ {
+    std::variant<nitro::NullType, TrackItem> variant;
+    std__variant_nitro__NullType__TrackItem_(std::variant<nitro::NullType, TrackItem> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, TrackItem>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline TrackItem get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__TrackItem_ create_std__variant_nitro__NullType__TrackItem_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__TrackItem_(value);
+  }
+  inline std__variant_nitro__NullType__TrackItem_ create_std__variant_nitro__NullType__TrackItem_(const TrackItem& value) noexcept {
+    return std__variant_nitro__NullType__TrackItem_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, TrackItem>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, TrackItem>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__TrackItem__ = std::optional<std::variant<nitro::NullType, TrackItem>>;
+  inline std::optional<std::variant<nitro::NullType, TrackItem>> create_std__optional_std__variant_nitro__NullType__TrackItem__(const std::variant<nitro::NullType, TrackItem>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, TrackItem>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__TrackItem__(const std::optional<std::variant<nitro::NullType, TrackItem>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, TrackItem> get_std__optional_std__variant_nitro__NullType__TrackItem__(const std::optional<std::variant<nitro::NullType, TrackItem>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<Reason>
+  /**
+   * Specialized version of `std::optional<Reason>`.
+   */
+  using std__optional_Reason_ = std::optional<Reason>;
+  inline std::optional<Reason> create_std__optional_Reason_(const Reason& value) noexcept {
+    return std::optional<Reason>(value);
+  }
+  inline bool has_value_std__optional_Reason_(const std::optional<Reason>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Reason get_std__optional_Reason_(const std::optional<Reason>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>
+  /**
+   * Specialized version of `std::function<void(const TrackItem&, std::optional<Reason>)>`.
+   */
+  using Func_void_TrackItem_std__optional_Reason_ = std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TrackItem& / * track * /, std::optional<Reason> / * reason * /)>`, this can be used from Swift.
+   */
+  class Func_void_TrackItem_std__optional_Reason__Wrapper final {
+  public:
+    explicit Func_void_TrackItem_std__optional_Reason__Wrapper(std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>&& func): _function(std::make_unique<std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>>(std::move(func))) {}
+    inline void call(TrackItem track, std::optional<Reason> reason) const noexcept {
+      _function->operator()(track, reason);
+    }
+  private:
+    std::unique_ptr<std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TrackItem_std__optional_Reason_ create_Func_void_TrackItem_std__optional_Reason_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TrackItem_std__optional_Reason__Wrapper wrap_Func_void_TrackItem_std__optional_Reason_(Func_void_TrackItem_std__optional_Reason_ value) noexcept {
+    return Func_void_TrackItem_std__optional_Reason__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>
+  /**
+   * Specialized version of `std::function<void(TrackPlayerState, std::optional<Reason>)>`.
+   */
+  using Func_void_TrackPlayerState_std__optional_Reason_ = std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>;
+  /**
+   * Wrapper class for a `std::function<void(TrackPlayerState / * state * /, std::optional<Reason> / * reason * /)>`, this can be used from Swift.
+   */
+  class Func_void_TrackPlayerState_std__optional_Reason__Wrapper final {
+  public:
+    explicit Func_void_TrackPlayerState_std__optional_Reason__Wrapper(std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>&& func): _function(std::make_unique<std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>>(std::move(func))) {}
+    inline void call(int state, std::optional<Reason> reason) const noexcept {
+      _function->operator()(static_cast<TrackPlayerState>(state), reason);
+    }
+  private:
+    std::unique_ptr<std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TrackPlayerState_std__optional_Reason_ create_Func_void_TrackPlayerState_std__optional_Reason_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TrackPlayerState_std__optional_Reason__Wrapper wrap_Func_void_TrackPlayerState_std__optional_Reason_(Func_void_TrackPlayerState_std__optional_Reason_ value) noexcept {
+    return Func_void_TrackPlayerState_std__optional_Reason__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(double /* position */, double /* totalDuration */)>
+  /**
+   * Specialized version of `std::function<void(double, double)>`.
+   */
+  using Func_void_double_double = std::function<void(double /* position */, double /* totalDuration */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * position * /, double / * totalDuration * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_Wrapper final {
+  public:
+    explicit Func_void_double_double_Wrapper(std::function<void(double /* position */, double /* totalDuration */)>&& func): _function(std::make_unique<std::function<void(double /* position */, double /* totalDuration */)>>(std::move(func))) {}
+    inline void call(double position, double totalDuration) const noexcept {
+      _function->operator()(position, totalDuration);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* position */, double /* totalDuration */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_Wrapper wrap_Func_void_double_double(Func_void_double_double value) noexcept {
+    return Func_void_double_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>
+  /**
+   * Specialized version of `std::function<void(double, double, std::optional<bool>)>`.
+   */
+  using Func_void_double_double_std__optional_bool_ = std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * position * /, double / * totalDuration * /, std::optional<bool> / * isManuallySeeked * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_std__optional_bool__Wrapper final {
+  public:
+    explicit Func_void_double_double_std__optional_bool__Wrapper(std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>&& func): _function(std::make_unique<std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>>(std::move(func))) {}
+    inline void call(double position, double totalDuration, std::optional<bool> isManuallySeeked) const noexcept {
+      _function->operator()(position, totalDuration, isManuallySeeked);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double_std__optional_bool_ create_Func_void_double_double_std__optional_bool_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_std__optional_bool__Wrapper wrap_Func_void_double_double_std__optional_bool_(Func_void_double_double_std__optional_bool_ value) noexcept {
+    return Func_void_double_double_std__optional_bool__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(bool /* connected */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* connected */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * connected * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* connected */)>&& func): _function(std::make_unique<std::function<void(bool /* connected */)>>(std::move(func))) {}
+    inline void call(bool connected) const noexcept {
+      _function->operator()(connected);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* connected */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridTrackPlayerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridTrackPlayerSpec>`.
+   */
+  using std__shared_ptr_HybridTrackPlayerSpec_ = std::shared_ptr<HybridTrackPlayerSpec>;
+  std::shared_ptr<HybridTrackPlayerSpec> create_std__shared_ptr_HybridTrackPlayerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridTrackPlayerSpec_(std__shared_ptr_HybridTrackPlayerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridTrackPlayerSpec>
+  using std__weak_ptr_HybridTrackPlayerSpec_ = std::weak_ptr<HybridTrackPlayerSpec>;
+  inline std__weak_ptr_HybridTrackPlayerSpec_ weakify_std__shared_ptr_HybridTrackPlayerSpec_(const std::shared_ptr<HybridTrackPlayerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<PlayerState>
+  using Result_PlayerState_ = Result<PlayerState>;
+  inline Result_PlayerState_ create_Result_PlayerState_(const PlayerState& value) noexcept {
+    return Result<PlayerState>::withValue(value);
+  }
+  inline Result_PlayerState_ create_Result_PlayerState_(const std::exception_ptr& error) noexcept {
+    return Result<PlayerState>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+
+} // namespace margelo::nitro::nitroplayer::bridge::swift

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

@@ -0,0 +1,80 @@
+///
+/// NitroPlayer-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `HybridAudioRoutePickerSpec` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { class HybridAudioRoutePickerSpec; }
+// 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 `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 `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 `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 "HybridAudioRoutePickerSpec.hpp"
+#include "HybridPlayerQueueSpec.hpp"
+#include "HybridTrackPlayerSpec.hpp"
+#include "PlayerConfig.hpp"
+#include "PlayerState.hpp"
+#include "Playlist.hpp"
+#include "QueueOperation.hpp"
+#include "Reason.hpp"
+#include "TrackItem.hpp"
+#include "TrackPlayerState.hpp"
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+// C++ helpers for Swift
+#include "NitroPlayer-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridAudioRoutePickerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridAudioRoutePickerSpec_cxx; }
+// Forward declaration of `HybridPlayerQueueSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
+// Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("NitroPlayer-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroPlayer".
+#include "NitroPlayer-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroPlayer/NitroPlayer-Swift.h>)
+#include <NitroPlayer/NitroPlayer-Swift.h>
+#else
+#error NitroPlayer's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroPlayer", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroPlayerAutolinking.mm

@@ -0,0 +1,49 @@
+///
+/// NitroPlayerAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroPlayer-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridPlayerQueueSpecSwift.hpp"
+#include "HybridTrackPlayerSpecSwift.hpp"
+#include "HybridAudioRoutePickerSpecSwift.hpp"
+
+@interface NitroPlayerAutolinking : NSObject
+@end
+
+@implementation NitroPlayerAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nitroplayer;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "PlayerQueue",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridPlayerQueueSpec> hybridObject = NitroPlayer::NitroPlayerAutolinking::createPlayerQueue();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "TrackPlayer",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridTrackPlayerSpec> hybridObject = NitroPlayer::NitroPlayerAutolinking::createTrackPlayer();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AudioRoutePicker",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridAudioRoutePickerSpec> hybridObject = NitroPlayer::NitroPlayerAutolinking::createAudioRoutePicker();
+      return hybridObject;
+    }
+  );
+}
+
+@end