@5stones/react-native-audio-browser 0.1.0

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

@@ -0,0 +1,207 @@
+///
+/// HybridAudioBrowserSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAudioBrowserSpec.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  void HybridAudioBrowserSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("path", &HybridAudioBrowserSpec::getPath);
+      prototype.registerHybridSetter("path", &HybridAudioBrowserSpec::setPath);
+      prototype.registerHybridGetter("tabs", &HybridAudioBrowserSpec::getTabs);
+      prototype.registerHybridSetter("tabs", &HybridAudioBrowserSpec::setTabs);
+      prototype.registerHybridGetter("onPathChanged", &HybridAudioBrowserSpec::getOnPathChanged);
+      prototype.registerHybridSetter("onPathChanged", &HybridAudioBrowserSpec::setOnPathChanged);
+      prototype.registerHybridGetter("onContentChanged", &HybridAudioBrowserSpec::getOnContentChanged);
+      prototype.registerHybridSetter("onContentChanged", &HybridAudioBrowserSpec::setOnContentChanged);
+      prototype.registerHybridGetter("onTabsChanged", &HybridAudioBrowserSpec::getOnTabsChanged);
+      prototype.registerHybridSetter("onTabsChanged", &HybridAudioBrowserSpec::setOnTabsChanged);
+      prototype.registerHybridGetter("onNavigationError", &HybridAudioBrowserSpec::getOnNavigationError);
+      prototype.registerHybridSetter("onNavigationError", &HybridAudioBrowserSpec::setOnNavigationError);
+      prototype.registerHybridGetter("onFormattedNavigationError", &HybridAudioBrowserSpec::getOnFormattedNavigationError);
+      prototype.registerHybridSetter("onFormattedNavigationError", &HybridAudioBrowserSpec::setOnFormattedNavigationError);
+      prototype.registerHybridGetter("configuration", &HybridAudioBrowserSpec::getConfiguration);
+      prototype.registerHybridSetter("configuration", &HybridAudioBrowserSpec::setConfiguration);
+      prototype.registerHybridGetter("onChapterMetadata", &HybridAudioBrowserSpec::getOnChapterMetadata);
+      prototype.registerHybridSetter("onChapterMetadata", &HybridAudioBrowserSpec::setOnChapterMetadata);
+      prototype.registerHybridGetter("onTrackMetadata", &HybridAudioBrowserSpec::getOnTrackMetadata);
+      prototype.registerHybridSetter("onTrackMetadata", &HybridAudioBrowserSpec::setOnTrackMetadata);
+      prototype.registerHybridGetter("onTimedMetadata", &HybridAudioBrowserSpec::getOnTimedMetadata);
+      prototype.registerHybridSetter("onTimedMetadata", &HybridAudioBrowserSpec::setOnTimedMetadata);
+      prototype.registerHybridGetter("onPlaybackActiveTrackChanged", &HybridAudioBrowserSpec::getOnPlaybackActiveTrackChanged);
+      prototype.registerHybridSetter("onPlaybackActiveTrackChanged", &HybridAudioBrowserSpec::setOnPlaybackActiveTrackChanged);
+      prototype.registerHybridGetter("onPlaybackError", &HybridAudioBrowserSpec::getOnPlaybackError);
+      prototype.registerHybridSetter("onPlaybackError", &HybridAudioBrowserSpec::setOnPlaybackError);
+      prototype.registerHybridGetter("onPlaybackPlayWhenReadyChanged", &HybridAudioBrowserSpec::getOnPlaybackPlayWhenReadyChanged);
+      prototype.registerHybridSetter("onPlaybackPlayWhenReadyChanged", &HybridAudioBrowserSpec::setOnPlaybackPlayWhenReadyChanged);
+      prototype.registerHybridGetter("onPlaybackPlayingState", &HybridAudioBrowserSpec::getOnPlaybackPlayingState);
+      prototype.registerHybridSetter("onPlaybackPlayingState", &HybridAudioBrowserSpec::setOnPlaybackPlayingState);
+      prototype.registerHybridGetter("onPlaybackProgressUpdated", &HybridAudioBrowserSpec::getOnPlaybackProgressUpdated);
+      prototype.registerHybridSetter("onPlaybackProgressUpdated", &HybridAudioBrowserSpec::setOnPlaybackProgressUpdated);
+      prototype.registerHybridGetter("onPlaybackQueueEnded", &HybridAudioBrowserSpec::getOnPlaybackQueueEnded);
+      prototype.registerHybridSetter("onPlaybackQueueEnded", &HybridAudioBrowserSpec::setOnPlaybackQueueEnded);
+      prototype.registerHybridGetter("onPlaybackQueueChanged", &HybridAudioBrowserSpec::getOnPlaybackQueueChanged);
+      prototype.registerHybridSetter("onPlaybackQueueChanged", &HybridAudioBrowserSpec::setOnPlaybackQueueChanged);
+      prototype.registerHybridGetter("onPlaybackRepeatModeChanged", &HybridAudioBrowserSpec::getOnPlaybackRepeatModeChanged);
+      prototype.registerHybridSetter("onPlaybackRepeatModeChanged", &HybridAudioBrowserSpec::setOnPlaybackRepeatModeChanged);
+      prototype.registerHybridGetter("onPlaybackShuffleModeChanged", &HybridAudioBrowserSpec::getOnPlaybackShuffleModeChanged);
+      prototype.registerHybridSetter("onPlaybackShuffleModeChanged", &HybridAudioBrowserSpec::setOnPlaybackShuffleModeChanged);
+      prototype.registerHybridGetter("onSleepTimerChanged", &HybridAudioBrowserSpec::getOnSleepTimerChanged);
+      prototype.registerHybridSetter("onSleepTimerChanged", &HybridAudioBrowserSpec::setOnSleepTimerChanged);
+      prototype.registerHybridGetter("onPlaybackChanged", &HybridAudioBrowserSpec::getOnPlaybackChanged);
+      prototype.registerHybridSetter("onPlaybackChanged", &HybridAudioBrowserSpec::setOnPlaybackChanged);
+      prototype.registerHybridGetter("onRemoteBookmark", &HybridAudioBrowserSpec::getOnRemoteBookmark);
+      prototype.registerHybridSetter("onRemoteBookmark", &HybridAudioBrowserSpec::setOnRemoteBookmark);
+      prototype.registerHybridGetter("onRemoteDislike", &HybridAudioBrowserSpec::getOnRemoteDislike);
+      prototype.registerHybridSetter("onRemoteDislike", &HybridAudioBrowserSpec::setOnRemoteDislike);
+      prototype.registerHybridGetter("onRemoteJumpBackward", &HybridAudioBrowserSpec::getOnRemoteJumpBackward);
+      prototype.registerHybridSetter("onRemoteJumpBackward", &HybridAudioBrowserSpec::setOnRemoteJumpBackward);
+      prototype.registerHybridGetter("onRemoteJumpForward", &HybridAudioBrowserSpec::getOnRemoteJumpForward);
+      prototype.registerHybridSetter("onRemoteJumpForward", &HybridAudioBrowserSpec::setOnRemoteJumpForward);
+      prototype.registerHybridGetter("onRemoteLike", &HybridAudioBrowserSpec::getOnRemoteLike);
+      prototype.registerHybridSetter("onRemoteLike", &HybridAudioBrowserSpec::setOnRemoteLike);
+      prototype.registerHybridGetter("onRemoteNext", &HybridAudioBrowserSpec::getOnRemoteNext);
+      prototype.registerHybridSetter("onRemoteNext", &HybridAudioBrowserSpec::setOnRemoteNext);
+      prototype.registerHybridGetter("onRemotePause", &HybridAudioBrowserSpec::getOnRemotePause);
+      prototype.registerHybridSetter("onRemotePause", &HybridAudioBrowserSpec::setOnRemotePause);
+      prototype.registerHybridGetter("onRemotePlay", &HybridAudioBrowserSpec::getOnRemotePlay);
+      prototype.registerHybridSetter("onRemotePlay", &HybridAudioBrowserSpec::setOnRemotePlay);
+      prototype.registerHybridGetter("onRemotePlayId", &HybridAudioBrowserSpec::getOnRemotePlayId);
+      prototype.registerHybridSetter("onRemotePlayId", &HybridAudioBrowserSpec::setOnRemotePlayId);
+      prototype.registerHybridGetter("onRemotePlaySearch", &HybridAudioBrowserSpec::getOnRemotePlaySearch);
+      prototype.registerHybridSetter("onRemotePlaySearch", &HybridAudioBrowserSpec::setOnRemotePlaySearch);
+      prototype.registerHybridGetter("onRemotePrevious", &HybridAudioBrowserSpec::getOnRemotePrevious);
+      prototype.registerHybridSetter("onRemotePrevious", &HybridAudioBrowserSpec::setOnRemotePrevious);
+      prototype.registerHybridGetter("onRemoteSeek", &HybridAudioBrowserSpec::getOnRemoteSeek);
+      prototype.registerHybridSetter("onRemoteSeek", &HybridAudioBrowserSpec::setOnRemoteSeek);
+      prototype.registerHybridGetter("onRemoteSetRating", &HybridAudioBrowserSpec::getOnRemoteSetRating);
+      prototype.registerHybridSetter("onRemoteSetRating", &HybridAudioBrowserSpec::setOnRemoteSetRating);
+      prototype.registerHybridGetter("onRemoteSkip", &HybridAudioBrowserSpec::getOnRemoteSkip);
+      prototype.registerHybridSetter("onRemoteSkip", &HybridAudioBrowserSpec::setOnRemoteSkip);
+      prototype.registerHybridGetter("onRemoteStop", &HybridAudioBrowserSpec::getOnRemoteStop);
+      prototype.registerHybridSetter("onRemoteStop", &HybridAudioBrowserSpec::setOnRemoteStop);
+      prototype.registerHybridGetter("onOptionsChanged", &HybridAudioBrowserSpec::getOnOptionsChanged);
+      prototype.registerHybridSetter("onOptionsChanged", &HybridAudioBrowserSpec::setOnOptionsChanged);
+      prototype.registerHybridGetter("onFavoriteChanged", &HybridAudioBrowserSpec::getOnFavoriteChanged);
+      prototype.registerHybridSetter("onFavoriteChanged", &HybridAudioBrowserSpec::setOnFavoriteChanged);
+      prototype.registerHybridGetter("onNowPlayingChanged", &HybridAudioBrowserSpec::getOnNowPlayingChanged);
+      prototype.registerHybridSetter("onNowPlayingChanged", &HybridAudioBrowserSpec::setOnNowPlayingChanged);
+      prototype.registerHybridGetter("handleRemoteBookmark", &HybridAudioBrowserSpec::getHandleRemoteBookmark);
+      prototype.registerHybridSetter("handleRemoteBookmark", &HybridAudioBrowserSpec::setHandleRemoteBookmark);
+      prototype.registerHybridGetter("handleRemoteDislike", &HybridAudioBrowserSpec::getHandleRemoteDislike);
+      prototype.registerHybridSetter("handleRemoteDislike", &HybridAudioBrowserSpec::setHandleRemoteDislike);
+      prototype.registerHybridGetter("handleRemoteJumpBackward", &HybridAudioBrowserSpec::getHandleRemoteJumpBackward);
+      prototype.registerHybridSetter("handleRemoteJumpBackward", &HybridAudioBrowserSpec::setHandleRemoteJumpBackward);
+      prototype.registerHybridGetter("handleRemoteJumpForward", &HybridAudioBrowserSpec::getHandleRemoteJumpForward);
+      prototype.registerHybridSetter("handleRemoteJumpForward", &HybridAudioBrowserSpec::setHandleRemoteJumpForward);
+      prototype.registerHybridGetter("handleRemoteLike", &HybridAudioBrowserSpec::getHandleRemoteLike);
+      prototype.registerHybridSetter("handleRemoteLike", &HybridAudioBrowserSpec::setHandleRemoteLike);
+      prototype.registerHybridGetter("handleRemoteNext", &HybridAudioBrowserSpec::getHandleRemoteNext);
+      prototype.registerHybridSetter("handleRemoteNext", &HybridAudioBrowserSpec::setHandleRemoteNext);
+      prototype.registerHybridGetter("handleRemotePause", &HybridAudioBrowserSpec::getHandleRemotePause);
+      prototype.registerHybridSetter("handleRemotePause", &HybridAudioBrowserSpec::setHandleRemotePause);
+      prototype.registerHybridGetter("handleRemotePlay", &HybridAudioBrowserSpec::getHandleRemotePlay);
+      prototype.registerHybridSetter("handleRemotePlay", &HybridAudioBrowserSpec::setHandleRemotePlay);
+      prototype.registerHybridGetter("handleRemotePlayId", &HybridAudioBrowserSpec::getHandleRemotePlayId);
+      prototype.registerHybridSetter("handleRemotePlayId", &HybridAudioBrowserSpec::setHandleRemotePlayId);
+      prototype.registerHybridGetter("handleRemotePlaySearch", &HybridAudioBrowserSpec::getHandleRemotePlaySearch);
+      prototype.registerHybridSetter("handleRemotePlaySearch", &HybridAudioBrowserSpec::setHandleRemotePlaySearch);
+      prototype.registerHybridGetter("handleRemotePrevious", &HybridAudioBrowserSpec::getHandleRemotePrevious);
+      prototype.registerHybridSetter("handleRemotePrevious", &HybridAudioBrowserSpec::setHandleRemotePrevious);
+      prototype.registerHybridGetter("handleRemoteSeek", &HybridAudioBrowserSpec::getHandleRemoteSeek);
+      prototype.registerHybridSetter("handleRemoteSeek", &HybridAudioBrowserSpec::setHandleRemoteSeek);
+      prototype.registerHybridGetter("handleRemoteSkip", &HybridAudioBrowserSpec::getHandleRemoteSkip);
+      prototype.registerHybridSetter("handleRemoteSkip", &HybridAudioBrowserSpec::setHandleRemoteSkip);
+      prototype.registerHybridGetter("handleRemoteStop", &HybridAudioBrowserSpec::getHandleRemoteStop);
+      prototype.registerHybridSetter("handleRemoteStop", &HybridAudioBrowserSpec::setHandleRemoteStop);
+      prototype.registerHybridGetter("onOnlineChanged", &HybridAudioBrowserSpec::getOnOnlineChanged);
+      prototype.registerHybridSetter("onOnlineChanged", &HybridAudioBrowserSpec::setOnOnlineChanged);
+      prototype.registerHybridGetter("onSystemVolumeChanged", &HybridAudioBrowserSpec::getOnSystemVolumeChanged);
+      prototype.registerHybridSetter("onSystemVolumeChanged", &HybridAudioBrowserSpec::setOnSystemVolumeChanged);
+      prototype.registerHybridGetter("onIosOutputChanged", &HybridAudioBrowserSpec::getOnIosOutputChanged);
+      prototype.registerHybridSetter("onIosOutputChanged", &HybridAudioBrowserSpec::setOnIosOutputChanged);
+      prototype.registerHybridGetter("onEqualizerChanged", &HybridAudioBrowserSpec::getOnEqualizerChanged);
+      prototype.registerHybridSetter("onEqualizerChanged", &HybridAudioBrowserSpec::setOnEqualizerChanged);
+      prototype.registerHybridGetter("onBatteryWarningPendingChanged", &HybridAudioBrowserSpec::getOnBatteryWarningPendingChanged);
+      prototype.registerHybridSetter("onBatteryWarningPendingChanged", &HybridAudioBrowserSpec::setOnBatteryWarningPendingChanged);
+      prototype.registerHybridGetter("onBatteryOptimizationStatusChanged", &HybridAudioBrowserSpec::getOnBatteryOptimizationStatusChanged);
+      prototype.registerHybridSetter("onBatteryOptimizationStatusChanged", &HybridAudioBrowserSpec::setOnBatteryOptimizationStatusChanged);
+      prototype.registerHybridMethod("navigatePath", &HybridAudioBrowserSpec::navigatePath);
+      prototype.registerHybridMethod("navigateTrack", &HybridAudioBrowserSpec::navigateTrack);
+      prototype.registerHybridMethod("onSearch", &HybridAudioBrowserSpec::onSearch);
+      prototype.registerHybridMethod("getContent", &HybridAudioBrowserSpec::getContent);
+      prototype.registerHybridMethod("getNavigationError", &HybridAudioBrowserSpec::getNavigationError);
+      prototype.registerHybridMethod("getFormattedNavigationError", &HybridAudioBrowserSpec::getFormattedNavigationError);
+      prototype.registerHybridMethod("notifyContentChanged", &HybridAudioBrowserSpec::notifyContentChanged);
+      prototype.registerHybridMethod("setFavorites", &HybridAudioBrowserSpec::setFavorites);
+      prototype.registerHybridMethod("setupPlayer", &HybridAudioBrowserSpec::setupPlayer);
+      prototype.registerHybridMethod("updateOptions", &HybridAudioBrowserSpec::updateOptions);
+      prototype.registerHybridMethod("getOptions", &HybridAudioBrowserSpec::getOptions);
+      prototype.registerHybridMethod("load", &HybridAudioBrowserSpec::load);
+      prototype.registerHybridMethod("reset", &HybridAudioBrowserSpec::reset);
+      prototype.registerHybridMethod("play", &HybridAudioBrowserSpec::play);
+      prototype.registerHybridMethod("pause", &HybridAudioBrowserSpec::pause);
+      prototype.registerHybridMethod("togglePlayback", &HybridAudioBrowserSpec::togglePlayback);
+      prototype.registerHybridMethod("stop", &HybridAudioBrowserSpec::stop);
+      prototype.registerHybridMethod("setPlayWhenReady", &HybridAudioBrowserSpec::setPlayWhenReady);
+      prototype.registerHybridMethod("getPlayWhenReady", &HybridAudioBrowserSpec::getPlayWhenReady);
+      prototype.registerHybridMethod("seekTo", &HybridAudioBrowserSpec::seekTo);
+      prototype.registerHybridMethod("seekBy", &HybridAudioBrowserSpec::seekBy);
+      prototype.registerHybridMethod("setVolume", &HybridAudioBrowserSpec::setVolume);
+      prototype.registerHybridMethod("getVolume", &HybridAudioBrowserSpec::getVolume);
+      prototype.registerHybridMethod("setRate", &HybridAudioBrowserSpec::setRate);
+      prototype.registerHybridMethod("getRate", &HybridAudioBrowserSpec::getRate);
+      prototype.registerHybridMethod("getProgress", &HybridAudioBrowserSpec::getProgress);
+      prototype.registerHybridMethod("getPlayback", &HybridAudioBrowserSpec::getPlayback);
+      prototype.registerHybridMethod("getPlayingState", &HybridAudioBrowserSpec::getPlayingState);
+      prototype.registerHybridMethod("getRepeatMode", &HybridAudioBrowserSpec::getRepeatMode);
+      prototype.registerHybridMethod("setRepeatMode", &HybridAudioBrowserSpec::setRepeatMode);
+      prototype.registerHybridMethod("getShuffleEnabled", &HybridAudioBrowserSpec::getShuffleEnabled);
+      prototype.registerHybridMethod("setShuffleEnabled", &HybridAudioBrowserSpec::setShuffleEnabled);
+      prototype.registerHybridMethod("getPlaybackError", &HybridAudioBrowserSpec::getPlaybackError);
+      prototype.registerHybridMethod("retry", &HybridAudioBrowserSpec::retry);
+      prototype.registerHybridMethod("getSleepTimer", &HybridAudioBrowserSpec::getSleepTimer);
+      prototype.registerHybridMethod("setSleepTimer", &HybridAudioBrowserSpec::setSleepTimer);
+      prototype.registerHybridMethod("setSleepTimerToEndOfTrack", &HybridAudioBrowserSpec::setSleepTimerToEndOfTrack);
+      prototype.registerHybridMethod("clearSleepTimer", &HybridAudioBrowserSpec::clearSleepTimer);
+      prototype.registerHybridMethod("add", &HybridAudioBrowserSpec::add);
+      prototype.registerHybridMethod("move", &HybridAudioBrowserSpec::move);
+      prototype.registerHybridMethod("remove", &HybridAudioBrowserSpec::remove);
+      prototype.registerHybridMethod("removeUpcomingTracks", &HybridAudioBrowserSpec::removeUpcomingTracks);
+      prototype.registerHybridMethod("skip", &HybridAudioBrowserSpec::skip);
+      prototype.registerHybridMethod("skipToNext", &HybridAudioBrowserSpec::skipToNext);
+      prototype.registerHybridMethod("skipToPrevious", &HybridAudioBrowserSpec::skipToPrevious);
+      prototype.registerHybridMethod("setActiveTrackFavorited", &HybridAudioBrowserSpec::setActiveTrackFavorited);
+      prototype.registerHybridMethod("toggleActiveTrackFavorited", &HybridAudioBrowserSpec::toggleActiveTrackFavorited);
+      prototype.registerHybridMethod("setQueue", &HybridAudioBrowserSpec::setQueue);
+      prototype.registerHybridMethod("getQueue", &HybridAudioBrowserSpec::getQueue);
+      prototype.registerHybridMethod("getTrack", &HybridAudioBrowserSpec::getTrack);
+      prototype.registerHybridMethod("getActiveTrackIndex", &HybridAudioBrowserSpec::getActiveTrackIndex);
+      prototype.registerHybridMethod("getActiveTrack", &HybridAudioBrowserSpec::getActiveTrack);
+      prototype.registerHybridMethod("updateNowPlaying", &HybridAudioBrowserSpec::updateNowPlaying);
+      prototype.registerHybridMethod("getNowPlaying", &HybridAudioBrowserSpec::getNowPlaying);
+      prototype.registerHybridMethod("getOnline", &HybridAudioBrowserSpec::getOnline);
+      prototype.registerHybridMethod("getSystemVolume", &HybridAudioBrowserSpec::getSystemVolume);
+      prototype.registerHybridMethod("setSystemVolume", &HybridAudioBrowserSpec::setSystemVolume);
+      prototype.registerHybridMethod("getIosOutput", &HybridAudioBrowserSpec::getIosOutput);
+      prototype.registerHybridMethod("openIosOutputPicker", &HybridAudioBrowserSpec::openIosOutputPicker);
+      prototype.registerHybridMethod("getEqualizerSettings", &HybridAudioBrowserSpec::getEqualizerSettings);
+      prototype.registerHybridMethod("setEqualizerEnabled", &HybridAudioBrowserSpec::setEqualizerEnabled);
+      prototype.registerHybridMethod("setEqualizerPreset", &HybridAudioBrowserSpec::setEqualizerPreset);
+      prototype.registerHybridMethod("setEqualizerLevels", &HybridAudioBrowserSpec::setEqualizerLevels);
+      prototype.registerHybridMethod("getBatteryWarningPending", &HybridAudioBrowserSpec::getBatteryWarningPending);
+      prototype.registerHybridMethod("getBatteryOptimizationStatus", &HybridAudioBrowserSpec::getBatteryOptimizationStatus);
+      prototype.registerHybridMethod("dismissBatteryWarning", &HybridAudioBrowserSpec::dismissBatteryWarning);
+      prototype.registerHybridMethod("openBatterySettings", &HybridAudioBrowserSpec::openBatterySettings);
+    });
+  }
+
+} // namespace margelo::nitro::audiobrowser

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 © 2026 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