@javascriptcommon/react-native-track-player 1.2.23 → 4.1.5

package/src/interfaces/PlayerOptions.ts

@@ -0,0 +1,138 @@
+import type {
+  AndroidAudioContentType,
+  IOSCategory,
+  IOSCategoryMode,
+  IOSCategoryOptions,
+} from '../constants';
+
+export interface PlayerOptions {
+  /**
+   * Minimum duration of media that the player will attempt to buffer in seconds.
+   *
+   * Supported on Android & iOS.
+   *
+   * @throws Will throw on Android if min buffer is higher than max buffer.
+   * @default 50
+   */
+  minBuffer?: number;
+  /**
+   * Maximum duration of media that the player will attempt to buffer in seconds.
+   * Max buffer may not be lower than min buffer.
+   *
+   * Supported on Android only.
+   *
+   * @throws Will throw if max buffer is lower than min buffer.
+   * @default 50
+   */
+  maxBuffer?: number;
+  /**
+   * Duration in seconds that should be kept in the buffer behind the current
+   * playhead time.
+   *
+   * Supported on Android only.
+   *
+   * @default 0
+   */
+  backBuffer?: number;
+  /**
+   * Duration of media in seconds that must be buffered for playback to start or
+   * resume following a user action such as a seek.
+   *
+   * Supported on Android only.
+   *
+   * @default 2.5
+   */
+  playBuffer?: number;
+  /**
+   * Maximum cache size in kilobytes.
+   *
+   * Supported on Android only.
+   *
+   * @default 0
+   */
+  maxCacheSize?: number;
+  /**
+   * [AVAudioSession.Category](https://developer.apple.com/documentation/avfoundation/avaudiosession/1616615-category)
+   * for iOS. Sets on `play()`.
+   */
+  iosCategory?: IOSCategory;
+  /**
+   * (iOS only) The audio session mode, together with the audio session category,
+   * indicates to the system how you intend to use audio in your app. You can use
+   * a mode to configure the audio system for specific use cases such as video
+   * recording, voice or video chat, or audio analysis.
+   * Sets on `play()`.
+   *
+   * See https://developer.apple.com/documentation/avfoundation/avaudiosession/1616508-mode
+   */
+  iosCategoryMode?: IOSCategoryMode;
+  /**
+   * [AVAudioSession.CategoryOptions](https://developer.apple.com/documentation/avfoundation/avaudiosession/1616503-categoryoptions) for iOS.
+   * Sets on `play()`.
+   */
+  iosCategoryOptions?: IOSCategoryOptions[];
+  /**
+   * (Android only) The audio content type indicates to the android system how
+   * you intend to use audio in your app.
+   *
+   * With `autoHandleInterruptions: true` and
+   * `androidAudioContentType: AndroidAudioContentType.Speech`, the audio will be
+   * paused during short interruptions, such as when a message arrives.
+   * Otherwise the playback volume is reduced while the notification is playing.
+   *
+   * @default AndroidAudioContentType.Music
+   */
+  androidAudioContentType?: AndroidAudioContentType;
+  /**
+   * auto pause playback when playback device changes from headset to speaker.
+   * @default true
+   */
+  androidHandleAudioBecomingNoisy?: boolean;
+  /**
+   * always show next and previous as android player command. this overrides
+   * exoplayer disabling the next button on playmode != all and at queue's end.
+   * @default true
+   */
+  androidAlwaysShowNext?: boolean;
+  /**
+   * enables exoplayer's skipSilence parser
+   * @default false
+   */
+  androidSkipSilence?: boolean;
+  /**
+   * set android exoplayer wake mode. 1 is WAKE_MODE_LOCAL, 2 is WAKE_MODE_NETWORK,
+   * and others is WAKE_MODE_NONE.
+   * @default 0
+   */
+  androidWakeMode?: number;
+  /**
+   * Indicates whether the player should automatically delay playback in order to minimize stalling.
+   * Defaults to `true`.
+   * @deprecated This option has been nominated for removal in a future version
+   * of RNTP. If you have this set to `true`, you can safely remove this from
+   * the options. If you are setting this to `false` and have a reason for that,
+   * please post a comment in the following discussion: https://github.com/doublesymmetry/react-native-track-player/pull/1695
+   * and describe why you are doing so.
+   */
+  waitForBuffer?: boolean;
+  /**
+   * Indicates whether the player should automatically update now playing metadata data in control center / notification.
+   * Defaults to `true`.
+   */
+  autoUpdateMetadata?: boolean;
+  /**
+   * Indicates whether the player should automatically handle audio interruptions.
+   * Defaults to `false`.
+   */
+  autoHandleInterruptions?: boolean;
+  /**
+   * enables crossfade. android only.
+   * Defaults to `false`.
+   */
+  crossfade?: boolean;
+  /**
+   * applies an FFT processor with the given sampling size. android only.
+   * Defaults to 0 (disables it).
+   */
+  useFFTProcessor?: number;
+}

