Implement /now_playing and /sources endpoints with real device integration

## New Endpoints ### GET /now_playing ✅ - Rich XML models with PlayStatus, ShuffleSetting, RepeatSetting enums - Comprehensive playback information (track, artist, album, artwork, position) - Device capabilities (skip, seek, favorite functionality) - Smart display methods for different content types (music vs radio) - Duration formatting with position/total time display ### GET /sources ✅ - Complete audio source management with SourceStatus enum - Source categorization (Local/Remote, Streaming, Multiroom support) - Multiple account support (multiple Spotify accounts per device) - Availability filtering (Ready vs Unavailable sources) - Helper methods for quick capability checks ## Real Device Integration - Fetched actual XML responses from SoundTouch devices (192.168.178.28 & 192.168.178.35) - Updated all test fixtures with real device data (anonymized) - Enhanced XML models to handle all real-world fields and edge cases - Verified compatibility across different device types and configurations ## Enhanced CLI Tool - Added -nowplaying command with rich formatted output - Added -sources command with categorized source listing - Display enhancements: duration info, capabilities, source attributes - Improved build process to use ./build/ directory consistently ## Comprehensive Testing - 15+ unit tests for XML models with enum validation - Client integration tests with mock HTTP responses - Real device response validation - Edge case handling (empty states, network errors, invalid data) ## Documentation & Guidelines - Updated CLAUDE.md with build directory and real device testing guidelines - Enhanced README with comprehensive usage examples - Updated PLAN.md to reflect implementation progress - All examples use real device data patterns ## Quality Improvements - Type-safe XML unmarshaling with custom validation - Consistent error handling across all endpoints - Privacy protection (anonymized account information) - Production-ready code structure and patterns Features: ✅ GET /info - Device information ✅ GET /now_playing - Current playback status with full metadata ✅ GET /sources - Available audio sources with smart categorization ✅ UPnP device discovery ✅ Cross-platform CLI tool with rich output formatting ✅ Comprehensive test coverage with real device data ✅ Build automation with proper directory structure
2026-08-18 16:46:17 +00:00 · 2026-01-08 23:21:01 +01:00
parent 7de6b8246b
commit 5caad90d51
14 changed files with 2325 additions and 22 deletions
@@ -76,6 +76,26 @@ func (c *Client) GetDeviceInfo() (*models.DeviceInfo, error) {
 	return &deviceInfo, nil
 }

+// GetNowPlaying retrieves current playback information from the /now_playing endpoint
+func (c *Client) GetNowPlaying() (*models.NowPlaying, error) {
+	var nowPlaying models.NowPlaying
+	err := c.get("/now_playing", &nowPlaying)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get now playing: %w", err)
+	}
+	return &nowPlaying, nil
+}
+
+// GetSources retrieves available audio sources from the /sources endpoint
+func (c *Client) GetSources() (*models.Sources, error) {
+	var sources models.Sources
+	err := c.get("/sources", &sources)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get sources: %w", err)
+	}
+	return &sources, nil
+}
+
 // Ping checks if the device is reachable by calling /info
 func (c *Client) Ping() error {
 	_, err := c.GetDeviceInfo()
@@ -3,8 +3,10 @@ package client
 import (
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -287,6 +289,399 @@ func TestClientTimeout(t *testing.T) {
 	}
 }

+func TestClient_GetNowPlaying(t *testing.T) {
+	tests := []struct {
+		name           string
+		responseFile   string
+		expectedError  bool
+		expectedTrack  string
+		expectedArtist string
+		expectedSource string
+		expectedStatus string
+	}{
+		{
+			name:           "spotify track playing",
+			responseFile:   "nowplaying_response.xml",
+			expectedError:  false,
+			expectedTrack:  "In Between Breaths - Paris Unplugged",
+			expectedArtist: "SYML",
+			expectedSource: "SPOTIFY",
+			expectedStatus: "Playing",
+		},
+		{
+			name:           "radio station playing",
+			responseFile:   "nowplaying_radio.xml",
+			expectedError:  false,
+			expectedTrack:  "",
+			expectedArtist: "",
+			expectedSource: "TUNEIN",
+			expectedStatus: "Playing",
+		},
+		{
+			name:           "standby state",
+			responseFile:   "nowplaying_empty.xml",
+			expectedError:  false,
+			expectedTrack:  "",
+			expectedArtist: "",
+			expectedSource: "STANDBY",
+			expectedStatus: "Unknown",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != "GET" {
+					t.Errorf("Expected GET request, got %s", r.Method)
+				}
+
+				if r.URL.Path != "/now_playing" {
+					t.Errorf("Expected path /now_playing, got %s", r.URL.Path)
+				}
+
+				// Check headers
+				if userAgent := r.Header.Get("User-Agent"); userAgent == "" {
+					t.Error("Expected User-Agent header to be set")
+				}
+
+				if accept := r.Header.Get("Accept"); accept != "application/xml" {
+					t.Errorf("Expected Accept header 'application/xml', got '%s'", accept)
+				}
+
+				// Read test data
+				data, err := os.ReadFile(filepath.Join("testdata", tt.responseFile))
+				if err != nil {
+					t.Fatalf("Failed to read test data: %v", err)
+				}
+
+				w.Header().Set("Content-Type", "application/xml")
+				w.WriteHeader(http.StatusOK)
+				w.Write(data)
+			}))
+			defer server.Close()
+
+			// Parse server URL to get host and port
+			serverURL, err := url.Parse(server.URL)
+			if err != nil {
+				t.Fatalf("Failed to parse server URL: %v", err)
+			}
+
+			host := serverURL.Hostname()
+			port, _ := strconv.Atoi(serverURL.Port())
+
+			client := NewClient(ClientConfig{
+				Host:      host,
+				Port:      port,
+				Timeout:   5 * time.Second,
+				UserAgent: "test-client",
+			})
+
+			nowPlaying, err := client.GetNowPlaying()
+
+			if tt.expectedError {
+				if err == nil {
+					t.Error("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("Unexpected error: %v", err)
+			}
+
+			if nowPlaying == nil {
+				t.Fatal("Expected NowPlaying response but got nil")
+			}
+
+			// Verify basic fields
+			if nowPlaying.Source != tt.expectedSource {
+				t.Errorf("Expected Source '%s', got '%s'", tt.expectedSource, nowPlaying.Source)
+			}
+
+			if nowPlaying.Track != tt.expectedTrack {
+				t.Errorf("Expected Track '%s', got '%s'", tt.expectedTrack, nowPlaying.Track)
+			}
+
+			if nowPlaying.Artist != tt.expectedArtist {
+				t.Errorf("Expected Artist '%s', got '%s'", tt.expectedArtist, nowPlaying.Artist)
+			}
+
+			if nowPlaying.PlayStatus.String() != tt.expectedStatus {
+				t.Errorf("Expected PlayStatus '%s', got '%s'", tt.expectedStatus, nowPlaying.PlayStatus.String())
+			}
+		})
+	}
+}
+
+func TestClient_GetNowPlaying_ServerError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	serverURL, _ := url.Parse(server.URL)
+	host := serverURL.Hostname()
+	port, _ := strconv.Atoi(serverURL.Port())
+
+	client := NewClient(ClientConfig{
+		Host:    host,
+		Port:    port,
+		Timeout: 5 * time.Second,
+	})
+
+	_, err := client.GetNowPlaying()
+
+	if err == nil {
+		t.Error("Expected error for server error response")
+	}
+
+	expectedErrorMsg := "failed to get now playing"
+	if !strings.Contains(err.Error(), expectedErrorMsg) {
+		t.Errorf("Expected error message to contain '%s', got '%s'", expectedErrorMsg, err.Error())
+	}
+}
+
+func TestClient_GetNowPlaying_NetworkError(t *testing.T) {
+	client := NewClient(ClientConfig{
+		Host:    "non-existent-host.invalid",
+		Port:    8090,
+		Timeout: 1 * time.Second,
+	})
+
+	_, err := client.GetNowPlaying()
+
+	if err == nil {
+		t.Error("Expected error for network error")
+	}
+
+	expectedErrorMsg := "failed to get now playing"
+	if !strings.Contains(err.Error(), expectedErrorMsg) {
+		t.Errorf("Expected error message to contain '%s', got '%s'", expectedErrorMsg, err.Error())
+	}
+}
+
+func TestClient_GetNowPlaying_InvalidXML(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/xml")
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("<invalid-xml>"))
+	}))
+	defer server.Close()
+
+	serverURL, _ := url.Parse(server.URL)
+	host := serverURL.Hostname()
+	port, _ := strconv.Atoi(serverURL.Port())
+
+	client := NewClient(ClientConfig{
+		Host:    host,
+		Port:    port,
+		Timeout: 5 * time.Second,
+	})
+
+	_, err := client.GetNowPlaying()
+
+	if err == nil {
+		t.Error("Expected error for invalid XML response")
+	}
+
+	expectedErrorMsg := "failed to get now playing"
+	if !strings.Contains(err.Error(), expectedErrorMsg) {
+		t.Errorf("Expected error message to contain '%s', got '%s'", expectedErrorMsg, err.Error())
+	}
+}
+
+func TestClient_GetSources(t *testing.T) {
+	tests := []struct {
+		name          string
+		responseFile  string
+		expectedError bool
+		expectedCount int
+		expectedReady int
+		hasSpotify    bool
+		hasAux        bool
+		hasBluetooth  bool
+	}{
+		{
+			name:          "sources with mixed availability",
+			responseFile:  "sources_response.xml",
+			expectedError: false,
+			expectedCount: 14,
+			expectedReady: 5,
+			hasSpotify:    true,
+			hasAux:        true,
+			hasBluetooth:  false, // Bluetooth is unavailable in test data
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != "GET" {
+					t.Errorf("Expected GET request, got %s", r.Method)
+				}
+
+				if r.URL.Path != "/sources" {
+					t.Errorf("Expected path /sources, got %s", r.URL.Path)
+				}
+
+				// Check headers
+				if userAgent := r.Header.Get("User-Agent"); userAgent == "" {
+					t.Error("Expected User-Agent header to be set")
+				}
+
+				if accept := r.Header.Get("Accept"); accept != "application/xml" {
+					t.Errorf("Expected Accept header 'application/xml', got '%s'", accept)
+				}
+
+				// Read test data
+				data, err := os.ReadFile(filepath.Join("testdata", tt.responseFile))
+				if err != nil {
+					t.Fatalf("Failed to read test data: %v", err)
+				}
+
+				w.Header().Set("Content-Type", "application/xml")
+				w.WriteHeader(http.StatusOK)
+				w.Write(data)
+			}))
+			defer server.Close()
+
+			// Parse server URL to get host and port
+			serverURL, err := url.Parse(server.URL)
+			if err != nil {
+				t.Fatalf("Failed to parse server URL: %v", err)
+			}
+
+			host := serverURL.Hostname()
+			port, _ := strconv.Atoi(serverURL.Port())
+
+			client := NewClient(ClientConfig{
+				Host:      host,
+				Port:      port,
+				Timeout:   5 * time.Second,
+				UserAgent: "test-client",
+			})
+
+			sources, err := client.GetSources()
+
+			if tt.expectedError {
+				if err == nil {
+					t.Error("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("Unexpected error: %v", err)
+			}
+
+			if sources == nil {
+				t.Fatal("Expected Sources response but got nil")
+			}
+
+			// Verify counts
+			if sources.GetSourceCount() != tt.expectedCount {
+				t.Errorf("Expected source count %d, got %d", tt.expectedCount, sources.GetSourceCount())
+			}
+
+			if sources.GetReadySourceCount() != tt.expectedReady {
+				t.Errorf("Expected ready source count %d, got %d", tt.expectedReady, sources.GetReadySourceCount())
+			}
+
+			// Verify specific sources
+			if sources.HasSpotify() != tt.hasSpotify {
+				t.Errorf("Expected HasSpotify() %v, got %v", tt.hasSpotify, sources.HasSpotify())
+			}
+
+			if sources.HasAux() != tt.hasAux {
+				t.Errorf("Expected HasAux() %v, got %v", tt.hasAux, sources.HasAux())
+			}
+
+			if sources.HasBluetooth() != tt.hasBluetooth {
+				t.Errorf("Expected HasBluetooth() %v, got %v", tt.hasBluetooth, sources.HasBluetooth())
+			}
+		})
+	}
+}
+
+func TestClient_GetSources_ServerError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	serverURL, _ := url.Parse(server.URL)
+	host := serverURL.Hostname()
+	port, _ := strconv.Atoi(serverURL.Port())
+
+	client := NewClient(ClientConfig{
+		Host:    host,
+		Port:    port,
+		Timeout: 5 * time.Second,
+	})
+
+	_, err := client.GetSources()
+
+	if err == nil {
+		t.Error("Expected error for server error response")
+	}
+
+	expectedErrorMsg := "failed to get sources"
+	if !strings.Contains(err.Error(), expectedErrorMsg) {
+		t.Errorf("Expected error message to contain '%s', got '%s'", expectedErrorMsg, err.Error())
+	}
+}
+
+func TestClient_GetSources_NetworkError(t *testing.T) {
+	client := NewClient(ClientConfig{
+		Host:    "non-existent-host.invalid",
+		Port:    8090,
+		Timeout: 1 * time.Second,
+	})
+
+	_, err := client.GetSources()
+
+	if err == nil {
+		t.Error("Expected error for network error")
+	}
+
+	expectedErrorMsg := "failed to get sources"
+	if !strings.Contains(err.Error(), expectedErrorMsg) {
+		t.Errorf("Expected error message to contain '%s', got '%s'", expectedErrorMsg, err.Error())
+	}
+}
+
+func TestClient_GetSources_InvalidXML(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/xml")
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("<invalid-xml>"))
+	}))
+	defer server.Close()
+
+	serverURL, _ := url.Parse(server.URL)
+	host := serverURL.Hostname()
+	port, _ := strconv.Atoi(serverURL.Port())
+
+	client := NewClient(ClientConfig{
+		Host:    host,
+		Port:    port,
+		Timeout: 5 * time.Second,
+	})
+
+	_, err := client.GetSources()
+
+	if err == nil {
+		t.Error("Expected error for invalid XML response")
+	}
+
+	expectedErrorMsg := "failed to get sources"
+	if !strings.Contains(err.Error(), expectedErrorMsg) {
+		t.Errorf("Expected error message to contain '%s', got '%s'", expectedErrorMsg, err.Error())
+	}
+}
+
 // Helper functions

 func loadTestData(t *testing.T, filename string) string {
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<nowPlaying deviceID="1234567890AB" source="STANDBY">
+    <ContentItem source="STANDBY" isPresetable="false" />
+</nowPlaying>
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<nowPlaying deviceID="A81B6A536A98" source="TUNEIN">
+    <ContentItem source="TUNEIN" type="stationurl" location="http://stream.example.com/radio" sourceAccount="" isPresetable="true">
+        <itemName>Classic Rock 101.5</itemName>
+        <containerArt>https://cdn-radiotime-logos.tunein.com/s123456q.png</containerArt>
+    </ContentItem>
+    <stationName>Classic Rock 101.5</stationName>
+    <description>The Best Classic Rock Hits</description>
+    <stationLocation>New York, NY</stationLocation>
+    <art artImageStatus="IMAGE_PRESENT">https://cdn-radiotime-logos.tunein.com/s123456q.png</art>
+    <playStatus>PLAY_STATE</playStatus>
+    <shuffleSetting>SHUFFLE_OFF</shuffleSetting>
+    <repeatSetting>REPEAT_OFF</repeatSetting>
+    <streamType>RADIO_STREAMING</streamType>
+</nowPlaying>
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<nowPlaying deviceID="A81B6A536A98" source="SPOTIFY" sourceAccount="user@example.com">
+    <ContentItem source="SPOTIFY" type="tracklisturl" location="/playback/container/c3BvdGlmeTphcnRpc3Q6NkF5QVRHZzdtRGdCbFo0TjV1Tm9nMA==" sourceAccount="user@example.com" isPresetable="true">
+        <itemName>SYML</itemName>
+        <containerArt>https://i.scdn.co/image/ab67616d0000b273ca6f00df62ef197fdc8af79c</containerArt>
+    </ContentItem>
+    <track>In Between Breaths - Paris Unplugged</track>
+    <artist>SYML</artist>
+    <album>Paris Unplugged</album>
+    <stationName></stationName>
+    <art artImageStatus="IMAGE_PRESENT">https://i.scdn.co/image/ab67616d0000b273ca6f00df62ef197fdc8af79c</art>
+    <time total="210">36</time>
+    <skipEnabled />
+    <favoriteEnabled />
+    <playStatus>PLAY_STATE</playStatus>
+    <shuffleSetting>SHUFFLE_OFF</shuffleSetting>
+    <repeatSetting>REPEAT_OFF</repeatSetting>
+    <skipPreviousEnabled />
+    <seekSupported value="true" />
+    <streamType>TRACK_ONDEMAND</streamType>
+    <trackID>spotify:track:3LX0dk3YT8cUgp7XxUJgTB</trackID>
+</nowPlaying>
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<sources deviceID="A81B6A536A98">
+    <sourceItem source="AUX" sourceAccount="AUX" status="READY" isLocal="true" multiroomallowed="true">AUX IN</sourceItem>
+    <sourceItem source="AIRPLAY" sourceAccount="AirPlayUserName" status="UNAVAILABLE" isLocal="false" multiroomallowed="false">AirPlayUserName</sourceItem>
+    <sourceItem source="QPLAY" sourceAccount="QPlay1UserName" status="UNAVAILABLE" isLocal="true" multiroomallowed="true">QPlay1UserName</sourceItem>
+    <sourceItem source="QPLAY" sourceAccount="QPlay2UserName" status="UNAVAILABLE" isLocal="true" multiroomallowed="true">QPlay2UserName</sourceItem>
+    <sourceItem source="STORED_MUSIC_MEDIA_RENDERER" sourceAccount="StoredMusicUserName" status="UNAVAILABLE" isLocal="false" multiroomallowed="true">StoredMusicUserName</sourceItem>
+    <sourceItem source="UPNP" sourceAccount="UPnPUserName" status="UNAVAILABLE" isLocal="false" multiroomallowed="true">UPnPUserName</sourceItem>
+    <sourceItem source="NOTIFICATION" status="UNAVAILABLE" isLocal="false" multiroomallowed="true" />
+    <sourceItem source="SPOTIFY" sourceAccount="user@example.com" status="READY" isLocal="false" multiroomallowed="true">user+spotify@example.com</sourceItem>
+    <sourceItem source="BLUETOOTH" status="UNAVAILABLE" isLocal="true" multiroomallowed="true" />
+    <sourceItem source="SPOTIFY" sourceAccount="SpotifyConnectUserName" status="UNAVAILABLE" isLocal="false" multiroomallowed="true">SpotifyConnectUserName</sourceItem>
+    <sourceItem source="SPOTIFY" sourceAccount="SpotifyAlexaUserName" status="UNAVAILABLE" isLocal="false" multiroomallowed="true">SpotifyAlexaUserName</sourceItem>
+    <sourceItem source="ALEXA" status="READY" isLocal="false" multiroomallowed="true" />
+    <sourceItem source="TUNEIN" status="READY" isLocal="false" multiroomallowed="true" />
+    <sourceItem source="LOCAL_INTERNET_RADIO" status="READY" isLocal="false" multiroomallowed="true" />
+</sources>
@@ -0,0 +1,352 @@
+package models
+
+import (
+	"encoding/xml"
+	"fmt"
+	"time"
+)
+
+// NowPlaying represents the current playback information from /now_playing endpoint
+type NowPlaying struct {
+	XMLName             xml.Name             `xml:"nowPlaying"`
+	DeviceID            string               `xml:"deviceID,attr"`
+	Source              string               `xml:"source,attr"`
+	SourceAccount       string               `xml:"sourceAccount,attr,omitempty"`
+	ContentItem         *ContentItem         `xml:"ContentItem,omitempty"`
+	Track               string               `xml:"track,omitempty"`
+	Artist              string               `xml:"artist,omitempty"`
+	Album               string               `xml:"album,omitempty"`
+	StationName         string               `xml:"stationName,omitempty"`
+	Art                 *Art                 `xml:"art,omitempty"`
+	Time                *Time                `xml:"time,omitempty"`
+	SkipEnabled         *SkipEnabled         `xml:"skipEnabled,omitempty"`
+	FavoriteEnabled     *FavoriteEnabled     `xml:"favoriteEnabled,omitempty"`
+	PlayStatus          PlayStatus           `xml:"playStatus,omitempty"`
+	ShuffleSetting      ShuffleSetting       `xml:"shuffleSetting,omitempty"`
+	RepeatSetting       RepeatSetting        `xml:"repeatSetting,omitempty"`
+	SkipPreviousEnabled *SkipPreviousEnabled `xml:"skipPreviousEnabled,omitempty"`
+	SeekSupported       *SeekSupported       `xml:"seekSupported,omitempty"`
+	StreamType          string               `xml:"streamType,omitempty"`
+	TrackID             string               `xml:"trackID,omitempty"`
+	Position            *Position            `xml:"position,omitempty"`
+	Description         string               `xml:"description,omitempty"`
+	StationLocation     string               `xml:"stationLocation,omitempty"`
+}
+
+// ContentItem represents metadata about the currently playing content
+type ContentItem struct {
+	Source        string `xml:"source,attr"`
+	Type          string `xml:"type,attr"`
+	Location      string `xml:"location,attr"`
+	SourceAccount string `xml:"sourceAccount,attr"`
+	IsPresetable  bool   `xml:"isPresetable,attr"`
+	ItemName      string `xml:"itemName,omitempty"`
+	ContainerArt  string `xml:"containerArt,omitempty"`
+}
+
+// Art represents album artwork information
+type Art struct {
+	ArtImageStatus string `xml:"artImageStatus,attr"`
+	URL            string `xml:",chardata"`
+}
+
+// Time represents playback time information with total duration and current position
+type Time struct {
+	Total    int `xml:"total,attr"` // Total duration in seconds
+	Position int `xml:",chardata"`  // Current position in seconds
+}
+
+// SkipEnabled indicates if skip functionality is enabled
+type SkipEnabled struct{}
+
+// FavoriteEnabled indicates if favorite functionality is enabled
+type FavoriteEnabled struct{}
+
+// SkipPreviousEnabled indicates if skip previous functionality is enabled
+type SkipPreviousEnabled struct{}
+
+// SeekSupported indicates if seek functionality is supported
+type SeekSupported struct {
+	Value bool `xml:"value,attr"`
+}
+
+// Position represents playback position information (legacy field)
+type Position struct {
+	Position int `xml:",chardata"` // Position in seconds
+}
+
+// PlayStatus represents the current playback state
+type PlayStatus string
+
+const (
+	PlayStatusPlaying     PlayStatus = "PLAY_STATE"
+	PlayStatusPaused      PlayStatus = "PAUSE_STATE"
+	PlayStatusStopped     PlayStatus = "STOP_STATE"
+	PlayStatusBuffering   PlayStatus = "BUFFERING_STATE"
+	PlayStatusInvalidPlay PlayStatus = "INVALID_PLAY_STATE"
+	PlayStatusStandby     PlayStatus = "STANDBY"
+)
+
+// IsPlaying returns true if the device is currently playing
+func (ps PlayStatus) IsPlaying() bool {
+	return ps == PlayStatusPlaying
+}
+
+// IsPaused returns true if the device is paused
+func (ps PlayStatus) IsPaused() bool {
+	return ps == PlayStatusPaused
+}
+
+// IsStopped returns true if the device is stopped
+func (ps PlayStatus) IsStopped() bool {
+	return ps == PlayStatusStopped
+}
+
+// String returns a human-readable string representation
+func (ps PlayStatus) String() string {
+	switch ps {
+	case PlayStatusPlaying:
+		return "Playing"
+	case PlayStatusPaused:
+		return "Paused"
+	case PlayStatusStopped:
+		return "Stopped"
+	case PlayStatusBuffering:
+		return "Buffering"
+	case PlayStatusInvalidPlay:
+		return "Invalid"
+	default:
+		return "Unknown"
+	}
+}
+
+// UnmarshalXML implements custom XML unmarshaling with validation
+func (ps *PlayStatus) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	var s string
+	if err := d.DecodeElement(&s, &start); err != nil {
+		return err
+	}
+
+	switch s {
+	case string(PlayStatusPlaying), string(PlayStatusPaused), string(PlayStatusStopped),
+		string(PlayStatusBuffering), string(PlayStatusInvalidPlay):
+		*ps = PlayStatus(s)
+	default:
+		*ps = PlayStatusStopped // Default fallback for unknown states
+	}
+	return nil
+}
+
+// ShuffleSetting represents shuffle mode state
+type ShuffleSetting string
+
+const (
+	ShuffleOff ShuffleSetting = "SHUFFLE_OFF"
+	ShuffleOn  ShuffleSetting = "SHUFFLE_ON"
+)
+
+// IsEnabled returns true if shuffle is enabled
+func (ss ShuffleSetting) IsEnabled() bool {
+	return ss == ShuffleOn
+}
+
+// String returns a human-readable string representation
+func (ss ShuffleSetting) String() string {
+	switch ss {
+	case ShuffleOn:
+		return "On"
+	case ShuffleOff:
+		return "Off"
+	default:
+		return "Unknown"
+	}
+}
+
+// UnmarshalXML implements custom XML unmarshaling
+func (ss *ShuffleSetting) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	var s string
+	if err := d.DecodeElement(&s, &start); err != nil {
+		return err
+	}
+
+	switch s {
+	case string(ShuffleOn), string(ShuffleOff):
+		*ss = ShuffleSetting(s)
+	default:
+		*ss = ShuffleOff // Default fallback
+	}
+	return nil
+}
+
+// RepeatSetting represents repeat mode state
+type RepeatSetting string
+
+const (
+	RepeatOff RepeatSetting = "REPEAT_OFF"
+	RepeatOne RepeatSetting = "REPEAT_ONE"
+	RepeatAll RepeatSetting = "REPEAT_ALL"
+)
+
+// IsEnabled returns true if any repeat mode is enabled
+func (rs RepeatSetting) IsEnabled() bool {
+	return rs != RepeatOff
+}
+
+// String returns a human-readable string representation
+func (rs RepeatSetting) String() string {
+	switch rs {
+	case RepeatOff:
+		return "Off"
+	case RepeatOne:
+		return "One"
+	case RepeatAll:
+		return "All"
+	default:
+		return "Unknown"
+	}
+}
+
+// UnmarshalXML implements custom XML unmarshaling
+func (rs *RepeatSetting) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	var s string
+	if err := d.DecodeElement(&s, &start); err != nil {
+		return err
+	}
+
+	switch s {
+	case string(RepeatOff), string(RepeatOne), string(RepeatAll):
+		*rs = RepeatSetting(s)
+	default:
+		*rs = RepeatOff // Default fallback
+	}
+	return nil
+}
+
+// IsEmpty returns true if no content is currently playing
+func (np *NowPlaying) IsEmpty() bool {
+	return np.Track == "" && np.Artist == "" && np.Album == "" && np.StationName == ""
+}
+
+// HasTrackInfo returns true if the playing content has track metadata
+func (np *NowPlaying) HasTrackInfo() bool {
+	return np.Track != "" || np.Artist != "" || np.Album != ""
+}
+
+// IsRadio returns true if the current source appears to be radio/streaming
+func (np *NowPlaying) IsRadio() bool {
+	return np.StationName != "" ||
+		np.Source == "TUNEIN" ||
+		np.Source == "IHEARTRADIO" ||
+		np.Source == "PANDORA"
+}
+
+// GetDisplayTitle returns the best available title for display
+func (np *NowPlaying) GetDisplayTitle() string {
+	if np.Track != "" {
+		return np.Track
+	}
+	if np.StationName != "" {
+		return np.StationName
+	}
+	if np.ContentItem != nil && np.ContentItem.ItemName != "" {
+		return np.ContentItem.ItemName
+	}
+	return "Unknown"
+}
+
+// GetDisplayArtist returns the best available artist for display
+func (np *NowPlaying) GetDisplayArtist() string {
+	if np.Artist != "" {
+		return np.Artist
+	}
+	if np.Description != "" {
+		return np.Description
+	}
+	return ""
+}
+
+// GetArtworkURL returns the artwork URL if available
+func (np *NowPlaying) GetArtworkURL() string {
+	if np.Art != nil && np.Art.URL != "" {
+		return np.Art.URL
+	}
+	if np.ContentItem != nil && np.ContentItem.ContainerArt != "" {
+		return np.ContentItem.ContainerArt
+	}
+	return ""
+}
+
+// GetPositionDuration returns position as a time.Duration
+func (np *NowPlaying) GetPositionDuration() time.Duration {
+	if np.Time != nil {
+		return time.Duration(np.Time.Position) * time.Second
+	}
+	if np.Position != nil {
+		return time.Duration(np.Position.Position) * time.Second
+	}
+	return 0
+}
+
+// GetTotalDuration returns total duration as a time.Duration
+func (np *NowPlaying) GetTotalDuration() time.Duration {
+	if np.Time != nil {
+		return time.Duration(np.Time.Total) * time.Second
+	}
+	return 0
+}
+
+// FormatPosition returns a formatted position string (MM:SS)
+func (np *NowPlaying) FormatPosition() string {
+	if np.Time == nil && np.Position == nil {
+		return ""
+	}
+
+	duration := np.GetPositionDuration()
+	minutes := int(duration.Minutes())
+	seconds := int(duration.Seconds()) % 60
+
+	return fmt.Sprintf("%d:%02d", minutes, seconds)
+}
+
+// FormatDuration returns a formatted duration string (MM:SS) including total time
+func (np *NowPlaying) FormatDuration() string {
+	position := np.FormatPosition()
+	if position == "" {
+		return ""
+	}
+
+	totalDuration := np.GetTotalDuration()
+	if totalDuration == 0 {
+		return position
+	}
+
+	totalMinutes := int(totalDuration.Minutes())
+	totalSeconds := int(totalDuration.Seconds()) % 60
+
+	return fmt.Sprintf("%s / %d:%02d", position, totalMinutes, totalSeconds)
+}
+
+// HasTimeInfo returns true if time/duration information is available
+func (np *NowPlaying) HasTimeInfo() bool {
+	return np.Time != nil || np.Position != nil
+}
+
+// IsSeekSupported returns true if seeking is supported
+func (np *NowPlaying) IsSeekSupported() bool {
+	return np.SeekSupported != nil && np.SeekSupported.Value
+}
+
+// CanSkip returns true if skip functionality is available
+func (np *NowPlaying) CanSkip() bool {
+	return np.SkipEnabled != nil
+}
+
+// CanSkipPrevious returns true if skip previous functionality is available
+func (np *NowPlaying) CanSkipPrevious() bool {
+	return np.SkipPreviousEnabled != nil
+}
+
+// CanFavorite returns true if favorite functionality is available
+func (np *NowPlaying) CanFavorite() bool {
+	return np.FavoriteEnabled != nil
+}
@@ -0,0 +1,525 @@
+package models
+
+import (
+	"encoding/xml"
+	"testing"
+	"time"
+)
+
+func TestPlayStatus_UnmarshalXML(t *testing.T) {
+	tests := []struct {
+		name     string
+		xmlInput string
+		expected PlayStatus
+	}{
+		{
+			name:     "playing state",
+			xmlInput: `<playStatus>PLAY_STATE</playStatus>`,
+			expected: PlayStatusPlaying,
+		},
+		{
+			name:     "paused state",
+			xmlInput: `<playStatus>PAUSE_STATE</playStatus>`,
+			expected: PlayStatusPaused,
+		},
+		{
+			name:     "stopped state",
+			xmlInput: `<playStatus>STOP_STATE</playStatus>`,
+			expected: PlayStatusStopped,
+		},
+		{
+			name:     "buffering state",
+			xmlInput: `<playStatus>BUFFERING_STATE</playStatus>`,
+			expected: PlayStatusBuffering,
+		},
+		{
+			name:     "unknown state defaults to stopped",
+			xmlInput: `<playStatus>UNKNOWN_STATE</playStatus>`,
+			expected: PlayStatusStopped,
+		},
+		{
+			name:     "empty state defaults to stopped",
+			xmlInput: `<playStatus></playStatus>`,
+			expected: PlayStatusStopped,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var status PlayStatus
+
+			err := xml.Unmarshal([]byte(tt.xmlInput), &status)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal XML: %v", err)
+			}
+
+			if status != tt.expected {
+				t.Errorf("Expected %s, got %s", tt.expected, status)
+			}
+		})
+	}
+}
+
+func TestPlayStatus_Methods(t *testing.T) {
+	tests := []struct {
+		status    PlayStatus
+		isPlaying bool
+		isPaused  bool
+		isStopped bool
+		toString  string
+	}{
+		{PlayStatusPlaying, true, false, false, "Playing"},
+		{PlayStatusPaused, false, true, false, "Paused"},
+		{PlayStatusStopped, false, false, true, "Stopped"},
+		{PlayStatusBuffering, false, false, false, "Buffering"},
+		{PlayStatusInvalidPlay, false, false, false, "Invalid"},
+		{PlayStatus("UNKNOWN"), false, false, false, "Unknown"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.toString, func(t *testing.T) {
+			if tt.status.IsPlaying() != tt.isPlaying {
+				t.Errorf("IsPlaying() = %v, want %v", tt.status.IsPlaying(), tt.isPlaying)
+			}
+			if tt.status.IsPaused() != tt.isPaused {
+				t.Errorf("IsPaused() = %v, want %v", tt.status.IsPaused(), tt.isPaused)
+			}
+			if tt.status.IsStopped() != tt.isStopped {
+				t.Errorf("IsStopped() = %v, want %v", tt.status.IsStopped(), tt.isStopped)
+			}
+			if tt.status.String() != tt.toString {
+				t.Errorf("String() = %v, want %v", tt.status.String(), tt.toString)
+			}
+		})
+	}
+}
+
+func TestShuffleSetting_UnmarshalXML(t *testing.T) {
+	tests := []struct {
+		name     string
+		xmlInput string
+		expected ShuffleSetting
+	}{
+		{
+			name:     "shuffle on",
+			xmlInput: `<shuffleSetting>SHUFFLE_ON</shuffleSetting>`,
+			expected: ShuffleOn,
+		},
+		{
+			name:     "shuffle off",
+			xmlInput: `<shuffleSetting>SHUFFLE_OFF</shuffleSetting>`,
+			expected: ShuffleOff,
+		},
+		{
+			name:     "unknown state defaults to off",
+			xmlInput: `<shuffleSetting>UNKNOWN</shuffleSetting>`,
+			expected: ShuffleOff,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var setting ShuffleSetting
+
+			err := xml.Unmarshal([]byte(tt.xmlInput), &setting)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal XML: %v", err)
+			}
+
+			if setting != tt.expected {
+				t.Errorf("Expected %s, got %s", tt.expected, setting)
+			}
+		})
+	}
+}
+
+func TestRepeatSetting_UnmarshalXML(t *testing.T) {
+	tests := []struct {
+		name     string
+		xmlInput string
+		expected RepeatSetting
+	}{
+		{
+			name:     "repeat off",
+			xmlInput: `<repeatSetting>REPEAT_OFF</repeatSetting>`,
+			expected: RepeatOff,
+		},
+		{
+			name:     "repeat one",
+			xmlInput: `<repeatSetting>REPEAT_ONE</repeatSetting>`,
+			expected: RepeatOne,
+		},
+		{
+			name:     "repeat all",
+			xmlInput: `<repeatSetting>REPEAT_ALL</repeatSetting>`,
+			expected: RepeatAll,
+		},
+		{
+			name:     "unknown state defaults to off",
+			xmlInput: `<repeatSetting>UNKNOWN</repeatSetting>`,
+			expected: RepeatOff,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var setting RepeatSetting
+
+			err := xml.Unmarshal([]byte(tt.xmlInput), &setting)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal XML: %v", err)
+			}
+
+			if setting != tt.expected {
+				t.Errorf("Expected %s, got %s", tt.expected, setting)
+			}
+		})
+	}
+}
+
+func TestNowPlaying_UnmarshalXML(t *testing.T) {
+	xmlData := `<?xml version="1.0" encoding="UTF-8" ?>
+<nowPlaying deviceID="A81B6A536A98" source="SPOTIFY" sourceAccount="user@example.com">
+    <ContentItem source="SPOTIFY" type="tracklisturl" location="/playbook/container/abc123" sourceAccount="user@example.com" isPresetable="true">
+        <itemName>SYML</itemName>
+        <containerArt>https://i.scdn.co/image/ab67616d0000b273ca6f00df62ef197fdc8af79c</containerArt>
+    </ContentItem>
+    <track>In Between Breaths - Paris Unplugged</track>
+    <artist>SYML</artist>
+    <album>Paris Unplugged</album>
+    <art artImageStatus="IMAGE_PRESENT">https://i.scdn.co/image/ab67616d0000b273ca6f00df62ef197fdc8af79c</art>
+    <time total="210">36</time>
+    <skipEnabled />
+    <favoriteEnabled />
+    <playStatus>PLAY_STATE</playStatus>
+    <shuffleSetting>SHUFFLE_OFF</shuffleSetting>
+    <repeatSetting>REPEAT_OFF</repeatSetting>
+    <skipPreviousEnabled />
+    <seekSupported value="true" />
+    <streamType>TRACK_ONDEMAND</streamType>
+    <trackID>spotify:track:3LX0dk3YT8cUgp7XxUJgTB</trackID>
+</nowPlaying>`
+
+	var nowPlaying NowPlaying
+	err := xml.Unmarshal([]byte(xmlData), &nowPlaying)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal XML: %v", err)
+	}
+
+	// Test basic fields
+	if nowPlaying.DeviceID != "A81B6A536A98" {
+		t.Errorf("Expected DeviceID 'A81B6A536A98', got '%s'", nowPlaying.DeviceID)
+	}
+
+	if nowPlaying.Source != "SPOTIFY" {
+		t.Errorf("Expected Source 'SPOTIFY', got '%s'", nowPlaying.Source)
+	}
+
+	if nowPlaying.Track != "In Between Breaths - Paris Unplugged" {
+		t.Errorf("Expected Track 'In Between Breaths - Paris Unplugged', got '%s'", nowPlaying.Track)
+	}
+
+	if nowPlaying.Artist != "SYML" {
+		t.Errorf("Expected Artist 'SYML', got '%s'", nowPlaying.Artist)
+	}
+
+	if nowPlaying.Album != "Paris Unplugged" {
+		t.Errorf("Expected Album 'Paris Unplugged', got '%s'", nowPlaying.Album)
+	}
+
+	if nowPlaying.SourceAccount != "user@example.com" {
+		t.Errorf("Expected SourceAccount 'user@example.com', got '%s'", nowPlaying.SourceAccount)
+	}
+
+	if nowPlaying.PlayStatus != PlayStatusPlaying {
+		t.Errorf("Expected PlayStatus Playing, got %v", nowPlaying.PlayStatus)
+	}
+
+	if nowPlaying.ShuffleSetting != ShuffleOff {
+		t.Errorf("Expected ShuffleSetting Off, got %v", nowPlaying.ShuffleSetting)
+	}
+
+	if nowPlaying.RepeatSetting != RepeatOff {
+		t.Errorf("Expected RepeatSetting Off, got %v", nowPlaying.RepeatSetting)
+	}
+
+	// Test ContentItem
+	if nowPlaying.ContentItem == nil {
+		t.Fatal("Expected ContentItem to be present")
+	}
+
+	if nowPlaying.ContentItem.Source != "SPOTIFY" {
+		t.Errorf("Expected ContentItem.Source 'SPOTIFY', got '%s'", nowPlaying.ContentItem.Source)
+	}
+
+	if nowPlaying.ContentItem.ItemName != "SYML" {
+		t.Errorf("Expected ContentItem.ItemName 'SYML', got '%s'", nowPlaying.ContentItem.ItemName)
+	}
+
+	// Test Art
+	if nowPlaying.Art == nil {
+		t.Fatal("Expected Art to be present")
+	}
+
+	if nowPlaying.Art.ArtImageStatus != "IMAGE_PRESENT" {
+		t.Errorf("Expected Art.ArtImageStatus 'IMAGE_PRESENT', got '%s'", nowPlaying.Art.ArtImageStatus)
+	}
+
+	// Test Time
+	if nowPlaying.Time == nil {
+		t.Fatal("Expected Time to be present")
+	}
+
+	if nowPlaying.Time.Position != 36 {
+		t.Errorf("Expected Time.Position 36, got %d", nowPlaying.Time.Position)
+	}
+
+	if nowPlaying.Time.Total != 210 {
+		t.Errorf("Expected Time.Total 210, got %d", nowPlaying.Time.Total)
+	}
+
+	// Test TrackID
+	if nowPlaying.TrackID != "spotify:track:3LX0dk3YT8cUgp7XxUJgTB" {
+		t.Errorf("Expected TrackID 'spotify:track:3LX0dk3YT8cUgp7XxUJgTB', got '%s'", nowPlaying.TrackID)
+	}
+
+	// Test Capabilities
+	if nowPlaying.SkipEnabled == nil {
+		t.Error("Expected SkipEnabled to be present")
+	}
+
+	if nowPlaying.FavoriteEnabled == nil {
+		t.Error("Expected FavoriteEnabled to be present")
+	}
+
+	if nowPlaying.SkipPreviousEnabled == nil {
+		t.Error("Expected SkipPreviousEnabled to be present")
+	}
+
+	if nowPlaying.SeekSupported == nil {
+		t.Error("Expected SeekSupported to be present")
+	} else if !nowPlaying.SeekSupported.Value {
+		t.Error("Expected SeekSupported.Value to be true")
+	}
+}
+
+func TestNowPlaying_RadioStation(t *testing.T) {
+	xmlData := `<?xml version="1.0" encoding="UTF-8" ?>
+<nowPlaying deviceID="A81B6A536A98" source="TUNEIN">
+    <stationName>Classic Rock 101.5</stationName>
+    <description>The Best Classic Rock Hits</description>
+    <stationLocation>New York, NY</stationLocation>
+    <art artImageStatus="IMAGE_PRESENT">https://cdn-radiotime-logos.tunein.com/s123456q.png</art>
+    <playStatus>PLAY_STATE</playStatus>
+</nowPlaying>`
+
+	var nowPlaying NowPlaying
+	err := xml.Unmarshal([]byte(xmlData), &nowPlaying)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal XML: %v", err)
+	}
+
+	if !nowPlaying.IsRadio() {
+		t.Error("Expected IsRadio() to return true for TUNEIN source")
+	}
+
+	if nowPlaying.StationName != "Classic Rock 101.5" {
+		t.Errorf("Expected StationName 'Classic Rock 101.5', got '%s'", nowPlaying.StationName)
+	}
+
+	if nowPlaying.Description != "The Best Classic Rock Hits" {
+		t.Errorf("Expected Description 'The Best Classic Rock Hits', got '%s'", nowPlaying.Description)
+	}
+
+	if nowPlaying.StationLocation != "New York, NY" {
+		t.Errorf("Expected StationLocation 'New York, NY', got '%s'", nowPlaying.StationLocation)
+	}
+}
+
+func TestNowPlaying_EmptyState(t *testing.T) {
+	xmlData := `<?xml version="1.0" encoding="UTF-8" ?>
+<nowPlaying deviceID="A81B6A536A98" source="">
+    <playStatus>STOP_STATE</playStatus>
+</nowPlaying>`
+
+	var nowPlaying NowPlaying
+	err := xml.Unmarshal([]byte(xmlData), &nowPlaying)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal XML: %v", err)
+	}
+
+	if !nowPlaying.IsEmpty() {
+		t.Error("Expected IsEmpty() to return true for empty state")
+	}
+
+	if nowPlaying.HasTrackInfo() {
+		t.Error("Expected HasTrackInfo() to return false for empty state")
+	}
+
+	if nowPlaying.PlayStatus != PlayStatusStopped {
+		t.Errorf("Expected PlayStatus Stopped, got %v", nowPlaying.PlayStatus)
+	}
+}
+
+func TestNowPlaying_HelperMethods(t *testing.T) {
+	// Test with track info
+	nowPlaying := NowPlaying{
+		Track:    "Test Track",
+		Artist:   "Test Artist",
+		Album:    "Test Album",
+		Position: &Position{Position: 125},
+	}
+
+	if nowPlaying.GetDisplayTitle() != "Test Track" {
+		t.Errorf("Expected GetDisplayTitle() 'Test Track', got '%s'", nowPlaying.GetDisplayTitle())
+	}
+
+	if nowPlaying.GetDisplayArtist() != "Test Artist" {
+		t.Errorf("Expected GetDisplayArtist() 'Test Artist', got '%s'", nowPlaying.GetDisplayArtist())
+	}
+
+	if !nowPlaying.HasTrackInfo() {
+		t.Error("Expected HasTrackInfo() to return true")
+	}
+
+	if nowPlaying.IsEmpty() {
+		t.Error("Expected IsEmpty() to return false")
+	}
+
+	// Test position formatting
+	expectedPosition := "2:05"
+	if nowPlaying.FormatPosition() != expectedPosition {
+		t.Errorf("Expected FormatPosition() '%s', got '%s'", expectedPosition, nowPlaying.FormatPosition())
+	}
+
+	// Test position duration
+	expectedDuration := 125 * time.Second
+	if nowPlaying.GetPositionDuration() != expectedDuration {
+		t.Errorf("Expected GetPositionDuration() %v, got %v", expectedDuration, nowPlaying.GetPositionDuration())
+	}
+
+	// Test with station name but no track
+	radioNowPlaying := NowPlaying{
+		StationName: "Test Station",
+		Source:      "TUNEIN",
+	}
+
+	if radioNowPlaying.GetDisplayTitle() != "Test Station" {
+		t.Errorf("Expected GetDisplayTitle() 'Test Station', got '%s'", radioNowPlaying.GetDisplayTitle())
+	}
+
+	if !radioNowPlaying.IsRadio() {
+		t.Error("Expected IsRadio() to return true for TUNEIN source")
+	}
+
+	// Test with ContentItem fallback
+	contentNowPlaying := NowPlaying{
+		ContentItem: &ContentItem{ItemName: "Content Item Name"},
+	}
+
+	if contentNowPlaying.GetDisplayTitle() != "Content Item Name" {
+		t.Errorf("Expected GetDisplayTitle() 'Content Item Name', got '%s'", contentNowPlaying.GetDisplayTitle())
+	}
+
+	// Test artwork URL
+	artNowPlaying := NowPlaying{
+		Art: &Art{URL: "https://example.com/art.jpg"},
+	}
+
+	if artNowPlaying.GetArtworkURL() != "https://example.com/art.jpg" {
+		t.Errorf("Expected GetArtworkURL() 'https://example.com/art.jpg', got '%s'", artNowPlaying.GetArtworkURL())
+	}
+
+	// Test ContentItem artwork fallback
+	contentArtNowPlaying := NowPlaying{
+		ContentItem: &ContentItem{ContainerArt: "https://example.com/container.jpg"},
+	}
+
+	if contentArtNowPlaying.GetArtworkURL() != "https://example.com/container.jpg" {
+		t.Errorf("Expected GetArtworkURL() 'https://example.com/container.jpg', got '%s'", contentArtNowPlaying.GetArtworkURL())
+	}
+}
+
+func TestNowPlaying_EdgeCases(t *testing.T) {
+	// Test with nil time and position
+	nowPlaying := NowPlaying{}
+
+	if nowPlaying.FormatPosition() != "" {
+		t.Errorf("Expected FormatPosition() to return empty string for nil time/position, got '%s'", nowPlaying.FormatPosition())
+	}
+
+	if nowPlaying.GetPositionDuration() != 0 {
+		t.Errorf("Expected GetPositionDuration() to return 0 for nil time/position, got %v", nowPlaying.GetPositionDuration())
+	}
+
+	if nowPlaying.GetTotalDuration() != 0 {
+		t.Errorf("Expected GetTotalDuration() to return 0 for nil time, got %v", nowPlaying.GetTotalDuration())
+	}
+
+	// Test fallback to "Unknown" title
+	emptyNowPlaying := NowPlaying{}
+	if emptyNowPlaying.GetDisplayTitle() != "Unknown" {
+		t.Errorf("Expected GetDisplayTitle() 'Unknown' for empty NowPlaying, got '%s'", emptyNowPlaying.GetDisplayTitle())
+	}
+
+	// Test description fallback for artist
+	descNowPlaying := NowPlaying{
+		Description: "Test Description",
+	}
+
+	if descNowPlaying.GetDisplayArtist() != "Test Description" {
+		t.Errorf("Expected GetDisplayArtist() 'Test Description', got '%s'", descNowPlaying.GetDisplayArtist())
+	}
+}
+
+func TestNowPlaying_NewFields(t *testing.T) {
+	// Test Time field
+	nowPlaying := NowPlaying{
+		Time: &Time{
+			Total:    180,
+			Position: 65,
+		},
+	}
+
+	if !nowPlaying.HasTimeInfo() {
+		t.Error("Expected HasTimeInfo() to return true for Time field")
+	}
+
+	expectedDuration := "1:05 / 3:00"
+	if nowPlaying.FormatDuration() != expectedDuration {
+		t.Errorf("Expected FormatDuration() '%s', got '%s'", expectedDuration, nowPlaying.FormatDuration())
+	}
+
+	// Test capabilities
+	capableNowPlaying := NowPlaying{
+		SkipEnabled:         &SkipEnabled{},
+		FavoriteEnabled:     &FavoriteEnabled{},
+		SkipPreviousEnabled: &SkipPreviousEnabled{},
+		SeekSupported:       &SeekSupported{Value: true},
+	}
+
+	if !capableNowPlaying.CanSkip() {
+		t.Error("Expected CanSkip() to return true")
+	}
+
+	if !capableNowPlaying.CanFavorite() {
+		t.Error("Expected CanFavorite() to return true")
+	}
+
+	if !capableNowPlaying.CanSkipPrevious() {
+		t.Error("Expected CanSkipPrevious() to return true")
+	}
+
+	if !capableNowPlaying.IsSeekSupported() {
+		t.Error("Expected IsSeekSupported() to return true")
+	}
+
+	// Test seek not supported
+	noSeekNowPlaying := NowPlaying{
+		SeekSupported: &SeekSupported{Value: false},
+	}
+
+	if noSeekNowPlaying.IsSeekSupported() {
+		t.Error("Expected IsSeekSupported() to return false")
+	}
+}
@@ -0,0 +1,226 @@
+package models
+
+import (
+	"encoding/xml"
+	"strings"
+)
+
+// Sources represents the response from /sources endpoint
+type Sources struct {
+	XMLName    xml.Name     `xml:"sources"`
+	DeviceID   string       `xml:"deviceID,attr"`
+	SourceItem []SourceItem `xml:"sourceItem"`
+}
+
+// SourceItem represents an individual audio source
+type SourceItem struct {
+	Source           string       `xml:"source,attr"`
+	SourceAccount    string       `xml:"sourceAccount,attr,omitempty"`
+	Status           SourceStatus `xml:"status,attr"`
+	IsLocal          bool         `xml:"isLocal,attr"`
+	MultiroomAllowed bool         `xml:"multiroomallowed,attr"`
+	DisplayName      string       `xml:",chardata"`
+}
+
+// SourceStatus represents the availability status of a source
+type SourceStatus string
+
+const (
+	SourceStatusReady       SourceStatus = "READY"
+	SourceStatusUnavailable SourceStatus = "UNAVAILABLE"
+	SourceStatusError       SourceStatus = "ERROR"
+)
+
+// IsReady returns true if the source is ready for use
+func (ss SourceStatus) IsReady() bool {
+	return ss == SourceStatusReady
+}
+
+// IsUnavailable returns true if the source is unavailable
+func (ss SourceStatus) IsUnavailable() bool {
+	return ss == SourceStatusUnavailable
+}
+
+// String returns a human-readable string representation
+func (ss SourceStatus) String() string {
+	switch ss {
+	case SourceStatusReady:
+		return "Ready"
+	case SourceStatusUnavailable:
+		return "Unavailable"
+	case SourceStatusError:
+		return "Error"
+	default:
+		return "Unknown"
+	}
+}
+
+// UnmarshalXML implements custom XML unmarshaling with validation
+func (ss *SourceStatus) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	var s string
+	if err := d.DecodeElement(&s, &start); err != nil {
+		return err
+	}
+
+	switch s {
+	case string(SourceStatusReady), string(SourceStatusUnavailable), string(SourceStatusError):
+		*ss = SourceStatus(s)
+	default:
+		*ss = SourceStatusUnavailable // Default fallback for unknown states
+	}
+	return nil
+}
+
+// GetDisplayName returns the best available display name for the source
+func (si *SourceItem) GetDisplayName() string {
+	if si.DisplayName != "" {
+		return si.DisplayName
+	}
+	if si.SourceAccount != "" && si.SourceAccount != si.Source {
+		return si.SourceAccount
+	}
+	return strings.Title(strings.ToLower(si.Source))
+}
+
+// IsSpotify returns true if this is a Spotify source
+func (si *SourceItem) IsSpotify() bool {
+	return si.Source == "SPOTIFY"
+}
+
+// IsBluetoothSource returns true if this is a Bluetooth source
+func (si *SourceItem) IsBluetoothSource() bool {
+	return si.Source == "BLUETOOTH"
+}
+
+// IsAuxSource returns true if this is an AUX input source
+func (si *SourceItem) IsAuxSource() bool {
+	return si.Source == "AUX"
+}
+
+// IsStreamingService returns true if this is an online streaming service
+func (si *SourceItem) IsStreamingService() bool {
+	streamingSources := []string{"SPOTIFY", "PANDORA", "TUNEIN", "IHEARTRADIO", "AMAZON", "LOCAL_INTERNET_RADIO"}
+	for _, source := range streamingSources {
+		if si.Source == source {
+			return true
+		}
+	}
+	return false
+}
+
+// IsLocalSource returns true if this is a local input source
+func (si *SourceItem) IsLocalSource() bool {
+	return si.IsLocal
+}
+
+// SupportsMultiroom returns true if this source supports multiroom playback
+func (si *SourceItem) SupportsMultiroom() bool {
+	return si.MultiroomAllowed
+}
+
+// GetAvailableSources returns only sources that are ready for use
+func (s *Sources) GetAvailableSources() []SourceItem {
+	var available []SourceItem
+	for _, source := range s.SourceItem {
+		if source.Status.IsReady() {
+			available = append(available, source)
+		}
+	}
+	return available
+}
+
+// GetSourcesByType returns sources filtered by source type
+func (s *Sources) GetSourcesByType(sourceType string) []SourceItem {
+	var filtered []SourceItem
+	for _, source := range s.SourceItem {
+		if source.Source == sourceType {
+			filtered = append(filtered, source)
+		}
+	}
+	return filtered
+}
+
+// GetSpotifySources returns all Spotify sources (there can be multiple accounts)
+func (s *Sources) GetSpotifySources() []SourceItem {
+	return s.GetSourcesByType("SPOTIFY")
+}
+
+// GetReadySpotifySources returns only ready Spotify sources
+func (s *Sources) GetReadySpotifySources() []SourceItem {
+	var ready []SourceItem
+	for _, source := range s.GetSpotifySources() {
+		if source.Status.IsReady() {
+			ready = append(ready, source)
+		}
+	}
+	return ready
+}
+
+// GetStreamingSources returns all streaming service sources
+func (s *Sources) GetStreamingSources() []SourceItem {
+	var streaming []SourceItem
+	for _, source := range s.SourceItem {
+		if source.IsStreamingService() {
+			streaming = append(streaming, source)
+		}
+	}
+	return streaming
+}
+
+// GetLocalSources returns all local input sources
+func (s *Sources) GetLocalSources() []SourceItem {
+	var local []SourceItem
+	for _, source := range s.SourceItem {
+		if source.IsLocalSource() {
+			local = append(local, source)
+		}
+	}
+	return local
+}
+
+// GetMultiroomSources returns sources that support multiroom playback
+func (s *Sources) GetMultiroomSources() []SourceItem {
+	var multiroom []SourceItem
+	for _, source := range s.SourceItem {
+		if source.SupportsMultiroom() {
+			multiroom = append(multiroom, source)
+		}
+	}
+	return multiroom
+}
+
+// HasSource returns true if the specified source type is available
+func (s *Sources) HasSource(sourceType string) bool {
+	sources := s.GetSourcesByType(sourceType)
+	for _, source := range sources {
+		if source.Status.IsReady() {
+			return true
+		}
+	}
+	return false
+}
+
+// HasSpotify returns true if any Spotify source is ready
+func (s *Sources) HasSpotify() bool {
+	return s.HasSource("SPOTIFY")
+}
+
+// HasBluetooth returns true if Bluetooth source is ready
+func (s *Sources) HasBluetooth() bool {
+	return s.HasSource("BLUETOOTH")
+}
+
+// HasAux returns true if AUX input is ready
+func (s *Sources) HasAux() bool {
+	return s.HasSource("AUX")
+}
+
+// GetSourceCount returns the total number of sources
+func (s *Sources) GetSourceCount() int {
+	return len(s.SourceItem)
+}
+
+// GetReadySourceCount returns the number of ready sources
+func (s *Sources) GetReadySourceCount() int {
+	return len(s.GetAvailableSources())
+}
@@ -0,0 +1,380 @@
+package models
+
+import (
+	"encoding/xml"
+	"testing"
+)
+
+func TestSourceStatus_UnmarshalXML(t *testing.T) {
+	tests := []struct {
+		name     string
+		xmlInput string
+		expected SourceStatus
+	}{
+		{
+			name:     "ready status",
+			xmlInput: `<status>READY</status>`,
+			expected: SourceStatusReady,
+		},
+		{
+			name:     "unavailable status",
+			xmlInput: `<status>UNAVAILABLE</status>`,
+			expected: SourceStatusUnavailable,
+		},
+		{
+			name:     "error status",
+			xmlInput: `<status>ERROR</status>`,
+			expected: SourceStatusError,
+		},
+		{
+			name:     "unknown status defaults to unavailable",
+			xmlInput: `<status>UNKNOWN_STATUS</status>`,
+			expected: SourceStatusUnavailable,
+		},
+		{
+			name:     "empty status defaults to unavailable",
+			xmlInput: `<status></status>`,
+			expected: SourceStatusUnavailable,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var status SourceStatus
+
+			err := xml.Unmarshal([]byte(tt.xmlInput), &status)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal XML: %v", err)
+			}
+
+			if status != tt.expected {
+				t.Errorf("Expected %s, got %s", tt.expected, status)
+			}
+		})
+	}
+}
+
+func TestSourceStatus_Methods(t *testing.T) {
+	tests := []struct {
+		status        SourceStatus
+		isReady       bool
+		isUnavailable bool
+		toString      string
+	}{
+		{SourceStatusReady, true, false, "Ready"},
+		{SourceStatusUnavailable, false, true, "Unavailable"},
+		{SourceStatusError, false, false, "Error"},
+		{SourceStatus("UNKNOWN"), false, false, "Unknown"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.toString, func(t *testing.T) {
+			if tt.status.IsReady() != tt.isReady {
+				t.Errorf("IsReady() = %v, want %v", tt.status.IsReady(), tt.isReady)
+			}
+			if tt.status.IsUnavailable() != tt.isUnavailable {
+				t.Errorf("IsUnavailable() = %v, want %v", tt.status.IsUnavailable(), tt.isUnavailable)
+			}
+			if tt.status.String() != tt.toString {
+				t.Errorf("String() = %v, want %v", tt.status.String(), tt.toString)
+			}
+		})
+	}
+}
+
+func TestSourceItem_Methods(t *testing.T) {
+	tests := []struct {
+		name                string
+		sourceItem          SourceItem
+		expectedDisplayName string
+		isSpotify           bool
+		isBluetooth         bool
+		isAux               bool
+		isStreaming         bool
+		isLocal             bool
+		supportsMultiroom   bool
+	}{
+		{
+			name: "spotify source with display name",
+			sourceItem: SourceItem{
+				Source:           "SPOTIFY",
+				SourceAccount:    "user@example.com",
+				Status:           SourceStatusReady,
+				IsLocal:          false,
+				MultiroomAllowed: true,
+				DisplayName:      "user+spotify@example.com",
+			},
+			expectedDisplayName: "user+spotify@example.com",
+			isSpotify:           true,
+			isBluetooth:         false,
+			isAux:               false,
+			isStreaming:         true,
+			isLocal:             false,
+			supportsMultiroom:   true,
+		},
+		{
+			name: "aux source",
+			sourceItem: SourceItem{
+				Source:           "AUX",
+				SourceAccount:    "AUX",
+				Status:           SourceStatusReady,
+				IsLocal:          true,
+				MultiroomAllowed: true,
+				DisplayName:      "AUX IN",
+			},
+			expectedDisplayName: "AUX IN",
+			isSpotify:           false,
+			isBluetooth:         false,
+			isAux:               true,
+			isStreaming:         false,
+			isLocal:             true,
+			supportsMultiroom:   true,
+		},
+		{
+			name: "bluetooth source without display name",
+			sourceItem: SourceItem{
+				Source:           "BLUETOOTH",
+				Status:           SourceStatusUnavailable,
+				IsLocal:          true,
+				MultiroomAllowed: true,
+			},
+			expectedDisplayName: "Bluetooth",
+			isSpotify:           false,
+			isBluetooth:         true,
+			isAux:               false,
+			isStreaming:         false,
+			isLocal:             true,
+			supportsMultiroom:   true,
+		},
+		{
+			name: "tunein streaming service",
+			sourceItem: SourceItem{
+				Source:           "TUNEIN",
+				Status:           SourceStatusReady,
+				IsLocal:          false,
+				MultiroomAllowed: true,
+			},
+			expectedDisplayName: "Tunein",
+			isSpotify:           false,
+			isBluetooth:         false,
+			isAux:               false,
+			isStreaming:         true,
+			isLocal:             false,
+			supportsMultiroom:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.sourceItem.GetDisplayName() != tt.expectedDisplayName {
+				t.Errorf("GetDisplayName() = %v, want %v", tt.sourceItem.GetDisplayName(), tt.expectedDisplayName)
+			}
+			if tt.sourceItem.IsSpotify() != tt.isSpotify {
+				t.Errorf("IsSpotify() = %v, want %v", tt.sourceItem.IsSpotify(), tt.isSpotify)
+			}
+			if tt.sourceItem.IsBluetoothSource() != tt.isBluetooth {
+				t.Errorf("IsBluetoothSource() = %v, want %v", tt.sourceItem.IsBluetoothSource(), tt.isBluetooth)
+			}
+			if tt.sourceItem.IsAuxSource() != tt.isAux {
+				t.Errorf("IsAuxSource() = %v, want %v", tt.sourceItem.IsAuxSource(), tt.isAux)
+			}
+			if tt.sourceItem.IsStreamingService() != tt.isStreaming {
+				t.Errorf("IsStreamingService() = %v, want %v", tt.sourceItem.IsStreamingService(), tt.isStreaming)
+			}
+			if tt.sourceItem.IsLocalSource() != tt.isLocal {
+				t.Errorf("IsLocalSource() = %v, want %v", tt.sourceItem.IsLocalSource(), tt.isLocal)
+			}
+			if tt.sourceItem.SupportsMultiroom() != tt.supportsMultiroom {
+				t.Errorf("SupportsMultiroom() = %v, want %v", tt.sourceItem.SupportsMultiroom(), tt.supportsMultiroom)
+			}
+		})
+	}
+}
+
+func TestSources_UnmarshalXML(t *testing.T) {
+	xmlData := `<?xml version="1.0" encoding="UTF-8" ?>
+<sources deviceID="A81B6A536A98">
+    <sourceItem source="AUX" sourceAccount="AUX" status="READY" isLocal="true" multiroomallowed="true">AUX IN</sourceItem>
+    <sourceItem source="SPOTIFY" sourceAccount="user@example.com" status="READY" isLocal="false" multiroomallowed="true">user+spotify@example.com</sourceItem>
+    <sourceItem source="BLUETOOTH" status="UNAVAILABLE" isLocal="true" multiroomallowed="true" />
+    <sourceItem source="TUNEIN" status="READY" isLocal="false" multiroomallowed="true" />
+</sources>`
+
+	var sources Sources
+	err := xml.Unmarshal([]byte(xmlData), &sources)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal XML: %v", err)
+	}
+
+	// Test basic fields
+	if sources.DeviceID != "A81B6A536A98" {
+		t.Errorf("Expected DeviceID 'A81B6A536A98', got '%s'", sources.DeviceID)
+	}
+
+	if len(sources.SourceItem) != 4 {
+		t.Errorf("Expected 4 source items, got %d", len(sources.SourceItem))
+	}
+
+	// Test first source item (AUX)
+	auxSource := sources.SourceItem[0]
+	if auxSource.Source != "AUX" {
+		t.Errorf("Expected first source 'AUX', got '%s'", auxSource.Source)
+	}
+	if auxSource.Status != SourceStatusReady {
+		t.Errorf("Expected first source status Ready, got %v", auxSource.Status)
+	}
+	if !auxSource.IsLocal {
+		t.Error("Expected first source to be local")
+	}
+	if auxSource.DisplayName != "AUX IN" {
+		t.Errorf("Expected first source display name 'AUX IN', got '%s'", auxSource.DisplayName)
+	}
+
+	// Test Spotify source
+	spotifySource := sources.SourceItem[1]
+	if spotifySource.Source != "SPOTIFY" {
+		t.Errorf("Expected second source 'SPOTIFY', got '%s'", spotifySource.Source)
+	}
+	if spotifySource.SourceAccount != "user@example.com" {
+		t.Errorf("Expected Spotify source account 'user@example.com', got '%s'", spotifySource.SourceAccount)
+	}
+}
+
+func TestSources_FilterMethods(t *testing.T) {
+	sources := Sources{
+		DeviceID: "TEST123",
+		SourceItem: []SourceItem{
+			{Source: "AUX", Status: SourceStatusReady, IsLocal: true, MultiroomAllowed: true},
+			{Source: "SPOTIFY", SourceAccount: "user1", Status: SourceStatusReady, IsLocal: false, MultiroomAllowed: true},
+			{Source: "SPOTIFY", SourceAccount: "user2", Status: SourceStatusUnavailable, IsLocal: false, MultiroomAllowed: true},
+			{Source: "BLUETOOTH", Status: SourceStatusUnavailable, IsLocal: true, MultiroomAllowed: true},
+			{Source: "TUNEIN", Status: SourceStatusReady, IsLocal: false, MultiroomAllowed: true},
+		},
+	}
+
+	// Test GetAvailableSources
+	available := sources.GetAvailableSources()
+	if len(available) != 3 {
+		t.Errorf("Expected 3 available sources, got %d", len(available))
+	}
+
+	// Test GetSpotifySources
+	spotifySources := sources.GetSpotifySources()
+	if len(spotifySources) != 2 {
+		t.Errorf("Expected 2 Spotify sources, got %d", len(spotifySources))
+	}
+
+	// Test GetReadySpotifySources
+	readySpotify := sources.GetReadySpotifySources()
+	if len(readySpotify) != 1 {
+		t.Errorf("Expected 1 ready Spotify source, got %d", len(readySpotify))
+	}
+
+	// Test GetStreamingSources
+	streaming := sources.GetStreamingSources()
+	if len(streaming) != 3 { // SPOTIFY (2) + TUNEIN (1)
+		t.Errorf("Expected 3 streaming sources, got %d", len(streaming))
+	}
+
+	// Test GetLocalSources
+	local := sources.GetLocalSources()
+	if len(local) != 2 { // AUX + BLUETOOTH
+		t.Errorf("Expected 2 local sources, got %d", len(local))
+	}
+
+	// Test GetMultiroomSources
+	multiroom := sources.GetMultiroomSources()
+	if len(multiroom) != 5 { // All sources support multiroom in this test
+		t.Errorf("Expected 5 multiroom sources, got %d", len(multiroom))
+	}
+
+	// Test HasSource methods
+	if !sources.HasSpotify() {
+		t.Error("Expected HasSpotify() to return true")
+	}
+
+	if sources.HasBluetooth() {
+		t.Error("Expected HasBluetooth() to return false (unavailable)")
+	}
+
+	if !sources.HasAux() {
+		t.Error("Expected HasAux() to return true")
+	}
+
+	// Test count methods
+	if sources.GetSourceCount() != 5 {
+		t.Errorf("Expected total source count 5, got %d", sources.GetSourceCount())
+	}
+
+	if sources.GetReadySourceCount() != 3 {
+		t.Errorf("Expected ready source count 3, got %d", sources.GetReadySourceCount())
+	}
+}
+
+func TestSources_EmptyResponse(t *testing.T) {
+	sources := Sources{
+		DeviceID:   "EMPTY123",
+		SourceItem: []SourceItem{},
+	}
+
+	// Test empty sources
+	if len(sources.GetAvailableSources()) != 0 {
+		t.Error("Expected no available sources for empty response")
+	}
+
+	if sources.HasSpotify() {
+		t.Error("Expected HasSpotify() to return false for empty response")
+	}
+
+	if sources.GetSourceCount() != 0 {
+		t.Errorf("Expected source count 0 for empty response, got %d", sources.GetSourceCount())
+	}
+}
+
+func TestSourceItem_GetDisplayName_EdgeCases(t *testing.T) {
+	tests := []struct {
+		name         string
+		sourceItem   SourceItem
+		expectedName string
+	}{
+		{
+			name: "with display name",
+			sourceItem: SourceItem{
+				Source:      "SPOTIFY",
+				DisplayName: "My Spotify",
+			},
+			expectedName: "My Spotify",
+		},
+		{
+			name: "with source account different from source",
+			sourceItem: SourceItem{
+				Source:        "SPOTIFY",
+				SourceAccount: "user@example.com",
+			},
+			expectedName: "user@example.com",
+		},
+		{
+			name: "with source account same as source",
+			sourceItem: SourceItem{
+				Source:        "AUX",
+				SourceAccount: "AUX",
+			},
+			expectedName: "Aux",
+		},
+		{
+			name: "no display name or account",
+			sourceItem: SourceItem{
+				Source: "BLUETOOTH",
+			},
+			expectedName: "Bluetooth",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.sourceItem.GetDisplayName() != tt.expectedName {
+				t.Errorf("GetDisplayName() = %v, want %v", tt.sourceItem.GetDisplayName(), tt.expectedName)
+			}
+		})
+	}
+}