@lox-audio-server/sonos 0.1.0

package/dist/esm/sonos/group.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosGroup = void 0;
+const constants_1 = require("./constants");
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const models_1 = require("./models");
+class SonosGroup {
+    client;
+    data;
+    activeSessionId = null;
+    playbackStatus = null;
+    playbackMetadata = null;
+    playbackStatusUpdatedAt = 0;
+    volumeData = null;
+    playModes = new models_1.PlayModesWrapper({});
+    playbackActions = new models_1.PlaybackActionsWrapper({});
+    unsubscribeCallbacks = [];
+    constructor(client, data) {
+        this.client = client;
+        this.data = data;
+    }
+    async init() {
+        try {
+            this.volumeData = await this.client.api.groupVolume.getVolume(this.id);
+            this.playbackStatus = await this.client.api.playback.getPlaybackStatus(this.id);
+            this.playbackStatusUpdatedAt = Date.now();
+            this.playbackActions = new models_1.PlaybackActionsWrapper(this.playbackStatus.availablePlaybackActions ?? {});
+            this.playModes = new models_1.PlayModesWrapper(this.playbackStatus.playModes ?? {});
+            this.playbackMetadata = await this.client.api.playbackMetadata.getMetadataStatus(this.id);
+            this.unsubscribeCallbacks = [
+                await this.client.api.playback.subscribe(this.id, (data) => this.handlePlaybackStatusUpdate(data)),
+                await this.client.api.groupVolume.subscribe(this.id, (data) => this.handleVolumeUpdate(data)),
+                await this.client.api.playbackMetadata.subscribe(this.id, (data) => this.handleMetadataUpdate(data)),
+            ];
+        }
+        catch (err) {
+            if (err instanceof errors_1.FailedCommand && err.errorCode === 'groupCoordinatorChanged') {
+                this.volumeData = null;
+                this.playbackStatus = null;
+                this.playbackActions = new models_1.PlaybackActionsWrapper({});
+                this.playModes = new models_1.PlayModesWrapper({});
+                this.playbackMetadata = null;
+                return;
+            }
+            throw err;
+        }
+        this.client.signalEvent({
+            eventType: constants_1.EventType.GROUP_ADDED,
+            objectId: this.id,
+            data: this,
+        });
+    }
+    cleanup() {
+        for (const cb of this.unsubscribeCallbacks)
+            cb();
+        this.unsubscribeCallbacks = [];
+    }
+    get id() {
+        return this.data.id;
+    }
+    get name() {
+        return this.data.name;
+    }
+    get coordinatorId() {
+        return this.data.coordinatorId;
+    }
+    get playerIds() {
+        return this.data.playerIds;
+    }
+    get areaIds() {
+        return this.data.areaIds ?? [];
+    }
+    get playbackState() {
+        return (this.playbackStatus?.playbackState ??
+            this.data.playbackState ??
+            types_1.PlayBackState.IDLE);
+    }
+    get playbackMetadataStatus() {
+        return this.playbackMetadata;
+    }
+    get playbackActionsWrapper() {
+        return this.playbackActions;
+    }
+    get playModesWrapper() {
+        return this.playModes;
+    }
+    get positionSeconds() {
+        if (!this.playbackStatus)
+            return 0;
+        if (this.playbackState === types_1.PlayBackState.PLAYING) {
+            const elapsed = (Date.now() - this.playbackStatusUpdatedAt) / 1000;
+            return (this.playbackStatus.positionMillis ?? 0) / 1000 + elapsed;
+        }
+        return (this.playbackStatus.positionMillis ?? 0) / 1000;
+    }
+    get isDucking() {
+        return this.playbackStatus?.isDucking ?? false;
+    }
+    get activeService() {
+        return (0, models_1.normalizeMusicService)(this.playbackMetadata?.container?.id?.serviceId);
+    }
+    get containerType() {
+        return (0, models_1.normalizeContainerType)(this.playbackMetadata?.container?.type);
+    }
+    async play() {
+        await this.client.api.playback.play(this.id);
+    }
+    async pause() {
+        await this.client.api.playback.pause(this.id);
+    }
+    async stop() {
+        try {
+            if (this.activeSessionId) {
+                await this.client.api.playbackSession.suspend(this.activeSessionId);
+            }
+        }
+        catch (err) {
+            if (!(err instanceof errors_1.FailedCommand))
+                throw err;
+            try {
+                await this.playStreamUrl('clear');
+            }
+            catch {
+                // ignore
+            }
+        }
+        finally {
+            this.activeSessionId = null;
+        }
+    }
+    async togglePlayPause() {
+        await this.client.api.playback.togglePlayPause(this.id);
+    }
+    async skipToNextTrack() {
+        await this.client.api.playback.skipToNextTrack(this.id);
+    }
+    async skipToPreviousTrack() {
+        await this.client.api.playback.skipToPreviousTrack(this.id);
+    }
+    async setPlayModes(options) {
+        await this.client.api.playback.setPlayModes(this.id, options);
+    }
+    async seek(positionMillis) {
+        await this.client.api.playback.seek(this.id, positionMillis);
+    }
+    async seekRelative(deltaMillis) {
+        await this.client.api.playback.seekRelative(this.id, deltaMillis);
+    }
+    async loadLineIn(deviceId, playOnCompletion = false) {
+        await this.client.api.playback.loadLineIn(this.id, deviceId, playOnCompletion);
+    }
+    async modifyGroupMembers(playerIdsToAdd, playerIdsToRemove) {
+        await this.client.api.groups.modifyGroupMembers(this.id, playerIdsToAdd, playerIdsToRemove);
+    }
+    async setGroupMembers(playerIds, areaIds) {
+        await this.client.api.groups.setGroupMembers(this.id, playerIds, areaIds);
+    }
+    async createPlaybackSession(appId = 'com.lox.sonos.playback', appContext = '1', accountId, customData) {
+        const session = await this.client.api.playbackSession.createSession(this.id, appId, appContext, accountId, customData);
+        this.activeSessionId = session.sessionId;
+        return session;
+    }
+    async playStreamUrl(url, metadata) {
+        await this.ensureSession();
+        if (!this.activeSessionId)
+            throw new Error('No active session');
+        await this.client.api.playbackSession.loadStreamUrl(this.activeSessionId, url, {
+            playOnCompletion: true,
+            stationMetadata: metadata,
+        });
+    }
+    async playCloudQueue(queueBaseUrl, options) {
+        await this.ensureSession();
+        if (!this.activeSessionId)
+            throw new Error('No active session');
+        await this.client.api.playbackSession.loadCloudQueue(this.activeSessionId, queueBaseUrl, {
+            ...options,
+            playOnCompletion: true,
+        });
+    }
+    updateData(newData) {
+        let changed = false;
+        for (const [key, value] of Object.entries(newData)) {
+            if (this.data[key] !== value) {
+                this.data[key] = value;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.client.signalEvent({
+                eventType: constants_1.EventType.GROUP_UPDATED,
+                objectId: this.id,
+                data: this,
+            });
+        }
+    }
+    async ensureSession() {
+        if (!this.activeSessionId) {
+            await this.createPlaybackSession();
+        }
+    }
+    handlePlaybackStatusUpdate(data) {
+        this.playbackStatus = data;
+        this.playbackStatusUpdatedAt = Date.now();
+        this.playbackActions = new models_1.PlaybackActionsWrapper(data.availablePlaybackActions ?? {});
+        this.playModes = new models_1.PlayModesWrapper(data.playModes ?? {});
+        this.client.signalEvent({
+            eventType: constants_1.EventType.GROUP_UPDATED,
+            objectId: this.id,
+            data: this,
+        });
+    }
+    handleMetadataUpdate(data) {
+        this.playbackMetadata = data;
+        this.client.signalEvent({
+            eventType: constants_1.EventType.GROUP_UPDATED,
+            objectId: this.id,
+            data: this,
+        });
+    }
+    handleVolumeUpdate(data) {
+        this.volumeData = data;
+        this.client.signalEvent({
+            eventType: constants_1.EventType.GROUP_UPDATED,
+            objectId: this.id,
+            data: this,
+        });
+    }
+}
+exports.SonosGroup = SonosGroup;

package/dist/esm/sonos/models.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayModesWrapper = exports.PlaybackActionsWrapper = void 0;
+exports.normalizeContainerType = normalizeContainerType;
+exports.normalizeMusicService = normalizeMusicService;
+const types_1 = require("./types");
+class PlaybackActionsWrapper {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    get canSkipForward() {
+        return this.raw.canSkipForward ?? this.raw.canSkip ?? false;
+    }
+    get canSkipBackward() {
+        return this.raw.canSkipBack ?? this.raw.canSkipToPrevious ?? false;
+    }
+    get canPlay() {
+        return this.raw.canPlay ?? false;
+    }
+    get canPause() {
+        return this.raw.canPause ?? false;
+    }
+    get canStop() {
+        return this.raw.canStop ?? false;
+    }
+}
+exports.PlaybackActionsWrapper = PlaybackActionsWrapper;
+class PlayModesWrapper {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    get crossfade() {
+        return this.raw.crossfade;
+    }
+    get repeat() {
+        return this.raw.repeat;
+    }
+    get repeatOne() {
+        return this.raw.repeatOne;
+    }
+    get shuffle() {
+        return this.raw.shuffle;
+    }
+}
+exports.PlayModesWrapper = PlayModesWrapper;
+function normalizeContainerType(containerType) {
+    if (!containerType)
+        return null;
+    if (Object.values(types_1.ContainerType).includes(containerType)) {
+        return containerType;
+    }
+    return containerType;
+}
+function normalizeMusicService(serviceId) {
+    if (!serviceId)
+        return null;
+    if (Object.values(types_1.MusicService).includes(serviceId)) {
+        return serviceId;
+    }
+    return serviceId;
+}

package/dist/esm/sonos/player.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosPlayer = void 0;
+const constants_1 = require("./constants");
+class SonosPlayer {
+    client;
+    data;
+    volumeData = null;
+    activeGroup = null;
+    constructor(client, data) {
+        this.client = client;
+        this.data = data;
+        this.activeGroup = this.client.groups.find((g) => g.coordinatorId === this.id || g.playerIds.includes(this.id)) ?? null;
+    }
+    async init() {
+        this.volumeData = await this.client.api.playerVolume.getVolume(this.id);
+        await this.client.api.playerVolume.subscribe(this.id, (data) => this.handleVolumeUpdate(data));
+    }
+    get id() {
+        return this.data.id;
+    }
+    get name() {
+        return this.data.name;
+    }
+    get icon() {
+        return this.data.icon ?? '';
+    }
+    get volumeLevel() {
+        return this.volumeData?.volume;
+    }
+    get volumeMuted() {
+        return this.volumeData?.muted;
+    }
+    get hasFixedVolume() {
+        return this.volumeData?.fixed;
+    }
+    get group() {
+        return this.activeGroup;
+    }
+    get groupMembers() {
+        return this.group?.playerIds ?? [];
+    }
+    get isCoordinator() {
+        return Boolean(this.group && this.group.coordinatorId === this.id);
+    }
+    get isPassive() {
+        return Boolean(this.group && this.group.coordinatorId !== this.id);
+    }
+    async setVolume(volume, muted) {
+        await this.client.api.playerVolume.setVolume(this.id, volume, muted);
+    }
+    async duck(durationMillis) {
+        await this.client.api.playerVolume.duck(this.id, durationMillis);
+    }
+    async leaveGroup() {
+        if (!this.group)
+            return;
+        await this.client.api.groups.modifyGroupMembers(this.group.id, [], [this.id]);
+    }
+    async joinGroup(groupId) {
+        await this.client.api.groups.modifyGroupMembers(groupId, [this.id], []);
+    }
+    async playAudioClip(url, options = {}) {
+        await this.client.api.audioClip.loadAudioClip(this.id, {
+            name: options.name ?? 'lox-sonos',
+            appId: 'lox-sonos',
+            streamUrl: url,
+            volume: options.volume,
+        });
+    }
+    async loadHomeTheaterPlayback() {
+        await this.client.api.homeTheater.loadHomeTheaterPlayback(this.id);
+    }
+    updateData(newData) {
+        this.checkActiveGroup();
+        let changed = false;
+        for (const [key, value] of Object.entries(newData)) {
+            if (this.data[key] !== value) {
+                this.data[key] = value;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.client.signalEvent({
+                eventType: constants_1.EventType.PLAYER_UPDATED,
+                objectId: this.id,
+                data: this,
+            });
+        }
+    }
+    checkActiveGroup() {
+        const prevGroupId = this.activeGroup?.id;
+        this.activeGroup =
+            this.client.groups.find((g) => g.coordinatorId === this.id || g.playerIds.includes(this.id)) ?? null;
+        if (prevGroupId !== this.activeGroup?.id) {
+            this.client.signalEvent({
+                eventType: constants_1.EventType.PLAYER_UPDATED,
+                objectId: this.id,
+                data: this,
+            });
+        }
+    }
+    handleVolumeUpdate(data) {
+        this.volumeData = data;
+        this.client.signalEvent({
+            eventType: constants_1.EventType.PLAYER_UPDATED,
+            objectId: this.id,
+            data: this,
+        });
+    }
+}
+exports.SonosPlayer = SonosPlayer;

package/dist/esm/sonos/types.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerType = exports.MusicService = exports.SonosCapability = exports.PlayBackState = void 0;
+var PlayBackState;
+(function (PlayBackState) {
+    PlayBackState["IDLE"] = "PLAYBACK_STATE_IDLE";
+    PlayBackState["BUFFERING"] = "PLAYBACK_STATE_BUFFERING";
+    PlayBackState["PAUSED"] = "PLAYBACK_STATE_PAUSED";
+    PlayBackState["PLAYING"] = "PLAYBACK_STATE_PLAYING";
+})(PlayBackState || (exports.PlayBackState = PlayBackState = {}));
+var SonosCapability;
+(function (SonosCapability) {
+    SonosCapability["CLOUD"] = "CLOUD";
+    SonosCapability["PLAYBACK"] = "PLAYBACK";
+    SonosCapability["AIRPLAY"] = "AIRPLAY";
+    SonosCapability["LINE_IN"] = "LINE_IN";
+    SonosCapability["VOICE"] = "VOICE";
+    SonosCapability["AUDIO_CLIP"] = "AUDIO_CLIP";
+    SonosCapability["MICROPHONE_SWITCH"] = "MICROPHONE_SWITCH";
+    SonosCapability["HT_PLAYBACK"] = "HT_PLAYBACK";
+})(SonosCapability || (exports.SonosCapability = SonosCapability = {}));
+var MusicService;
+(function (MusicService) {
+    MusicService["SPOTIFY"] = "9";
+    MusicService["MUSIC_ASSISTANT"] = "mass";
+    MusicService["TUNEIN"] = "303";
+    MusicService["QOBUZ"] = "31";
+    MusicService["YOUTUBE_MUSIC"] = "284";
+    MusicService["LOCAL_LIBRARY"] = "local-library";
+})(MusicService || (exports.MusicService = MusicService = {}));
+var ContainerType;
+(function (ContainerType) {
+    ContainerType["LINEIN"] = "linein";
+    ContainerType["STATION"] = "station";
+    ContainerType["PLAYLIST"] = "playlist";
+    ContainerType["AIRPLAY"] = "linein.airplay";
+    ContainerType["PODCAST"] = "podcast";
+    ContainerType["BOOK"] = "book";
+    ContainerType["ARTIST"] = "artist";
+    ContainerType["ALBUM"] = "album";
+    ContainerType["ARTIST_LOCAL"] = "artist.local";
+    ContainerType["ALBUM_LOCAL"] = "album.local";
+    ContainerType["HOME_THEATER_SPDIF"] = "linein.homeTheater.spdif";
+    ContainerType["HOME_THEATER_HDMI"] = "linein.homeTheater.hdmi";
+    // fallbacks for unknown types will be treated as strings
+})(ContainerType || (exports.ContainerType = ContainerType = {}));

package/dist/esm/sonos/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiscoveryInfo = getDiscoveryInfo;
+const undici_1 = require("undici");
+const constants_1 = require("./constants");
+async function getDiscoveryInfo(playerIp, options) {
+    const dispatcher = options?.dispatcher ?? new undici_1.Agent({ connect: { rejectUnauthorized: false } });
+    const resp = await (0, undici_1.fetch)(`https://${playerIp}:1443/api/v1/players/local/info`, {
+        method: 'GET',
+        headers: { 'X-Sonos-Api-Key': constants_1.LOCAL_API_TOKEN },
+        dispatcher,
+    });
+    if (!resp.ok) {
+        throw new Error(`Sonos discovery failed (${resp.status} ${resp.statusText})`);
+    }
+    const data = (await resp.json());
+    return data;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { SonosClient, SonosClientOptions } from './sonos/client';
+export { SonosGroup } from './sonos/group';
+export { SonosPlayer } from './sonos/player';
+export * from './sonos/models';
+export * from './sonos/types';
+export * from './sonos/constants';
+export * from './sonos/errors';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosPlayer = exports.SonosGroup = exports.SonosClient = void 0;
+var client_1 = require("./sonos/client");
+Object.defineProperty(exports, "SonosClient", { enumerable: true, get: function () { return client_1.SonosClient; } });
+var group_1 = require("./sonos/group");
+Object.defineProperty(exports, "SonosGroup", { enumerable: true, get: function () { return group_1.SonosGroup; } });
+var player_1 = require("./sonos/player");
+Object.defineProperty(exports, "SonosPlayer", { enumerable: true, get: function () { return player_1.SonosPlayer; } });
+__exportStar(require("./sonos/models"), exports);
+__exportStar(require("./sonos/types"), exports);
+__exportStar(require("./sonos/constants"), exports);
+__exportStar(require("./sonos/errors"), exports);

package/dist/sonos/api/namespace.d.ts

@@ -0,0 +1,16 @@
+import type { SonosWebSocketApi } from './websocket';
+export type SubscribeCallback<T> = (payload: T) => void;
+export type UnsubscribeCallback = () => void;
+/**
+ * Base helper for namespace handlers.
+ */
+export declare class SonosNamespace<TEventPayload> {
+    protected api: SonosWebSocketApi;
+    protected namespace: string;
+    protected eventKey: string;
+    protected listeners: Map<string, SubscribeCallback<TEventPayload>>;
+    readonly eventType: string;
+    constructor(api: SonosWebSocketApi, namespace: string, eventType: string, eventKey: string);
+    protected handleSubscribe(id: string, callback: SubscribeCallback<TEventPayload>): Promise<UnsubscribeCallback>;
+    handleEvent(event: Record<string, unknown>, eventData: TEventPayload): void;
+}

package/dist/sonos/api/namespace.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosNamespace = void 0;
+/**
+ * Base helper for namespace handlers.
+ */
+class SonosNamespace {
+    api;
+    namespace;
+    eventKey;
+    listeners = new Map();
+    eventType;
+    constructor(api, namespace, eventType, eventKey) {
+        this.api = api;
+        this.namespace = namespace;
+        this.eventKey = eventKey;
+        this.eventType = eventType;
+    }
+    async handleSubscribe(id, callback) {
+        if (this.listeners.has(id)) {
+            this.api.logger.error(`Duplicate subscription detected for ${id}`);
+        }
+        await this.api.sendCommand(this.namespace, 'subscribe', undefined, { [this.eventKey]: id });
+        this.listeners.set(id, callback);
+        return () => {
+            this.listeners.delete(id);
+            this.api.sendCommandNoWait(this.namespace, 'unsubscribe', undefined, { [this.eventKey]: id });
+        };
+    }
+    handleEvent(event, eventData) {
+        const id = event[this.eventKey];
+        if (typeof id === 'string') {
+            const handler = this.listeners.get(id);
+            handler?.(eventData);
+        }
+    }
+}
+exports.SonosNamespace = SonosNamespace;

package/dist/sonos/api/namespaces/audioClip.d.ts

@@ -0,0 +1,16 @@
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+import { AudioClipStatusEvent } from '../../types';
+export declare class AudioClipNamespace extends SonosNamespace<AudioClipStatusEvent> {
+    constructor(api: any);
+    loadAudioClip(playerId: string, options: {
+        name: string;
+        appId: string;
+        streamUrl?: string;
+        volume?: number;
+        priority?: string;
+        clipType?: string;
+        httpAuthorization?: string;
+        clipLEDBehavior?: string;
+    }): Promise<any>;
+    subscribe(playerId: string, callback: SubscribeCallback<AudioClipStatusEvent>): Promise<UnsubscribeCallback>;
+}

package/dist/sonos/api/namespaces/audioClip.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioClipNamespace = void 0;
+const namespace_1 = require("../namespace");
+class AudioClipNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'audioClip', 'audioClip', 'playerId');
+    }
+    async loadAudioClip(playerId, options) {
+        return this.api.sendCommand(this.namespace, 'loadAudioClip', {
+            name: options.name,
+            appId: options.appId,
+            priority: options.priority,
+            clipType: options.clipType,
+            streamUrl: options.streamUrl,
+            httpAuthorization: options.httpAuthorization,
+            volume: options.volume,
+            clipLEDBehavior: options.clipLEDBehavior,
+        }, { playerId });
+    }
+    async subscribe(playerId, callback) {
+        return this.handleSubscribe(playerId, callback);
+    }
+}
+exports.AudioClipNamespace = AudioClipNamespace;