package/src/interfaces/Progress.ts

@@ -0,0 +1,15 @@
+export interface Progress {
+  /**
+   * The playback position of the current track in seconds.
+   * See https://rntp.dev/docs/api/functions/player#getposition
+   **/
+  position: number;
+  /** The duration of the current track in seconds.
+   * See https://rntp.dev/docs/api/functions/player#getduration
+   **/
+  duration: number;
+  /**
+   * The buffered position of the current track in seconds.
+   **/
+  buffered: number;
+}

package/src/interfaces/ResourceObject.ts

@@ -0,0 +1 @@
+export type ResourceObject = number;

package/src/interfaces/ServiceHandler.ts

@@ -0,0 +1 @@
+export type ServiceHandler = () => Promise<void>;

package/src/interfaces/Track.ts

@@ -0,0 +1,23 @@
+import type { PitchAlgorithm, TrackType } from '../constants';
+import { ResourceObject } from './ResourceObject';
+import type { TrackMetadataBase } from './TrackMetadataBase';
+
+export interface Track extends TrackMetadataBase {
+  url: string;
+  type?: TrackType;
+  /** The user agent HTTP header */
+  userAgent?: string;
+  /** Mime type of the media file */
+  contentType?: string;
+  /** (iOS only) The pitch algorithm to apply to the sound. */
+  pitchAlgorithm?: PitchAlgorithm;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  headers?: { [key: string]: any };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any;
+}
+
+export type AddTrack = Track & {
+  url: string | ResourceObject;
+  artwork?: string | ResourceObject;
+};

package/src/interfaces/TrackMetadataBase.ts

@@ -0,0 +1,29 @@
+import type { RatingType } from '../constants';
+
+export interface TrackMetadataBase {
+  /** The track title */
+  title?: string;
+  /** The track album */
+  album?: string;
+  /** The track artist */
+  artist?: string;
+  /** The track duration in seconds */
+  duration?: number;
+  /** The track artwork */
+  artwork?: string;
+  /** track description */
+  description?: string;
+  /** track mediaId */
+  mediaId?: string;
+  /** The track genre */
+  genre?: string;
+  /** The track release date in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) */
+  date?: string;
+  /** The track rating */
+  rating?: RatingType;
+  /**
+   * (iOS only) Whether the track is presented in the control center as being
+   * live
+   **/
+  isLiveStream?: boolean;
+}

package/src/interfaces/UpdateOptions.ts

@@ -0,0 +1,59 @@
+import type { AndroidOptions } from './AndroidOptions';
+import type { FeedbackOptions } from './FeedbackOptions';
+import type { ResourceObject } from './ResourceObject';
+import type { RatingType, Capability } from '../constants';
+import { CustomButtons } from './CustomButtons';
+
+export interface UpdateOptions {
+  android?: AndroidOptions;
+  ratingType?: RatingType;
+  forwardJumpInterval?: number;
+  backwardJumpInterval?: number;
+  progressUpdateEventInterval?: number; // in seconds
+
+  // ios
+  likeOptions?: FeedbackOptions;
+  dislikeOptions?: FeedbackOptions;
+  bookmarkOptions?: FeedbackOptions;
+
+  capabilities?: Capability[];
+
+  // android
+  /**
+   * @deprecated Use `android` options and `appKilledPlaybackMode` instead.
+   * @example
+   * ```
+   * await TrackPlayer.updateOptions({
+   *   android: {
+   *     appKilledPlaybackMode: AppKilledPlaybackMode.PausePlayback
+   *  },
+   * });
+   *  ```
+   */
+  stoppingAppPausesPlayback?: boolean;
+  /**
+   * @deprecated use `TrackPlayer.updateOptions({ android: { alwaysPauseOnInterruption: boolean }})` instead
+   */
+  alwaysPauseOnInterruption?: boolean;
+  notificationCapabilities?: Capability[];
+  compactCapabilities?: Capability[];
+
+  icon?: ResourceObject;
+  playIcon?: ResourceObject;
+  pauseIcon?: ResourceObject;
+  stopIcon?: ResourceObject;
+  previousIcon?: ResourceObject;
+  nextIcon?: ResourceObject;
+  rewindIcon?: ResourceObject;
+  forwardIcon?: ResourceObject;
+  color?: number;
+  /**
+   * Android Only. Specifies custom Actions using the key customActionsList as a list of strings,
+   * then specify the imported icons for the actions to keys for each action.
+   * This is useful for android auto, as any extra buttons (when total > 5, > 4 extra buttons) will show up in a menu.
+   * please note customActions will always show in the notification bar, because there is no other way
+   * they will be called.
+   * isCompat is always false unless there is a need to show them.
+   */
+  customActions?: CustomButtons;
+}

package/src/interfaces/events/AudioMetadataReceivedEvent.ts

@@ -0,0 +1,37 @@
+export interface AudioMetadataReceivedEvent {
+  metadata: AudioMetadata[];
+}
+
+export interface AudioCommonMetadataReceivedEvent {
+  metadata: AudioCommonMetadata;
+}
+
+export interface AudioCommonMetadata {
+  title: string | undefined;
+  artist: string | undefined;
+  albumTitle: string | undefined;
+  subtitle: string | undefined;
+  description: string | undefined;
+  artworkUri: string | undefined;
+  trackNumber: string | undefined;
+  composer: string | undefined;
+  conductor: string | undefined;
+  genre: string | undefined;
+  compilation: string | undefined;
+  station: string | undefined;
+  mediaType: string | undefined;
+  creationDate: string | undefined;
+  creationYear: string | undefined;
+}
+
+export interface AudioMetadata extends AudioCommonMetadata {
+  raw: RawEntry[];
+}
+
+export interface RawEntry {
+  commonKey: string | undefined;
+  keySpace: string | undefined;
+  time: number | undefined;
+  value: unknown | null;
+  key: string;
+}

package/src/interfaces/events/ControllerConnectedEvent.ts

@@ -0,0 +1,9 @@
+export interface ControllerConnectedEvent extends ControllerDisconnectedEvent {
+  isMediaNotificationController: boolean;
+  isAutomotiveController: boolean;
+  isAutoCompanionController: boolean;
+}
+
+export interface ControllerDisconnectedEvent {
+  package: string;
+}

package/src/interfaces/events/EventPayloadByEvent.ts

