react-native-audio-browser 0.0.1 → 0.1.0-next.2

package/nitrogen/generated/shared/c++/HybridAudioBrowserSpec.hpp

@@ -0,0 +1,375 @@
+///
+/// HybridAudioBrowserSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Track` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Track; }
+// Forward declaration of `ResolvedTrack` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ResolvedTrack; }
+// Forward declaration of `NavigationErrorEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NavigationErrorEvent; }
+// Forward declaration of `FormattedNavigationError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct FormattedNavigationError; }
+// Forward declaration of `NativeBrowserConfiguration` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NativeBrowserConfiguration; }
+// Forward declaration of `ChapterMetadata` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ChapterMetadata; }
+// Forward declaration of `TrackMetadata` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct TrackMetadata; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct TimedMetadata; }
+// Forward declaration of `PlaybackActiveTrackChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackActiveTrackChangedEvent; }
+// Forward declaration of `PlaybackErrorEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackErrorEvent; }
+// Forward declaration of `PlaybackPlayWhenReadyChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackPlayWhenReadyChangedEvent; }
+// Forward declaration of `PlayingState` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlayingState; }
+// Forward declaration of `PlaybackProgressUpdatedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackProgressUpdatedEvent; }
+// Forward declaration of `PlaybackQueueEndedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackQueueEndedEvent; }
+// Forward declaration of `RepeatModeChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RepeatModeChangedEvent; }
+// Forward declaration of `SleepTimerTime` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct SleepTimerTime; }
+// Forward declaration of `SleepTimerEndOfTrack` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct SleepTimerEndOfTrack; }
+// Forward declaration of `Playback` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Playback; }
+// Forward declaration of `RemoteJumpBackwardEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteJumpBackwardEvent; }
+// Forward declaration of `RemoteJumpForwardEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteJumpForwardEvent; }
+// Forward declaration of `RemotePlayIdEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemotePlayIdEvent; }
+// Forward declaration of `RemotePlaySearchEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemotePlaySearchEvent; }
+// Forward declaration of `RemoteSeekEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteSeekEvent; }
+// Forward declaration of `RemoteSetRatingEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteSetRatingEvent; }
+// Forward declaration of `RemoteSkipEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteSkipEvent; }
+// Forward declaration of `Options` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Options; }
+// Forward declaration of `FavoriteChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct FavoriteChangedEvent; }
+// Forward declaration of `NowPlayingMetadata` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NowPlayingMetadata; }
+// Forward declaration of `IosOutput` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct IosOutput; }
+// Forward declaration of `EqualizerSettings` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct EqualizerSettings; }
+// Forward declaration of `BatteryWarningPendingChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct BatteryWarningPendingChangedEvent; }
+// Forward declaration of `BatteryOptimizationStatusChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct BatteryOptimizationStatusChangedEvent; }
+// Forward declaration of `NavigationError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NavigationError; }
+// Forward declaration of `PartialSetupPlayerOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PartialSetupPlayerOptions; }
+// Forward declaration of `NativeUpdateOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NativeUpdateOptions; }
+// Forward declaration of `UpdateOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct UpdateOptions; }
+// Forward declaration of `Progress` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Progress; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class RepeatMode; }
+// Forward declaration of `PlaybackError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackError; }
+// Forward declaration of `NowPlayingUpdate` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NowPlayingUpdate; }
+// Forward declaration of `BatteryOptimizationStatus` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class BatteryOptimizationStatus; }
+
+#include <string>
+#include <optional>
+#include "Track.hpp"
+#include <vector>
+#include <functional>
+#include "ResolvedTrack.hpp"
+#include "NavigationErrorEvent.hpp"
+#include "FormattedNavigationError.hpp"
+#include "NativeBrowserConfiguration.hpp"
+#include "ChapterMetadata.hpp"
+#include "TrackMetadata.hpp"
+#include "TimedMetadata.hpp"
+#include "PlaybackActiveTrackChangedEvent.hpp"
+#include "PlaybackErrorEvent.hpp"
+#include "PlaybackPlayWhenReadyChangedEvent.hpp"
+#include "PlayingState.hpp"
+#include "PlaybackProgressUpdatedEvent.hpp"
+#include "PlaybackQueueEndedEvent.hpp"
+#include "RepeatModeChangedEvent.hpp"
+#include <NitroModules/Null.hpp>
+#include "SleepTimerTime.hpp"
+#include "SleepTimerEndOfTrack.hpp"
+#include <variant>
+#include "Playback.hpp"
+#include "RemoteJumpBackwardEvent.hpp"
+#include "RemoteJumpForwardEvent.hpp"
+#include "RemotePlayIdEvent.hpp"
+#include "RemotePlaySearchEvent.hpp"
+#include "RemoteSeekEvent.hpp"
+#include "RemoteSetRatingEvent.hpp"
+#include "RemoteSkipEvent.hpp"
+#include "Options.hpp"
+#include "FavoriteChangedEvent.hpp"
+#include "NowPlayingMetadata.hpp"
+#include "IosOutput.hpp"
+#include "EqualizerSettings.hpp"
+#include "BatteryWarningPendingChangedEvent.hpp"
+#include "BatteryOptimizationStatusChangedEvent.hpp"
+#include <NitroModules/Promise.hpp>
+#include "NavigationError.hpp"
+#include "PartialSetupPlayerOptions.hpp"
+#include "NativeUpdateOptions.hpp"
+#include "UpdateOptions.hpp"
+#include "Progress.hpp"
+#include "RepeatMode.hpp"
+#include "PlaybackError.hpp"
+#include "NowPlayingUpdate.hpp"
+#include "BatteryOptimizationStatus.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AudioBrowser`
+   * Inherit this class to create instances of `HybridAudioBrowserSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAudioBrowser: public HybridAudioBrowserSpec {
+   * public:
+   *   HybridAudioBrowser(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAudioBrowserSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAudioBrowserSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAudioBrowserSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::string> getPath() = 0;
+      virtual void setPath(const std::optional<std::string>& path) = 0;
+      virtual std::optional<std::vector<Track>> getTabs() = 0;
+      virtual void setTabs(const std::optional<std::vector<Track>>& tabs) = 0;
+      virtual std::function<void(const std::string& /* path */)> getOnPathChanged() = 0;
+      virtual void setOnPathChanged(const std::function<void(const std::string& /* path */)>& onPathChanged) = 0;
+      virtual std::function<void(const std::optional<ResolvedTrack>& /* content */)> getOnContentChanged() = 0;
+      virtual void setOnContentChanged(const std::function<void(const std::optional<ResolvedTrack>& /* content */)>& onContentChanged) = 0;
+      virtual std::function<void(const std::vector<Track>& /* tabs */)> getOnTabsChanged() = 0;
+      virtual void setOnTabsChanged(const std::function<void(const std::vector<Track>& /* tabs */)>& onTabsChanged) = 0;
+      virtual std::function<void(const NavigationErrorEvent& /* data */)> getOnNavigationError() = 0;
+      virtual void setOnNavigationError(const std::function<void(const NavigationErrorEvent& /* data */)>& onNavigationError) = 0;
+      virtual std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)> getOnFormattedNavigationError() = 0;
+      virtual void setOnFormattedNavigationError(const std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>& onFormattedNavigationError) = 0;
+      virtual NativeBrowserConfiguration getConfiguration() = 0;
+      virtual void setConfiguration(const NativeBrowserConfiguration& configuration) = 0;
+      virtual std::function<void(const std::vector<ChapterMetadata>& /* chapters */)> getOnChapterMetadata() = 0;
+      virtual void setOnChapterMetadata(const std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>& onChapterMetadata) = 0;
+      virtual std::function<void(const TrackMetadata& /* metadata */)> getOnTrackMetadata() = 0;
+      virtual void setOnTrackMetadata(const std::function<void(const TrackMetadata& /* metadata */)>& onTrackMetadata) = 0;
+      virtual std::function<void(const TimedMetadata& /* metadata */)> getOnTimedMetadata() = 0;
+      virtual void setOnTimedMetadata(const std::function<void(const TimedMetadata& /* metadata */)>& onTimedMetadata) = 0;
+      virtual std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)> getOnPlaybackActiveTrackChanged() = 0;
+      virtual void setOnPlaybackActiveTrackChanged(const std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>& onPlaybackActiveTrackChanged) = 0;
+      virtual std::function<void(const PlaybackErrorEvent& /* data */)> getOnPlaybackError() = 0;
+      virtual void setOnPlaybackError(const std::function<void(const PlaybackErrorEvent& /* data */)>& onPlaybackError) = 0;
+      virtual std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)> getOnPlaybackPlayWhenReadyChanged() = 0;
+      virtual void setOnPlaybackPlayWhenReadyChanged(const std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>& onPlaybackPlayWhenReadyChanged) = 0;
+      virtual std::function<void(const PlayingState& /* data */)> getOnPlaybackPlayingState() = 0;
+      virtual void setOnPlaybackPlayingState(const std::function<void(const PlayingState& /* data */)>& onPlaybackPlayingState) = 0;
+      virtual std::function<void(const PlaybackProgressUpdatedEvent& /* data */)> getOnPlaybackProgressUpdated() = 0;
+      virtual void setOnPlaybackProgressUpdated(const std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>& onPlaybackProgressUpdated) = 0;
+      virtual std::function<void(const PlaybackQueueEndedEvent& /* data */)> getOnPlaybackQueueEnded() = 0;
+      virtual void setOnPlaybackQueueEnded(const std::function<void(const PlaybackQueueEndedEvent& /* data */)>& onPlaybackQueueEnded) = 0;
+      virtual std::function<void(const std::vector<Track>& /* queue */)> getOnPlaybackQueueChanged() = 0;
+      virtual void setOnPlaybackQueueChanged(const std::function<void(const std::vector<Track>& /* queue */)>& onPlaybackQueueChanged) = 0;
+      virtual std::function<void(const RepeatModeChangedEvent& /* data */)> getOnPlaybackRepeatModeChanged() = 0;
+      virtual void setOnPlaybackRepeatModeChanged(const std::function<void(const RepeatModeChangedEvent& /* data */)>& onPlaybackRepeatModeChanged) = 0;
+      virtual std::function<void(bool /* enabled */)> getOnPlaybackShuffleModeChanged() = 0;
+      virtual void setOnPlaybackShuffleModeChanged(const std::function<void(bool /* enabled */)>& onPlaybackShuffleModeChanged) = 0;
+      virtual std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)> getOnSleepTimerChanged() = 0;
+      virtual void setOnSleepTimerChanged(const std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>& onSleepTimerChanged) = 0;
+      virtual std::function<void(const Playback& /* data */)> getOnPlaybackChanged() = 0;
+      virtual void setOnPlaybackChanged(const std::function<void(const Playback& /* data */)>& onPlaybackChanged) = 0;
+      virtual std::function<void()> getOnRemoteBookmark() = 0;
+      virtual void setOnRemoteBookmark(const std::function<void()>& onRemoteBookmark) = 0;
+      virtual std::function<void()> getOnRemoteDislike() = 0;
+      virtual void setOnRemoteDislike(const std::function<void()>& onRemoteDislike) = 0;
+      virtual std::function<void(const RemoteJumpBackwardEvent& /* event */)> getOnRemoteJumpBackward() = 0;
+      virtual void setOnRemoteJumpBackward(const std::function<void(const RemoteJumpBackwardEvent& /* event */)>& onRemoteJumpBackward) = 0;
+      virtual std::function<void(const RemoteJumpForwardEvent& /* event */)> getOnRemoteJumpForward() = 0;
+      virtual void setOnRemoteJumpForward(const std::function<void(const RemoteJumpForwardEvent& /* event */)>& onRemoteJumpForward) = 0;
+      virtual std::function<void()> getOnRemoteLike() = 0;
+      virtual void setOnRemoteLike(const std::function<void()>& onRemoteLike) = 0;
+      virtual std::function<void()> getOnRemoteNext() = 0;
+      virtual void setOnRemoteNext(const std::function<void()>& onRemoteNext) = 0;
+      virtual std::function<void()> getOnRemotePause() = 0;
+      virtual void setOnRemotePause(const std::function<void()>& onRemotePause) = 0;
+      virtual std::function<void()> getOnRemotePlay() = 0;
+      virtual void setOnRemotePlay(const std::function<void()>& onRemotePlay) = 0;
+      virtual std::function<void(const RemotePlayIdEvent& /* event */)> getOnRemotePlayId() = 0;
+      virtual void setOnRemotePlayId(const std::function<void(const RemotePlayIdEvent& /* event */)>& onRemotePlayId) = 0;
+      virtual std::function<void(const RemotePlaySearchEvent& /* event */)> getOnRemotePlaySearch() = 0;
+      virtual void setOnRemotePlaySearch(const std::function<void(const RemotePlaySearchEvent& /* event */)>& onRemotePlaySearch) = 0;
+      virtual std::function<void()> getOnRemotePrevious() = 0;
+      virtual void setOnRemotePrevious(const std::function<void()>& onRemotePrevious) = 0;
+      virtual std::function<void(const RemoteSeekEvent& /* event */)> getOnRemoteSeek() = 0;
+      virtual void setOnRemoteSeek(const std::function<void(const RemoteSeekEvent& /* event */)>& onRemoteSeek) = 0;
+      virtual std::function<void(const RemoteSetRatingEvent& /* event */)> getOnRemoteSetRating() = 0;
+      virtual void setOnRemoteSetRating(const std::function<void(const RemoteSetRatingEvent& /* event */)>& onRemoteSetRating) = 0;
+      virtual std::function<void(const RemoteSkipEvent& /* event */)> getOnRemoteSkip() = 0;
+      virtual void setOnRemoteSkip(const std::function<void(const RemoteSkipEvent& /* event */)>& onRemoteSkip) = 0;
+      virtual std::function<void()> getOnRemoteStop() = 0;
+      virtual void setOnRemoteStop(const std::function<void()>& onRemoteStop) = 0;
+      virtual std::function<void(const Options& /* event */)> getOnOptionsChanged() = 0;
+      virtual void setOnOptionsChanged(const std::function<void(const Options& /* event */)>& onOptionsChanged) = 0;
+      virtual std::function<void(const FavoriteChangedEvent& /* event */)> getOnFavoriteChanged() = 0;
+      virtual void setOnFavoriteChanged(const std::function<void(const FavoriteChangedEvent& /* event */)>& onFavoriteChanged) = 0;
+      virtual std::function<void(const NowPlayingMetadata& /* metadata */)> getOnNowPlayingChanged() = 0;
+      virtual void setOnNowPlayingChanged(const std::function<void(const NowPlayingMetadata& /* metadata */)>& onNowPlayingChanged) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemoteBookmark() = 0;
+      virtual void setHandleRemoteBookmark(const std::optional<std::function<void()>>& handleRemoteBookmark) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemoteDislike() = 0;
+      virtual void setHandleRemoteDislike(const std::optional<std::function<void()>>& handleRemoteDislike) = 0;
+      virtual std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>> getHandleRemoteJumpBackward() = 0;
+      virtual void setHandleRemoteJumpBackward(const std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>& handleRemoteJumpBackward) = 0;
+      virtual std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>> getHandleRemoteJumpForward() = 0;
+      virtual void setHandleRemoteJumpForward(const std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>& handleRemoteJumpForward) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemoteLike() = 0;
+      virtual void setHandleRemoteLike(const std::optional<std::function<void()>>& handleRemoteLike) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemoteNext() = 0;
+      virtual void setHandleRemoteNext(const std::optional<std::function<void()>>& handleRemoteNext) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemotePause() = 0;
+      virtual void setHandleRemotePause(const std::optional<std::function<void()>>& handleRemotePause) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemotePlay() = 0;
+      virtual void setHandleRemotePlay(const std::optional<std::function<void()>>& handleRemotePlay) = 0;
+      virtual std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>> getHandleRemotePlayId() = 0;
+      virtual void setHandleRemotePlayId(const std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>& handleRemotePlayId) = 0;
+      virtual std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>> getHandleRemotePlaySearch() = 0;
+      virtual void setHandleRemotePlaySearch(const std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>& handleRemotePlaySearch) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemotePrevious() = 0;
+      virtual void setHandleRemotePrevious(const std::optional<std::function<void()>>& handleRemotePrevious) = 0;
+      virtual std::optional<std::function<void(const RemoteSeekEvent& /* event */)>> getHandleRemoteSeek() = 0;
+      virtual void setHandleRemoteSeek(const std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>& handleRemoteSeek) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemoteSkip() = 0;
+      virtual void setHandleRemoteSkip(const std::optional<std::function<void()>>& handleRemoteSkip) = 0;
+      virtual std::optional<std::function<void()>> getHandleRemoteStop() = 0;
+      virtual void setHandleRemoteStop(const std::optional<std::function<void()>>& handleRemoteStop) = 0;
+      virtual std::function<void(bool /* online */)> getOnOnlineChanged() = 0;
+      virtual void setOnOnlineChanged(const std::function<void(bool /* online */)>& onOnlineChanged) = 0;
+      virtual std::function<void(double /* volume */)> getOnSystemVolumeChanged() = 0;
+      virtual void setOnSystemVolumeChanged(const std::function<void(double /* volume */)>& onSystemVolumeChanged) = 0;
+      virtual std::function<void(const IosOutput& /* output */)> getOnIosOutputChanged() = 0;
+      virtual void setOnIosOutputChanged(const std::function<void(const IosOutput& /* output */)>& onIosOutputChanged) = 0;
+      virtual std::function<void(const EqualizerSettings& /* settings */)> getOnEqualizerChanged() = 0;
+      virtual void setOnEqualizerChanged(const std::function<void(const EqualizerSettings& /* settings */)>& onEqualizerChanged) = 0;
+      virtual std::function<void(const BatteryWarningPendingChangedEvent& /* event */)> getOnBatteryWarningPendingChanged() = 0;
+      virtual void setOnBatteryWarningPendingChanged(const std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>& onBatteryWarningPendingChanged) = 0;
+      virtual std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)> getOnBatteryOptimizationStatusChanged() = 0;
+      virtual void setOnBatteryOptimizationStatusChanged(const std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>& onBatteryOptimizationStatusChanged) = 0;
+
+    public:
+      // Methods
+      virtual void navigatePath(const std::string& path) = 0;
+      virtual void navigateTrack(const Track& track) = 0;
+      virtual std::shared_ptr<Promise<std::vector<Track>>> onSearch(const std::string& query) = 0;
+      virtual std::optional<ResolvedTrack> getContent() = 0;
+      virtual std::optional<NavigationError> getNavigationError() = 0;
+      virtual std::optional<FormattedNavigationError> getFormattedNavigationError() = 0;
+      virtual void notifyContentChanged(const std::string& path) = 0;
+      virtual void setFavorites(const std::vector<std::string>& favorites) = 0;
+      virtual std::shared_ptr<Promise<void>> setupPlayer(const PartialSetupPlayerOptions& options) = 0;
+      virtual void updateOptions(const NativeUpdateOptions& options) = 0;
+      virtual UpdateOptions getOptions() = 0;
+      virtual void load(const Track& track) = 0;
+      virtual void reset() = 0;
+      virtual void play() = 0;
+      virtual void pause() = 0;
+      virtual void togglePlayback() = 0;
+      virtual void stop() = 0;
+      virtual void setPlayWhenReady(bool playWhenReady) = 0;
+      virtual bool getPlayWhenReady() = 0;
+      virtual void seekTo(double position) = 0;
+      virtual void seekBy(double offset) = 0;
+      virtual void setVolume(double level) = 0;
+      virtual double getVolume() = 0;
+      virtual void setRate(double rate) = 0;
+      virtual double getRate() = 0;
+      virtual Progress getProgress() = 0;
+      virtual Playback getPlayback() = 0;
+      virtual PlayingState getPlayingState() = 0;
+      virtual RepeatMode getRepeatMode() = 0;
+      virtual void setRepeatMode(RepeatMode mode) = 0;
+      virtual bool getShuffleEnabled() = 0;
+      virtual void setShuffleEnabled(bool enabled) = 0;
+      virtual std::optional<PlaybackError> getPlaybackError() = 0;
+      virtual void retry() = 0;
+      virtual std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack> getSleepTimer() = 0;
+      virtual void setSleepTimer(double seconds) = 0;
+      virtual void setSleepTimerToEndOfTrack() = 0;
+      virtual bool clearSleepTimer() = 0;
+      virtual void add(const std::vector<Track>& tracks, std::optional<double> insertBeforeIndex) = 0;
+      virtual void move(double fromIndex, double toIndex) = 0;
+      virtual void remove(const std::vector<double>& indexes) = 0;
+      virtual void removeUpcomingTracks() = 0;
+      virtual void skip(double index, std::optional<double> initialPosition) = 0;
+      virtual void skipToNext(std::optional<double> initialPosition) = 0;
+      virtual void skipToPrevious(std::optional<double> initialPosition) = 0;
+      virtual void setActiveTrackFavorited(bool favorited) = 0;
+      virtual void toggleActiveTrackFavorited() = 0;
+      virtual void setQueue(const std::vector<Track>& tracks, std::optional<double> startIndex, std::optional<double> startPositionMs) = 0;
+      virtual std::vector<Track> getQueue() = 0;
+      virtual std::optional<Track> getTrack(double index) = 0;
+      virtual std::optional<double> getActiveTrackIndex() = 0;
+      virtual std::optional<Track> getActiveTrack() = 0;
+      virtual void updateNowPlaying(const std::optional<NowPlayingUpdate>& update) = 0;
+      virtual std::optional<NowPlayingMetadata> getNowPlaying() = 0;
+      virtual bool getOnline() = 0;
+      virtual double getSystemVolume() = 0;
+      virtual void setSystemVolume(double volume) = 0;
+      virtual std::optional<IosOutput> getIosOutput() = 0;
+      virtual void openIosOutputPicker() = 0;
+      virtual std::optional<EqualizerSettings> getEqualizerSettings() = 0;
+      virtual void setEqualizerEnabled(bool enabled) = 0;
+      virtual void setEqualizerPreset(const std::string& preset) = 0;
+      virtual void setEqualizerLevels(const std::vector<double>& levels) = 0;
+      virtual bool getBatteryWarningPending() = 0;
+      virtual BatteryOptimizationStatus getBatteryOptimizationStatus() = 0;
+      virtual void dismissBatteryWarning() = 0;
+      virtual void openBatterySettings() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AudioBrowser";
+  };
+
+} // namespace margelo::nitro::audiobrowser

package/nitrogen/generated/shared/c++/IOSCategory.hpp

@@ -0,0 +1,92 @@
+///
+/// IOSCategory.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::audiobrowser {
+
+  /**
+   * An enum which can be represented as a JavaScript union (IOSCategory).
+   */
+  enum class IOSCategory {
+    PLAYBACK      SWIFT_NAME(playback) = 0,
+    PLAYANDRECORD      SWIFT_NAME(playandrecord) = 1,
+    MULTIROUTE      SWIFT_NAME(multiroute) = 2,
+    AMBIENT      SWIFT_NAME(ambient) = 3,
+    SOLOAMBIENT      SWIFT_NAME(soloambient) = 4,
+    RECORD      SWIFT_NAME(record) = 5,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::audiobrowser
+
+namespace margelo::nitro {
+
+  // C++ IOSCategory <> JS IOSCategory (union)
+  template <>
+  struct JSIConverter<margelo::nitro::audiobrowser::IOSCategory> final {
+    static inline margelo::nitro::audiobrowser::IOSCategory fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("playback"): return margelo::nitro::audiobrowser::IOSCategory::PLAYBACK;
+        case hashString("playAndRecord"): return margelo::nitro::audiobrowser::IOSCategory::PLAYANDRECORD;
+        case hashString("multiRoute"): return margelo::nitro::audiobrowser::IOSCategory::MULTIROUTE;
+        case hashString("ambient"): return margelo::nitro::audiobrowser::IOSCategory::AMBIENT;
+        case hashString("soloAmbient"): return margelo::nitro::audiobrowser::IOSCategory::SOLOAMBIENT;
+        case hashString("record"): return margelo::nitro::audiobrowser::IOSCategory::RECORD;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum IOSCategory - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::audiobrowser::IOSCategory arg) {
+      switch (arg) {
+        case margelo::nitro::audiobrowser::IOSCategory::PLAYBACK: return JSIConverter<std::string>::toJSI(runtime, "playback");
+        case margelo::nitro::audiobrowser::IOSCategory::PLAYANDRECORD: return JSIConverter<std::string>::toJSI(runtime, "playAndRecord");
+        case margelo::nitro::audiobrowser::IOSCategory::MULTIROUTE: return JSIConverter<std::string>::toJSI(runtime, "multiRoute");
+        case margelo::nitro::audiobrowser::IOSCategory::AMBIENT: return JSIConverter<std::string>::toJSI(runtime, "ambient");
+        case margelo::nitro::audiobrowser::IOSCategory::SOLOAMBIENT: return JSIConverter<std::string>::toJSI(runtime, "soloAmbient");
+        case margelo::nitro::audiobrowser::IOSCategory::RECORD: return JSIConverter<std::string>::toJSI(runtime, "record");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert IOSCategory to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("playback"):
+        case hashString("playAndRecord"):
+        case hashString("multiRoute"):
+        case hashString("ambient"):
+        case hashString("soloAmbient"):
+        case hashString("record"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/IOSCategoryMode.hpp

@@ -0,0 +1,104 @@
+///
+/// IOSCategoryMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::audiobrowser {
+
+  /**
+   * An enum which can be represented as a JavaScript union (IOSCategoryMode).
+   */
+  enum class IOSCategoryMode {
+    DEFAULT      SWIFT_NAME(default) = 0,
+    GAMECHAT      SWIFT_NAME(gamechat) = 1,
+    MEASUREMENT      SWIFT_NAME(measurement) = 2,
+    MOVIEPLAYBACK      SWIFT_NAME(movieplayback) = 3,
+    SPOKENAUDIO      SWIFT_NAME(spokenaudio) = 4,
+    VIDEOCHAT      SWIFT_NAME(videochat) = 5,
+    VIDEORECORDING      SWIFT_NAME(videorecording) = 6,
+    VOICECHAT      SWIFT_NAME(voicechat) = 7,
+    VOICEPROMPT      SWIFT_NAME(voiceprompt) = 8,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::audiobrowser
+
+namespace margelo::nitro {
+
+  // C++ IOSCategoryMode <> JS IOSCategoryMode (union)
+  template <>
+  struct JSIConverter<margelo::nitro::audiobrowser::IOSCategoryMode> final {
+    static inline margelo::nitro::audiobrowser::IOSCategoryMode fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("default"): return margelo::nitro::audiobrowser::IOSCategoryMode::DEFAULT;
+        case hashString("gameChat"): return margelo::nitro::audiobrowser::IOSCategoryMode::GAMECHAT;
+        case hashString("measurement"): return margelo::nitro::audiobrowser::IOSCategoryMode::MEASUREMENT;
+        case hashString("moviePlayback"): return margelo::nitro::audiobrowser::IOSCategoryMode::MOVIEPLAYBACK;
+        case hashString("spokenAudio"): return margelo::nitro::audiobrowser::IOSCategoryMode::SPOKENAUDIO;
+        case hashString("videoChat"): return margelo::nitro::audiobrowser::IOSCategoryMode::VIDEOCHAT;
+        case hashString("videoRecording"): return margelo::nitro::audiobrowser::IOSCategoryMode::VIDEORECORDING;
+        case hashString("voiceChat"): return margelo::nitro::audiobrowser::IOSCategoryMode::VOICECHAT;
+        case hashString("voicePrompt"): return margelo::nitro::audiobrowser::IOSCategoryMode::VOICEPROMPT;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum IOSCategoryMode - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::audiobrowser::IOSCategoryMode arg) {
+      switch (arg) {
+        case margelo::nitro::audiobrowser::IOSCategoryMode::DEFAULT: return JSIConverter<std::string>::toJSI(runtime, "default");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::GAMECHAT: return JSIConverter<std::string>::toJSI(runtime, "gameChat");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::MEASUREMENT: return JSIConverter<std::string>::toJSI(runtime, "measurement");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::MOVIEPLAYBACK: return JSIConverter<std::string>::toJSI(runtime, "moviePlayback");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::SPOKENAUDIO: return JSIConverter<std::string>::toJSI(runtime, "spokenAudio");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::VIDEOCHAT: return JSIConverter<std::string>::toJSI(runtime, "videoChat");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::VIDEORECORDING: return JSIConverter<std::string>::toJSI(runtime, "videoRecording");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::VOICECHAT: return JSIConverter<std::string>::toJSI(runtime, "voiceChat");
+        case margelo::nitro::audiobrowser::IOSCategoryMode::VOICEPROMPT: return JSIConverter<std::string>::toJSI(runtime, "voicePrompt");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert IOSCategoryMode to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("default"):
+        case hashString("gameChat"):
+        case hashString("measurement"):
+        case hashString("moviePlayback"):
+        case hashString("spokenAudio"):
+        case hashString("videoChat"):
+        case hashString("videoRecording"):
+        case hashString("voiceChat"):
+        case hashString("voicePrompt"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro