daemon

type ApiAddToQueue struct {
	// Uri The URI for the track that should be added
	Uri string `json:"uri"`
}

type ApiContextTrackItem struct {
	// Track Full track metadata, or null while the background sweep has not resolved this entry yet
	Track *ApiTrack `json:"track"`

	// Uri The track URI
	Uri string `json:"uri"`
}

type ApiContextTracks struct {
	// Cached Entries with full metadata; poll again while cached < length
	Cached int `json:"cached"`

	// Length Number of track entries
	Length int `json:"length"`

	// Ready False while the context is still being enumerated in the background; the listing is empty until it is true
	Ready  bool                  `json:"ready"`
	Tracks []ApiContextTrackItem `json:"tracks"`

	// Uri The context URI
	Uri string `json:"uri"`
}

type ApiDeviceAuth struct {
	// Code The code the user must enter at the URL, if prompted
	Code string `json:"code"`

	// ExpiresAt When the code stops being accepted
	ExpiresAt time.Time `json:"expires_at"`

	// Url The URL the user must visit to approve the request. It usually embeds the code already, in which case entering it is not needed.
	Url string `json:"url"`
}

type ApiEvent struct {
	Type ApiEventType `json:"type"`
	Data any          `json:"data"`
}

type ApiEventDataMetadata ApiTrack

type ApiEventDataNotPlaying struct {
	ContextUri string `json:"context_uri"`
	Uri        string `json:"uri"`
	PlayOrigin string `json:"play_origin"`
}

type ApiEventDataPaused struct {
	ContextUri string `json:"context_uri"`
	Uri        string `json:"uri"`
	PlayOrigin string `json:"play_origin"`
}

type ApiEventDataPlaybackError struct {
	ContextUri string `json:"context_uri"`
	Uri        string `json:"uri"`
	PlayOrigin string `json:"play_origin"`
	Stage      string `json:"stage"`
	Kind       string `json:"kind"`
	Unplayable bool   `json:"unplayable"`
	Message    string `json:"message"`
}

type ApiEventDataPlaying struct {
	ContextUri string `json:"context_uri"`
	Uri        string `json:"uri"`
	Resume     bool   `json:"resume"`
	PlayOrigin string `json:"play_origin"`
}

type ApiEventDataRepeatContext struct {
	Value bool `json:"value"`
}

type ApiEventDataRepeatTrack struct {
	Value bool `json:"value"`
}

type ApiEventDataSeek struct {
	ContextUri string `json:"context_uri"`
	Uri        string `json:"uri"`
	Position   int    `json:"position"`
	Duration   int    `json:"duration"`
	PlayOrigin string `json:"play_origin"`
}

type ApiEventDataShuffleContext struct {
	Value bool `json:"value"`
}

type ApiEventDataStopped struct {
	PlayOrigin string `json:"play_origin"`
}

type ApiEventDataVolume ApiVolume

type ApiEventDataWillPlay struct {
	ContextUri string `json:"context_uri"`
	Uri        string `json:"uri"`
	PlayOrigin string `json:"play_origin"`
}

type ApiEventType string

type ApiNext struct {
	// Uri The track URI to skip to. When omitted the next track in the context is played.
	Uri *string `json:"uri,omitempty"`
}

type ApiOutput struct {
	// Device The output device name to open (backend-specific, e.g. an ALSA device). Empty selects the configured default.
	Device string `json:"device,omitempty"`
}

type ApiPlay struct {
	// Paused Start playback as paused
	Paused bool `json:"paused,omitempty"`

	// Position Position in milliseconds to start playback at within the selected track (0 starts from the beginning)
	Position int64 `json:"position,omitempty"`

	// SkipToUri Spotify URI to skip to (when playing playlists)
	SkipToUri string `json:"skip_to_uri,omitempty"`

	// Uri Spotify URI to start playing
	Uri string `json:"uri"`
}

type ApiRepeatContext struct {
	// RepeatContext Whether repeating context should be enabled
	RepeatContext bool `json:"repeat_context"`
}

