@corewire/airplay 0.0.0 → 1.0.0-beta.1

package/dist/mrp.d.mts

@@ -0,0 +1,687 @@
+import { A as KeyboardState_Enum, B as PlayerPath, C as SendCommandResultMessage, D as PlaybackQueue$1, E as PlaybackQueueParticipant, F as ContentItemMetadata, G as ErrorCode_Enum, H as RepeatMode_Enum, I as ContentItemMetadata_MediaType, J as Extendee, K as ProtocolMessage, L as CommandOptions, M as VolumeCapabilities_Enum, N as ContentItem, O as NowPlayingInfo, P as LyricsItem, R as Command, S as HandlerReturnStatus_Enum, T as PlaybackQueueRequestMessage, U as ShuffleMode_Enum, V as PlaybackState_Enum, W as AdjustVolumeMessage_Adjustment, X as DescExtension, Y as ExtensionValueShape, _ as parseMessages, b as ActionType_Enum, d as DataChannel, g as decodeMessage, h as MrpMessageName, j as TextEditingAttributes, k as LyricsEvent, m as MrpMessageMap, p as MrpMessage, q as ProtocolMessage_Type, t as AirPlaySession, v as index_d_exports, w as SendError_Enum, x as SetConnectionStateMessage_ConnectionState, y as AVOutputDeviceDescriptor, z as CommandInfo } from "./session-oDF9A9as.mjs";
+import { EventEmitter } from "node:events";
+import { CommandError } from "@corewire/core";
+import { Context, DeviceIdentity } from "@corewire/core/transport";
+
+//#region src/identity.d.ts
+/** Every identity field, with the defaults filled in. */
+type ResolvedIdentity = Required<DeviceIdentity>;
+declare namespace messages_d_exports {
+  export { PlaybackQueueAssetOptions, adjustVolume, audioFade, clientUpdatesConfig, configureConnection, deviceInfo, getExtension, getKeyboardSession, getRemoteTextInputSession, getState, getVolume, getVolumeMuted, modifyOutputContext, notification, playbackQueueRequest, playbackSessionMigrateBegin, playbackSessionMigrateEnd, protocol, registerHIDDevice, remoteTextInput, requestGroupSession, sendButtonEvent, sendCommand, sendCommandWithPlaybackPosition, sendCommandWithPlaybackRate, sendCommandWithRepeatMode, sendCommandWithShuffleMode, sendCommandWithSkipInterval, sendCommandWithSleepTimer, sendHIDEvent, sendPackedVirtualTouchEvent, sendVirtualTouchEvent, setConnectionState, setConversationDetectionEnabled, setDiscoveryMode, setListeningMode, setReadyState, setVolume, setVolumeMuted, textInput, wakeDevice };
+}
+/** A ProtocolMessage without extension, with a random `identifier` that the data channel matches replies on. */
+declare function protocol(type: ProtocolMessage_Type, errorCode?: ErrorCode_Enum): ProtocolMessage;
+/** Subscribes to state changes. Send early in the session to receive now-playing, volume and artwork updates. */
+declare function clientUpdatesConfig(artworkUpdates?: boolean, nowPlayingUpdates?: boolean, volumeUpdates?: boolean, keyboardUpdates?: boolean, outputDeviceUpdates?: boolean, systemEndpointUpdates?: boolean, subscribedPlayerPaths?: PlayerPath[]): [ProtocolMessage, DescExtension];
+/** CONFIGURE_CONNECTION, which sets the group ID of this connection. */
+declare function configureConnection(groupId: string): [ProtocolMessage, DescExtension];
+/**
+* DEVICE_INFO, the first message of a session, which introduces this controller to the receiver.
+*
+* @param pairingId - The pairing identifier from pair-verify.
+*/
+declare function deviceInfo(pairingId: Buffer, identity: ResolvedIdentity): [ProtocolMessage, DescExtension];
+/**
+* MODIFY_OUTPUT_CONTEXT_REQUEST, which changes the devices of a multiroom group.
+*
+* @param settingDevices - Replaces the whole output context.
+*/
+declare function modifyOutputContext(addingDevices?: string[], removingDevices?: string[], settingDevices?: string[]): [ProtocolMessage, DescExtension];
+/** GET_STATE, which asks for the current playback state. */
+declare function getState(): [ProtocolMessage, DescExtension];
+/** GET_VOLUME, which asks for the volume of an output device. */
+declare function getVolume(outputDeviceUID: string): [ProtocolMessage, DescExtension];
+/** GET_VOLUME_MUTED, which asks whether an output device is muted. */
+declare function getVolumeMuted(outputDeviceUID: string): [ProtocolMessage, DescExtension];
+/** NOTIFICATION, which sends a named notification to the receiver. */
+declare function notification(notification: string): [ProtocolMessage, DescExtension];
+type PlaybackQueueAssetOptions = Pick<PlaybackQueueRequestMessage, "contentItemIdentifiers" | "playerPath" | "includeAvailableArtworkFormats" | "requestedAnimatedArtworkPreviewFrameFormats" | "requestedAnimatedArtworkAssetURLFormats">;
+/**
+* PLAYBACK_QUEUE_REQUEST, which asks for queue metadata and assets. Animated artwork formats
+* have to be requested explicitly.
+*
+* @param location - Index of the first item.
+* @param artworkWidth - In pixels.
+* @param artworkHeight - In pixels; -1 keeps the aspect ratio.
+*/
+declare function playbackQueueRequest(location: number, length: number, artworkWidth?: number, artworkHeight?: number, options?: Partial<PlaybackQueueAssetOptions>): [ProtocolMessage, DescExtension];
+/** GET_KEYBOARD_SESSION, which asks whether a text field is active; the answer is a KEYBOARD message. */
+declare function getKeyboardSession(): [ProtocolMessage, DescExtension];
+/** Requests an RTI session; the receiver supplies a RemoteTextInputMessage. */
+declare function getRemoteTextInputSession(): [ProtocolMessage, DescExtension];
+/**
+* REMOTE_TEXT_INPUT, which carries one RTI text operation.
+*
+* @param data - The archived RTI operation.
+* @param version - The version of the RTI session it edits.
+*/
+declare function remoteTextInput(data: Uint8Array, version?: bigint): [ProtocolMessage, DescExtension];
+/**
+* TEXT_INPUT, which sends text to the active keyboard session.
+*
+* @param actionType - For example done, search or send.
+*/
+declare function textInput(text: string, actionType: ActionType_Enum): [ProtocolMessage, DescExtension];
+/**
+* SEND_BUTTON_EVENT, a USB HID button press or release.
+*
+* @param usagePage - For example 0x01 for Generic Desktop, 0x0c for Consumer.
+* @param buttonDown - `true` for key down, `false` for key up.
+*/
+declare function sendButtonEvent(usagePage: number, usage: number, buttonDown: boolean): [ProtocolMessage, DescExtension];
+/** @param skipInterval - Seconds. */
+declare function sendCommandWithSkipInterval(command: Command, skipInterval: number): [ProtocolMessage, DescExtension];
+/** @param playbackPosition - Seconds from the start. */
+declare function sendCommandWithPlaybackPosition(command: Command, playbackPosition: number): [ProtocolMessage, DescExtension];
+/** @param playbackRate - 1 is normal speed, 2 is double speed. */
+declare function sendCommandWithPlaybackRate(command: Command, playbackRate: number): [ProtocolMessage, DescExtension];
+declare function sendCommandWithShuffleMode(command: Command, shuffleMode: ShuffleMode_Enum): [ProtocolMessage, DescExtension];
+declare function sendCommandWithRepeatMode(command: Command, repeatMode: RepeatMode_Enum): [ProtocolMessage, DescExtension];
+/** SEND_COMMAND, a playback command such as play, pause or next track. */
+declare function sendCommand(command: Command, options?: CommandOptions): [ProtocolMessage, DescExtension];
+/**
+* A Pause command that carries a sleep timer.
+*
+* @param seconds - Timer duration; 0 cancels a running timer.
+* @param stopMode - 0 stops playback, 1 pauses, 2 waits for the end of the track, 3 for the end of the queue.
+*/
+declare function sendCommandWithSleepTimer(seconds: number, stopMode?: number): [ProtocolMessage, DescExtension];
+/**
+* REGISTER_HID_DEVICE, which claims a virtual touch device. The Apple TV answers with a
+* REGISTER_HID_DEVICE_RESULT that holds the device identifier {@link sendVirtualTouchEvent} has
+* to carry; an unclaimed identifier makes it drop the session.
+*
+* @param absolute - Whether coordinates are absolute positions instead of relative movement.
+* @param integratedDisplay - Whether the surface sits on top of a display, as on a phone.
+*/
+declare function registerHIDDevice(screenWidth?: number, screenHeight?: number, absolute?: boolean, integratedDisplay?: boolean): [ProtocolMessage, DescExtension];
+/**
+* SEND_PACKED_VIRTUAL_TOUCH_EVENT, the packed form of a touch event: the five values as 16-bit
+* little endian integers in one byte array, in the order x, y, phase, device identifier, finger.
+*
+* @param phase - 1 began, 2 moved, 3 stationary, 4 ended, 5 cancelled.
+* @param deviceId - The identifier {@link registerHIDDevice} handed out.
+* @param finger - Finger index for multi-touch.
+*/
+declare function sendPackedVirtualTouchEvent(x: number, y: number, phase: number, deviceId: number, finger: number): [ProtocolMessage, DescExtension];
+/**
+* SEND_VIRTUAL_TOUCH_EVENT, a touch on the virtual touchpad of {@link registerHIDDevice}.
+*
+* @param phase - 1 began, 2 moved, 3 stationary, 4 ended, 5 cancelled.
+* @param finger - Finger index for multi-touch.
+* @param deviceId - The identifier {@link registerHIDDevice} handed out.
+*/
+declare function sendVirtualTouchEvent(x: number, y: number, phase: number, finger: number, deviceId?: number): [ProtocolMessage, DescExtension];
+/**
+* SEND_HID_EVENT, a raw USB HID event report for a navigation or media key.
+*
+* @param usePage - For example 0x01 for Generic Desktop, 0x0c for Consumer.
+* @param down - `true` for key down, `false` for key up.
+*/
+declare function sendHIDEvent(usePage: number, usage: number, down: boolean): [ProtocolMessage, DescExtension];
+/** SET_CONNECTION_STATE, which tells the receiver our connection state. */
+declare function setConnectionState(state?: SetConnectionStateMessage_ConnectionState): [ProtocolMessage, DescExtension];
+/** SET_READY_STATE, which tells the receiver this controller is ready. */
+declare function setReadyState(): [ProtocolMessage, DescExtension];
+/**
+* SET_VOLUME, which sets the volume of an output device.
+*
+* @param volume - 0 to 1.
+*/
+declare function setVolume(outputDeviceUID: string, volume: number): [ProtocolMessage, DescExtension];
+/** SET_VOLUME_MUTED, which mutes or unmutes an output device. */
+declare function setVolumeMuted(outputDeviceUID: string, isMuted: boolean): [ProtocolMessage, DescExtension];
+/** SET_CONVERSATION_DETECTION_ENABLED, which turns conversation detection of a HomePod on or off: it ducks the volume while people talk. */
+declare function setConversationDetectionEnabled(enabled: boolean, outputDeviceUID: string): [ProtocolMessage, DescExtension];
+/**
+* ADJUST_VOLUME (extension field 97), a relative volume step that needs no current volume.
+*
+* @param adjustment - For example IncrementSmall or DecrementSmall.
+*/
+declare function adjustVolume(adjustment: AdjustVolumeMessage_Adjustment, outputDeviceUID: string): [ProtocolMessage, DescExtension];
+/**
+* AUDIO_FADE, which asks the receiver to fade its audio.
+*
+* @param fadeType - 0 fades out, 1 fades in.
+* @param playerPath - Targets one player instead of the active one.
+*/
+declare function audioFade(fadeType: number, playerPath?: PlayerPath): [ProtocolMessage, DescExtension];
+/**
+* SET_LISTENING_MODE, which sets the listening mode of a HomePod.
+*
+* @param listeningMode - For example `Default`, `Vivid` or `LateNight`.
+*/
+declare function setListeningMode(listeningMode: string, outputDeviceUID: string): [ProtocolMessage, DescExtension];
+/** SET_DISCOVERY_MODE, which turns device discovery on or off. */
+declare function setDiscoveryMode(mode: number): [ProtocolMessage, DescExtension];
+/** REQUEST_GROUP_SESSION, which starts a SharePlay group session. */
+declare function requestGroupSession(): [ProtocolMessage, DescExtension];
+/** PLAYBACK_SESSION_MIGRATE_BEGIN, which starts moving playback to another device. */
+declare function playbackSessionMigrateBegin(playerPath?: PlayerPath): [ProtocolMessage, DescExtension];
+/** PLAYBACK_SESSION_MIGRATE_END, which completes moving playback to another device. */
+declare function playbackSessionMigrateEnd(playerPath?: PlayerPath): [ProtocolMessage, DescExtension];
+/** WAKE_DEVICE, which wakes a sleeping Apple TV or HomePod. */
+declare function wakeDevice(): [ProtocolMessage, DescExtension];
+/** Reads a protobuf extension of a ProtocolMessage, typed by its descriptor. */
+declare function getExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): ExtensionValueShape<Desc>;
+//#endregion
+//#region src/mrp/player.d.ts
+/** The player the receiver reports when no specific player is active. */
+declare const DEFAULT_PLAYER_ID = "MediaRemote-DefaultPlayer";
+/**
+* One player of a now-playing app; an app can have several, such as picture-in-picture. Tracks
+* the now-playing metadata and playback state, and extrapolates the elapsed time from the Cocoa
+* timestamp and the playback rate.
+*/
+declare class Player {
+  #private;
+  /** The player identifier, such as a player path. */
+  get identifier(): string;
+  get displayName(): string;
+  /** Whether this is `MediaRemote-DefaultPlayer`, the player of an app without a specific one. */
+  get isDefaultPlayer(): boolean;
+  get nowPlayingInfo(): NowPlayingInfo | null;
+  get playbackQueue(): PlaybackQueue$1 | null;
+  get playbackState(): PlaybackState_Enum;
+  /** The timestamp of the last playback state update; an older update is ignored. */
+  get playbackStateTimestamp(): number;
+  get supportedCommands(): CommandInfo[];
+  get title(): string;
+  get artist(): string;
+  get album(): string;
+  get genre(): string;
+  get seriesName(): string;
+  /** The season number, or 0 when unknown. */
+  get seasonNumber(): number;
+  /** The episode number, or 0 when unknown. */
+  get episodeNumber(): number;
+  /** The episode title. Only the Apple TV app sends it, in its archived now-playing info. */
+  get episodeTitle(): string;
+  /** The localized content rating, such as `12+`. */
+  get contentRating(): string;
+  get mediaType(): ContentItemMetadata_MediaType;
+  /** The content identifier of the current item, such as a store ID. */
+  get contentIdentifier(): string;
+  /** The duration of the current item in seconds. */
+  get duration(): number;
+  /** The playback rate, where 1 is normal speed, 0 is paused and 2 is double speed. */
+  get playbackRate(): number;
+  get isPlaying(): boolean;
+  /** The shuffle mode, read from the info of the ChangeShuffleMode command. */
+  get shuffleMode(): ShuffleMode_Enum;
+  /** The repeat mode, read from the info of the ChangeRepeatMode command. */
+  get repeatMode(): RepeatMode_Enum;
+  /**
+  * The elapsed time in seconds, extrapolated from the newer timestamp of the now-playing info
+  * and the content item. Metadata after a track change can report rate 0 during playback, so the
+  * player's rate fills in. A paused player can still report rate 1, so its position stays put.
+  */
+  get elapsedTime(): number;
+  /** The item at the queue location, or the first item when the location is out of range. */
+  get currentItem(): ContentItem | null;
+  get currentItemMetadata(): ContentItemMetadata | null;
+  /** An identifier that changes with the artwork, or null when the metadata shows no sign of artwork. */
+  get artworkId(): string | null;
+  /**
+  * The artwork URL of the current item, from the metadata `artworkURL`, the remote artworks or
+  * the artwork identifier as a URL template, in that order.
+  *
+  * @param width - In pixels; only a template uses it.
+  * @param height - In pixels; -1 keeps the aspect ratio.
+  */
+  artworkUrl(width?: number, height?: number): string | null;
+  /** The image bytes embedded in the current item, or null. */
+  get currentItemArtwork(): Uint8Array | null;
+  /** The artwork URL at 600 pixels wide, or null. */
+  get currentItemArtworkUrl(): string | null;
+  get currentItemLyrics(): LyricsItem | null;
+  constructor(identifier: string, displayName: string);
+  findCommand(command: Command): CommandInfo | null;
+  /** Whether the command is in the list and not disabled. */
+  isCommandSupported(command: Command): boolean;
+  setNowPlayingInfo(nowPlayingInfo: NowPlayingInfo): void;
+  setPlaybackQueue(playbackQueue: PlaybackQueue$1): void;
+  /** Ignores an update with a timestamp older than the current one, so stale state never wins. */
+  setPlaybackState(playbackState: PlaybackState_Enum, playbackStateTimestamp: number): void;
+  setSupportedCommands(supportedCommands: CommandInfo[]): void;
+  /** Merges the fields an update carries into the queue item with the same identifier. */
+  updateContentItem(item: ContentItem): void;
+}
+//#endregion
+//#region src/mrp/client.d.ts
+/**
+* A now-playing app on the receiver, keyed by bundle identifier, with one or more players. The
+* now-playing getters read from the active player.
+*/
+declare class Client {
+  #private;
+  /** The bundle identifier of the app, such as `com.apple.TVMusic`. */
+  get bundleIdentifier(): string;
+  get displayName(): string;
+  /** The players of this app, keyed by player identifier. */
+  get players(): Map<string, Player>;
+  /** The player set active, or the default player when none is set; null when that player does not exist. */
+  get activePlayer(): Player | null;
+  get nowPlayingInfo(): NowPlayingInfo | null;
+  get playbackQueue(): PlaybackQueue$1 | null;
+  get playbackState(): PlaybackState_Enum;
+  /** The timestamp of the last playback state update, or -1 without an active player. */
+  get playbackStateTimestamp(): number;
+  /** The commands of the active player, followed by the client defaults it does not list. */
+  get supportedCommands(): CommandInfo[];
+  get title(): string;
+  get artist(): string;
+  get album(): string;
+  get genre(): string;
+  get seriesName(): string;
+  get seasonNumber(): number;
+  get episodeNumber(): number;
+  get episodeTitle(): string;
+  get contentRating(): string;
+  get mediaType(): ContentItemMetadata_MediaType;
+  get contentIdentifier(): string;
+  /** The duration of the current item in seconds. */
+  get duration(): number;
+  /** The playback rate, where 1 is normal speed and 0 is paused. */
+  get playbackRate(): number;
+  get isPlaying(): boolean;
+  get shuffleMode(): ShuffleMode_Enum;
+  get repeatMode(): RepeatMode_Enum;
+  /** The elapsed time in seconds, extrapolated to now. */
+  get elapsedTime(): number;
+  /** An identifier that changes with the artwork, or null without artwork. */
+  get artworkId(): string | null;
+  /**
+  * The artwork URL of the current item; see {@link Player.artworkUrl}.
+  *
+  * @param width - In pixels.
+  * @param height - In pixels; -1 keeps the aspect ratio.
+  */
+  artworkUrl(width?: number, height?: number): string | null;
+  get currentItem(): ContentItem | null;
+  get currentItemMetadata(): ContentItemMetadata | null;
+  /** The image bytes embedded in the current item, or null. */
+  get currentItemArtwork(): Uint8Array | null;
+  /** The artwork URL at 600 pixels wide, or null. */
+  get currentItemArtworkUrl(): string | null;
+  get currentItemLyrics(): LyricsItem | null;
+  constructor(bundleIdentifier: string, displayName: string);
+  /**
+  * Returns the player with this identifier, created when it does not exist yet.
+  *
+  * @param displayName - The name of a new player; the identifier when omitted.
+  */
+  getOrCreatePlayer(identifier: string, displayName?: string): Player;
+  setActivePlayer(identifier: string): void;
+  /** Removes a player; removing the active one makes the default player active. */
+  removePlayer(identifier: string): void;
+  /** Sets the commands that complete the list of the active player. */
+  setDefaultSupportedCommands(supportedCommands: CommandInfo[]): void;
+  /** Finds a command in the list of the active player first, then in the defaults. */
+  findCommand(command: Command): CommandInfo | null;
+  /** Whether {@link findCommand} finds the command and it is not disabled. */
+  isCommandSupported(command: Command): boolean;
+  updateDisplayName(displayName: string): void;
+}
+//#endregion
+//#region src/mrp/state.d.ts
+/**
+* What the state derives from the messages, announced once the new values are in place. The
+* messages themselves are the events of the data channel; the state does not repeat them.
+*/
+type MediaRemoteStateEventMap = {
+  readonly activePlayerChanged: [client: Client | null, player: Player | null];
+  readonly artworkChanged: [client: Client, player: Player];
+  readonly clients: [Record<string, Client>];
+  readonly clusterChanged: [clusterID: string | null, isLeader: boolean];
+  readonly keyboardChanged: [state: KeyboardState_Enum, attributes: TextEditingAttributes | null];
+  readonly lyricsEvent: [event: LyricsEvent, playerPath: PlayerPath | undefined];
+  readonly nowPlayingChanged: [client: Client | null, player: Player | null];
+  readonly outputDevicesChanged: [devices: AVOutputDeviceDescriptor[]];
+  readonly participantsChanged: [participants: PlaybackQueueParticipant[]];
+  readonly playbackQueueChanged: [client: Client, player: Player];
+  readonly playbackStateChanged: [client: Client, player: Player, oldState: PlaybackState_Enum, newState: PlaybackState_Enum];
+  readonly supportedCommandsChanged: [client: Client, player: Player, commands: CommandInfo[]];
+  readonly volumeChanged: [volume: number];
+  readonly volumeControlChanged: [available: boolean, capabilities: VolumeCapabilities_Enum];
+  readonly volumeMutedChanged: [muted: boolean];
+};
+/**
+* The MRP state of a receiver as a model: clients and their players, what plays now, volume,
+* keyboard, output devices and cluster. It derives everything from the messages it is given with
+* {@link apply} and does no I/O, so recorded traffic feeds it as well as a live data channel.
+*/
+declare class MediaRemoteState extends EventEmitter<MediaRemoteStateEventMap> {
+  #private;
+  /** The now-playing apps, keyed by bundle identifier. */
+  get clients(): Record<string, Client>;
+  /** Whether a text input session is open on the receiver. */
+  get isKeyboardActive(): boolean;
+  get keyboardAttributes(): TextEditingAttributes | null;
+  get keyboardState(): KeyboardState_Enum;
+  /** The app that plays now, or null when the receiver named none. */
+  get nowPlayingClient(): Client | null;
+  /** The device that volume commands address; the cluster ID for a clustered HomePod pair. */
+  get outputDeviceUID(): string | null;
+  /** The devices in the current AirPlay group. */
+  get outputDevices(): AVOutputDeviceDescriptor[];
+  /** The identifier of the multiroom cluster, or null outside one. */
+  get clusterID(): string | null;
+  /** The cluster type code, 0 outside a cluster. */
+  get clusterType(): number;
+  get isClusterAware(): boolean;
+  get isClusterLeader(): boolean;
+  /** The playback queue participants, such as SharePlay users. */
+  get participants(): PlaybackQueueParticipant[];
+  /** The JPEG bytes of the last SET_ARTWORK, or null before one arrived. */
+  get artworkJpegData(): Uint8Array | null;
+  /** The volume, from 0 to 1. */
+  get volume(): number;
+  get volumeAvailable(): boolean;
+  get volumeCapabilities(): VolumeCapabilities_Enum;
+  get volumeMuted(): boolean;
+  constructor();
+  /**
+  * Applies one decoded message. Messages the state does not track are ignored.
+  *
+  * @example
+  * const decoded = decodeMessage(protocolMessage);
+  * decoded && state.apply(...decoded);
+  */
+  apply(...[name, message]: MrpMessage): void;
+  /**
+  * Resets every value to its initial one. A state that outlives a session is cleared when the
+  * next one connects, not when the last one ends.
+  */
+  clear(): void;
+}
+//#endregion
+//#region src/mrp/playbackQueue.d.ts
+/**
+* Requests for the playback queue. The receiver answers with a SET_STATE carrying the queue, so
+* the result lands in the state; these only wait for the reply.
+*/
+declare class PlaybackQueue {
+  #private;
+  constructor(channel: DataChannel, state: MediaRemoteState);
+  /** Requests the first `length` items of the queue. */
+  request(length: number, artworkWidth?: number, artworkHeight?: number): Promise<void>;
+  /**
+  * Requests extra assets of the current item, such as artwork formats or lyrics, and returns
+  * the item once they arrived.
+  *
+  * @returns Null without a current item, or when the track changed while waiting.
+  * @throws {Error} When the receiver answers with an error code.
+  */
+  requestAssets(options?: Partial<PlaybackQueueAssetOptions>, width?: number, height?: number): Promise<ContentItem | null>;
+}
+//#endregion
+//#region src/mrp/artwork.d.ts
+type AnimatedArtworkResult = {
+  readonly format: string;
+  readonly url: string | null;
+  readonly source?: "device" | "apple-music";
+};
+/** Artwork of the current item, as a URL or as image bytes; at least one of the two is set. */
+type ArtworkResult = {
+  readonly url: string | null;
+  readonly data: Uint8Array | null; /** For example `image/jpeg` or `image/png`. */
+  readonly mimeType: string; /** The artwork identifier of the item, for change detection. */
+  readonly identifier: string | null; /** In pixels; 0 when unknown. */
+  readonly width: number; /** In pixels; 0 when unknown. */
+  readonly height: number;
+};
+/**
+* The artwork of what plays now, from the sources MRP offers, in this order: a URL from the item
+* metadata, image bytes inside the queue, the JPEG of the last SET_ARTWORK, and finally a queue
+* request when the metadata promises artwork that has not arrived. A result is cached per
+* artwork identifier.
+*/
+declare class Artwork {
+  #private;
+  constructor(state: MediaRemoteState, queue: PlaybackQueue);
+  /**
+  * Returns the artwork of the current item.
+  *
+  * @param width - In pixels.
+  * @param height - In pixels; -1 keeps the aspect ratio.
+  * @returns Null when there is no artwork.
+  */
+  get(width?: number, height?: number): Promise<ArtworkResult | null>;
+  /** Asks for the available animated formats first, then for the asset URLs of those formats. */
+  getAnimated(width?: number, height?: number): Promise<AnimatedArtworkResult[]>;
+  /** Forgets the cached result, so the next {@link get} looks again. */
+  clear(): void;
+}
+//#endregion
+//#region src/mrp/commands.d.ts
+/** The receiver refused a SendCommand. */
+declare class SendCommandError extends CommandError {
+  readonly sendError: SendError_Enum;
+  readonly handlerReturnStatus: HandlerReturnStatus_Enum;
+  constructor(sendError: SendError_Enum, handlerReturnStatus: HandlerReturnStatus_Enum);
+}
+/**
+* Playback commands to the now-playing app, each a SEND_COMMAND exchange. A result with a send
+* error throws {@link SendCommandError}; a reply without a result counts as success.
+*/
+declare class Commands {
+  #private;
+  constructor(channel: DataChannel);
+  /** @throws {SendCommandError} When the receiver reports a send error. */
+  send(command: Command, options?: CommandOptions): Promise<SendCommandResultMessage | undefined>;
+  play(): Promise<void>;
+  pause(): Promise<void>;
+  togglePlayPause(): Promise<void>;
+  stop(): Promise<void>;
+  nextTrack(): Promise<void>;
+  previousTrack(): Promise<void>;
+  /** @param interval - Seconds. */
+  skipForward(interval?: number): Promise<void>;
+  /** @param interval - Seconds. */
+  skipBackward(interval?: number): Promise<void>;
+  /** @param position - Seconds from the start. */
+  seekToPosition(position: number): Promise<void>;
+  setShuffleMode(mode: ShuffleMode_Enum): Promise<void>;
+  setRepeatMode(mode: RepeatMode_Enum): Promise<void>;
+  /** @param rate - 1 is normal speed. */
+  changePlaybackRate(rate: number): Promise<void>;
+  advanceShuffleMode(): Promise<void>;
+  advanceRepeatMode(): Promise<void>;
+  beginFastForward(): Promise<void>;
+  endFastForward(): Promise<void>;
+  beginRewind(): Promise<void>;
+  endRewind(): Promise<void>;
+  nextChapter(): Promise<void>;
+  previousChapter(): Promise<void>;
+  likeTrack(): Promise<void>;
+  dislikeTrack(): Promise<void>;
+  bookmarkTrack(): Promise<void>;
+  addNowPlayingItemToLibrary(): Promise<void>;
+  /**
+  * Sets a sleep timer. It goes out as an option on a Pause command.
+  *
+  * @param seconds - Timer duration; 0 cancels a running timer.
+  * @param stopMode - 0 stops playback, 1 pauses, 2 waits for the end of the track, 3 for the end of the queue.
+  */
+  setSleepTimer(seconds: number, stopMode?: number): Promise<void>;
+}
+//#endregion
+//#region src/mrp/hid.d.ts
+/**
+* Keys as USB HID events: Generic Desktop (0x01) for navigation, Consumer (0x0c) for media.
+*
+* Every event goes out with `send()`: the receiver never replies to a HID event, so waiting for one
+* would time out on key-down and key-up would never be sent. Touch is not here: tvOS drops the
+* session on a virtual touch event over MRP.
+*/
+declare class Hid {
+  #private;
+  constructor(channel: DataChannel, state: MediaRemoteState);
+  up(): Promise<void>;
+  down(): Promise<void>;
+  left(): Promise<void>;
+  right(): Promise<void>;
+  menu(): Promise<void>;
+  select(): Promise<void>;
+  home(): Promise<void>;
+  suspend(): Promise<void>;
+  wake(): Promise<void>;
+  play(): Promise<void>;
+  pause(): Promise<void>;
+  /** Pause when the now-playing client plays, play otherwise. */
+  playPause(): Promise<void>;
+  stop(): Promise<void>;
+  next(): Promise<void>;
+  previous(): Promise<void>;
+  volumeUp(): Promise<void>;
+  volumeDown(): Promise<void>;
+  mute(): Promise<void>;
+  topMenu(): Promise<void>;
+  channelUp(): Promise<void>;
+  channelDown(): Promise<void>;
+  /** Two presses 150 ms apart. */
+  doublePress(usePage: number, usage: number): Promise<void>;
+  /**
+  * Holds a key down.
+  *
+  * @param duration - Hold time in milliseconds.
+  */
+  longPress(usePage: number, usage: number, duration?: number): Promise<void>;
+  /** Key-down, 25 ms, key-up. */
+  press(usePage: number, usage: number): Promise<void>;
+}
+//#endregion
+//#region src/mrp/keyboard.d.ts
+/**
+* Text input over MRP. Every operation asks the receiver for its current RTI text session first,
+* then sends the edit for that session. Operations run one at a time, in call order.
+*/
+declare class Keyboard {
+  #private;
+  constructor(channel: DataChannel);
+  /** Replaces the text in the focused field. */
+  set(text: string): Promise<void>;
+  append(text: string): Promise<void>;
+  clear(): Promise<void>;
+  /** Asks for the keyboard session; the answer arrives as a KEYBOARD message on the state. */
+  getSession(): Promise<void>;
+}
+//#endregion
+//#region src/mrp/outputDevices.d.ts
+/** The output context of the receiver: which devices play along, and per-device audio settings. */
+declare class OutputDevices {
+  #private;
+  constructor(channel: DataChannel, state: MediaRemoteState);
+  /** Adds devices to the output context. */
+  add(deviceUIDs: string[]): Promise<void>;
+  /** Removes devices from the output context. */
+  remove(deviceUIDs: string[]): Promise<void>;
+  /** Replaces the output context with these devices. */
+  set(deviceUIDs: string[]): Promise<void>;
+  /**
+  * Turns conversation detection of the active output device on or off (HomePod).
+  *
+  * @throws {Error} When no output device is active.
+  */
+  setConversationDetectionEnabled(enabled: boolean): Promise<void>;
+  /** Sets the listening mode of the active output device (HomePod), e.g. `Default`, `Vivid`, `LateNight`. Does nothing without one. */
+  setListeningMode(mode: string): Promise<void>;
+}
+//#endregion
+//#region src/mrp/volume.d.ts
+/**
+* Volume of the receiver on a 0 to 1 scale. Absolute volume goes to the output device the state
+* names; a receiver that only supports relative volume gets the HID volume keys instead.
+*/
+declare class Volume {
+  #private;
+  constructor(channel: DataChannel, context: Context, state: MediaRemoteState, hid: Hid);
+  /** @throws {CommandError} When the receiver has no volume control. */
+  down(): Promise<void>;
+  /** @throws {CommandError} When the receiver has no volume control. */
+  up(): Promise<void>;
+  /** @throws {CommandError} When no output device is active or the receiver answers otherwise. */
+  get(): Promise<number>;
+  /**
+  * Sets an absolute volume, clamped to 0 to 1.
+  *
+  * @throws {CommandError} When no output device is active or absolute volume is not available.
+  */
+  set(volume: number): Promise<void>;
+  /** @throws {CommandError} When no output device is active. */
+  mute(): Promise<void>;
+  /** @throws {CommandError} When no output device is active. */
+  unmute(): Promise<void>;
+  /** @throws {CommandError} When no output device is active. */
+  toggleMute(): Promise<void>;
+  /** Sets the volume of one output device in a group, clamped to 0 to 1. */
+  setForDevice(outputDeviceUID: string, volume: number): Promise<void>;
+  /** @throws {CommandError} When the receiver answers otherwise. */
+  getForDevice(outputDeviceUID: string): Promise<number>;
+  muteDevice(outputDeviceUID: string): Promise<void>;
+  unmuteDevice(outputDeviceUID: string): Promise<void>;
+  /**
+  * Steps the volume of an output device up or down by a small, medium or large amount.
+  *
+  * @param outputDeviceUID - The active output device when omitted.
+  * @throws {CommandError} When no output device is given or active.
+  */
+  adjust(adjustment: AdjustVolumeMessage_Adjustment, outputDeviceUID?: string): Promise<void>;
+  /** Asks the receiver to fade its audio: 0 fades out, 1 fades in. */
+  audioFade(fadeType: number): Promise<void>;
+  /**
+  * Fades to a volume in steps of {@link FADE_STEP_INTERVAL} ms; the last step sets the target exactly.
+  *
+  * @param durationMs - Duration of the fade in milliseconds.
+  * @throws {CommandError} When no output device is active or absolute volume is not available.
+  */
+  fade(targetVolume: number, durationMs: number): Promise<void>;
+}
+//#endregion
+//#region src/mrp/mediaRemote.d.ts
+type MediaRemoteOptions = {
+  /**
+  * The state to feed; a new one when omitted. Pass one to keep its listeners across sessions.
+  * It is fed as it is: clear it yourself when a new session should start empty.
+  */
+  readonly state?: MediaRemoteState;
+};
+/**
+* Remote control of a receiver over MRP, on the data channel of an AirPlay session. It owns the
+* state the messages feed and the parts that send: keys, commands, volume, text input, output
+* devices, the playback queue and artwork. It lives as long as its session.
+*/
+declare class MediaRemote {
+  #private;
+  /** The MRP data channel this remote sends on. */
+  get channel(): DataChannel;
+  readonly artwork: Artwork;
+  readonly commands: Commands;
+  readonly hid: Hid;
+  readonly keyboard: Keyboard;
+  readonly outputDevices: OutputDevices;
+  readonly playbackQueue: PlaybackQueue;
+  readonly state: MediaRemoteState;
+  readonly volume: Volume;
+  /**
+  * Opens remote control on the session and runs the MRP startup: DEVICE_INFO as an exchange,
+  * then the connection state, the update subscription and GET_STATE, each sent without waiting.
+  * The state listens from before the data channel connects, so it misses nothing the receiver
+  * sends right away. A failed startup ends the session.
+  *
+  * @throws {SetupError} When a SETUP fails.
+  * @throws {TimeoutError} When DEVICE_INFO gets no reply.
+  * @throws {ConnectionClosedError} When the session ends during setup.
+  */
+  static open(session: AirPlaySession, options?: MediaRemoteOptions): Promise<MediaRemote>;
+  /** Use {@link open}. */
+  constructor(session: AirPlaySession, channel: DataChannel, state: MediaRemoteState);
+  /** Wakes the receiver from sleep with a WAKE_DEVICE message. */
+  wake(): Promise<void>;
+}
+//#endregion
+//#region src/mrp/describe.d.ts
+declare function describeProtocolMessage(message: ProtocolMessage): Record<string, unknown>;
+//#endregion
+export { type AnimatedArtworkResult, Artwork, type ArtworkResult, Client, Commands, DEFAULT_PLAYER_ID, Hid, Keyboard, MediaRemote, type MediaRemoteOptions, MediaRemoteState, type MediaRemoteStateEventMap, messages_d_exports as Messages, type MrpMessage, type MrpMessageMap, type MrpMessageName, OutputDevices, PlaybackQueue, Player, index_d_exports as Proto, SendCommandError, Volume, decodeMessage, describeProtocolMessage, parseMessages };