@basmilius/apple-devices 0.1.3 → 0.2.1

package/dist/airplay/device.d.ts

@@ -18,7 +18,7 @@ export default class extends EventEmitter<EventMap> {
 	get volume(): Volume;
 	get timingServer(): TimingServer | undefined;
 	set timingServer(timingServer: TimingServer | undefined);
-	constructor(discoveryResult: DiscoveryResult);
+	constructor(deviceId: string, discoveryResult: DiscoveryResult);
 	connect(): Promise<void>;
 	disconnect(): Promise<void>;
 	disconnectSafely(): Promise<void>;

package/dist/airplay/state.d.ts

@@ -34,23 +34,23 @@ export default class extends EventEmitter<EventMap> {
 	get volumeCapabilities(): Proto.VolumeCapabilities_Enum;
 	constructor(device: Device);
 	clear(): void;
-	onDeviceInfo(message: Proto.DeviceInfoMessage): Promise<void>;
-	onDeviceInfoUpdate(message: Proto.DeviceInfoMessage): Promise<void>;
-	onOriginClientProperties(message: Proto.OriginClientPropertiesMessage): Promise<void>;
-	onPlayerClientProperties(message: Proto.PlayerClientPropertiesMessage): Promise<void>;
-	onRemoveClient(message: Proto.RemoveClientMessage): Promise<void>;
-	onSendCommandResult(message: Proto.SendCommandResultMessage): Promise<void>;
-	onSetArtwork(message: Proto.SetArtworkMessage): Promise<void>;
-	onSetDefaultSupportedCommands(message: Proto.SetDefaultSupportedCommandsMessage): Promise<void>;
-	onSetNowPlayingClient(message: Proto.SetNowPlayingClientMessage): Promise<void>;
-	onSetNowPlayingPlayer(message: Proto.SetNowPlayingPlayerMessage): Promise<void>;
-	onSetState(message: Proto.SetStateMessage): Promise<void>;
-	onUpdateContentItem(message: Proto.UpdateContentItemMessage): Promise<void>;
-	onUpdateContentItemArtwork(message: Proto.UpdateContentItemArtworkMessage): Promise<void>;
-	onUpdatePlayer(message: Proto.UpdatePlayerMessage): Promise<void>;
-	onUpdateClient(message: Proto.UpdateClientMessage): Promise<void>;
-	onUpdateOutputDevice(message: Proto.UpdateOutputDeviceMessage): Promise<void>;
-	onVolumeControlAvailability(message: Proto.VolumeControlAvailabilityMessage): Promise<void>;
-	onVolumeControlCapabilitiesDidChange(message: Proto.VolumeControlCapabilitiesDidChangeMessage): Promise<void>;
-	onVolumeDidChange(message: Proto.VolumeDidChangeMessage): Promise<void>;
+	onDeviceInfo(message: Proto.DeviceInfoMessage): void;
+	onDeviceInfoUpdate(message: Proto.DeviceInfoMessage): void;
+	onOriginClientProperties(message: Proto.OriginClientPropertiesMessage): void;
+	onPlayerClientProperties(message: Proto.PlayerClientPropertiesMessage): void;
+	onRemoveClient(message: Proto.RemoveClientMessage): void;
+	onSendCommandResult(message: Proto.SendCommandResultMessage): void;
+	onSetArtwork(message: Proto.SetArtworkMessage): void;
+	onSetDefaultSupportedCommands(message: Proto.SetDefaultSupportedCommandsMessage): void;
+	onSetNowPlayingClient(message: Proto.SetNowPlayingClientMessage): void;
+	onSetNowPlayingPlayer(message: Proto.SetNowPlayingPlayerMessage): void;
+	onSetState(message: Proto.SetStateMessage): void;
+	onUpdateContentItem(message: Proto.UpdateContentItemMessage): void;
+	onUpdateContentItemArtwork(message: Proto.UpdateContentItemArtworkMessage): void;
+	onUpdatePlayer(message: Proto.UpdatePlayerMessage): void;
+	onUpdateClient(message: Proto.UpdateClientMessage): void;
+	onUpdateOutputDevice(message: Proto.UpdateOutputDeviceMessage): void;
+	onVolumeControlAvailability(message: Proto.VolumeControlAvailabilityMessage): void;
+	onVolumeControlCapabilitiesDidChange(message: Proto.VolumeControlCapabilitiesDidChangeMessage): void;
+	onVolumeDidChange(message: Proto.VolumeDidChangeMessage): void;
 }

package/dist/companion-link/device.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "node:events";
 import type { AccessoryCredentials, DiscoveryResult } from "@basmilius/apple-common";
-import type { AttentionState, ButtonPressType, HidCommandKey, LaunchableApp, MediaControlCommandKey, UserAccount } from "@basmilius/apple-companion-link";
+import { type AttentionState, type ButtonPressType, type HidCommandKey, type LaunchableApp, type MediaControlCommandKey, type UserAccount } from "@basmilius/apple-companion-link";
 type EventMap = {
 	connected: [];
 	disconnected: [unexpected: boolean];
@@ -11,7 +11,7 @@ export default class extends EventEmitter<EventMap> {
 	get discoveryResult(): DiscoveryResult;
 	set discoveryResult(discoveryResult: DiscoveryResult);
 	get isConnected(): boolean;
-	constructor(discoveryResult: DiscoveryResult);
+	constructor(deviceId: string, discoveryResult: DiscoveryResult);
 	connect(): Promise<void>;
 	disconnect(): Promise<void>;
 	disconnectSafely(): Promise<void>;

package/dist/index.js

@@ -16,12 +16,11 @@ var STATE_SUBSCRIBE_SYMBOL = Symbol("com.basmilius.airplay:subscribe");
 var STATE_UNSUBSCRIBE_SYMBOL = Symbol("com.basmilius.airplay:unsubscribe");
 // src/airplay/device.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
-import { AirPlay as AirPlay2, DataStreamMessage as DataStreamMessage3, Proto as Proto5 } from "@basmilius/apple-airplay";
-import { reporter as reporter2, waitFor as waitFor2 } from "@basmilius/apple-common";
+import { DataStreamMessage as DataStreamMessage3, Proto as Proto5, Protocol } from "@basmilius/apple-airplay";
+import { waitFor as waitFor2 } from "@basmilius/apple-common";
 
 // src/airplay/remote.ts
-import { DataStreamMessage } from "@basmilius/apple-airplay";
-import { Proto } from "@basmilius/apple-airplay";
+import { DataStreamMessage, Proto } from "@basmilius/apple-airplay";
 import { waitFor } from "@basmilius/apple-common";
 class remote_default {
   get #dataStream() {
@@ -1270,7 +1269,7 @@ class state_default extends EventEmitter {
     this.onVolumeControlCapabilitiesDidChange = this.onVolumeControlCapabilitiesDidChange.bind(this);
     this.onVolumeDidChange = this.onVolumeDidChange.bind(this);
   }
-  async[STATE_SUBSCRIBE_SYMBOL]() {
+  [STATE_SUBSCRIBE_SYMBOL]() {
     this.#dataStream.on("deviceInfo", this.onDeviceInfo);
     this.#dataStream.on("deviceInfoUpdate", this.onDeviceInfoUpdate);
     this.#dataStream.on("originClientProperties", this.onOriginClientProperties);
@@ -1291,7 +1290,7 @@ class state_default extends EventEmitter {
     this.#dataStream.on("volumeControlCapabilitiesDidChange", this.onVolumeControlCapabilitiesDidChange);
     this.#dataStream.on("volumeDidChange", this.onVolumeDidChange);
   }
-  async[STATE_UNSUBSCRIBE_SYMBOL]() {
+  [STATE_UNSUBSCRIBE_SYMBOL]() {
     const dataStream = this.#dataStream;
     if (!dataStream) {
       return;
@@ -1324,7 +1323,7 @@ class state_default extends EventEmitter {
     this.#volumeAvailable = false;
     this.#volumeCapabilities = Proto3.VolumeCapabilities_Enum.None;
   }
-  async onDeviceInfo(message) {
+  onDeviceInfo(message) {
     if (message.clusterID) {
       this.#outputDeviceUID = message.clusterID;
     } else if (message.deviceUID) {
@@ -1334,7 +1333,7 @@ class state_default extends EventEmitter {
     }
     this.emit("deviceInfo", message);
   }
-  async onDeviceInfoUpdate(message) {
+  onDeviceInfoUpdate(message) {
     if (message.clusterID) {
       this.#outputDeviceUID = message.clusterID;
     } else if (message.deviceUID) {
@@ -1344,36 +1343,36 @@ class state_default extends EventEmitter {
     }
     this.emit("deviceInfoUpdate", message);
   }
-  async onOriginClientProperties(message) {
+  onOriginClientProperties(message) {
     this.emit("originClientProperties", message);
   }
-  async onPlayerClientProperties(message) {
+  onPlayerClientProperties(message) {
     this.emit("playerClientProperties", message);
   }
-  async onRemoveClient(message) {
+  onRemoveClient(message) {
     if (!(message.client.bundleIdentifier in this.#clients)) {
       return;
     }
     delete this.#clients[message.client.bundleIdentifier];
     this.emit("clients", this.#clients);
   }
-  async onSendCommandResult(message) {
+  onSendCommandResult(message) {
     this.emit("sendCommandResult", message);
   }
-  async onSetArtwork(message) {
+  onSetArtwork(message) {
     this.emit("setArtwork", message);
   }
-  async onSetDefaultSupportedCommands(message) {
+  onSetDefaultSupportedCommands(message) {
     this.emit("setDefaultSupportedCommands", message);
   }
-  async onSetNowPlayingClient(message) {
+  onSetNowPlayingClient(message) {
     this.#nowPlayingClientBundleIdentifier = message.client?.bundleIdentifier ?? null;
     this.emit("setNowPlayingClient", message);
   }
-  async onSetNowPlayingPlayer(message) {
+  onSetNowPlayingPlayer(message) {
     this.emit("setNowPlayingPlayer", message);
   }
-  async onSetState(message) {
+  onSetState(message) {
     const client = this.#client(message.playerPath.client.bundleIdentifier, message.displayName);
     if (message.playbackState) {
       client.setPlaybackState(message.playbackState, message.playbackStateTimestamp);
@@ -1386,7 +1385,7 @@ class state_default extends EventEmitter {
     }
     this.emit("setState", message);
   }
-  async onUpdateContentItem(message) {
+  onUpdateContentItem(message) {
     const client = this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName);
     if (!client) {
       return;
@@ -1396,30 +1395,30 @@ class state_default extends EventEmitter {
     }
     this.emit("updateContentItem", message);
   }
-  async onUpdateContentItemArtwork(message) {
+  onUpdateContentItemArtwork(message) {
     this.emit("updateContentItemArtwork", message);
   }
-  async onUpdatePlayer(message) {
+  onUpdatePlayer(message) {
     this.emit("updatePlayer", message);
   }
-  async onUpdateClient(message) {
+  onUpdateClient(message) {
     this.#client(message.client.bundleIdentifier, message.client.displayName);
     this.emit("clients", this.#clients);
   }
-  async onUpdateOutputDevice(message) {
+  onUpdateOutputDevice(message) {
     this.emit("updateOutputDevice", message);
   }
-  async onVolumeControlAvailability(message) {
+  onVolumeControlAvailability(message) {
     this.#volumeAvailable = message.volumeControlAvailable;
     this.#volumeCapabilities = message.volumeCapabilities;
     this.emit("volumeControlAvailability", message.volumeControlAvailable, message.volumeCapabilities);
   }
-  async onVolumeControlCapabilitiesDidChange(message) {
+  onVolumeControlCapabilitiesDidChange(message) {
     this.#volumeAvailable = message.capabilities.volumeControlAvailable;
     this.#volumeCapabilities = message.capabilities.volumeCapabilities;
     this.emit("volumeControlCapabilitiesDidChange", message.capabilities.volumeControlAvailable, message.capabilities.volumeCapabilities);
   }
-  async onVolumeDidChange(message) {
+  onVolumeDidChange(message) {
     this.#volume = message.volume;
     this.emit("volumeDidChange", message.volume);
   }
@@ -1437,11 +1436,10 @@ class state_default extends EventEmitter {
 
 // src/airplay/volume.ts
 import { DataStreamMessage as DataStreamMessage2, Proto as Proto4 } from "@basmilius/apple-airplay";
-import { reporter } from "@basmilius/apple-common";
 var VOLUME_STEP = 0.05;
 
 class volume_default {
-  get #airplay() {
+  get #protocol() {
     return this.#device[PROTOCOL];
   }
   get #state() {
@@ -1483,7 +1481,7 @@ class volume_default {
     if (!this.#state.outputDeviceUID) {
       throw new Error("No output device active.");
     }
-    const response = await this.#airplay.dataStream.exchange(DataStreamMessage2.getVolume(this.#state.outputDeviceUID));
+    const response = await this.#protocol.dataStream.exchange(DataStreamMessage2.getVolume(this.#state.outputDeviceUID));
     if (response.type === Proto4.ProtocolMessage_Type.GET_VOLUME_RESULT_MESSAGE) {
       const message = DataStreamMessage2.getExtension(response, Proto4.getVolumeResultMessage);
       return message.volume;
@@ -1498,8 +1496,8 @@ class volume_default {
       throw new Error("Absolute volume control is not available.");
     }
     volume = Math.min(1, Math.max(0, volume));
-    reporter.info(`Setting volume to ${volume} for device ${this.#state.outputDeviceUID}`);
-    await this.#airplay.dataStream.exchange(DataStreamMessage2.setVolume(this.#state.outputDeviceUID, volume));
+    this.#protocol.context.logger.info(`Setting volume to ${volume} for device ${this.#state.outputDeviceUID}`);
+    await this.#protocol.dataStream.exchange(DataStreamMessage2.setVolume(this.#state.outputDeviceUID, volume));
   }
 }
 
@@ -1515,7 +1513,7 @@ class device_default extends EventEmitter2 {
     this.#discoveryResult = discoveryResult;
   }
   get isConnected() {
-    return this.#protocol?.rtsp?.isConnected ?? false;
+    return this.#protocol?.controlStream?.isConnected ?? false;
   }
   get remote() {
     return this.#remote;
@@ -1532,6 +1530,7 @@ class device_default extends EventEmitter2 {
   set timingServer(timingServer) {
     this.#timingServer = timingServer;
   }
+  #deviceId;
   #remote;
   #state;
   #volume;
@@ -1542,8 +1541,9 @@ class device_default extends EventEmitter2 {
   #keys;
   #protocol;
   #timingServer;
-  constructor(discoveryResult) {
+  constructor(deviceId, discoveryResult) {
     super();
+    this.#deviceId = deviceId;
     this.#discoveryResult = discoveryResult;
     this.#remote = new remote_default(this);
     this.#state = new state_default(this);
@@ -1552,10 +1552,10 @@ class device_default extends EventEmitter2 {
   async connect() {
     this.#disconnect = false;
     this.#state.clear();
-    this.#protocol = new AirPlay2(this.#discoveryResult);
-    this.#protocol.rtsp.on("close", async () => this.#onClose());
-    this.#protocol.rtsp.on("error", async (err) => this.#onError(err));
-    this.#protocol.rtsp.on("timeout", async () => this.#onTimeout());
+    this.#protocol = new Protocol(this.#deviceId, this.#discoveryResult);
+    this.#protocol.controlStream.on("close", async () => this.#onClose());
+    this.#protocol.controlStream.on("error", async (err) => this.#onError(err));
+    this.#protocol.controlStream.on("timeout", async () => this.#onTimeout());
     await this.#protocol.connect();
     if (this.#credentials) {
       this.#keys = await this.#protocol.verify.start(this.#credentials);
@@ -1591,11 +1591,11 @@ class device_default extends EventEmitter2 {
       await this.#protocol.feedback();
       await this.#protocol.dataStream.exchange(DataStreamMessage3.setConnectionState(Proto5.SetConnectionStateMessage_ConnectionState.Connected));
     } catch (err) {
-      reporter2.error("Feedback error", err);
+      this.#protocol.context.logger.error("Feedback error", err);
     }
   }
   async#onClose() {
-    reporter2.net("#onClose() called on airplay device.");
+    this.#protocol.context.logger.net("#onClose() called on airplay device.");
     if (!this.#disconnect) {
       await this.disconnectSafely();
       this.emit("disconnected", true);
@@ -1604,21 +1604,21 @@ class device_default extends EventEmitter2 {
     }
   }
   async#onError(err) {
-    reporter2.error("AirPlay error", err);
+    this.#protocol.context.logger.error("AirPlay error", err);
   }
   async#onTimeout() {
-    reporter2.error("AirPlay timeout");
-    await this.#protocol.rtsp.destroy();
+    this.#protocol.context.logger.error("AirPlay timeout");
+    await this.#protocol.controlStream.destroy();
   }
   async#setup() {
     const keys = this.#keys;
-    await this.#protocol.rtsp.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
-    await this.#unsubscribe();
+    this.#protocol.controlStream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+    this.#unsubscribe();
     if (this.#timingServer) {
-      await this.#protocol.setupTimingServer(this.#timingServer);
+      this.#protocol.useTimingServer(this.#timingServer);
     }
-    await this.#protocol.setupEventStream(keys.pairingId, keys.sharedSecret);
-    await this.#protocol.setupDataStream(keys.sharedSecret, async () => await this.#subscribe());
+    await this.#protocol.setupEventStream(keys.sharedSecret, keys.pairingId);
+    await this.#protocol.setupDataStream(keys.sharedSecret, () => this.#subscribe());
     this.#protocol.dataStream.on("error", async (err) => this.#onError(err));
     this.#protocol.dataStream.on("timeout", async () => this.#onTimeout());
     this.#protocol.eventStream.on("error", async (err) => this.#onError(err));
@@ -1647,17 +1647,17 @@ class device_default extends EventEmitter2 {
     if (!result) {
       await this.#onError(new Error("Device did not respond in time with its info."));
     } else {
-      reporter2.info("Device info received successfully, protocol should be ready.");
+      this.#protocol.context.logger.info("Device info received successfully, protocol should be ready.");
     }
   }
-  async#subscribe() {
-    await this.#state[STATE_SUBSCRIBE_SYMBOL]();
+  #subscribe() {
+    this.#state[STATE_SUBSCRIBE_SYMBOL]();
   }
-  async#unsubscribe() {
+  #unsubscribe() {
     try {
-      await this.#state[STATE_UNSUBSCRIBE_SYMBOL]();
+      this.#state[STATE_UNSUBSCRIBE_SYMBOL]();
     } catch (err) {
-      reporter2.error("State unsubscribe error", err);
+      this.#protocol.context.logger.error("State unsubscribe error", err);
     }
   }
 }
@@ -1665,8 +1665,7 @@ class device_default extends EventEmitter2 {
 var PROTOCOL2 = Symbol("com.basmilius.companion-link:protocol");
 // src/companion-link/device.ts
 import { EventEmitter as EventEmitter3 } from "node:events";
-import { reporter as reporter3 } from "@basmilius/apple-common";
-import { CompanionLink, convertAttentionState } from "@basmilius/apple-companion-link";
+import { convertAttentionState, Protocol as Protocol2 } from "@basmilius/apple-companion-link";
 class device_default2 extends EventEmitter3 {
   get [PROTOCOL2]() {
     return this.#protocol;
@@ -1678,16 +1677,18 @@ class device_default2 extends EventEmitter3 {
     this.#discoveryResult = discoveryResult;
   }
   get isConnected() {
-    return this.#protocol?.socket?.isConnected ?? false;
+    return this.#protocol?.stream?.isConnected ?? false;
   }
+  #deviceId;
   #credentials;
   #disconnect = false;
   #discoveryResult;
   #heartbeatInterval;
   #keys;
   #protocol;
-  constructor(discoveryResult) {
+  constructor(deviceId, discoveryResult) {
     super();
+    this.#deviceId = deviceId;
     this.#discoveryResult = discoveryResult;
     this.onSystemStatus = this.onSystemStatus.bind(this);
     this.onTVSystemStatus = this.onTVSystemStatus.bind(this);
@@ -1697,10 +1698,10 @@ class device_default2 extends EventEmitter3 {
       throw new Error("Credentials are required to connect to a Companion Link device.");
     }
     this.#disconnect = false;
-    this.#protocol = new CompanionLink(this.#discoveryResult);
-    this.#protocol.socket.on("close", async () => this.#onClose());
-    this.#protocol.socket.on("error", async (err) => this.#onError(err));
-    this.#protocol.socket.on("timeout", async () => this.#onTimeout());
+    this.#protocol = new Protocol2(this.#deviceId, this.#discoveryResult);
+    this.#protocol.stream.on("close", async () => this.#onClose());
+    this.#protocol.stream.on("error", async (err) => this.#onError(err));
+    this.#protocol.stream.on("timeout", async () => this.#onTimeout());
     await this.#protocol.connect();
     this.#keys = await this.#protocol.verify.start(this.#credentials);
     await this.#setup();
@@ -1748,11 +1749,11 @@ class device_default2 extends EventEmitter3 {
     try {
       await this.#protocol._systemInfo(this.#credentials.pairingId);
     } catch (err) {
-      reporter3.error("Heartbeat error", err);
+      this.#protocol.context.logger.error("Heartbeat error", err);
     }
   }
   async#onClose() {
-    reporter3.net("#onClose() called on companion link device.");
+    this.#protocol.context.logger.net("#onClose() called on companion link device.");
     if (!this.#disconnect) {
       await this.disconnectSafely();
       this.emit("disconnected", true);
@@ -1761,15 +1762,15 @@ class device_default2 extends EventEmitter3 {
     }
   }
   async#onError(err) {
-    reporter3.error("Companion Link error", err);
+    this.#protocol.context.logger.error("Companion Link error", err);
   }
   async#onTimeout() {
-    reporter3.error("Companion Link timeout");
-    await this.#protocol.socket.destroy();
+    this.#protocol.context.logger.error("Companion Link timeout");
+    await this.#protocol.stream.destroy();
   }
   async#setup() {
     const keys = this.#keys;
-    await this.#protocol.socket.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+    this.#protocol.stream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
     await this.#protocol._systemInfo(this.#credentials.pairingId);
     await this.#protocol._sessionStart();
     await this.#protocol._tvrcSessionStart();
@@ -1792,17 +1793,17 @@ class device_default2 extends EventEmitter3 {
     } catch (_) {}
   }
   async onSystemStatus(data) {
-    reporter3.info("System Status", data);
+    this.#protocol.context.logger.info("System Status", data);
     this.emit("power", convertAttentionState(data.state));
   }
   async onTVSystemStatus(data) {
-    reporter3.info("TV System Status", data);
+    this.#protocol.context.logger.info("TV System Status", data);
     this.emit("power", convertAttentionState(data.state));
   }
 }
 // src/model/apple-tv.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { Proto as Proto6 } from "@basmilius/apple-airplay";
+import * as AirPlay from "@basmilius/apple-airplay";
 class apple_tv_default extends EventEmitter4 {
   get airplay() {
     return this.#airplay;
@@ -1813,6 +1814,9 @@ class apple_tv_default extends EventEmitter4 {
   get bundleIdentifier() {
     return this.#airplay.state.nowPlayingClient?.bundleIdentifier ?? null;
   }
+  get deviceId() {
+    return this.#deviceId;
+  }
   get displayName() {
     return this.#airplay.state.nowPlayingClient?.displayName ?? null;
   }
@@ -1820,24 +1824,26 @@ class apple_tv_default extends EventEmitter4 {
     return this.#airplay.isConnected && this.#companionLink.isConnected;
   }
   get isPlaying() {
-    return this.playbackState === Proto6.PlaybackState_Enum.Playing;
+    return this.playbackState === AirPlay.Proto.PlaybackState_Enum.Playing;
   }
   get playbackQueue() {
     return this.#airplay.state.nowPlayingClient?.playbackQueue ?? null;
   }
   get playbackState() {
-    return this.#airplay.state.nowPlayingClient?.playbackState ?? Proto6.PlaybackState_Enum.Unknown;
+    return this.#airplay.state.nowPlayingClient?.playbackState ?? AirPlay.Proto.PlaybackState_Enum.Unknown;
   }
   get playbackStateTimestamp() {
     return this.#airplay.state.nowPlayingClient?.playbackStateTimestamp ?? -1;
   }
   #airplay;
   #companionLink;
+  #deviceId;
   #disconnect = false;
-  constructor(airplayDiscoveryResult, companionLinkDiscoveryResult) {
+  constructor(deviceId, airplayDiscoveryResult, companionLinkDiscoveryResult) {
     super();
-    this.#airplay = new device_default(airplayDiscoveryResult);
-    this.#companionLink = new device_default2(companionLinkDiscoveryResult);
+    this.#deviceId = deviceId;
+    this.#airplay = new device_default(this.#deviceId, airplayDiscoveryResult);
+    this.#companionLink = new device_default2(this.#deviceId, companionLinkDiscoveryResult);
     this.#airplay.on("connected", () => this.#onConnected());
     this.#airplay.on("disconnected", (unexpected) => this.#onDisconnected(unexpected));
     this.#companionLink.on("connected", () => this.#onConnected());
@@ -1861,22 +1867,22 @@ class apple_tv_default extends EventEmitter4 {
     await this.#airplay.remote.wake();
   }
   async pause() {
-    await this.#airplay.sendCommand(Proto6.Command.Pause);
+    await this.#airplay.sendCommand(AirPlay.Proto.Command.Pause);
   }
   async playPause() {
-    await this.#airplay.sendCommand(Proto6.Command.TogglePlayPause);
+    await this.#airplay.sendCommand(AirPlay.Proto.Command.TogglePlayPause);
   }
   async play() {
-    await this.#airplay.sendCommand(Proto6.Command.Play);
+    await this.#airplay.sendCommand(AirPlay.Proto.Command.Play);
   }
   async stop() {
-    await this.#airplay.sendCommand(Proto6.Command.Stop);
+    await this.#airplay.sendCommand(AirPlay.Proto.Command.Stop);
   }
   async next() {
-    await this.#airplay.sendCommand(Proto6.Command.NextInContext);
+    await this.#airplay.sendCommand(AirPlay.Proto.Command.NextInContext);
   }
   async previous() {
-    await this.#airplay.sendCommand(Proto6.Command.PreviousInContext);
+    await this.#airplay.sendCommand(AirPlay.Proto.Command.PreviousInContext);
   }
   async volumeDown() {
     await this.#airplay.remote.volumeDown();
@@ -1918,7 +1924,7 @@ class apple_tv_default extends EventEmitter4 {
 }
 // src/model/homepod-base.ts
 import { EventEmitter as EventEmitter5 } from "node:events";
-import { Proto as Proto7 } from "@basmilius/apple-airplay";
+import * as AirPlay2 from "@basmilius/apple-airplay";
 class homepod_base_default extends EventEmitter5 {
   get airplay() {
     return this.#airplay;
@@ -1926,6 +1932,9 @@ class homepod_base_default extends EventEmitter5 {
   get bundleIdentifier() {
     return this.#airplay.state.nowPlayingClient?.bundleIdentifier ?? null;
   }
+  get deviceId() {
+    return this.#deviceId;
+  }
   get displayName() {
     return this.#airplay.state.nowPlayingClient?.displayName ?? null;
   }
@@ -1933,13 +1942,13 @@ class homepod_base_default extends EventEmitter5 {
     return this.#airplay.isConnected;
   }
   get isPlaying() {
-    return this.playbackState === Proto7.PlaybackState_Enum.Playing;
+    return this.playbackState === AirPlay2.Proto.PlaybackState_Enum.Playing;
   }
   get playbackQueue() {
     return this.#airplay.state.nowPlayingClient?.playbackQueue ?? null;
   }
   get playbackState() {
-    return this.#airplay.state.nowPlayingClient?.playbackState ?? Proto7.PlaybackState_Enum.Unknown;
+    return this.#airplay.state.nowPlayingClient?.playbackState ?? AirPlay2.Proto.PlaybackState_Enum.Unknown;
   }
   get playbackStateTimestamp() {
     return this.#airplay.state.nowPlayingClient?.playbackStateTimestamp ?? -1;
@@ -1948,10 +1957,12 @@ class homepod_base_default extends EventEmitter5 {
     return this.#airplay.state.volume ?? 0;
   }
   #airplay;
+  #deviceId;
   #disconnect = false;
-  constructor(discoveryResult) {
+  constructor(deviceId, discoveryResult) {
     super();
-    this.#airplay = new device_default(discoveryResult);
+    this.#deviceId = deviceId;
+    this.#airplay = new device_default(this.#deviceId, discoveryResult);
     this.#airplay.on("connected", () => this.#onConnected());
     this.#airplay.on("disconnected", (unexpected) => this.#onDisconnected(unexpected));
   }
@@ -1963,22 +1974,22 @@ class homepod_base_default extends EventEmitter5 {
     await this.#airplay.disconnect();
   }
   async pause() {
-    await this.#airplay.sendCommand(Proto7.Command.Pause);
+    await this.#airplay.sendCommand(AirPlay2.Proto.Command.Pause);
   }
   async playPause() {
-    await this.#airplay.sendCommand(Proto7.Command.TogglePlayPause);
+    await this.#airplay.sendCommand(AirPlay2.Proto.Command.TogglePlayPause);
   }
   async play() {
-    await this.#airplay.sendCommand(Proto7.Command.Play);
+    await this.#airplay.sendCommand(AirPlay2.Proto.Command.Play);
   }
   async stop() {
-    await this.#airplay.sendCommand(Proto7.Command.Stop);
+    await this.#airplay.sendCommand(AirPlay2.Proto.Command.Stop);
   }
   async next() {
-    await this.#airplay.sendCommand(Proto7.Command.NextInContext);
+    await this.#airplay.sendCommand(AirPlay2.Proto.Command.NextInContext);
   }
   async previous() {
-    await this.#airplay.sendCommand(Proto7.Command.PreviousInContext);
+    await this.#airplay.sendCommand(AirPlay2.Proto.Command.PreviousInContext);
   }
   async getCommandInfo(command) {
     const client = this.#airplay.state.nowPlayingClient;

package/dist/model/apple-tv.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "node:events";
-import { Proto } from "@basmilius/apple-airplay";
 import type { AccessoryCredentials, DiscoveryResult } from "@basmilius/apple-common";
+import * as AirPlay from "@basmilius/apple-airplay";
 import { AirPlayDevice } from "../airplay";
 import { CompanionLinkDevice } from "../companion-link";
 type EventMap = {
@@ -12,13 +12,14 @@ export default class extends EventEmitter<EventMap> {
 	get airplay(): AirPlayDevice;
 	get companionLink(): CompanionLinkDevice;
 	get bundleIdentifier(): string | null;
+	get deviceId(): string;
 	get displayName(): string | null;
 	get isConnected(): boolean;
 	get isPlaying(): boolean;
-	get playbackQueue(): Proto.PlaybackQueue | null;
-	get playbackState(): Proto.PlaybackState_Enum;
+	get playbackQueue(): AirPlay.Proto.PlaybackQueue | null;
+	get playbackState(): AirPlay.Proto.PlaybackState_Enum;
 	get playbackStateTimestamp(): number;
-	constructor(airplayDiscoveryResult: DiscoveryResult, companionLinkDiscoveryResult: DiscoveryResult);
+	constructor(deviceId: string, airplayDiscoveryResult: DiscoveryResult, companionLinkDiscoveryResult: DiscoveryResult);
 	connect(credentials: AccessoryCredentials): Promise<void>;
 	disconnect(): Promise<void>;
 	turnOff(): Promise<void>;
@@ -32,6 +33,6 @@ export default class extends EventEmitter<EventMap> {
 	volumeDown(): Promise<void>;
 	volumeMute(): Promise<void>;
 	volumeUp(): Promise<void>;
-	getCommandInfo(command: Proto.Command): Promise<Proto.CommandInfo | null>;
-	isCommandSupported(command: Proto.Command): Promise<boolean>;
+	getCommandInfo(command: AirPlay.Proto.Command): Promise<AirPlay.Proto.CommandInfo | null>;
+	isCommandSupported(command: AirPlay.Proto.Command): Promise<boolean>;
 }

package/dist/model/homepod-base.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "node:events";
-import { Proto } from "@basmilius/apple-airplay";
 import type { DiscoveryResult } from "@basmilius/apple-common";
+import * as AirPlay from "@basmilius/apple-airplay";
 import { AirPlayDevice } from "../airplay";
 type EventMap = {
 	connected: [];
@@ -10,14 +10,15 @@ export default abstract class extends EventEmitter<EventMap> {
 	#private;
 	get airplay(): AirPlayDevice;
 	get bundleIdentifier(): string | null;
+	get deviceId(): string;
 	get displayName(): string | null;
 	get isConnected(): boolean;
 	get isPlaying(): boolean;
-	get playbackQueue(): Proto.PlaybackQueue | null;
-	get playbackState(): Proto.PlaybackState_Enum;
+	get playbackQueue(): AirPlay.Proto.PlaybackQueue | null;
+	get playbackState(): AirPlay.Proto.PlaybackState_Enum;
 	get playbackStateTimestamp(): number;
 	get volume(): number;
-	constructor(discoveryResult: DiscoveryResult);
+	constructor(deviceId: string, discoveryResult: DiscoveryResult);
 	connect(): Promise<void>;
 	disconnect(): Promise<void>;
 	pause(): Promise<void>;
@@ -26,6 +27,6 @@ export default abstract class extends EventEmitter<EventMap> {
 	stop(): Promise<void>;
 	next(): Promise<void>;
 	previous(): Promise<void>;
-	getCommandInfo(command: Proto.Command): Promise<Proto.CommandInfo | null>;
-	isCommandSupported(command: Proto.Command): Promise<boolean>;
+	getCommandInfo(command: AirPlay.Proto.Command): Promise<AirPlay.Proto.CommandInfo | null>;
+	isCommandSupported(command: AirPlay.Proto.Command): Promise<boolean>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-devices",
     "description": "Exposes various Apple devices to connect with either AirPlay or Companion Link.",
-    "version": "0.1.3",
+    "version": "0.2.1",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -43,10 +43,10 @@
         }
     },
     "dependencies": {
-        "@basmilius/apple-airplay": "0.1.3",
-        "@basmilius/apple-common": "0.1.3",
-        "@basmilius/apple-companion-link": "0.1.3",
-        "@basmilius/apple-encoding": "0.1.3"
+        "@basmilius/apple-airplay": "0.2.1",
+        "@basmilius/apple-common": "0.2.1",
+        "@basmilius/apple-companion-link": "0.2.1",
+        "@basmilius/apple-encoding": "0.2.1"
     },
     "devDependencies": {
         "@basmilius/tools": "^2.23.0",