type ApiRepeatTrack struct {
	// RepeatTrack Whether repeating track should be enabled
	RepeatTrack bool `json:"repeat_track"`
}

type ApiRequest struct {
	Type ApiRequestType
	Data any
	// contains filtered or unexported fields
}

type ApiRequestDataContextTracks struct {
	Uri string
}

type ApiRequestType string

type ApiRoot struct {
	// PlaybackReady Whether the daemon is fully bootstrapped and ready to accept /player/play
	PlaybackReady bool `json:"playback_ready"`
}

type ApiSeek struct {
	// Position Seek position in milliseconds. Must not be negative unless relative is set.
	Position int64 `json:"position"`

	// Relative Whether the seek position is relative to the current one
	Relative bool `json:"relative,omitempty"`
}

type ApiServer interface {
	Emit(ev *ApiEvent)
	Receive() <-chan ApiRequest
	SetAuthCode(auth *ApiDeviceAuth)
	Close() error
}

type ApiSetDeviceName struct {
	// Name The new device name
	Name string `json:"name"`
}

type ApiSetVolume struct {
	// Relative Whether to change the volume relative to the current volume
	Relative bool `json:"relative,omitempty"`

	// Volume Volume from 0 to max. Must not be negative unless relative is set.
	Volume int32 `json:"volume"`
}

type ApiShuffleContext struct {
	// ShuffleContext Whether shuffling context should be enabled
	ShuffleContext bool `json:"shuffle_context"`
}

type ApiStatus struct {
	// Buffering Whether the player is buffering
	Buffering bool `json:"buffering"`

	// ContextName The display name of the context, for example the playlist or album name, null when there is no context or the resolver did not provide a description
	ContextName *string `json:"context_name"`

	// ContextUri The URI of the context playback is coming from, null when there is no context
	ContextUri *string `json:"context_uri"`

	// DeviceId The player device ID
	DeviceId string `json:"device_id"`

	// DeviceName The player device name
	DeviceName string `json:"device_name"`

	// DeviceType The player device type, for example COMPUTER or SPEAKER
	DeviceType string `json:"device_type"`

	// NextTrack The upcoming track when its metadata is cached (metadata.enabled), so clients can pre-warm its name and cover art before the user skips to it. Absent when unknown.
	NextTrack *ApiTrack `json:"next_track,omitempty"`

	// Paused Whether the player is paused
	Paused bool `json:"paused"`

	// PlayOrigin Who started the playback, "go-librespot" identifies the API as the play origin, everything else is Spotify own stuff, null when nothing has started playback yet
	PlayOrigin *string `json:"play_origin"`

	// PlayOriginDeviceId The device ID that sent the command starting the playback, null when the playback was started locally through this API
	PlayOriginDeviceId *string `json:"play_origin_device_id"`

	// RepeatContext Whether the repeat context feature is enabled
	RepeatContext bool `json:"repeat_context"`

	// RepeatTrack Whether the repeat track feature is enabled
	RepeatTrack bool `json:"repeat_track"`

	// ShuffleContext Whether the shuffle context feature is enabled
	ShuffleContext bool `json:"shuffle_context"`

	// Stopped Whether the player is stopped
	Stopped bool      `json:"stopped"`
	Track   *ApiTrack `json:"track"`

	// Username Currently active account's username
	Username string `json:"username"`

	// Volume The player current volume from 0 to max
	Volume uint32 `json:"volume"`

	// VolumeSteps The player max volume value
	VolumeSteps uint32 `json:"volume_steps"`
}

type ApiToken struct {
	// Token The access token
	Token string `json:"token"`
}