@@ -0,0 +1,80 @@
+import { Event } from '../../constants';
+
+import type { PlaybackState } from '../PlaybackState';
+import type { PlaybackActiveTrackChangedEvent } from './PlaybackActiveTrackChangedEvent';
+import type { PlaybackErrorEvent } from './PlaybackErrorEvent';
+import type { PlaybackMetadataReceivedEvent } from './PlaybackMetadataReceivedEvent';
+import type { AudioMetadataReceivedEvent } from './AudioMetadataReceivedEvent';
+import type { AudioCommonMetadataReceivedEvent } from './AudioMetadataReceivedEvent';
+import type { PlaybackPlayWhenReadyChangedEvent } from './PlaybackPlayWhenReadyChangedEvent';
+import type { PlaybackProgressUpdatedEvent } from './PlaybackProgressUpdatedEvent';
+import type { PlaybackQueueEndedEvent } from './PlaybackQueueEndedEvent';
+import type { PlaybackTrackChangedEvent } from './PlaybackTrackChangedEvent';
+import { PlayerErrorEvent } from './PlayerErrorEvent';
+import type { RemoteDuckEvent } from './RemoteDuckEvent';
+import type { RemoteJumpBackwardEvent } from './RemoteJumpBackwardEvent';
+import type { RemoteJumpForwardEvent } from './RemoteJumpForwardEvent';
+import type { RemotePlayIdEvent } from './RemotePlayIdEvent';
+import type { RemotePlaySearchEvent } from './RemotePlaySearchEvent';
+import type { RemoteSearchEvent } from './RemoteSearchEvent';
+import type { RemoteSeekEvent } from './RemoteSeekEvent';
+import type { RemoteSetRatingEvent } from './RemoteSetRatingEvent';
+import type { RemoteSkipEvent } from './RemoteSkipEvent';
+import type { PlaybackAnimatedVolumeChangedEvent } from './PlaybackAnimatedVolumeChangedEvent';
+import type { RemoteBrowseEvent } from './RemoteBrowseEvent';
+import type { RemoteCustomActionEvent } from './RemoteCustomActionEvent';
+import type { PlaybackResumeEvent } from './PlaybackResumeEvent';
+import type {
+  ControllerConnectedEvent,
+  ControllerDisconnectedEvent,
+} from './ControllerConnectedEvent';
+import type { FFTUpdateEvent } from './FFTUpdateEvent';
+
+export type EventPayloadByEvent = {
+  [Event.PlayerError]: PlayerErrorEvent;
+  [Event.PlaybackState]: PlaybackState;
+  [Event.PlaybackError]: PlaybackErrorEvent;
+  [Event.PlaybackQueueEnded]: PlaybackQueueEndedEvent;
+  [Event.PlaybackTrackChanged]: PlaybackTrackChangedEvent;
+  [Event.PlaybackActiveTrackChanged]: PlaybackActiveTrackChangedEvent;
+  [Event.PlaybackMetadataReceived]: PlaybackMetadataReceivedEvent;
+  [Event.PlaybackPlayWhenReadyChanged]: PlaybackPlayWhenReadyChangedEvent;
+  [Event.PlaybackProgressUpdated]: PlaybackProgressUpdatedEvent;
+  [Event.RemotePlay]: never;
+  [Event.RemotePlayPause]: never;
+  [Event.RemotePlayId]: RemotePlayIdEvent;
+  [Event.RemotePlaySearch]: RemotePlaySearchEvent;
+  [Event.RemoteSearch]: RemoteSearchEvent;
+  [Event.RemotePause]: never;
+  [Event.RemoteStop]: never;
+  [Event.RemoteSkip]: RemoteSkipEvent;
+  [Event.RemoteNext]: never;
+  [Event.RemotePrevious]: never;
+  [Event.RemoteJumpForward]: RemoteJumpForwardEvent;
+  [Event.RemoteJumpBackward]: RemoteJumpBackwardEvent;
+  [Event.RemoteSeek]: RemoteSeekEvent;
+  [Event.RemoteSetRating]: RemoteSetRatingEvent;
+  [Event.RemoteDuck]: RemoteDuckEvent;
+  [Event.RemoteLike]: never;
+  [Event.RemoteDislike]: never;
+  [Event.RemoteBookmark]: never;
+  [Event.PlaybackAnimatedVolumeChanged]: PlaybackAnimatedVolumeChangedEvent;
+  [Event.RemoteBrowse]: RemoteBrowseEvent;
+  [Event.PlaybackResume]: PlaybackResumeEvent;
+  [Event.RemoteCustomAction]: RemoteCustomActionEvent;
+  [Event.MetadataChapterReceived]: AudioMetadataReceivedEvent;
+  [Event.MetadataTimedReceived]: AudioMetadataReceivedEvent;
+  [Event.MetadataCommonReceived]: AudioCommonMetadataReceivedEvent;
+  [Event.connectorConnected]: ControllerConnectedEvent;
+  [Event.connectorDisconnected]: ControllerDisconnectedEvent;
+  [Event.fftUpdate]: FFTUpdateEvent;
+};
+
+// eslint-disable-next-line
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+export type EventPayloadByEventWithType = {
+  [K in keyof EventPayloadByEvent]: EventPayloadByEvent[K] extends never
+    ? { type: K }
+    : Simplify<EventPayloadByEvent[K] & { type: K }>;
+};

package/src/interfaces/events/FFTUpdateEvent.ts

@@ -0,0 +1,9 @@
+/**
+ * android & ios only. returns a FFT doubleArray of the current playback, sample rate = 4096
+ **/
+export interface FFTUpdateEvent {
+  // FFT doubleArray of the current playback buffer
+  data: number[];
+  // ios only.
+  amplitude?: number;
+}

package/src/interfaces/events/PlaybackActiveTrackChangedEvent.ts

