@jellybrick/mpris-service 2.1.5 → 2.2.0

package/dist/index.d.mts

@@ -0,0 +1,314 @@
+import { EventEmitter } from "node:events";
+import { Variant } from "@jellybrick/dbus-next";
+
+//#region src/interfaces/mpris-interface.d.ts
+declare const Interface: typeof import("@jellybrick/dbus-next").Interface;
+type SettableProperty = 'Fullscreen' | 'Rate' | 'Shuffle' | 'Volume' | 'LoopStatus';
+declare class MprisInterface extends Interface {
+  player: Player;
+  constructor(name: string, player: Player);
+  protected _setPropertyInternal(property: SettableProperty, valueDbus: unknown): void;
+  setProperty(property: string, valuePlain: unknown): void;
+}
+//#endregion
+//#region src/types.d.ts
+type PlayBackStatus = 'Playing' | 'Paused' | 'Stopped';
+type LoopStatus = 'None' | 'Track' | 'Playlist';
+type Interfaces = 'player' | 'trackList' | 'playlists';
+interface Playlist {
+  Id: string;
+  Name: string;
+  Icon: string;
+}
+interface Track {
+  'mpris:trackid'?: string;
+  'mpris:length'?: number;
+  'mpris:artUrl'?: string;
+  'xesam:album'?: string;
+  'xesam:albumArtist'?: string[];
+  'xesam:artist'?: string[];
+  'xesam:asText'?: string;
+  'xesam:audioBPM'?: number;
+  'xesam:autoRating'?: number;
+  'xesam:comment'?: string[];
+  'xesam:composer'?: string[];
+  'xesam:contentCreated'?: string;
+  'xesam:discNumber'?: number;
+  'xesam:firstUsed'?: string;
+  'xesam:genre'?: string[];
+  'xesam:lastUsed'?: string;
+  'xesam:lyricist'?: string[];
+  'xesam:title'?: string;
+  'xesam:trackNumber'?: number;
+  'xesam:url'?: string;
+  'xesam:useCount'?: number;
+  'xesam:userRating'?: number;
+}
+interface Position {
+  trackId: string;
+  position: number;
+}
+interface RootInterfaceOptions {
+  identity?: string;
+  supportedUriSchemes?: string[];
+  supportedMimeTypes?: string[];
+  desktopEntry?: string;
+}
+interface AdditionalPlayerOptions {
+  name: string;
+  supportedInterfaces?: Interfaces[];
+}
+type PlayerOptions = RootInterfaceOptions & AdditionalPlayerOptions;
+interface Events {
+  raise: void;
+  quit: void;
+  fullscreen: boolean;
+  next: void;
+  previous: void;
+  pause: void;
+  playpause: void;
+  stop: void;
+  play: void;
+  seek: number;
+  position: Position;
+  open: {
+    uri: string;
+  };
+  volume: number;
+  shuffle: boolean;
+  rate: number;
+  loopStatus: LoopStatus;
+  addTrack: {
+    uri: string;
+    afterTrack: string;
+    setAsCurrent: boolean;
+  };
+  removeTrack: string;
+  goTo: string;
+  activatePlaylist: string;
+  error: Error;
+}
+type ToArgs<T> = [T] extends [void] ? [] : [data: T];
+type EventsMap = { [K in keyof Events]: ToArgs<Events[K]> };
+//#endregion
+//#region src/interfaces/root.d.ts
+declare class RootInterface extends MprisInterface {
+  constructor(player: Player, opts?: RootInterfaceOptions);
+  private _CanQuit;
+  private _Fullscreen;
+  private _CanSetFullscreen;
+  private _CanRaise;
+  private _HasTrackList;
+  private _Identity;
+  private _DesktopEntry;
+  private _SupportedUriSchemes;
+  private _SupportedMimeTypes;
+  get CanQuit(): boolean;
+  get Fullscreen(): boolean;
+  set Fullscreen(value: boolean);
+  get CanSetFullscreen(): boolean;
+  get CanRaise(): boolean;
+  get HasTrackList(): boolean;
+  get Identity(): string;
+  get DesktopEntry(): string;
+  get SupportedUriSchemes(): string[];
+  get SupportedMimeTypes(): string[];
+  Raise(): void;
+  Quit(): void;
+}
+//#endregion
+//#region src/interfaces/player.d.ts
+declare class PlayerInterface extends MprisInterface {
+  constructor(player: Player);
+  private _CanControl;
+  private _CanPause;
+  private _CanPlay;
+  private _CanSeek;
+  private _CanGoNext;
+  private _CanGoPrevious;
+  private _Metadata;
+  private _MaximumRate;
+  private _MinimumRate;
+  private _Rate;
+  private _Shuffle;
+  private _Volume;
+  private _LoopStatus;
+  private _PlaybackStatus;
+  get CanControl(): boolean;
+  get CanPause(): boolean;
+  get CanPlay(): boolean;
+  get CanSeek(): boolean;
+  get CanGoNext(): boolean;
+  get CanGoPrevious(): boolean;
+  get Metadata(): Record<string, Variant>;
+  get MaximumRate(): number;
+  get MinimumRate(): number;
+  get Rate(): number;
+  set Rate(value: number);
+  get Shuffle(): boolean;
+  set Shuffle(value: boolean);
+  get Volume(): number;
+  set Volume(value: number);
+  get Position(): number;
+  get LoopStatus(): string;
+  set LoopStatus(value: string);
+  get PlaybackStatus(): string;
+  Next(): void;
+  Previous(): void;
+  Pause(): void;
+  PlayPause(): void;
+  Stop(): void;
+  Play(): void;
+  Seek(offset: bigint): void;
+  SetPosition(trackId: string, position: bigint): void;
+  OpenUri(uri: string): void;
+  Seeked(position: number): number;
+}
+//#endregion
+//#region src/interfaces/playlists.d.ts
+declare class PlaylistsInterface extends MprisInterface {
+  constructor(player: Player);
+  private _ActivePlaylist;
+  private _PlaylistCount;
+  get PlaylistCount(): number;
+  get Orderings(): string[];
+  get ActivePlaylist(): [boolean, [string, string, string]];
+  setActivePlaylistId(playlistId: string): void;
+  ActivatePlaylist(playlistId: string): void;
+  GetPlaylists(index: number, maxCount: number, order: string, reverseOrder: boolean): [string, string, string][];
+  PlaylistChanged(playlist: Playlist): [string, string, string];
+}
+//#endregion
+//#region src/interfaces/tracklist.d.ts
+declare class TracklistInterface extends MprisInterface {
+  constructor(player: Player);
+  private _Tracks;
+  private _CanEditTracks;
+  setTracks(tracksPlain: Track[]): void;
+  get Tracks(): string[];
+  get CanEditTracks(): boolean;
+  GetTracksMetadata(trackIds: string[]): Record<string, Variant>[];
+  AddTrack(uri: string, afterTrack: string, setAsCurrent: boolean): void;
+  RemoveTrack(trackId: string): void;
+  GoTo(trackId: string): void;
+  TrackListReplaced(replacedPlain: Track[]): [string[], string];
+  TrackAdded(metadata: Track): Record<string, Variant>;
+  TrackRemoved(path: string): string;
+  TrackMetadataChanged(path: string, metadata: Track): [string, Record<string, Variant>];
+}
+//#endregion
+//#region src/player.d.ts
+interface PlayerInterfaces {
+  root?: RootInterface;
+  player?: PlayerInterface;
+  tracklist?: TracklistInterface;
+  playlists?: PlaylistsInterface;
+}
+interface Player {
+  identity: string;
+  fullscreen: boolean;
+  supportedUriSchemes: string[];
+  supportedMimeTypes: string[];
+  canQuit: boolean;
+  canRaise: boolean;
+  canSetFullscreen: boolean;
+  hasTrackList: boolean;
+  desktopEntry: string;
+  playbackStatus: PlayBackStatus;
+  loopStatus: LoopStatus;
+  rate: number;
+  shuffle: boolean;
+  metadata: Track;
+  volume: number;
+  canControl: boolean;
+  canPause: boolean;
+  canPlay: boolean;
+  canSeek: boolean;
+  canGoNext: boolean;
+  canGoPrevious: boolean;
+  minimumRate: number;
+  maximumRate: number;
+  canEditTracks: boolean;
+  tracks: Track[];
+  playlistCount: number;
+  activePlaylist: string;
+  playlists: Playlist[];
+}
+declare class Player extends EventEmitter<EventsMap> {
+  #private;
+  name: string;
+  supportedInterfaces: Interfaces[];
+  serviceName: string;
+  private _bus;
+  interfaces: PlayerInterfaces;
+  private _tracks;
+  constructor(options: PlayerOptions);
+  private init;
+  /**
+   * Get a valid object path with the `subpath` as the basename which is suitable
+   * for use as an id.
+   *
+   * @name Player#objectPath
+   * @function
+   * @param {String} subpath - The basename of this path
+   * @returns {String} - A valid object path that can be used as an id.
+   */
+  objectPath(subpath?: string): string;
+  /**
+   * Gets the position of this player. This method is intended to be overridden
+   * by the user to return the position of the player in microseconds.
+   *
+   * @name Player#getPosition
+   * @function
+   * @returns {Number} - The current position of the player in microseconds. (Integer)
+   */
+  getPosition(): number;
+  /**
+   * Emits the `Seeked` DBus signal to listening clients with the given position.
+   *
+   * @name Player#seeked
+   * @function
+   * @param {Number} position - The position in microseconds. (Integer)
+   */
+  seeked(position: number): void;
+  getTrackIndex(trackId: string): number;
+  getTrack(trackId: string): Track | undefined;
+  addTrack(track: Track): void;
+  removeTrack(trackId: string): void;
+  /**
+   * Get the index of a playlist entry in the `playlists` list property of the
+   * player from the given id.
+   *
+   * @name Player#getPlaylistIndex
+   * @function
+   * @param {String} playlistId - The id for the playlist entry.
+   */
+  getPlaylistIndex(playlistId: string): number;
+  /**
+   * Set the list of playlists advertised to listeners on the bus. Each playlist
+   * must have string members `Id`, `Name`, and `Icon`.
+   *
+   * @name Player#setPlaylists
+   * @function
+   * @param {Array} playlists - A list of playlists.
+   */
+  setPlaylists(playlists: Playlist[]): void;
+  /**
+   * Set the playlist identified by `playlistId` to be the currently active
+   * playlist.
+   *
+   * @name Player#setActivePlaylist
+   * @function
+   * @param {String} playlistId - The id of the playlist to activate.
+   */
+  setActivePlaylist(playlistId: string): void;
+  static PLAYBACK_STATUS_PLAYING: PlayBackStatus;
+  static PLAYBACK_STATUS_PAUSED: PlayBackStatus;
+  static PLAYBACK_STATUS_STOPPED: PlayBackStatus;
+  static LOOP_STATUS_NONE: LoopStatus;
+  static LOOP_STATUS_TRACK: LoopStatus;
+  static LOOP_STATUS_PLAYLIST: LoopStatus;
+}
+//#endregion
+export { type AdditionalPlayerOptions, type Events, type EventsMap, type Interfaces, type LoopStatus, type PlayBackStatus, type PlayerOptions, type Playlist, type Position, type RootInterfaceOptions, type Track, Player as default };
+//# sourceMappingURL=index.d.mts.map