type ApiTrack struct {
	// AlbumCoverUrl Album cover URL
	AlbumCoverUrl *string `json:"album_cover_url"`

	// AlbumName Album name
	AlbumName string `json:"album_name"`

	// ArtistNames Artists name
	ArtistNames []string `json:"artist_names"`

	// BitDepth Bits per sample of the source audio, null for lossy formats which have no meaningful source bit depth
	BitDepth *int `json:"bit_depth"`

	// Bitrate Nominal bitrate in kbps, null for formats without a fixed one such as FLAC
	Bitrate *int `json:"bitrate"`

	// Codec Codec family of the audio file
	Codec TrackCodec `json:"codec"`

	// DiscNumber Disc number within the album, zero for episodes
	DiscNumber int `json:"disc_number"`

	// Duration Duration in milliseconds
	Duration int `json:"duration"`

	// Format Spotify name of the audio file being decoded, for example OGG_VORBIS_160
	Format string `json:"format"`

	// Name Name
	Name string `json:"name"`

	// Position Playback position in milliseconds
	Position int64 `json:"position"`

	// ReleaseDate Album release date, empty for episodes
	ReleaseDate string `json:"release_date"`

	// SampleRate Sample rate of the decoded audio in Hz
	SampleRate *int `json:"sample_rate"`

	// TrackNumber Track number within the disc, zero for episodes
	TrackNumber int `json:"track_number"`

	// Uri URI
	Uri string `json:"uri"`
}

type ApiVolume struct {
	// Max The max volume value
	Max uint32 `json:"max"`

	// Value The current volume, ranging from 0 to max
	Value uint32 `json:"value"`
}

type App struct {
	// contains filtered or unexported fields
}

type AppPlayer struct {
	// contains filtered or unexported fields
}

type CacheConfig struct {
	// Enabled turns the audio file cache on or off.
	Enabled bool
	// Dir is the directory the cache is stored in.
	Dir string
	// SizeLimit is the maximum total size of the cached audio files in bytes.
	// A value of zero disables eviction (unbounded cache).
	SizeLimit int64
}

type ConcreteApiServer struct {
	// contains filtered or unexported fields
}

type Config struct {
	DeviceId    string
	DeviceName  string
	DeviceType  string
	ClientToken string

	AudioBackend                 string
	AudioBackendRuntimeSocket    string
	AudioDevice                  string
	MixerDevice                  string
	MixerControlName             string
	AudioBufferTime              int
	AudioPeriodCount             int
	AudioOutputPipe              string
	AudioOutputPipeFormat        string
	AudioOutputPipeWaitForReader bool

	Bitrate                   int
	VolumeSteps               uint32
	InitialVolume             uint32
	IgnoreLastVolume          bool
	NormalisationDisabled     bool
	NormalisationUseAlbumGain bool
	NormalisationPregain      float32
	CrossfadeDuration         int
	ExternalVolume            bool
	DisableAutoplay           bool

	// SkipDebounce is how long a skip that follows another within this window
	// waits before loading the track it landed on, so that a burst of next or
	// prev presses costs one load rather than one per press. Zero loads every
	// skip immediately.
	SkipDebounce time.Duration

	ZeroconfEnabled               bool
	ZeroconfPort                  int
	ZeroconfBackend               string
	ZeroconfInterfacesToAdvertise []string

	FlacEnabled bool

	// PreferFirewallFriendlyPorts tries accesspoints on 443 and 80 before the
	// default 4070, which some networks block outbound.
	PreferFirewallFriendlyPorts bool

	// ImageSize selects which cover-art image variant the API server returns:
	// "default", "small", "medium", "large", "xlarge".
	ImageSize string

	Cache CacheConfig

	Metadata MetadataConfig

	Credentials CredentialsConfig
}

type CredentialsConfig struct {
	Type         string
	Interactive  InteractiveCredentials
	SpotifyToken SpotifyTokenCredentials
	Zeroconf     ZeroconfCredentials
}

type GetContextTracksParams struct {
	// Uri Spotify context URI (playlist, album, artist, show, collection)
	Uri string `form:"uri" json:"uri"`
}