package/dist/sonos/api/namespaces/groupVolume.d.ts

@@ -0,0 +1,10 @@
+import { GroupVolume } from '../../types';
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+export declare class GroupVolumeNamespace extends SonosNamespace<GroupVolume> {
+    constructor(api: any);
+    setVolume(groupId: string, volume: number): Promise<void>;
+    getVolume(groupId: string): Promise<GroupVolume>;
+    setMute(groupId: string, muted: boolean): Promise<void>;
+    setRelativeVolume(groupId: string, volumeDelta?: number): Promise<void>;
+    subscribe(groupId: string, callback: SubscribeCallback<GroupVolume>): Promise<UnsubscribeCallback>;
+}

package/dist/sonos/api/namespaces/groupVolume.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupVolumeNamespace = void 0;
+const namespace_1 = require("../namespace");
+class GroupVolumeNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'groupVolume', 'groupVolume', 'groupId');
+    }
+    async setVolume(groupId, volume) {
+        await this.api.sendCommand(this.namespace, 'setVolume', { volume }, { groupId });
+    }
+    async getVolume(groupId) {
+        return this.api.sendCommand(this.namespace, 'getVolume', undefined, { groupId });
+    }
+    async setMute(groupId, muted) {
+        await this.api.sendCommand(this.namespace, 'setMute', { muted }, { groupId });
+    }
+    async setRelativeVolume(groupId, volumeDelta) {
+        await this.api.sendCommand(this.namespace, 'setRelativeVolume', { volumeDelta }, { groupId });
+    }
+    async subscribe(groupId, callback) {
+        return this.handleSubscribe(groupId, callback);
+    }
+}
+exports.GroupVolumeNamespace = GroupVolumeNamespace;

package/dist/sonos/api/namespaces/groups.d.ts

@@ -0,0 +1,10 @@
+import { GroupInfo, Groups } from '../../types';
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+export declare class GroupsNamespace extends SonosNamespace<Groups> {
+    constructor(api: any);
+    modifyGroupMembers(groupId: string, playerIdsToAdd: string[], playerIdsToRemove: string[]): Promise<GroupInfo>;
+    setGroupMembers(groupId: string, playerIds: string[], areaIds?: string[]): Promise<GroupInfo>;
+    getGroups(householdId: string, includeDeviceInfo?: boolean): Promise<Groups>;
+    createGroup(householdId: string, playerIds: string[], musicContextGroupId?: string): Promise<GroupInfo>;
+    subscribe(householdId: string, callback: SubscribeCallback<Groups>): Promise<UnsubscribeCallback>;
+}