@@ -0,0 +1,29 @@
+import type { Track } from '../Track';
+
+export interface PlaybackActiveTrackChangedEvent {
+  /** The index of previously active track. */
+  lastIndex?: number;
+
+  /**
+   * The previously active track or `undefined` when there wasn't a previously
+   * active track.
+   */
+  lastTrack?: Track;
+
+  /**
+   * The position of the previously active track in seconds.
+   */
+  lastPosition: number;
+
+  /**
+   * The newly active track index or `undefined` if there is no longer an
+   * active track.
+   */
+  index?: number;
+
+  /**
+   * The newly active track or `undefined` if there is no longer an
+   * active track.
+   */
+  track?: Track;
+}

package/src/interfaces/events/PlaybackAnimatedVolumeChangedEvent.ts

@@ -0,0 +1,4 @@
+export interface PlaybackAnimatedVolumeChangedEvent {
+  /** the event message */
+  data: string;
+}

package/src/interfaces/events/PlaybackErrorEvent.ts

@@ -0,0 +1,6 @@
+export interface PlaybackErrorEvent {
+  /** The error code */
+  code: string;
+  /** The error message */
+  message: string;
+}

package/src/interfaces/events/PlaybackMetadataReceivedEvent.ts

@@ -0,0 +1,16 @@
+export interface PlaybackMetadataReceivedEvent {
+  /** The metadata source  */
+  source: string;
+  /** The track title */
+  title: string | null;
+  /** The track url */
+  url: string | null;
+  /** The track artist */
+  artist: string | null;
+  /** The track album */
+  album: string | null;
+  /** The track date */
+  date: string | null;
+  /** The track genre */
+  genre: string | null;
+}

package/src/interfaces/events/PlaybackPlayWhenReadyChangedEvent.ts

@@ -0,0 +1,4 @@
+export interface PlaybackPlayWhenReadyChangedEvent {
+  /** Whether the player will play when it is ready to do so. */
+  playWhenReady: boolean;
+}

package/src/interfaces/events/PlaybackProgressUpdatedEvent.ts

@@ -0,0 +1,5 @@
+import type { Progress } from '../Progress';
+
+export interface PlaybackProgressUpdatedEvent extends Progress {
+  track: number;
+}

package/src/interfaces/events/PlaybackQueueEndedEvent.ts

@@ -0,0 +1,9 @@
+export interface PlaybackQueueEndedEvent {
+  /** The index of the active track when the playback queue ended. */
+  track: number;
+  /**
+   * The playback position in seconds of the active track when the playback
+   * queue ended.
+   **/
+  position: number;
+}

package/src/interfaces/events/PlaybackResumeEvent.ts

@@ -0,0 +1,5 @@
+import type { Progress } from '../Progress';
+
+export interface PlaybackResumeEvent {
+  package: string;
+}

package/src/interfaces/events/PlaybackTrackChangedEvent.ts

@@ -0,0 +1,11 @@
+/**
+ * @deprecated
+ */
+export interface PlaybackTrackChangedEvent {
+  /** The index of previously active track. */
+  track: number | null;
+  /** The previous track position in seconds. */
+  position: number;
+  /** The next (active) track index. */
+  nextTrack: number;
+}

package/src/interfaces/events/PlayerErrorEvent.ts

@@ -0,0 +1,6 @@
+export interface PlayerErrorEvent {
+  /** The error code */
+  code: 'android-foreground-service-start-not-allowed';
+  /** The error message */
+  message: string;
+}

package/src/interfaces/events/RemoteBrowseEvent.ts

@@ -0,0 +1,4 @@
+export interface RemoteBrowseEvent {
+  /** The browsable media id */
+  mediaId: string;
+}

package/src/interfaces/events/RemoteCustomActionEvent.ts

@@ -0,0 +1,7 @@
+export interface RemoteCustomActionEvent {
+  /**
+   * The custom action button pressed event.
+   * remote-custom-action
+   **/
+  customAction: string;
+}

package/src/interfaces/events/RemoteDuckEvent.ts

@@ -0,0 +1,13 @@
+export interface RemoteDuckEvent {
+  /**
+   * On Android when true the player should pause playback, when false the
+   * player may resume playback. On iOS when true the playback was paused and
+   * when false the player may resume playback.
+   **/
+  paused: boolean;
+  /**
+   * Whether the interruption is permanent. On Android the player should stop
+   * playback.
+   **/
+  permanent: boolean;
+}