type InteractiveCredentials struct {
	CallbackPort int
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type MetadataConfig struct {
	// Enabled turns on the metadata cache, the batched fetch of metadata for
	// the tracks around the playback position, and the /context/tracks
	// endpoint. Off, the daemon performs no metadata request playback does not
	// need.
	Enabled bool
	// ContextSweep additionally resolves metadata for the whole context when
	// one starts playing, so every track is known before the user skips
	// anywhere. Requires Enabled.
	ContextSweep bool
	// MaxTracks caps how many tracks of a context are enumerated and swept.
	MaxTracks int
}

type MiddlewareFunc func(http.Handler) http.Handler

type Options struct {
	Logger     librespot.Logger
	Config     *Config
	StateStore librespot.StateStore

	APIServer   ApiServer
	MediaPlayer mpris.Server
}

type PlayerAddToQueueJSONRequestBody = ApiAddToQueue

type PlayerNextJSONRequestBody = ApiNext

type PlayerOutputJSONRequestBody = ApiOutput

type PlayerPlayJSONRequestBody = ApiPlay

type PlayerRepeatContextJSONRequestBody = ApiRepeatContext

type PlayerRepeatTrackJSONRequestBody = ApiRepeatTrack

type PlayerSeekJSONRequestBody = ApiSeek

type PlayerSetVolumeJSONRequestBody = ApiSetVolume

type PlayerShuffleContextJSONRequestBody = ApiShuffleContext

type ProductInfo struct {
	XMLName  xml.Name `xml:"products"`
	Products []struct {
		XMLName      xml.Name `xml:"product"`
		Type         string   `xml:"type"`
		HeadFilesUrl string   `xml:"head-files-url"`
		ImageUrl     string   `xml:"image-url"`
	} `xml:"product"`
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	ServeHTTP(w http.ResponseWriter, r *http.Request)
}

type ServerInterface interface {

	// (GET /)
	GetRoot(w http.ResponseWriter, r *http.Request)

	// (GET /auth/code)
	GetAuthCode(w http.ResponseWriter, r *http.Request)

	// (GET /context/tracks)
	GetContextTracks(w http.ResponseWriter, r *http.Request, params GetContextTracksParams)

	// (GET /events)
	GetEvents(w http.ResponseWriter, r *http.Request)

	// (POST /player/add_to_queue)
	PlayerAddToQueue(w http.ResponseWriter, r *http.Request)

	// (POST /player/next)
	PlayerNext(w http.ResponseWriter, r *http.Request)

	// (POST /player/output)
	PlayerOutput(w http.ResponseWriter, r *http.Request)

	// (POST /player/pause)
	PlayerPause(w http.ResponseWriter, r *http.Request)

	// (POST /player/play)
	PlayerPlay(w http.ResponseWriter, r *http.Request)

	// (POST /player/playpause)
	PlayerPlayPause(w http.ResponseWriter, r *http.Request)

	// (POST /player/prev)
	PlayerPrev(w http.ResponseWriter, r *http.Request)

	// (POST /player/repeat_context)
	PlayerRepeatContext(w http.ResponseWriter, r *http.Request)

	// (POST /player/repeat_track)
	PlayerRepeatTrack(w http.ResponseWriter, r *http.Request)

	// (POST /player/resume)
	PlayerResume(w http.ResponseWriter, r *http.Request)

	// (POST /player/seek)
	PlayerSeek(w http.ResponseWriter, r *http.Request)

	// (POST /player/shuffle_context)
	PlayerShuffleContext(w http.ResponseWriter, r *http.Request)

	// (POST /player/stop)
	PlayerStop(w http.ResponseWriter, r *http.Request)

	// (GET /player/volume)
	PlayerGetVolume(w http.ResponseWriter, r *http.Request)

	// (POST /player/volume)
	PlayerSetVolume(w http.ResponseWriter, r *http.Request)

	// (POST /set_device_name)
	SetDeviceName(w http.ResponseWriter, r *http.Request)

	// (GET /status)
	GetStatus(w http.ResponseWriter, r *http.Request)

	// (POST /token)
	GetToken(w http.ResponseWriter, r *http.Request)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type SetDeviceNameJSONRequestBody = ApiSetDeviceName

type SpotifyTokenCredentials struct {
	Username    string
	AccessToken string
}

type State struct {
	// contains filtered or unexported fields
}

type StdHTTPServerOptions struct {
	BaseURL          string
	BaseRouter       ServeMux
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type StubApiServer struct {
	// contains filtered or unexported fields
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type TrackCodec string

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

type ZeroconfCredentials struct {
	PersistCredentials bool
}