package/src/interfaces/events/RemoteJumpBackwardEvent.ts

@@ -0,0 +1,7 @@
+export interface RemoteJumpBackwardEvent {
+  /**
+   * The number of seconds to jump backward.
+   * See https://rntp.dev/docs/api/events#remotejumpbackward
+   **/
+  interval: number;
+}

package/src/interfaces/events/RemoteJumpForwardEvent.ts

@@ -0,0 +1,7 @@
+export interface RemoteJumpForwardEvent {
+  /**
+   * The number of seconds to jump forward.
+   * See https://rntp.dev/docs/api/events#remotejumpforward
+   **/
+  interval: number;
+}

package/src/interfaces/events/RemotePlayIdEvent.ts

@@ -0,0 +1,4 @@
+export interface RemotePlayIdEvent {
+  /** The track id */
+  id: string;
+}

package/src/interfaces/events/RemotePlaySearchEvent.ts

@@ -0,0 +1,21 @@
+export interface RemotePlaySearchEvent {
+  /*
+  below is the Google Voice event log:
+  Event.RemotePlaySearchEvent {
+    "android.intent.extra.REFERRER_NAME": "android-app://com.google.android.googlequicksearchbox/https/www.google.com",
+    "android.intent.extra.START_PLAYBACK": true,
+    "android.intent.extra.focus": "vnd.android.cursor.item/*",
+    "android.intent.extra.user_query": "play seat",
+    "android.intent.extra.user_query_language": "en-US",
+    "com.google.android.projection.gearhead.ignore_original_pkg": false,
+    "opa_allow_launch_intent_on_lockscreen": true,
+    "query": "seat"} 
+  */
+  query: string;
+  focus?: 'artist' | 'album' | 'playlist' | 'genre';
+  title?: string;
+  artist?: string;
+  album?: string;
+  date?: string;
+  playlist?: string;
+}

package/src/interfaces/events/RemoteSearchEvent.ts

@@ -0,0 +1,3 @@
+export interface RemoteSearchEvent {
+  query: string
+}

package/src/interfaces/events/RemoteSeekEvent.ts

@@ -0,0 +1,4 @@
+export interface RemoteSeekEvent {
+  /** The position to seek to in seconds. */
+  position: number;
+}

package/src/interfaces/events/RemoteSetRatingEvent.ts

@@ -0,0 +1,5 @@
+import type { RatingType } from '../../constants';
+
+export interface RemoteSetRatingEvent {
+  rating: RatingType;
+}

package/src/interfaces/events/RemoteSkipEvent.ts

@@ -0,0 +1,3 @@
+export interface RemoteSkipEvent {
+  index: number;
+}

package/src/interfaces/events/index.ts

@@ -0,0 +1,20 @@
+export * from './EventPayloadByEvent';
+export * from './PlaybackActiveTrackChangedEvent';
+export * from './PlaybackErrorEvent';
+export * from './PlaybackMetadataReceivedEvent';
+export * from './PlaybackPlayWhenReadyChangedEvent';
+export * from './PlaybackProgressUpdatedEvent';
+export * from './PlaybackQueueEndedEvent';
+export * from './PlaybackTrackChangedEvent';
+export * from './RemoteDuckEvent';
+export * from './RemoteJumpBackwardEvent';
+export * from './RemoteJumpForwardEvent';
+export * from './RemotePlayIdEvent';
+export * from './RemotePlaySearchEvent';
+export * from './RemoteSearchEvent';
+export * from './RemoteSeekEvent';
+export * from './RemoteSetRatingEvent';
+export * from './RemoteSkipEvent';
+export * from './RemoteBrowseEvent';
+export * from './ControllerConnectedEvent';
+export * from './FFTUpdateEvent';

package/src/interfaces/index.ts

@@ -0,0 +1,15 @@
+export * from './AndroidOptions';
+export * from './FeedbackOptions';
+export * from './MetadataOptions';
+export * from './NowPlayingMetadata';
+export * from './PlaybackState';
+export * from './PlayerOptions';
+export * from './Progress';
+export * from './ResourceObject';
+export * from './ServiceHandler';
+export * from './Track';
+export * from './TrackMetadataBase';
+export * from './UpdateOptions';
+export * from './events';
+export * from './MediaItem';
+export * from './AndroidAutoBrowseTree';