SYMBOL INDEX (1697 symbols across 122 files)

FILE: audio/src/decrypt.rs
  type Aes128Ctr (line 5) | type Aes128Ctr = ctr::Ctr128BE<aes::Aes128>;
  constant AUDIO_AESIV (line 9) | const AUDIO_AESIV: [u8; 16] = [
  type AudioDecrypt (line 13) | pub struct AudioDecrypt<T: io::Read> {
  function new (line 20) | pub fn new(key: Option<AudioKey>, reader: T) -> AudioDecrypt<T> {
  function read (line 33) | fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
  function seek (line 45) | fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {

FILE: audio/src/fetch/mod.rs
  type AudioFileResult (line 29) | pub type AudioFileResult = Result<(), librespot_core::Error>;
  constant DOWNLOAD_STATUS_POISON_MSG (line 31) | const DOWNLOAD_STATUS_POISON_MSG: &str = "audio download status mutex sh...
  type AudioFileError (line 34) | pub enum AudioFileError {
  method from (line 50) | fn from(err: AudioFileError) -> Self {
  type AudioFetchParams (line 63) | pub struct AudioFetchParams {
    method set (line 123) | pub fn set(params: AudioFetchParams) -> Result<(), AudioFetchParams> {
    method get (line 127) | pub fn get() -> &'static AudioFetchParams {
  method default (line 102) | fn default() -> Self {
  type AudioFile (line 132) | pub enum AudioFile {
    method open (line 380) | pub async fn open(
    method get_stream_loader_controller (line 415) | pub fn get_stream_loader_controller(&self) -> Result<StreamLoaderContr...
    method is_cached (line 432) | pub fn is_cached(&self) -> bool {
  type StreamingRequest (line 138) | pub struct StreamingRequest {
  type StreamLoaderCommand (line 146) | pub enum StreamLoaderCommand {
  type StreamLoaderController (line 152) | pub struct StreamLoaderController {
    method len (line 159) | pub fn len(&self) -> usize {
    method is_empty (line 163) | pub fn is_empty(&self) -> bool {
    method range_available (line 167) | pub fn range_available(&self, range: Range) -> bool {
    method range_to_end_available (line 183) | pub fn range_to_end_available(&self) -> bool {
    method ping_time (line 193) | pub fn ping_time(&self) -> Option<Duration> {
    method send_stream_loader_command (line 197) | fn send_stream_loader_command(&self, command: StreamLoaderCommand) {
    method fetch (line 205) | pub fn fetch(&self, range: Range) {
    method fetch_blocking (line 210) | pub fn fetch_blocking(&self, mut range: Range) -> AudioFileResult {
    method fetch_next_and_wait (line 260) | pub fn fetch_next_and_wait(
    method set_random_access_mode (line 285) | pub fn set_random_access_mode(&self) {
    method set_stream_mode (line 292) | pub fn set_stream_mode(&self) {
    method close (line 299) | pub fn close(&self) {
    method from_local_file (line 304) | pub fn from_local_file(file_size: u64) -> Self {
  type AudioFileStreaming (line 313) | pub struct AudioFileStreaming {
    method open (line 438) | pub async fn open(
  type AudioFileDownloadStatus (line 320) | struct AudioFileDownloadStatus {
  type AudioFileShared (line 325) | struct AudioFileShared {
    method is_download_streaming (line 339) | fn is_download_streaming(&self) -> bool {
    method set_download_streaming (line 343) | fn set_download_streaming(&self, streaming: bool) {
    method ping_time (line 347) | fn ping_time(&self) -> Duration {
    method set_ping_time (line 356) | fn set_ping_time(&self, duration: Duration) {
    method throughput (line 361) | fn throughput(&self) -> usize {
    method set_throughput (line 365) | fn set_throughput(&self, throughput: usize) {
    method read_position (line 369) | fn read_position(&self) -> usize {
    method set_read_position (line 373) | fn set_read_position(&self, position: u64) {
  method read (line 553) | fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
  method seek (line 629) | fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
  method read (line 674) | fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
  method seek (line 683) | fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {

FILE: audio/src/fetch/receive.rs
  type PartialFileData (line 24) | struct PartialFileData {
  type ReceivedData (line 29) | enum ReceivedData {
  constant ONE_SECOND (line 35) | const ONE_SECOND: Duration = Duration::from_secs(1);
  constant DOWNLOAD_STATUS_POISON_MSG (line 36) | const DOWNLOAD_STATUS_POISON_MSG: &str = "audio download status mutex sh...
  function receive_data (line 38) | async fn receive_data(
  type AudioFileFetch (line 154) | struct AudioFileFetch {
    method has_download_slots_available (line 174) | fn has_download_slots_available(&self) -> bool {
    method download_range (line 178) | fn download_range(&mut self, offset: usize, mut length: usize) -> Audi...
    method pre_fetch_more_data (line 237) | fn pre_fetch_more_data(&mut self, bytes: usize) -> AudioFileResult {
    method handle_file_data (line 276) | fn handle_file_data(&mut self, data: ReceivedData) -> Result<ControlFl...
    method handle_stream_loader_command (line 390) | fn handle_stream_loader_command(
    method finish (line 404) | fn finish(&mut self) -> AudioFileResult {
  type ControlFlow (line 168) | enum ControlFlow {
  function audio_file_fetch (line 422) | pub(super) async fn audio_file_fetch(

FILE: audio/src/range_set.rs
  type Range (line 8) | pub struct Range {
    method fmt (line 14) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 20) | pub fn new(start: usize, length: usize) -> Range {
    method end (line 24) | pub fn end(&self) -> usize {
  type RangeSet (line 30) | pub struct RangeSet {
    method fmt (line 35) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 45) | pub fn new() -> RangeSet {
    method is_empty (line 51) | pub fn is_empty(&self) -> bool {
    method len (line 55) | pub fn len(&self) -> usize {
    method get_range (line 59) | pub fn get_range(&self, index: usize) -> Range {
    method iter (line 63) | pub fn iter(&self) -> Iter<'_, Range> {
    method contains (line 67) | pub fn contains(&self, value: usize) -> bool {
    method contained_length_from_value (line 78) | pub fn contained_length_from_value(&self, value: usize) -> usize {
    method contains_range_set (line 90) | pub fn contains_range_set(&self, other: &RangeSet) -> bool {
    method add_range (line 99) | pub fn add_range(&mut self, range: &Range) {
    method add_range_set (line 136) | pub fn add_range_set(&mut self, other: &RangeSet) {
    method union (line 143) | pub fn union(&self, other: &RangeSet) -> RangeSet {
    method subtract_range (line 149) | pub fn subtract_range(&mut self, range: &Range) {
    method subtract_range_set (line 197) | pub fn subtract_range_set(&mut self, other: &RangeSet) {
    method minus (line 203) | pub fn minus(&self, other: &RangeSet) -> RangeSet {
    method intersection (line 209) | pub fn intersection(&self, other: &RangeSet) -> RangeSet {

FILE: connect/src/context_resolver.rs
  type Resolve (line 20) | enum Resolve {
  type ContextAction (line 26) | pub(super) enum ContextAction {
  type ResolveContext (line 32) | pub(super) struct ResolveContext {
    method append_context (line 40) | fn append_context(uri: impl Into<String>) -> Self {
    method from_uri (line 49) | pub fn from_uri(
    method from_context (line 64) | pub fn from_context(context: Context, update: ContextType, action: Con...
    method resolve_uri (line 74) | fn resolve_uri(&self) -> Option<&str> {
    method context_uri (line 87) | fn context_uri(&self) -> &str {
  method fmt (line 96) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type ContextResolverError (line 108) | enum ContextResolverError {
  method from (line 118) | fn from(value: ContextResolverError) -> Self {
  type ContextResolver (line 123) | pub struct ContextResolver {
    method new (line 133) | pub fn new(session: Session) -> Self {
    method add (line 141) | pub fn add(&mut self, resolve: ResolveContext) {
    method add_list (line 174) | pub fn add_list(&mut self, resolve: Vec<ResolveContext>) {
    method remove_used_and_invalid (line 180) | pub fn remove_used_and_invalid(&mut self) {
    method clear (line 187) | pub fn clear(&mut self) {
    method find_next (line 191) | fn find_next(&self) -> Option<(&ResolveContext, &str, usize)> {
    method has_next (line 205) | pub fn has_next(&self) -> bool {
    method get_next_context (line 209) | pub async fn get_next_context(
    method mark_next_unavailable (line 244) | pub fn mark_next_unavailable(&mut self) {
    method apply_next_context (line 251) | pub fn apply_next_context(
    method try_finish (line 284) | pub fn try_finish(
  constant RETRY_UNAVAILABLE (line 130) | const RETRY_UNAVAILABLE: Duration = Duration::from_secs(3600);

FILE: connect/src/model.rs
  type LoadRequest (line 9) | pub struct LoadRequest {
    method from_context_uri (line 92) | pub fn from_context_uri(context_uri: String, options: LoadRequestOptio...
    method from_tracks (line 103) | pub fn from_tracks(tracks: Vec<String>, options: LoadRequestOptions) -...
  type Target (line 15) | type Target = LoadRequestOptions;
  method deref (line 17) | fn deref(&self) -> &Self::Target {
  type PlayContext (line 23) | pub(super) enum PlayContext {
  type LoadRequestOptions (line 30) | pub struct LoadRequestOptions {
  type LoadContextOptions (line 54) | pub enum LoadContextOptions {
  type Options (line 66) | pub struct Options {
    method from (line 76) | fn from(value: ContextPlayerOptionOverrides) -> Self {
  type PlayingTrack (line 113) | pub enum PlayingTrack {
    type Error (line 133) | type Error = ();
    method try_from (line 135) | fn try_from(value: SkipTo) -> Result<Self, Self::Error> {
  type SpircPlayStatus (line 151) | pub(super) enum SpircPlayStatus {

FILE: connect/src/shuffle_vec.rs
  type ShuffleVec (line 8) | pub struct ShuffleVec<T> {
  method eq (line 20) | fn eq(&self, other: &Self) -> bool {
  type Target (line 26) | type Target = Vec<T>;
  method deref (line 28) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 34) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Item (line 40) | type Item = T;
  type IntoIter (line 41) | type IntoIter = IntoIter<T>;
  method into_iter (line 43) | fn into_iter(self) -> Self::IntoIter {
  function from (line 49) | fn from(vec: Vec<T>) -> Self {
  function shuffle_with_seed (line 59) | pub fn shuffle_with_seed<F: Fn(&T) -> bool>(&mut self, seed: u64, is_fir...
  function shuffle_with_rng (line 63) | pub fn shuffle_with_rng<F: Fn(&T) -> bool>(&mut self, mut rng: impl Rng,...
  function unshuffle (line 92) | pub fn unshuffle(&mut self) {
  function base (line 118) | fn base(range: Range<usize>) -> (ShuffleVec<usize>, u64) {
  function test_shuffle_without_first (line 126) | fn test_shuffle_without_first() {
  function test_shuffle_with_first (line 150) | fn test_shuffle_with_first() {

FILE: connect/src/spirc.rs
  type SpircError (line 48) | enum SpircError {
  method from (line 62) | fn from(err: SpircError) -> Self {
  type SpircTask (line 72) | struct SpircTask {
    method run (line 441) | async fn run(mut self) {
    method handle_next_context (line 607) | fn handle_next_context(&mut self, next_context: Result<Context, Error>...
    method emit_set_queue_event (line 654) | fn emit_set_queue_event(&self) {
    method now_ms (line 691) | fn now_ms(&self) -> i64 {
    method handle_command (line 699) | async fn handle_command(&mut self, cmd: SpircCommand) -> Result<(), Er...
    method handle_player_event (line 755) | fn handle_player_event(&mut self, event: PlayerEvent) -> Result<(), Er...
    method handle_connection_id_update (line 888) | async fn handle_connection_id_update(&mut self, connection_id: String)...
    method handle_user_attributes_update (line 940) | fn handle_user_attributes_update(&mut self, update: UserAttributesUpda...
    method handle_user_attributes_mutation (line 950) | fn handle_user_attributes_mutation(&mut self, mutation: UserAttributes...
    method handle_cluster_update (line 986) | async fn handle_cluster_update(
    method handle_connect_state_request (line 1018) | async fn handle_connect_state_request(
    method handle_request (line 1040) | async fn handle_request(&mut self, request: Request) -> Result<(), Err...
    method handle_transfer (line 1167) | fn handle_transfer(&mut self, mut transfer: TransferState) -> Result<(...
    method handle_disconnect (line 1289) | async fn handle_disconnect(&mut self) -> Result<(), Error> {
    method handle_stop (line 1305) | fn handle_stop(&mut self) {
    method handle_activate (line 1315) | fn handle_activate(&mut self) {
    method handle_load (line 1344) | async fn handle_load(
    method load_context_from_uri (line 1448) | async fn load_context_from_uri(
    method load_context_from_tracks (line 1496) | fn load_context_from_tracks(&mut self, tracks: impl Into<ContextPage>)...
    method handle_play (line 1515) | fn handle_play(&mut self) {
    method handle_play_pause (line 1542) | fn handle_play_pause(&mut self) {
    method handle_pause (line 1554) | fn handle_pause(&mut self) {
    method handle_seek (line 1577) | fn handle_seek(&mut self, position_ms: u32) {
    method handle_shuffle (line 1607) | fn handle_shuffle(&mut self, shuffle: bool) -> Result<(), Error> {
    method handle_repeat_context (line 1612) | fn handle_repeat_context(&mut self, repeat: bool) -> Result<(), Error> {
    method handle_repeat_track (line 1618) | fn handle_repeat_track(&mut self, repeat: bool) {
    method handle_add_to_queue (line 1624) | async fn handle_add_to_queue(&mut self, uri: SpotifyUri) {
    method handle_preload_next_track (line 1654) | fn handle_preload_next_track(&mut self) {
    method handle_unavailable (line 1676) | fn handle_unavailable(&mut self, track_id: &SpotifyUri) -> Result<(), ...
    method add_autoplay_resolving_when_required (line 1683) | fn add_autoplay_resolving_when_required(&mut self) {
    method handle_next (line 1717) | fn handle_next(&mut self, track_uri: Option<String>) -> Result<(), Err...
    method handle_prev (line 1747) | fn handle_prev(&mut self) -> Result<(), Error> {
    method handle_volume_up (line 1768) | fn handle_volume_up(&mut self) {
    method handle_volume_down (line 1775) | fn handle_volume_down(&mut self) {
    method handle_playlist_modification (line 1782) | fn handle_playlist_modification(
    method handle_session_update (line 1809) | fn handle_session_update(&mut self, session_update: FallbackWrapper<Se...
    method position (line 1861) | fn position(&mut self) -> u32 {
    method load_track (line 1873) | fn load_track(&mut self, start_playing: bool, position_ms: u32) -> Res...
    method notify (line 1896) | async fn notify(&mut self) -> Result<(), Error> {
    method set_volume (line 1912) | fn set_volume(&mut self, volume: u16) {
  type SpircCommand (line 120) | enum SpircCommand {
  constant CONTEXT_FETCH_THRESHOLD (line 141) | const CONTEXT_FETCH_THRESHOLD: usize = 2;
  constant VOLUME_UPDATE_DELAY (line 144) | const VOLUME_UPDATE_DELAY: Duration = Duration::from_millis(500);
  constant UPDATE_STATE_DELAY (line 146) | const UPDATE_STATE_DELAY: Duration = Duration::from_millis(200);
  type Spirc (line 149) | pub struct Spirc {
    method new (line 160) | pub async fn new(
    method shutdown (line 289) | pub fn shutdown(&self) -> Result<(), Error> {
    method play (line 296) | pub fn play(&self) -> Result<(), Error> {
    method play_pause (line 303) | pub fn play_pause(&self) -> Result<(), Error> {
    method pause (line 310) | pub fn pause(&self) -> Result<(), Error> {
    method prev (line 320) | pub fn prev(&self) -> Result<(), Error> {
    method next (line 327) | pub fn next(&self) -> Result<(), Error> {
    method volume_up (line 334) | pub fn volume_up(&self) -> Result<(), Error> {
    method volume_down (line 341) | pub fn volume_down(&self) -> Result<(), Error> {
    method shuffle (line 352) | pub fn shuffle(&self, shuffle: bool) -> Result<(), Error> {
    method repeat (line 359) | pub fn repeat(&self, repeat: bool) -> Result<(), Error> {
    method repeat_track (line 368) | pub fn repeat_track(&self, repeat: bool) -> Result<(), Error> {
    method set_volume (line 375) | pub fn set_volume(&self, volume: u16) -> Result<(), Error> {
    method set_position_ms (line 385) | pub fn set_position_ms(&self, position_ms: u32) -> Result<(), Error> {
    method load (line 394) | pub fn load(&self, command: LoadRequest) -> Result<(), Error> {
    method add_to_queue (line 403) | pub fn add_to_queue(&self, uri: SpotifyUri) -> Result<(), Error> {
    method disconnect (line 419) | pub fn disconnect(&self, pause: bool) -> Result<(), Error> {
    method activate (line 426) | pub fn activate(&self) -> Result<(), Error> {
    method transfer (line 433) | pub fn transfer(&self, transfer_request: Option<TransferRequest>) -> R...
  method drop (line 1933) | fn drop(&mut self) {

FILE: connect/src/state.rs
  constant SPOTIFY_MAX_PREV_TRACKS_SIZE (line 40) | const SPOTIFY_MAX_PREV_TRACKS_SIZE: usize = 10;
  constant SPOTIFY_MAX_NEXT_TRACKS_SIZE (line 41) | const SPOTIFY_MAX_NEXT_TRACKS_SIZE: usize = 80;
  type StateError (line 44) | pub(super) enum StateError {
  method from (line 65) | fn from(err: StateError) -> Self {
  type ConnectConfig (line 80) | pub struct ConnectConfig {
  method default (line 98) | fn default() -> Self {
  type ConnectState (line 112) | pub(super) struct ConnectState {
    method new (line 140) | pub fn new(cfg: ConnectConfig, session: &Session) -> Self {
    method reset (line 218) | fn reset(&mut self) {
    method device_mut (line 239) | fn device_mut(&mut self) -> &mut Device {
    method player_mut (line 246) | fn player_mut(&mut self) -> &mut PlayerState {
    method device_info (line 253) | pub fn device_info(&self) -> &DeviceInfo {
    method player (line 257) | pub fn player(&self) -> &PlayerState {
    method is_active (line 261) | pub fn is_active(&self) -> bool {
    method is_playing (line 268) | pub fn is_playing(&self) -> bool {
    method is_pause (line 276) | pub fn is_pause(&self) -> bool {
    method set_volume (line 281) | pub fn set_volume(&mut self, volume: u32) {
    method set_last_command (line 289) | pub fn set_last_command(&mut self, command: Request) {
    method set_now (line 294) | pub fn set_now(&mut self, now: u64) {
    method set_active (line 307) | pub fn set_active(&mut self, value: bool) {
    method set_origin (line 321) | pub fn set_origin(&mut self, origin: PlayOrigin) {
    method set_session_id (line 325) | pub fn set_session_id(&mut self, session_id: String) {
    method set_status (line 329) | pub(crate) fn set_status(&mut self, status: &SpircPlayStatus) {
    method update_current_index (line 366) | pub fn update_current_index(&mut self, f: impl Fn(&mut ContextIndex)) {
    method update_position (line 377) | pub fn update_position(&mut self, position_ms: u32, timestamp: i64) {
    method update_duration (line 383) | pub fn update_duration(&mut self, duration: u32) {
    method update_queue_revision (line 387) | pub fn update_queue_revision(&mut self) {
    method reset_playback_to_position (line 395) | pub fn reset_playback_to_position(&mut self, new_index: Option<usize>)...
    method mark_as_unavailable_for_match (line 435) | fn mark_as_unavailable_for_match(track: &mut ProvidedTrack, uri: &str) {
    method update_position_in_relation (line 442) | pub fn update_position_in_relation(&mut self, timestamp: i64) {
    method became_inactive (line 462) | pub async fn became_inactive(&mut self, session: &Session) -> SpClient...
    method send_with_reason (line 469) | async fn send_with_reason(
    method notify_new_device_appeared (line 484) | pub async fn notify_new_device_appeared(&mut self, session: &Session) ...
    method notify_volume_changed (line 490) | pub async fn notify_volume_changed(&mut self, session: &Session) -> Sp...
    method send_state (line 496) | pub async fn send_state(&self, session: &Session) -> SpClientResult {

FILE: connect/src/state/context.rs
  constant LOCAL_FILES_IDENTIFIER (line 21) | const LOCAL_FILES_IDENTIFIER: &str = "spotify:local-files";
  constant SEARCH_IDENTIFIER (line 22) | const SEARCH_IDENTIFIER: &str = "spotify:search";
  type StateContext (line 25) | pub struct StateContext {
  type ContextType (line 34) | pub enum ContextType {
  type ResetContext (line 40) | pub enum ResetContext<'s> {
  function page_url_to_uri (line 52) | fn page_url_to_uri(page_url: &str) -> String {
  method find_index_in_context (line 68) | pub fn find_index_in_context<F: Fn(&ProvidedTrack) -> bool>(
  method get_context (line 78) | pub fn get_context(&self, ty: ContextType) -> Result<&StateContext, Stat...
  method get_context_mut (line 86) | pub fn get_context_mut(&mut self, ty: ContextType) -> Result<&mut StateC...
  method context_uri (line 94) | pub fn context_uri(&self) -> &String {
  method different_context_uri (line 98) | fn different_context_uri(&self, uri: &str) -> bool {
  method reset_context (line 103) | pub fn reset_context(&mut self, mut reset_as: ResetContext) {
  method valid_resolve_uri (line 140) | pub fn valid_resolve_uri(uri: &str) -> Option<&str> {
  method find_valid_uri (line 148) | pub fn find_valid_uri<'s>(
  method set_active_context (line 157) | pub fn set_active_context(&mut self, new_context: ContextType) {
  method update_context (line 188) | pub fn update_context(
  method find_first_prev_track_index (line 300) | fn find_first_prev_track_index(&self, ctx: &StateContext) -> Option<usiz...
  method find_last_index_in_new_context (line 311) | fn find_last_index_in_new_context(
  method state_context_from_page (line 346) | fn state_context_from_page(
  method is_skip_track (line 386) | pub fn is_skip_track(&self, track: &ProvidedTrack, iteration: Option<u32...
  method merge_context (line 399) | pub fn merge_context(&mut self, new_page: Option<ContextPage>) -> Option...
  method update_context_index (line 429) | pub(super) fn update_context_index(
  method context_to_provided_track (line 440) | pub fn context_to_provided_track(
  method fill_context_from_page (line 505) | pub fn fill_context_from_page(&mut self, page: ContextPage) -> Result<()...

FILE: connect/src/state/handle.rs
  method handle_shuffle (line 12) | pub fn handle_shuffle(&mut self, shuffle: bool) -> Result<(), Error> {
  method handle_set_queue (line 37) | pub fn handle_set_queue(&mut self, set_queue: SetQueueCommand) {
  method handle_set_repeat_context (line 43) | pub fn handle_set_repeat_context(&mut self, repeat: bool) -> Result<(), ...

FILE: connect/src/state/metadata.rs
  constant CONTEXT_URI (line 8) | const CONTEXT_URI: &str = "context_uri";
  constant ENTITY_URI (line 9) | const ENTITY_URI: &str = "entity_uri";
  constant IS_QUEUED (line 10) | const IS_QUEUED: &str = "is_queued";
  constant IS_AUTOPLAY (line 11) | const IS_AUTOPLAY: &str = "autoplay.is_autoplay";
  constant HIDDEN (line 12) | const HIDDEN: &str = "hidden";
  constant ITERATION (line 13) | const ITERATION: &str = "iteration";
  constant CUSTOM_CONTEXT_INDEX (line 15) | const CUSTOM_CONTEXT_INDEX: &str = "context_index";
  constant CUSTOM_SHUFFLE_SEED (line 16) | const CUSTOM_SHUFFLE_SEED: &str = "shuffle_seed";
  constant CUSTOM_INITIAL_TRACK (line 17) | const CUSTOM_INITIAL_TRACK: &str = "initial_track";
  type Metadata (line 41) | pub(super) trait Metadata {
    method metadata (line 42) | fn metadata(&self) -> &HashMap<String, String>;
    method metadata_mut (line 44) | fn metadata_mut(&mut self) -> &mut HashMap<String, String>;
    method get_bool (line 46) | fn get_bool(&self, entry: &str) -> bool {
    method get_usize (line 50) | fn get_usize(&self, entry: &str) -> Option<usize> {
    method get (line 54) | fn get(&self, entry: &str) -> Option<&String> {

FILE: connect/src/state/options.rs
  type ShuffleState (line 14) | pub(crate) struct ShuffleState {
  method add_options_if_empty (line 20) | fn add_options_if_empty(&mut self) {
  method set_repeat_context (line 26) | pub fn set_repeat_context(&mut self, repeat: bool) {
  method set_repeat_track (line 33) | pub fn set_repeat_track(&mut self, repeat: bool) {
  method set_shuffle (line 40) | pub fn set_shuffle(&mut self, shuffle: bool) {
  method reset_options (line 47) | pub fn reset_options(&mut self) {
  method validate_shuffle_allowed (line 53) | fn validate_shuffle_allowed(&self) -> Result<(), Error> {
  method shuffle_restore (line 69) | pub fn shuffle_restore(&mut self, shuffle_state: ShuffleState) -> Result...
  method shuffle_new (line 75) | pub fn shuffle_new(&mut self) -> Result<(), Error> {
  method shuffle (line 84) | fn shuffle(&mut self, seed: u64, initial_track: &str) -> Result<(), Erro...
  method shuffling_context (line 102) | pub fn shuffling_context(&self) -> bool {
  method repeat_context (line 106) | pub fn repeat_context(&self) -> bool {
  method repeat_track (line 110) | pub fn repeat_track(&self) -> bool {

FILE: connect/src/state/provider.rs
  constant PROVIDER_CONTEXT (line 5) | const PROVIDER_CONTEXT: &str = "context";
  constant PROVIDER_QUEUE (line 6) | const PROVIDER_QUEUE: &str = "queue";
  constant PROVIDER_AUTOPLAY (line 7) | const PROVIDER_AUTOPLAY: &str = "autoplay";
  constant PROVIDER_UNAVAILABLE (line 12) | const PROVIDER_UNAVAILABLE: &str = "unavailable";
  type Provider (line 15) | pub enum Provider {
  method fmt (line 23) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type IsProvider (line 37) | pub trait IsProvider {
    method is_autoplay (line 38) | fn is_autoplay(&self) -> bool;
    method is_context (line 39) | fn is_context(&self) -> bool;
    method is_queue (line 40) | fn is_queue(&self) -> bool;
    method is_unavailable (line 41) | fn is_unavailable(&self) -> bool;
    method set_provider (line 43) | fn set_provider(&mut self, provider: Provider);
    method is_autoplay (line 47) | fn is_autoplay(&self) -> bool {
    method is_context (line 51) | fn is_context(&self) -> bool {
    method is_queue (line 55) | fn is_queue(&self) -> bool {
    method is_unavailable (line 59) | fn is_unavailable(&self) -> bool {
    method set_provider (line 63) | fn set_provider(&mut self, provider: Provider) {

FILE: connect/src/state/restrictions.rs
  method clear_restrictions (line 7) | pub fn clear_restrictions(&mut self) {
  method update_restrictions (line 14) | pub fn update_restrictions(&mut self) {

FILE: connect/src/state/tracks.rs
  constant IDENTIFIER_DELIMITER (line 15) | pub const IDENTIFIER_DELIMITER: &str = "delimiter";
  method new_delimiter (line 18) | fn new_delimiter(iteration: i64) -> ProvidedTrack {
  method push_prev (line 31) | fn push_prev(&mut self, prev: ProvidedTrack) {
  method get_next_track (line 41) | fn get_next_track(&mut self) -> Option<ProvidedTrack> {
  method prev_tracks_mut (line 51) | fn prev_tracks_mut(&mut self) -> &mut Vec<ProvidedTrack> {
  method prev_tracks (line 56) | pub(super) fn prev_tracks(&self) -> &Vec<ProvidedTrack> {
  method next_tracks_mut (line 61) | fn next_tracks_mut(&mut self) -> &mut Vec<ProvidedTrack> {
  method next_tracks (line 66) | pub(super) fn next_tracks(&self) -> &Vec<ProvidedTrack> {
  method set_current_track_random (line 70) | pub fn set_current_track_random(&mut self) -> Result<(), Error> {
  method set_current_track (line 76) | pub fn set_current_track(&mut self, index: usize) -> Result<(), Error> {
  method next_track (line 105) | pub fn next_track(&mut self) -> Result<Option<u32>, Error> {
  method prev_track (line 170) | pub fn prev_track(&mut self) -> Result<Option<&MessageField<ProvidedTrac...
  method current_track (line 224) | pub fn current_track<F: Fn(&'ct MessageField<ProvidedTrack>) -> R, R>(
  method set_track (line 231) | pub fn set_track(&mut self, track: ProvidedTrack) {
  method set_next_tracks (line 235) | pub fn set_next_tracks(&mut self, mut tracks: Vec<ProvidedTrack>) {
  method set_prev_tracks (line 261) | pub fn set_prev_tracks(&mut self, tracks: Vec<ProvidedTrack>) {
  method clear_prev_track (line 265) | pub fn clear_prev_track(&mut self) {
  method clear_next_tracks (line 269) | pub fn clear_next_tracks(&mut self) {
  method fill_up_next_tracks (line 284) | pub fn fill_up_next_tracks(&mut self) -> Result<(), Error> {
  method preview_next_track (line 355) | pub fn preview_next_track(&mut self) -> Option<SpotifyUri> {
  method has_next_tracks (line 365) | pub fn has_next_tracks(&self, min: Option<usize>) -> bool {
  method recent_track_uris (line 373) | pub fn recent_track_uris(&self) -> Vec<String> {
  method mark_unavailable (line 384) | pub fn mark_unavailable(&mut self, id: &SpotifyUri) -> Result<(), Error> {
  method add_to_queue (line 414) | pub fn add_to_queue(&mut self, mut track: ProvidedTrack, rev_update: boo...

FILE: connect/src/state/transfer.rs
  method current_track_from_transfer (line 15) | pub fn current_track_from_transfer(
  method handle_initial_transfer (line 42) | pub fn handle_initial_transfer(
  method finish_transfer (line 121) | pub fn finish_transfer(&mut self, transfer: TransferState) -> Result<(),...

FILE: core/build.rs
  function main (line 5) | fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: core/src/apresolve.rs
  type SocketAddress (line 9) | pub type SocketAddress = (String, u16);
  type AccessPoints (line 12) | pub struct AccessPoints {
    method is_any_empty (line 39) | fn is_any_empty(&self) -> bool {
  type ApResolveData (line 19) | pub struct ApResolveData {
    method fallback (line 29) | fn fallback() -> Self {
  method port_config (line 53) | pub fn port_config(&self) -> Option<u16> {
  method process_ap_strings (line 61) | fn process_ap_strings(&self, data: Vec<String>) -> VecDeque<SocketAddres...
  method parse_resolve_to_access_points (line 77) | fn parse_resolve_to_access_points(&self, resolve: ApResolveData) -> Acce...
  method try_apresolve (line 85) | pub async fn try_apresolve(&self) -> Result<ApResolveData, Error> {
  method apresolve (line 97) | async fn apresolve(&self) {
  method is_any_empty (line 122) | fn is_any_empty(&self) -> bool {
  method resolve (line 126) | pub async fn resolve(&self, endpoint: &str) -> Result<SocketAddress, Err...

FILE: core/src/audio_key.rs
  type AudioKey (line 11) | pub struct AudioKey(pub [u8; 16]);
  type AudioKeyError (line 14) | pub enum AudioKeyError {
  method from (line 28) | fn from(err: AudioKeyError) -> Self {
  method dispatch (line 47) | pub(crate) fn dispatch(&self, cmd: PacketType, mut data: Bytes) -> Resul...
  method request (line 81) | pub async fn request(&self, track: SpotifyId, file: FileId) -> Result<Au...
  method send_key_request (line 101) | fn send_key_request(&self, seq: u32, track: SpotifyId, file: FileId) -> ...

FILE: core/src/authentication.rs
  type AuthenticationError (line 16) | pub enum AuthenticationError {
  method from (line 24) | fn from(err: AuthenticationError) -> Self {
  type Credentials (line 31) | pub struct Credentials {
    method with_password (line 53) | pub fn with_password(username: impl Into<String>, password: impl Into<...
    method with_access_token (line 61) | pub fn with_access_token(token: impl Into<String>) -> Self {
    method with_blob (line 70) | pub fn with_blob(
  function serialize_protobuf_enum (line 156) | fn serialize_protobuf_enum<T, S>(v: &T, ser: S) -> Result<S::Ok, S::Error>
  function deserialize_protobuf_enum (line 164) | fn deserialize_protobuf_enum<'de, T, D>(de: D) -> Result<T, D::Error>
  function serialize_base64 (line 173) | fn serialize_base64<T, S>(v: &T, ser: S) -> Result<S::Ok, S::Error>
  function deserialize_base64 (line 181) | fn deserialize_base64<'de, D>(de: D) -> Result<Vec<u8>, D::Error>

FILE: core/src/cache.rs
  constant CACHE_LIMITER_POISON_MSG (line 18) | const CACHE_LIMITER_POISON_MSG: &str = "cache limiter mutex should not b...
  type CacheError (line 21) | pub enum CacheError {
  method from (line 27) | fn from(err: CacheError) -> Self {
  type SizeLimiter (line 35) | struct SizeLimiter {
    method new (line 44) | fn new(limit: u64) -> Self {
    method add (line 56) | fn add(&mut self, file: &Path, size: u64, accessed: SystemTime) {
    method exceeds_limit (line 67) | fn exceeds_limit(&self) -> bool {
    method pop (line 76) | fn pop(&mut self) -> Option<PathBuf> {
    method update (line 95) | fn update(&mut self, file: &Path, access_time: SystemTime) -> bool {
    method remove (line 102) | fn remove(&mut self, file: &Path) -> bool {
  type FsSizeLimiter (line 117) | struct FsSizeLimiter {
    method get_metadata (line 123) | fn get_metadata(file: &Path) -> io::Result<(SystemTime, u64)> {
    method init_dir (line 143) | fn init_dir(limiter: &mut SizeLimiter, path: &Path) {
    method add (line 194) | fn add(&self, file: &Path, size: u64) {
    method touch (line 201) | fn touch(&self, file: &Path) -> bool {
    method remove (line 208) | fn remove(&self, file: &Path) -> bool {
    method prune_internal (line 215) | fn prune_internal<F: FnMut() -> Option<PathBuf>>(mut pop: F) -> Result...
    method prune (line 246) | fn prune(&self) -> Result<(), Error> {
    method new (line 250) | fn new(path: &Path, limit: u64) -> Result<Self, Error> {
  type Cache (line 264) | pub struct Cache {
    method new (line 272) | pub fn new<P: AsRef<Path>>(
    method credentials (line 315) | pub fn credentials(&self) -> Option<Credentials> {
    method save_credentials (line 343) | pub fn save_credentials(&self, cred: &Credentials) {
    method volume (line 361) | pub fn volume(&self) -> Option<u16> {
    method save_volume (line 382) | pub fn save_volume(&self, volume: u16) {
    method file_path (line 391) | pub fn file_path(&self, file: FileId) -> Option<PathBuf> {
    method file (line 400) | pub fn file(&self, file: FileId) -> Option<File> {
    method save_file (line 420) | pub fn save_file<F: Read>(&self, file: FileId, contents: &mut F) -> Re...
    method remove_file (line 438) | pub fn remove_file(&self, file: FileId) -> Result<(), Error> {
  function ordered_time (line 455) | fn ordered_time(v: u64) -> SystemTime {
  function test_size_limiter (line 460) | fn test_size_limiter() {

FILE: core/src/cdn_url.rs
  type MaybeExpiringUrl (line 15) | pub struct MaybeExpiringUrl(pub String, pub Option<Date>);
  constant CDN_URL_EXPIRY_MARGIN (line 17) | const CDN_URL_EXPIRY_MARGIN: Duration = Duration::seconds(5 * 60);
  type MaybeExpiringUrls (line 20) | pub struct MaybeExpiringUrls(pub Vec<MaybeExpiringUrl>);
    type Error (line 130) | type Error = crate::Error;
    method try_from (line 131) | fn try_from(msg: CdnUrlMessage) -> Result<Self, Self::Error> {
  type Target (line 23) | type Target = Vec<MaybeExpiringUrl>;
  method deref (line 24) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 30) | fn deref_mut(&mut self) -> &mut Self::Target {
  type CdnUrlError (line 36) | pub enum CdnUrlError {
  method from (line 46) | fn from(err: CdnUrlError) -> Self {
  type CdnUrl (line 55) | pub struct CdnUrl {
    method new (line 61) | pub fn new(file_id: FileId) -> Self {
    method resolve_audio (line 68) | pub async fn resolve_audio(&self, session: &Session) -> Result<Self, E...
    method try_get_url (line 82) | pub fn try_get_url(&self) -> Result<&str, Error> {
    method try_get_urls (line 100) | pub fn try_get_urls(&self) -> Result<Vec<&str>, Error> {
  function test_maybe_expiring_urls (line 225) | fn test_maybe_expiring_urls() {

FILE: core/src/channel.rs
  constant ONE_SECOND (line 30) | const ONE_SECOND: Duration = Duration::from_secs(1);
  type ChannelError (line 33) | pub struct ChannelError;
    method fmt (line 42) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method from (line 36) | fn from(err: ChannelError) -> Self {
  type Channel (line 47) | pub struct Channel {
    method recv_packet (line 133) | fn recv_packet(&mut self, cx: &mut Context<'_>) -> Poll<Result<Bytes, ...
    method split (line 149) | pub fn split(self) -> (ChannelHeaders, ChannelData) {
  type ChannelHeaders (line 52) | pub struct ChannelHeaders(BiLock<Channel>);
  type ChannelData (line 53) | pub struct ChannelData(BiLock<Channel>);
  type ChannelEvent (line 55) | pub enum ChannelEvent {
  type ChannelState (line 61) | enum ChannelState {
  method allocate (line 68) | pub fn allocate(&self) -> (u16, Channel) {
  method dispatch (line 87) | pub(crate) fn dispatch(&self, cmd: PacketType, mut data: Bytes) -> Resul...
  method get_download_rate_estimate (line 119) | pub fn get_download_rate_estimate(&self) -> usize {
  method shutdown (line 123) | pub(crate) fn shutdown(&self) {
  type Item (line 157) | type Item = Result<ChannelEvent, ChannelError>;
  method poll_next (line 159) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Item (line 203) | type Item = Result<Bytes, ChannelError>;
  method poll_next (line 205) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Item (line 219) | type Item = Result<(u8, Vec<u8>), ChannelError>;
  method poll_next (line 221) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: core/src/component.rs
  constant COMPONENT_POISON_MSG (line 1) | pub(crate) const COMPONENT_POISON_MSG: &str = "component mutex should no...

FILE: core/src/config.rs
  constant KEYMASTER_CLIENT_ID (line 6) | pub(crate) const KEYMASTER_CLIENT_ID: &str = "65b708073fc0480ea92a077233...
  constant ANDROID_CLIENT_ID (line 7) | pub(crate) const ANDROID_CLIENT_ID: &str = "9a8d2f0ce77a4e248bb71fefcb55...
  constant IOS_CLIENT_ID (line 8) | pub(crate) const IOS_CLIENT_ID: &str = "58bd3c95768941ea9eb4350aaa033eb3";
  constant OS (line 14) | pub const OS: &str = std::env::consts::OS;
  function os_version (line 20) | pub fn os_version() -> String {
  type SessionConfig (line 25) | pub struct SessionConfig {
    method default_for_os (line 35) | pub(crate) fn default_for_os(os: &str) -> Self {
  method default (line 56) | fn default() -> Self {
  type DeviceType (line 62) | pub enum DeviceType {
    method fmt (line 142) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 85) | type Err = ();
  method from_str (line 86) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function from (line 110) | fn from(d: &DeviceType) -> &'static str {
  function from (line 136) | fn from(d: DeviceType) -> &'static str {
  method from (line 149) | fn from(value: DeviceType) -> Self {

FILE: core/src/connection/codec.rs
  constant HEADER_SIZE (line 9) | const HEADER_SIZE: usize = 3;
  constant MAC_SIZE (line 10) | const MAC_SIZE: usize = 4;
  type ApCodecError (line 13) | pub enum ApCodecError {
  type DecodeState (line 19) | enum DecodeState {
  type ApCodec (line 24) | pub struct ApCodec {
    method new (line 34) | pub fn new(send_key: &[u8], recv_key: &[u8]) -> ApCodec {
    type Error (line 47) | type Error = io::Error;
    method encode (line 49) | fn encode(&mut self, item: (u8, Vec<u8>), buf: &mut BytesMut) -> io::R...
  type Item (line 72) | type Item = (u8, Bytes);
  type Error (line 73) | type Error = io::Error;
  method decode (line 75) | fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<(u8, Bytes...

FILE: core/src/connection/handshake.rs
  constant SERVER_KEY (line 22) | const SERVER_KEY: [u8; 256] = [
  type HandshakeError (line 42) | pub enum HandshakeError {
  function handshake (line 49) | pub async fn handshake<T: AsyncRead + AsyncWrite + Unpin>(
  function client_hello (line 106) | async fn client_hello<T>(connection: &mut T, gc: Vec<u8>) -> io::Result<...
  function client_response (line 200) | async fn client_response<T>(connection: &mut T, challenge: Vec<u8>) -> i...
  function recv_packet (line 224) | async fn recv_packet<T, M>(connection: &mut T, acc: &mut Vec<u8>) -> io:...
  function read_into_accumulator (line 236) | async fn read_into_accumulator<'b, T: AsyncRead + Unpin>(
  function compute_keys (line 248) | fn compute_keys(shared_secret: &[u8], packets: &[u8]) -> io::Result<(Vec...

FILE: core/src/connection/mod.rs
  type Transport (line 20) | pub type Transport = Framed<TcpStream, ApCodec>;
  function login_error_message (line 22) | fn login_error_message(code: &ErrorCode) -> &'static str {
  type AuthenticationError (line 40) | pub enum AuthenticationError {
    method from (line 60) | fn from(login_failure: APLoginFailed) -> Self {
  method from (line 50) | fn from(err: AuthenticationError) -> Self {
  function connect (line 65) | pub async fn connect(host: &str, port: u16, proxy: Option<&Url>) -> io::...
  function connect_with_retry (line 75) | pub async fn connect_with_retry(
  function authenticate (line 98) | pub async fn authenticate(

FILE: core/src/date.rs
  method from (line 14) | fn from(err: ComponentRange) -> Self {
  type Date (line 20) | pub struct Date(pub OffsetDateTime);
    method as_timestamp_ms (line 30) | pub fn as_timestamp_ms(&self) -> i64 {
    method from_timestamp_ms (line 34) | pub fn from_timestamp_ms(timestamp: i64) -> Result<Self, Error> {
    method as_utc (line 39) | pub fn as_utc(&self) -> OffsetDateTime {
    method from_utc (line 43) | pub fn from_utc(date_time: PrimitiveDateTime) -> Self {
    method now_utc (line 47) | pub fn now_utc() -> Self {
    method from_iso8601 (line 51) | pub fn from_iso8601(input: &str) -> Result<Self, Error> {
    type Error (line 58) | type Error = crate::Error;
    method try_from (line 59) | fn try_from(msg: &DateMessage) -> Result<Self, Self::Error> {
    method from (line 78) | fn from(datetime: OffsetDateTime) -> Self {
  type Target (line 23) | type Target = OffsetDateTime;
  method deref (line 24) | fn deref(&self) -> &Self::Target {

FILE: core/src/dealer/manager.rs
  type BoxedStream (line 22) | pub type BoxedStream<T> = Pin<Box<dyn Stream<Item = T> + Send>>;
  type BoxedStreamResult (line 23) | pub type BoxedStreamResult<T> = BoxedStream<Result<T, Error>>;
  type DealerError (line 26) | enum DealerError {
  method from (line 36) | fn from(err: DealerError) -> Self {
  type Reply (line 42) | pub enum Reply {
  type RequestReply (line 48) | pub type RequestReply = (Request, mpsc::UnboundedSender<Reply>);
  type RequestReceiver (line 49) | type RequestReceiver = mpsc::UnboundedReceiver<RequestReply>;
  type RequestSender (line 50) | type RequestSender = mpsc::UnboundedSender<RequestReply>;
  type DealerRequestHandler (line 52) | struct DealerRequestHandler(RequestSender);
    method new (line 55) | pub fn new() -> (Self, RequestReceiver) {
  method handle_request (line 62) | fn handle_request(&self, request: Request, responder: Responder) {
  method get_url (line 85) | async fn get_url(session: Session) -> GetUrlResult {
  method add_listen_for (line 93) | pub fn add_listen_for(&self, url: impl Into<String>) -> Result<Subscript...
  method listen_for (line 106) | pub fn listen_for<T>(
  method add_handle_for (line 114) | pub fn add_handle_for(&self, url: impl Into<String>) -> Result<RequestRe...
  method handle_for (line 129) | pub fn handle_for(&self, uri: impl Into<String>) -> Result<BoxedStream<R...
  method handles (line 135) | pub fn handles(&self, uri: &str) -> bool {
  method start (line 147) | pub async fn start(&self) -> Result<(), Error> {
  method close (line 169) | pub async fn close(&self) {

FILE: core/src/dealer/maps.rs
  type HandlerMapError (line 7) | pub enum HandlerMapError {
  method from (line 13) | fn from(err: HandlerMapError) -> Self {
  type HandlerMap (line 18) | pub enum HandlerMap<T> {
  method default (line 24) | fn default() -> Self {
  function contains (line 30) | pub fn contains(&self, path: &str) -> bool {
  function insert (line 34) | pub fn insert<'a>(
  function get (line 55) | pub fn get<'a>(&self, mut path: impl Iterator<Item = &'a str>) -> Option...
  function remove (line 65) | pub fn remove<'a>(&mut self, mut path: impl Iterator<Item = &'a str>) ->...
  type SubscriberMap (line 87) | pub struct SubscriberMap<T> {
  method default (line 93) | fn default() -> Self {
  function insert (line 102) | pub fn insert<'a>(&mut self, mut path: impl Iterator<Item = &'a str>, ha...
  function contains (line 113) | pub fn contains<'a>(&self, mut path: impl Iterator<Item = &'a str>) -> b...
  function is_empty (line 129) | pub fn is_empty(&self) -> bool {
  function retain (line 133) | pub fn retain<'a>(

FILE: core/src/dealer/mod.rs
  type WsMessage (line 41) | type WsMessage = tungstenite::Message;
  type WsError (line 42) | type WsError = tungstenite::Error;
  type WsResult (line 43) | type WsResult<T> = Result<T, Error>;
  type GetUrlResult (line 44) | type GetUrlResult = Result<Url, Error>;
  method from (line 47) | fn from(err: WsError) -> Self {
  constant WEBSOCKET_CLOSE_TIMEOUT (line 52) | const WEBSOCKET_CLOSE_TIMEOUT: Duration = Duration::from_secs(3);
  constant PING_INTERVAL (line 54) | const PING_INTERVAL: Duration = Duration::from_secs(30);
  constant PING_TIMEOUT (line 55) | const PING_TIMEOUT: Duration = Duration::from_secs(3);
  constant RECONNECT_INTERVAL (line 57) | const RECONNECT_INTERVAL: Duration = Duration::from_secs(10);
  constant DEALER_REQUEST_HANDLERS_POISON_MSG (line 59) | const DEALER_REQUEST_HANDLERS_POISON_MSG: &str =
  constant DEALER_MESSAGE_HANDLERS_POISON_MSG (line 61) | const DEALER_MESSAGE_HANDLERS_POISON_MSG: &str =
  type Response (line 64) | struct Response {
  type Responder (line 68) | struct Responder {
    method new (line 75) | fn new(key: String, tx: mpsc::UnboundedSender<WsMessage>) -> Self {
    method send_internal (line 84) | fn send_internal(&mut self, response: Response) {
    method send (line 99) | pub fn send(mut self, response: Response) {
    method force_unanswered (line 104) | pub fn force_unanswered(mut self) {
  method drop (line 110) | fn drop(&mut self) {
  type IntoResponse (line 117) | trait IntoResponse {
    method respond (line 118) | fn respond(self, responder: Responder);
    method respond (line 122) | fn respond(self, responder: Responder) {
    method respond (line 131) | fn respond(self, responder: Responder) {
  type RequestHandler (line 148) | trait RequestHandler: Send + 'static {
    method handle_request (line 143) | fn handle_request(&self, request: Request, responder: Responder) {
    method handle_request (line 149) | fn handle_request(&self, request: Request, responder: Responder);
  type MessageHandler (line 152) | type MessageHandler = mpsc::UnboundedSender<Message>;
  type Subscription (line 156) | pub struct Subscription(UnboundedReceiver<Message>);
  type Item (line 159) | type Item = Message;
  method poll_next (line 161) | fn poll_next(
  function split_uri (line 169) | fn split_uri(s: &str) -> Option<impl Iterator<Item = &'_ str>> {
  type AddHandlerError (line 187) | enum AddHandlerError {
  method from (line 195) | fn from(err: AddHandlerError) -> Self {
  type SubscriptionError (line 204) | enum SubscriptionError {
  method from (line 210) | fn from(err: SubscriptionError) -> Self {
  function add_handler (line 215) | fn add_handler(
  function remove_handler (line 224) | fn remove_handler<T>(map: &mut HandlerMap<T>, uri: &str) -> Option<T> {
  function subscribe (line 228) | fn subscribe(
  function handles (line 242) | fn handles(
  type Builder (line 258) | struct Builder {
    method new (line 288) | pub fn new() -> Self {
    method add_handler (line 292) | pub fn add_handler(&mut self, uri: &str, handler: impl RequestHandler)...
    method subscribe (line 296) | pub fn subscribe(&mut self, uris: &[&str]) -> Result<Subscription, Err...
    method handles (line 300) | pub fn handles(&self, uri: &str) -> bool {
    method launch_in_background (line 304) | pub fn launch_in_background<Fut, F>(self, get_url: F, proxy: Option<Ur...
    method launch (line 312) | pub async fn launch<Fut, F>(self, get_url: F, proxy: Option<Url>) -> W...
  type DealerShared (line 330) | struct DealerShared {
    method dispatch_message (line 340) | fn dispatch_message(&self, mut msg: WebsocketMessage) {
    method dispatch_request (line 367) | fn dispatch_request(
    method dispatch (line 408) | fn dispatch(&self, m: MessageOrRequest, send_tx: &mpsc::UnboundedSende...
    method closed (line 415) | async fn closed(&self) {
    method is_closed (line 421) | fn is_closed(&self) -> bool {
  type Dealer (line 426) | struct Dealer {
    method add_handler (line 432) | pub fn add_handler<H>(&self, uri: &str, handler: H) -> Result<(), Error>
    method remove_handler (line 447) | pub fn remove_handler(&self, uri: &str) -> Option<Box<dyn RequestHandl...
    method subscribe (line 458) | pub fn subscribe(&self, uris: &[&str]) -> Result<Subscription, Error> {
    method handles (line 469) | pub fn handles(&self, uri: &str) -> bool {
    method close (line 485) | pub async fn close(mut self) {
  function connect (line 499) | async fn connect(
  function run (line 663) | async fn run<F, Fut>(

FILE: core/src/dealer/protocol.rs
  constant IGNORE_UNKNOWN (line 16) | const IGNORE_UNKNOWN: protobuf_json_mapping::ParseOptions = protobuf_jso...
  type JsonValue (line 21) | type JsonValue = serde_json::Value;
  type ProtocolError (line 24) | enum ProtocolError {
  method from (line 40) | fn from(err: ProtocolError) -> Self {
  type Payload (line 49) | pub(super) struct Payload {
  type WebsocketRequest (line 54) | pub(super) struct WebsocketRequest {
    method handle_payload (line 150) | pub fn handle_payload(&self) -> Result<Request, Error> {
  type WebsocketMessage (line 63) | pub(super) struct WebsocketMessage {
    method handle_payload (line 129) | pub fn handle_payload(&mut self) -> Result<PayloadValue, Error> {
  type MessagePayloadValue (line 74) | pub enum MessagePayloadValue {
  type MessageOrRequest (line 82) | pub(super) enum MessageOrRequest {
  type PayloadValue (line 88) | pub enum PayloadValue {
  type Message (line 95) | pub struct Message {
    method try_from_json (line 109) | pub fn try_from_json<M: protobuf::MessageFull>(
    method from_raw (line 118) | pub fn from_raw<M: protobuf::Message>(value: Self) -> Result<M, Error> {
  type FallbackWrapper (line 103) | pub enum FallbackWrapper<T: protobuf::MessageFull> {
  function handle_transfer_encoding (line 172) | fn handle_transfer_encoding(

FILE: core/src/dealer/protocol/request.rs
  type Request (line 15) | pub struct Request {
  type Command (line 25) | pub enum Command {
  method fmt (line 48) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type TransferCommand (line 84) | pub struct TransferCommand {
  type PlayCommand (line 93) | pub struct PlayCommand {
  type PauseCommand (line 103) | pub struct PauseCommand {
  type SeekToCommand (line 109) | pub struct SeekToCommand {
  type SkipNextCommand (line 116) | pub struct SkipNextCommand {
  type SetValueCommand (line 123) | pub struct SetValueCommand {
  type AddToQueueCommand (line 129) | pub struct AddToQueueCommand {
  type SetQueueCommand (line 136) | pub struct SetQueueCommand {
  type SetOptionsCommand (line 148) | pub struct SetOptionsCommand {
  type UpdateContextCommand (line 157) | pub struct UpdateContextCommand {
  type GenericCommand (line 164) | pub struct GenericCommand {
  type TransferOptions (line 169) | pub struct TransferOptions {
  type PlayOptions (line 181) | pub struct PlayOptions {
  type OptionsOptions (line 197) | pub struct OptionsOptions {
  type SkipTo (line 204) | pub struct SkipTo {
  type LoggingParams (line 211) | pub struct LoggingParams {

FILE: core/src/deserialize_with.rs
  constant IGNORE_UNKNOWN (line 8) | const IGNORE_UNKNOWN: protobuf_json_mapping::ParseOptions = protobuf_jso...
  function parse_value_to_msg (line 13) | fn parse_value_to_msg<T: MessageFull>(
  function base64_proto (line 19) | pub fn base64_proto<'de, T, D>(de: D) -> Result<Option<T>, D::Error>
  function json_proto (line 32) | pub fn json_proto<'de, T, D>(de: D) -> Result<T, D::Error>
  function option_json_proto (line 41) | pub fn option_json_proto<'de, T, D>(de: D) -> Result<Option<T>, D::Error>
  function vec_json_proto (line 50) | pub fn vec_json_proto<'de, T, D>(de: D) -> Result<Vec<T>, D::Error>
  function boxed (line 69) | pub fn boxed<'de, T, D>(de: D) -> Result<Box<T>, D::Error>
  function bool_from_string (line 78) | pub fn bool_from_string<'de, D>(de: D) -> Result<bool, D::Error>

FILE: core/src/diffie_hellman.rs
  function powm (line 21) | fn powm(base: &BigUint, exp: &BigUint, modulus: &BigUint) -> BigUint {
  type DhLocalKeys (line 37) | pub struct DhLocalKeys {
    method random (line 43) | pub fn random<R: Rng + CryptoRng>(rng: &mut R) -> DhLocalKeys {
    method public_key (line 55) | pub fn public_key(&self) -> Vec<u8> {
    method shared_secret (line 59) | pub fn shared_secret(&self, remote_key: &[u8]) -> Vec<u8> {

FILE: core/src/error.rs
  type Error (line 25) | pub struct Error {
    method new (line 94) | pub fn new<E>(kind: ErrorKind, error: E) -> Error
    method aborted (line 104) | pub fn aborted<E>(error: E) -> Error
    method already_exists (line 114) | pub fn already_exists<E>(error: E) -> Error
    method cancelled (line 124) | pub fn cancelled<E>(error: E) -> Error
    method data_loss (line 134) | pub fn data_loss<E>(error: E) -> Error
    method deadline_exceeded (line 144) | pub fn deadline_exceeded<E>(error: E) -> Error
    method do_not_use (line 154) | pub fn do_not_use<E>(error: E) -> Error
    method failed_precondition (line 164) | pub fn failed_precondition<E>(error: E) -> Error
    method internal (line 174) | pub fn internal<E>(error: E) -> Error
    method invalid_argument (line 184) | pub fn invalid_argument<E>(error: E) -> Error
    method not_found (line 194) | pub fn not_found<E>(error: E) -> Error
    method out_of_range (line 204) | pub fn out_of_range<E>(error: E) -> Error
    method permission_denied (line 214) | pub fn permission_denied<E>(error: E) -> Error
    method resource_exhausted (line 224) | pub fn resource_exhausted<E>(error: E) -> Error
    method unauthenticated (line 234) | pub fn unauthenticated<E>(error: E) -> Error
    method unavailable (line 244) | pub fn unavailable<E>(error: E) -> Error
    method unimplemented (line 254) | pub fn unimplemented<E>(error: E) -> Error
    method unknown (line 264) | pub fn unknown<E>(error: E) -> Error
    method source (line 276) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 282) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 290) | fn from(err: OAuthError) -> Self {
    method from (line 309) | fn from(err: DecodeError) -> Self {
    method from (line 315) | fn from(err: http::Error) -> Self {
    method from (line 334) | fn from(err: hyper::Error) -> Self {
    method from (line 360) | fn from(err: hyper_util::client::legacy::Error) -> Self {
    method from (line 370) | fn from(err: time::error::Parse) -> Self {
    method from (line 376) | fn from(err: quick_xml::Error) -> Self {
    method from (line 382) | fn from(err: serde_json::Error) -> Self {
    method from (line 388) | fn from(err: std::io::Error) -> Self {
    method from (line 417) | fn from(err: FromUtf8Error) -> Self {
    method from (line 423) | fn from(err: InvalidHeaderValue) -> Self {
    method from (line 429) | fn from(err: InvalidUri) -> Self {
    method from (line 435) | fn from(err: ParseError) -> Self {
    method from (line 441) | fn from(err: ParseIntError) -> Self {
    method from (line 447) | fn from(err: TryFromIntError) -> Self {
    method from (line 453) | fn from(err: ProtobufError) -> Self {
    method from (line 459) | fn from(err: RecvError) -> Self {
    method from (line 465) | fn from(err: SendError<T>) -> Self {
    method from (line 474) | fn from(err: AcquireError) -> Self {
    method from (line 483) | fn from(err: TryAcquireError) -> Self {
    method from (line 492) | fn from(err: ToStrError) -> Self {
    method from (line 498) | fn from(err: Utf8Error) -> Self {
    method from (line 504) | fn from(err: protobuf_json_mapping::ParseError) -> Self {
  type ErrorKind (line 31) | pub enum ErrorKind {
  type ErrorMessage (line 85) | struct ErrorMessage(String);
    method fmt (line 88) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/src/file_id.rs
  constant RAW_LEN (line 5) | const RAW_LEN: usize = 20;
  type FileId (line 8) | pub struct FileId(pub [u8; RAW_LEN]);
    method from_raw (line 11) | pub fn from_raw(src: &[u8]) -> FileId {
    method to_base16 (line 22) | pub fn to_base16(&self) -> String {
    method fmt (line 32) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 44) | fn from(src: &[u8]) -> Self {
    method from (line 49) | fn from(image: &protocol::metadata::Image) -> Self {
    method from (line 55) | fn from(file: &protocol::metadata::AudioFile) -> Self {
    method from (line 61) | fn from(video: &protocol::metadata::VideoFile) -> Self {

FILE: core/src/http_client.rs
  constant RATE_LIMIT_INTERVAL (line 39) | pub const RATE_LIMIT_INTERVAL: Duration = Duration::from_secs(30);
  constant RATE_LIMIT_MAX_WAIT (line 40) | pub const RATE_LIMIT_MAX_WAIT: Duration = Duration::from_secs(10);
  constant RATE_LIMIT_CALLS_PER_INTERVAL (line 41) | pub const RATE_LIMIT_CALLS_PER_INTERVAL: u32 = 300;
  type HttpClientError (line 44) | pub enum HttpClientError {
  method from (line 50) | fn from(err: HttpClientError) -> Self {
  type HyperClient (line 95) | type HyperClient = Client<ProxyConnector<HttpsConnector<HttpConnector>>,...
  type HttpClient (line 97) | pub struct HttpClient {
    method new (line 107) | pub fn new(proxy_url: Option<&Url>) -> Self {
    method try_create_hyper_client (line 147) | fn try_create_hyper_client(proxy_url: Option<&Url>) -> Result<HyperCli...
    method hyper_client (line 176) | fn hyper_client(&self) -> &HyperClient {
    method request (line 181) | pub async fn request(&self, req: Request<Bytes>) -> Result<Response<In...
    method request_body (line 224) | pub async fn request_body(&self, req: Request<Bytes>) -> Result<Bytes,...
    method request_stream (line 229) | pub fn request_stream(&self, req: Request<Bytes>) -> Result<IntoStream...
    method request_fut (line 233) | pub fn request_fut(&self, mut req: Request<Bytes>) -> Result<ResponseF...
    method get_retry_after (line 259) | pub fn get_retry_after(headers: &HeaderMap<HeaderValue>) -> Option<Dur...

FILE: core/src/login5.rs
  constant MAX_LOGIN_TRIES (line 23) | const MAX_LOGIN_TRIES: u8 = 3;
  constant LOGIN_TIMEOUT (line 24) | const LOGIN_TIMEOUT: Duration = Duration::from_secs(3);
  type Login5Error (line 33) | enum Login5Error {
  method from (line 47) | fn from(err: Login5Error) -> Self {
  method request (line 61) | async fn request(&self, message: &LoginRequest) -> Result<Bytes, Error> {
  method login5_request (line 75) | async fn login5_request(&self, login: Login_method) -> Result<LoginOk, E...
  method login (line 136) | pub async fn login(
  method auth_token (line 166) | pub async fn auth_token(&self) -> Result<Token, Error> {
  method handle_challenges (line 207) | fn handle_challenges(
  method token_from_login (line 261) | fn token_from_login(token: String, expires_in: i32) -> Token {

FILE: core/src/mercury/mod.rs
  type MercuryPending (line 31) | pub struct MercuryPending {
  type MercuryFuture (line 37) | pub struct MercuryFuture<T> {
  type Output (line 42) | type Output = Result<T, Error>;
  method poll (line 44) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method next_seq (line 50) | fn next_seq(&self) -> Vec<u8> {
  method request (line 56) | fn request(&self, req: MercuryRequest) -> Result<MercuryFuture<MercuryRe...
  method get (line 79) | pub fn get<T: Into<String>>(&self, uri: T) -> Result<MercuryFuture<Mercu...
  method send (line 88) | pub fn send<T: Into<String>>(
  method sender (line 101) | pub fn sender<T: Into<String>>(&self, uri: T) -> MercurySender {
  method subscribe (line 105) | pub fn subscribe<T: Into<String>>(
  method listen_for (line 154) | pub fn listen_for<T: Into<String>>(
  method dispatch (line 175) | pub(crate) fn dispatch(&self, cmd: PacketType, mut data: Bytes) -> Resul...
  method parse_part (line 223) | fn parse_part(data: &mut Bytes) -> Vec<u8> {
  method complete_request (line 228) | fn complete_request(&self, cmd: PacketType, mut pending: MercuryPending)...
  method shutdown (line 298) | pub(crate) fn shutdown(&self) {

FILE: core/src/mercury/sender.rs
  type MercurySender (line 7) | pub struct MercurySender {
    method new (line 15) | pub(crate) fn new(mercury: MercuryManager, uri: String) -> MercurySend...
    method is_flushed (line 24) | pub fn is_flushed(&self) -> bool {
    method send (line 28) | pub fn send(&mut self, item: Vec<u8>) -> Result<(), Error> {
    method flush (line 34) | pub async fn flush(&mut self) -> Result<(), Error> {
  method clone (line 48) | fn clone(&self) -> MercurySender {

FILE: core/src/mercury/types.rs
  type MercuryMethod (line 10) | pub enum MercuryMethod {
    method fmt (line 53) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method command (line 65) | pub fn command(&self) -> PacketType {
  type MercuryRequest (line 18) | pub struct MercuryRequest {
    method encode (line 76) | pub fn encode(&self, seq: &[u8]) -> Result<Vec<u8>, Error> {
  type MercuryResponse (line 26) | pub struct MercuryResponse {
  type MercuryError (line 33) | pub enum MercuryError {
  method from (line 43) | fn from(err: MercuryError) -> Self {

FILE: core/src/packet.rs
  type PacketType (line 6) | pub enum PacketType {

FILE: core/src/proxytunnel.rs
  function proxy_connect (line 5) | pub async fn proxy_connect<T: AsyncRead + AsyncWrite + Unpin>(

FILE: core/src/session.rs
  constant SESSION_DATA_POISON_MSG (line 46) | const SESSION_DATA_POISON_MSG: &str = "session data rwlock should not be...
  type SessionError (line 49) | pub enum SessionError {
  method from (line 61) | fn from(err: SessionError) -> Self {
  method from (line 72) | fn from(err: quick_xml::encoding::EncodingError) -> Self {
  type UserAttributes (line 77) | pub type UserAttributes = HashMap<String, String>;
  type UserData (line 80) | pub struct UserData {
  type SessionData (line 87) | struct SessionData {
  type SessionInternal (line 100) | struct SessionInternal {
  type Session (line 130) | pub struct Session(Arc<SessionInternal>);
    method new (line 133) | pub fn new(config: SessionConfig, cache: Option<Cache>) -> Self {
    method connect_inner (line 163) | async fn connect_inner(
    method connect (line 206) | pub async fn connect(
    method apresolver (line 290) | pub fn apresolver(&self) -> &ApResolver {
    method audio_key (line 296) | pub fn audio_key(&self) -> &AudioKeyManager {
    method channel (line 302) | pub fn channel(&self) -> &ChannelManager {
    method http_client (line 308) | pub fn http_client(&self) -> &HttpClient {
    method mercury (line 312) | pub fn mercury(&self) -> &MercuryManager {
    method dealer (line 318) | pub fn dealer(&self) -> &DealerManager {
    method spclient (line 324) | pub fn spclient(&self) -> &SpClient {
    method token_provider (line 328) | pub fn token_provider(&self) -> &TokenProvider {
    method login5 (line 334) | pub fn login5(&self) -> &Login5Manager {
    method time_delta (line 340) | pub fn time_delta(&self) -> i64 {
    method spawn (line 348) | pub fn spawn<T>(&self, task: T)
    method debug_info (line 356) | fn debug_info(&self) {
    method check_catalogue (line 364) | fn check_catalogue(attributes: &UserAttributes) {
    method send_packet (line 376) | pub fn send_packet(&self, cmd: PacketType, data: Vec<u8>) -> Result<()...
    method cache (line 383) | pub fn cache(&self) -> Option<&Arc<Cache>> {
    method config (line 387) | pub fn config(&self) -> &SessionConfig {
    method user_data (line 394) | pub fn user_data(&self) -> UserData {
    method session_id (line 403) | pub fn session_id(&self) -> String {
    method set_session_id (line 412) | pub fn set_session_id(&self, session_id: &str) {
    method device_id (line 423) | pub fn device_id(&self) -> &str {
    method client_id (line 427) | pub fn client_id(&self) -> String {
    method set_client_id (line 436) | pub fn set_client_id(&self, client_id: &str) {
    method client_name (line 447) | pub fn client_name(&self) -> String {
    method set_client_name (line 456) | pub fn set_client_name(&self, client_name: &str) {
    method client_brand_name (line 467) | pub fn client_brand_name(&self) -> String {
    method set_client_brand_name (line 476) | pub fn set_client_brand_name(&self, client_brand_name: &str) {
    method client_model_name (line 487) | pub fn client_model_name(&self) -> String {
    method set_client_model_name (line 496) | pub fn set_client_model_name(&self, client_model_name: &str) {
    method connection_id (line 507) | pub fn connection_id(&self) -> String {
    method set_connection_id (line 516) | pub fn set_connection_id(&self, connection_id: &str) {
    method username (line 527) | pub fn username(&self) -> String {
    method set_username (line 537) | pub fn set_username(&self, username: &str) {
    method auth_data (line 549) | pub fn auth_data(&self) -> Vec<u8> {
    method set_auth_data (line 558) | pub fn set_auth_data(&self, auth_data: &[u8]) {
    method country (line 569) | pub fn country(&self) -> String {
    method filter_explicit_content (line 579) | pub fn filter_explicit_content(&self) -> bool {
    method autoplay (line 586) | pub fn autoplay(&self) -> bool {
    method set_user_attribute (line 597) | pub fn set_user_attribute(&self, key: &str, value: &str) -> Option<Str...
    method set_user_attributes (line 611) | pub fn set_user_attributes(&self, attributes: UserAttributes) {
    method get_user_attribute (line 623) | pub fn get_user_attribute(&self, key: &str) -> Option<String> {
    method weak (line 634) | fn weak(&self) -> SessionWeak {
    method shutdown (line 638) | pub fn shutdown(&self) {
    method is_invalid (line 645) | pub fn is_invalid(&self) -> bool {
  type SessionWeak (line 651) | pub struct SessionWeak(Weak<SessionInternal>);
    method try_upgrade (line 654) | fn try_upgrade(&self) -> Option<Session> {
    method upgrade (line 658) | pub(crate) fn upgrade(&self) -> Session {
  method drop (line 665) | fn drop(&mut self) {
  type KeepAliveState (line 671) | enum KeepAliveState {
    method debug (line 689) | fn debug(&self, sleep: &Sleep) {
  constant INITIAL_PING_TIMEOUT (line 683) | const INITIAL_PING_TIMEOUT: TokioDuration = TokioDuration::from_secs(20);
  constant PING_TIMEOUT (line 684) | const PING_TIMEOUT: TokioDuration = TokioDuration::from_secs(80);
  constant PONG_DELAY (line 685) | const PONG_DELAY: TokioDuration = TokioDuration::from_secs(60);
  constant PONG_ACK_TIMEOUT (line 686) | const PONG_ACK_TIMEOUT: TokioDuration = TokioDuration::from_secs(20);
  function new (line 727) | fn new(session: SessionWeak, stream: S) -> Self {
  function dispatch (line 736) | fn dispatch(
  type Output (line 875) | type Output = Result<(), S::Error>;
  method poll (line 877) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: core/src/socket.rs
  function connect (line 8) | pub async fn connect(host: &str, port: u16, proxy: Option<&Url>) -> io::...

FILE: core/src/spclient.rs
  type SpClientResult (line 52) | pub type SpClientResult = Result<Bytes, Error>;
  constant CLIENT_TOKEN (line 55) | pub const CLIENT_TOKEN: HeaderName = HeaderName::from_static("client-tok...
  constant CONNECTION_ID (line 57) | const CONNECTION_ID: HeaderName = HeaderName::from_static("x-spotify-con...
  constant NO_METRICS_AND_SALT (line 59) | const NO_METRICS_AND_SALT: RequestOptions = RequestOptions {
  type SpClientError (line 66) | pub enum SpClientError {
  method from (line 76) | fn from(err: SpClientError) -> Self {
  type RequestStrategy (line 82) | pub enum RequestStrategy {
  method default (line 88) | fn default() -> Self {
  type RequestOptions (line 93) | pub struct RequestOptions {
  method default (line 100) | fn default() -> Self {
  type TransferRequest (line 110) | pub struct TransferRequest {
  method set_strategy (line 115) | pub fn set_strategy(&self, strategy: RequestStrategy) {
  method flush_accesspoint (line 119) | pub async fn flush_accesspoint(&self) {
  method get_accesspoint (line 123) | pub async fn get_accesspoint(&self) -> Result<SocketAddress, Error> {
  method base_url (line 141) | pub async fn base_url(&self) -> Result<String, Error> {
  method client_token_request (line 146) | async fn client_token_request<M: Message>(&self, message: &M) -> Result<...
  method client_token (line 158) | pub async fn client_token(&self) -> Result<String, Error> {
  method request_with_protobuf (line 378) | pub async fn request_with_protobuf<M: Message + MessageFull>(
  method request_with_protobuf_and_options (line 395) | pub async fn request_with_protobuf_and_options<M: Message + MessageFull>(
  method request_as_json (line 415) | pub async fn request_as_json(
  method request (line 429) | pub async fn request(
  method request_with_options (line 440) | pub async fn request_with_options(
  method put_connect_state_request (line 552) | pub async fn put_connect_state_request(&self, state: &PutStateRequest) -...
  method delete_connect_state_request (line 562) | pub async fn delete_connect_state_request(&self) -> SpClientResult {
  method put_connect_state_inactive (line 567) | pub async fn put_connect_state_inactive(&self, notify: bool) -> SpClient...
  method get_extended_metadata (line 580) | pub async fn get_extended_metadata(
  method get_metadata (line 595) | pub async fn get_metadata(&self, kind: ExtensionKind, id: &SpotifyUri) -...
  method get_track_metadata (line 625) | pub async fn get_track_metadata(&self, track_uri: &SpotifyUri) -> SpClie...
  method get_episode_metadata (line 629) | pub async fn get_episode_metadata(&self, episode_uri: &SpotifyUri) -> Sp...
  method get_album_metadata (line 634) | pub async fn get_album_metadata(&self, album_uri: &SpotifyUri) -> SpClie...
  method get_artist_metadata (line 638) | pub async fn get_artist_metadata(&self, artist_uri: &SpotifyUri) -> SpCl...
  method get_show_metadata (line 643) | pub async fn get_show_metadata(&self, show_uri: &SpotifyUri) -> SpClient...
  method get_lyrics (line 647) | pub async fn get_lyrics(&self, track_id: &SpotifyId) -> SpClientResult {
  method get_lyrics_for_image (line 654) | pub async fn get_lyrics_for_image(
  method get_playlist (line 669) | pub async fn get_playlist(&self, playlist_id: &SpotifyId) -> SpClientRes...
  method get_user_profile (line 675) | pub async fn get_user_profile(
  method get_user_followers (line 702) | pub async fn get_user_followers(&self, username: &str) -> SpClientResult {
  method get_user_following (line 709) | pub async fn get_user_following(&self, username: &str) -> SpClientResult {
  method get_radio_for_track (line 716) | pub async fn get_radio_for_track(&self, track_uri: &SpotifyUri) -> SpCli...
  method get_apollo_station (line 735) | pub async fn get_apollo_station(
  method get_next_page (line 764) | pub async fn get_next_page(&self, next_page_uri: &str) -> SpClientResult {
  method get_audio_storage (line 773) | pub async fn get_audio_storage(&self, file_id: &FileId) -> SpClientResult {
  method stream_from_cdn (line 781) | pub fn stream_from_cdn<U>(
  method request_url (line 805) | pub async fn request_url(&self, url: &str) -> SpClientResult {
  method get_audio_preview (line 815) | pub async fn get_audio_preview(&self, preview_id: &FileId) -> SpClientRe...
  method get_head_file (line 833) | pub async fn get_head_file(&self, file_id: &FileId) -> SpClientResult {
  method get_image (line 845) | pub async fn get_image(&self, image_id: &FileId) -> SpClientResult {
  method get_context (line 879) | pub async fn get_context(&self, uri: &str) -> Result<Context, Error> {
  method get_autoplay_context (line 899) | pub async fn get_autoplay_context(
  method get_rootlist (line 927) | pub async fn get_rootlist(&self, from: usize, length: Option<usize>) -> ...
  method transfer (line 941) | pub async fn transfer(

FILE: core/src/spotify_id.rs
  type SpotifyId (line 11) | pub struct SpotifyId {
    constant SIZE (line 34) | const SIZE: usize = 16;
    constant SIZE_BASE62 (line 35) | const SIZE_BASE62: usize = 22;
    method from_base16 (line 42) | pub fn from_base16(src: &str) -> SpotifyIdResult {
    method from_base62 (line 56) | pub fn from_base62(src: &str) -> SpotifyIdResult {
    method from_raw (line 80) | pub fn from_raw(src: &[u8]) -> SpotifyIdResult {
    method to_base16 (line 91) | pub fn to_base16(&self) -> String {
    method to_base62 (line 100) | pub fn to_base62(&self) -> String {
    method to_raw (line 143) | pub fn to_raw(&self) -> [u8; Self::SIZE] {
    method fmt (line 149) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 155) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 161) | type Error = crate::Error;
    method try_from (line 162) | fn try_from(src: &[u8]) -> Result<Self, Self::Error> {
    type Error (line 168) | type Error = crate::Error;
    method try_from (line 169) | fn try_from(src: &str) -> Result<Self, Self::Error> {
    type Error (line 175) | type Error = crate::Error;
    method try_from (line 176) | fn try_from(src: String) -> Result<Self, Self::Error> {
    type Error (line 182) | type Error = crate::Error;
    method try_from (line 183) | fn try_from(src: &Vec<u8>) -> Result<Self, Self::Error> {
    type Error (line 189) | type Error = crate::Error;
    method try_from (line 190) | fn try_from(value: &SpotifyUri) -> Result<Self, Self::Error> {
  type SpotifyIdError (line 16) | pub enum SpotifyIdError {
  method from (line 24) | fn from(err: SpotifyIdError) -> Self {
  type SpotifyIdResult (line 29) | pub type SpotifyIdResult = Result<SpotifyId, Error>;
  constant BASE62_DIGITS (line 31) | const BASE62_DIGITS: &[u8; 62] = b"0123456789abcdefghijklmnopqrstuvwxyzA...
  type ConversionCase (line 209) | struct ConversionCase {
  function from_base62 (line 310) | fn from_base62() {
  function to_base62 (line 321) | fn to_base62() {
  function from_base16 (line 330) | fn from_base16() {
  function to_base16 (line 341) | fn to_base16() {
  function from_raw (line 350) | fn from_raw() {

FILE: core/src/spotify_uri.rs
  constant SPOTIFY_ITEM_TYPE_ALBUM (line 7) | const SPOTIFY_ITEM_TYPE_ALBUM: &str = "album";
  constant SPOTIFY_ITEM_TYPE_ARTIST (line 8) | const SPOTIFY_ITEM_TYPE_ARTIST: &str = "artist";
  constant SPOTIFY_ITEM_TYPE_EPISODE (line 9) | const SPOTIFY_ITEM_TYPE_EPISODE: &str = "episode";
  constant SPOTIFY_ITEM_TYPE_PLAYLIST (line 10) | const SPOTIFY_ITEM_TYPE_PLAYLIST: &str = "playlist";
  constant SPOTIFY_ITEM_TYPE_SHOW (line 11) | const SPOTIFY_ITEM_TYPE_SHOW: &str = "show";
  constant SPOTIFY_ITEM_TYPE_TRACK (line 12) | const SPOTIFY_ITEM_TYPE_TRACK: &str = "track";
  constant SPOTIFY_ITEM_TYPE_LOCAL (line 13) | const SPOTIFY_ITEM_TYPE_LOCAL: &str = "local";
  constant SPOTIFY_ITEM_TYPE_UNKNOWN (line 14) | const SPOTIFY_ITEM_TYPE_UNKNOWN: &str = "unknown";
  type SpotifyUriError (line 17) | pub enum SpotifyUriError {
  method from (line 25) | fn from(err: SpotifyUriError) -> Self {
  type SpotifyUriResult (line 30) | pub type SpotifyUriResult = Result<SpotifyUri, Error>;
  type SpotifyUri (line 33) | pub enum SpotifyUri {
    method is_playable (line 67) | pub fn is_playable(&self) -> bool {
    method item_type (line 75) | pub fn item_type(&self) -> &'static str {
    method to_id (line 90) | pub fn to_id(&self) -> String {
    method from_uri (line 121) | pub fn from_uri(src: &str) -> SpotifyUriResult {
    method to_uri (line 206) | pub fn to_uri(&self) -> String {
    method to_base62 (line 227) | pub fn to_base62(&self) -> String {
    method fmt (line 233) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 239) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 245) | type Error = crate::Error;
    method try_from (line 246) | fn try_from(album: &protocol::metadata::Album) -> Result<Self, Self::E...
    type Error (line 254) | type Error = crate::Error;
    method try_from (line 255) | fn try_from(artist: &protocol::metadata::Artist) -> Result<Self, Self:...
    type Error (line 263) | type Error = crate::Error;
    method try_from (line 264) | fn try_from(episode: &protocol::metadata::Episode) -> Result<Self, Sel...
    type Error (line 272) | type Error = crate::Error;
    method try_from (line 273) | fn try_from(track: &protocol::metadata::Track) -> Result<Self, Self::E...
    type Error (line 281) | type Error = crate::Error;
    method try_from (line 282) | fn try_from(show: &protocol::metadata::Show) -> Result<Self, Self::Err...
    type Error (line 290) | type Error = crate::Error;
    method try_from (line 291) | fn try_from(artist: &protocol::metadata::ArtistWithRole) -> Result<Sel...
    type Error (line 299) | type Error = crate::Error;
    method try_from (line 300) | fn try_from(item: &protocol::playlist4_external::Item) -> Result<Self,...
    type Error (line 308) | type Error = crate::Error;
    method try_from (line 309) | fn try_from(item: &protocol::playlist4_external::MetaItem) -> Result<S...
    type Error (line 319) | type Error = crate::Error;
    method try_from (line 320) | fn try_from(
    type Error (line 334) | type Error = crate::Error;
    method try_from (line 335) | fn try_from(
  type ConversionCase (line 349) | struct ConversionCase {
  type ItemTypeCase (line 439) | struct ItemTypeCase {
  function to_id (line 485) | fn to_id() {
  function item_type (line 492) | fn item_type() {
  function from_uri (line 518) | fn from_uri() {
  function from_invalid_type_uri (line 531) | fn from_invalid_type_uri() {
  function from_local_uri (line 545) | fn from_local_uri() {
  function from_local_uri_missing_fields (line 563) | fn from_local_uri_missing_fields() {
  function from_named_uri (line 578) | fn from_named_uri() {
  function to_uri (line 596) | fn to_uri() {
  function to_named_uri (line 603) | fn to_named_uri() {

FILE: core/src/token.rs
  type TokenError (line 25) | pub enum TokenError {
  method from (line 31) | fn from(err: TokenError) -> Self {
  type Token (line 37) | pub struct Token {
    constant EXPIRY_THRESHOLD (line 109) | const EXPIRY_THRESHOLD: Duration = Duration::from_secs(10);
    method from_json (line 111) | pub fn from_json(body: String) -> Result<Self, Error> {
    method is_expired (line 122) | pub fn is_expired(&self) -> bool {
    method in_scope (line 126) | pub fn in_scope(&self, scope: &str) -> bool {
    method in_scopes (line 135) | pub fn in_scopes(&self, scopes: Vec<&str>) -> bool {
  type TokenData (line 47) | struct TokenData {
  method find_token (line 55) | fn find_token(&self, scopes: Vec<&str>) -> Option<usize> {
  method get_token (line 65) | pub async fn get_token(&self, scopes: &str) -> Result<Token, Error> {
  method get_token_with_client_id (line 70) | pub async fn get_token_with_client_id(

FILE: core/src/util.rs
  function keep_flushing (line 18) | pub(crate) fn keep_flushing<'a, T, S: Sink<T> + Unpin + 'a>(
  type CancelOnDrop (line 27) | pub struct CancelOnDrop<T>(pub JoinHandle<T>);
  type Output (line 30) | type Output = <JoinHandle<T> as Future>::Output;
  method poll (line 32) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method drop (line 38) | fn drop(&mut self) {
  type TimeoutOnDrop (line 43) | pub struct TimeoutOnDrop<T: Send + 'static> {
  function new (line 49) | pub fn new(handle: JoinHandle<T>, timeout: tokio::time::Duration) -> Self {
  function take (line 56) | pub fn take(&mut self) -> Option<JoinHandle<T>> {
  type Output (line 62) | type Output = <JoinHandle<T> as Future>::Output;
  method poll (line 64) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method drop (line 77) | fn drop(&mut self) {
  type Seq (line 101) | pub trait Seq {
    method next (line 102) | fn next(&self) -> Self;
  type SeqGenerator (line 116) | pub struct SeqGenerator<T: Seq>(T);
  function new (line 119) | pub fn new(value: T) -> Self {
  function get (line 123) | pub fn get(&mut self) -> T {
  function solve_hash_cash (line 129) | pub fn solve_hash_cash(
  function get_next_query_separator (line 170) | pub fn get_next_query_separator(url: &str) -> &'static str {

FILE: core/src/version.rs
  constant VERSION_STRING (line 2) | pub const VERSION_STRING: &str = concat!("librespot-", env!("VERGEN_GIT_...
  constant BUILD_DATE (line 5) | pub const BUILD_DATE: &str = env!("VERGEN_BUILD_DATE");
  constant SHA_SHORT (line 8) | pub const SHA_SHORT: &str = env!("VERGEN_GIT_SHA");
  constant COMMIT_DATE (line 11) | pub const COMMIT_DATE: &str = env!("VERGEN_GIT_COMMIT_DATE");
  constant SEMVER (line 14) | pub const SEMVER: &str = env!("CARGO_PKG_VERSION");
  constant BUILD_ID (line 17) | pub const BUILD_ID: &str = env!("LIBRESPOT_BUILD_ID");
  constant SPOTIFY_VERSION (line 20) | pub const SPOTIFY_VERSION: u64 = 124200290;
  constant SPOTIFY_SEMANTIC_VERSION (line 23) | pub const SPOTIFY_SEMANTIC_VERSION: &str = "1.2.52.442";
  constant SPOTIFY_PROPERTY_SET_ID (line 26) | pub const SPOTIFY_PROPERTY_SET_ID: &str = "b4c7e4b5835079ed94391b2e65fca...
  constant SPOTIFY_MOBILE_VERSION (line 29) | pub const SPOTIFY_MOBILE_VERSION: &str = "8.9.82.620";
  constant SPOTIFY_MOBILE_PROPERTY_SET_ID (line 32) | pub const SPOTIFY_MOBILE_PROPERTY_SET_ID: &str =
  constant SPOTIFY_SPIRC_VERSION (line 36) | pub const SPOTIFY_SPIRC_VERSION: &str = "3.2.6";
  constant FALLBACK_USER_AGENT (line 39) | pub const FALLBACK_USER_AGENT: &str = "Spotify/124200290 Linux/0 (libres...
  function spotify_version (line 41) | pub fn spotify_version() -> String {
  function spotify_semantic_version (line 48) | pub fn spotify_semantic_version() -> String {

FILE: core/tests/connect.rs
  function test_connection (line 8) | async fn test_connection() {

FILE: discovery/examples/discovery.rs
  function main (line 7) | async fn main() {

FILE: discovery/examples/discovery_group.rs
  function main (line 7) | async fn main() {

FILE: discovery/src/avahi.rs
  type Server (line 22) | pub trait Server {
    method entry_group_new (line 25) | fn entry_group_new(&self);
    method get_state (line 28) | fn get_state(&self) -> zbus::Result<i32>;
    method state_changed (line 32) | fn state_changed(&self, state: i32, error: &str) -> zbus::Result<()>;
  type EntryGroupState (line 42) | pub enum EntryGroupState {
    constant SIGNATURE (line 56) | const SIGNATURE: &'static zvariant::Signature = &zvariant::Signature::...
  type EntryGroup (line 64) | pub trait EntryGroup {
    method add_address (line 66) | fn add_address(
    method add_record (line 77) | fn add_record(
    method add_service (line 91) | fn add_service(
    method add_service_subtype (line 106) | fn add_service_subtype(
    method commit (line 118) | fn commit(&self) -> zbus::Result<()>;
    method free (line 121) | fn free(&self) -> zbus::Result<()>;
    method get_state (line 124) | fn get_state(&self) -> zbus::Result<EntryGroupState>;
    method is_empty (line 127) | fn is_empty(&self) -> zbus::Result<bool>;
    method reset (line 130) | fn reset(&self) -> zbus::Result<()>;
    method update_service_txt (line 134) | fn update_service_txt(
    method state_changed (line 147) | fn state_changed(&self, state: EntryGroupState, error: &str) -> zbus::...

FILE: discovery/src/lib.rs
  type DiscoveryEvent (line 35) | pub enum DiscoveryEvent {
  type ZeroconfCmd (line 41) | enum ZeroconfCmd {
  type DnsSdHandle (line 45) | pub struct DnsSdHandle {
    method shutdown (line 51) | async fn shutdown(self) {
  type DnsSdServiceBuilder (line 66) | pub type DnsSdServiceBuilder = fn(
  constant BACKENDS (line 75) | pub const BACKENDS: &[(
  function find (line 94) | pub fn find(name: Option<&str>) -> Result<DnsSdServiceBuilder, Error> {
  type Discovery (line 119) | pub struct Discovery {
    method builder (line 525) | pub fn builder<T: Into<String>>(device_id: T, client_id: T) -> Builder {
    method new (line 530) | pub fn new<T: Into<String>>(device_id: T, client_id: T) -> Result<Self...
    method shutdown (line 534) | pub async fn shutdown(self) {
  type Builder (line 130) | pub struct Builder {
    method new (line 432) | pub fn new<T: Into<String>>(device_id: T, client_id: T) -> Self {
    method name (line 449) | pub fn name(mut self, name: impl Into<Cow<'static, str>>) -> Self {
    method device_type (line 455) | pub fn device_type(mut self, device_type: DeviceType) -> Self {
    method is_group (line 461) | pub fn is_group(mut self, is_group: bool) -> Self {
    method add_alias (line 467) | pub fn add_alias(
    method zeroconf_ip (line 482) | pub fn zeroconf_ip(mut self, zeroconf_ip: Vec<std::net::IpAddr>) -> Se...
    method zeroconf_backend (line 488) | pub fn zeroconf_backend(mut self, zeroconf_backend: DnsSdServiceBuilde...
    method port (line 495) | pub fn port(mut self, port: u16) -> Self {
    method launch (line 504) | pub fn launch(self) -> Result<Discovery, Error> {
  type DiscoveryError (line 139) | pub enum DiscoveryError {
    method from (line 158) | fn from(error: zbus::Error) -> Self {
  method from (line 164) | fn from(err: DiscoveryError) -> Self {
  constant DNS_SD_SERVICE_NAME (line 176) | const DNS_SD_SERVICE_NAME: &str = "_spotify-connect._tcp";
  constant TXT_RECORD (line 178) | const TXT_RECORD: [&str; 2] = ["VERSION=1.0", "CPath=/"];
  function avahi_task (line 181) | async fn avahi_task(
  function launch_avahi (line 313) | fn launch_avahi(
  function launch_dns_sd (line 349) | fn launch_dns_sd(
  function launch_libmdns (line 389) | fn launch_libmdns(
  type Item (line 540) | type Item = Credentials;
  method poll_next (line 542) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: discovery/src/server.rs
  type Aes128Ctr (line 30) | type Aes128Ctr = ctr::Ctr128BE<aes::Aes128>;
  type Params (line 32) | type Params<'a> = BTreeMap<Cow<'a, str>, Cow<'a, str>>;
  type Alias (line 34) | pub struct Alias {
  type Config (line 40) | pub struct Config {
  type RequestHandler (line 49) | struct RequestHandler {
    method new (line 57) | fn new(config: Config, event_tx: mpsc::UnboundedSender<DiscoveryEvent>...
    method active_user (line 66) | fn active_user(&self) -> String {
    method handle_get_info (line 75) | fn handle_get_info(&self) -> Response<Full<Bytes>> {
    method handle_add_user (line 135) | fn handle_add_user(&self, params: &Params<'_>) -> Result<Response<Full...
    method not_found (line 231) | fn not_found(&self) -> Response<Full<Bytes>> {
    method handle (line 237) | async fn handle(
  type DiscoveryServerCmd (line 268) | pub(crate) enum DiscoveryServerCmd {
  type DiscoveryServer (line 272) | pub struct DiscoveryServer {
    method new (line 278) | pub fn new(
    method shutdown (line 358) | pub async fn shutdown(self) {

FILE: examples/get_token.rs
  constant SCOPES (line 5) | const SCOPES: &str =
  function main (line 9) | async fn main() {

FILE: examples/play.rs
  function main (line 17) | async fn main() {

FILE: examples/play_connect.rs
  constant CACHE (line 17) | const CACHE: &str = ".cache";
  constant CACHE_FILES (line 18) | const CACHE_FILES: &str = ".cache/files";
  function main (line 21) | async fn main() -> Result<(), Error> {

FILE: examples/playlist_tracks.rs
  function main (line 12) | async fn main() {

FILE: metadata/src/album.rs
  type Album (line 27) | pub struct Album {
    method tracks (line 68) | pub fn tracks(&self) -> impl Iterator<Item = &SpotifyUri> {
    type Error (line 91) | type Error = librespot_core::Error;
    method try_from (line 92) | fn try_from(album: &<Self as Metadata>::Message) -> Result<Self, Self:...
  type Albums (line 51) | pub struct Albums(pub Vec<SpotifyUri>);
  type Disc (line 56) | pub struct Disc {
    type Error (line 121) | type Error = librespot_core::Error;
    method try_from (line 122) | fn try_from(disc: &DiscMessage) -> Result<Self, Self::Error> {
  type Discs (line 63) | pub struct Discs(pub Vec<Disc>);
  type Message (line 75) | type Message = protocol::metadata::Album;
  method request (line 77) | async fn request(session: &Session, album_uri: &SpotifyUri) -> RequestRe...
  method parse (line 85) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/artist.rs
  type Artist (line 31) | pub struct Artist {
    method albums_current (line 143) | pub fn albums_current(&self) -> impl Iterator<Item = &SpotifyUri> {
    method singles_current (line 150) | pub fn singles_current(&self) -> impl Iterator<Item = &SpotifyUri> {
    method compilations_current (line 158) | pub fn compilations_current(&self) -> impl Iterator<Item = &SpotifyUri> {
    method appears_on_albums_current (line 165) | pub fn appears_on_albums_current(&self) -> impl Iterator<Item = &Spoti...
    type Error (line 188) | type Error = librespot_core::Error;
    method try_from (line 189) | fn try_from(artist: &<Self as Metadata>::Message) -> Result<Self, Self...
  type Artists (line 53) | pub struct Artists(pub Vec<Artist>);
  type ArtistWithRole (line 58) | pub struct ArtistWithRole {
    type Error (line 221) | type Error = librespot_core::Error;
    method try_from (line 222) | fn try_from(artist_with_role: &ArtistWithRoleMessage) -> Result<Self, ...
  type ArtistsWithRole (line 65) | pub struct ArtistsWithRole(pub Vec<ArtistWithRole>);
  type TopTracks (line 70) | pub struct TopTracks {
    type Error (line 234) | type Error = librespot_core::Error;
    method try_from (line 235) | fn try_from(top_tracks: &TopTracksMessage) -> Result<Self, Self::Error> {
  type CountryTopTracks (line 76) | pub struct CountryTopTracks(pub Vec<TopTracks>);
    method for_country (line 126) | pub fn for_country(&self, country: &str) -> Tracks {
  type AlbumGroup (line 81) | pub struct AlbumGroup(pub Albums);
    type Error (line 246) | type Error = librespot_core::Error;
    method try_from (line 247) | fn try_from(album_groups: &AlbumGroupMessage) -> Result<Self, Self::Er...
  type AlbumGroups (line 95) | pub struct AlbumGroups(pub Vec<AlbumGroup>);
    method current_releases (line 256) | pub fn current_releases(&self) -> impl Iterator<Item = &SpotifyUri> {
  type Biography (line 100) | pub struct Biography {
    method from (line 264) | fn from(biography: &BiographyMessage) -> Self {
  type Biographies (line 107) | pub struct Biographies(pub Vec<Biography>);
  type ActivityPeriod (line 112) | pub enum ActivityPeriod {
    type Error (line 282) | type Error = librespot_core::Error;
    method try_from (line 284) | fn try_from(period: &ActivityPeriodMessage) -> Result<Self, Self::Erro...
  type ActivityPeriods (line 121) | pub struct ActivityPeriods(pub Vec<ActivityPeriod>);
  type Message (line 172) | type Message = protocol::metadata::Artist;
  method request (line 174) | async fn request(session: &Session, artist_uri: &SpotifyUri) -> RequestR...
  method parse (line 182) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/audio/file.rs
  type AudioFileFormat (line 18) | pub enum AudioFileFormat {
    type Error (line 42) | type Error = i32;
    method try_from (line 44) | fn try_from(value: i32) -> Result<Self, Self::Error> {
    method from (line 56) | fn from(value: Format) -> Self {
  type AudioFiles (line 78) | pub struct AudioFiles(pub HashMap<AudioFileFormat, FileId>);
    method is_ogg_vorbis (line 83) | pub fn is_ogg_vorbis(format: AudioFileFormat) -> bool {
    method is_mp3 (line 92) | pub fn is_mp3(format: AudioFileFormat) -> bool {
    method is_flac (line 103) | pub fn is_flac(format: AudioFileFormat) -> bool {
    method mime_type (line 107) | pub fn mime_type(format: AudioFileFormat) -> Option<&'static str> {
    method from (line 121) | fn from(files: &[AudioFileMessage]) -> Self {

FILE: metadata/src/audio/item.rs
  type AudioItemResult (line 18) | pub type AudioItemResult = Result<AudioItem, Error>;
  type CoverImage (line 21) | pub struct CoverImage {
  type AudioItem (line 29) | pub struct AudioItem {
    method get_file (line 71) | pub async fn get_file(session: &Session, uri: SpotifyUri) -> AudioItem...
  type UniqueFields (line 44) | pub enum UniqueFields {
  function get_covers (line 194) | fn get_covers(covers: Images, image_url: String) -> Vec<CoverImage> {
  function allowed_for_user (line 220) | fn allowed_for_user(user_data: &UserData, restrictions: &Restrictions) -...
  function available (line 259) | fn available(availability: &Availabilities) -> AudioItemAvailability {
  function available_for_user (line 275) | fn available_for_user(

FILE: metadata/src/availability.rs
  type AudioItemAvailability (line 15) | pub type AudioItemAvailability = Result<(), UnavailabilityReason>;
  type Availability (line 18) | pub struct Availability {
    type Error (line 41) | type Error = librespot_core::Error;
    method try_from (line 42) | fn try_from(availability: &AvailabilityMessage) -> Result<Self, Self::...
  type Availabilities (line 24) | pub struct Availabilities(pub Vec<Availability>);
  type UnavailabilityReason (line 29) | pub enum UnavailabilityReason {

FILE: metadata/src/content_rating.rs
  type ContentRating (line 12) | pub struct ContentRating {
    method from (line 23) | fn from(content_rating: &ContentRatingMessage) -> Self {
  type ContentRatings (line 18) | pub struct ContentRatings(pub Vec<ContentRating>);

FILE: metadata/src/copyright.rs
  type Copyright (line 13) | pub struct Copyright {
    method from (line 24) | fn from(copyright: &CopyrightMessage) -> Self {
  type Copyrights (line 19) | pub struct Copyrights(pub Vec<Copyright>);

FILE: metadata/src/episode.rs
  type Episode (line 24) | pub struct Episode {
    type Error (line 74) | type Error = librespot_core::Error;
    method try_from (line 75) | fn try_from(episode: &<Self as Metadata>::Message) -> Result<Self, Sel...
  type Episodes (line 52) | pub struct Episodes(pub Vec<SpotifyUri>);
  type Message (line 58) | type Message = protocol::metadata::Episode;
  method request (line 60) | async fn request(session: &Session, episode_uri: &SpotifyUri) -> Request...
  method parse (line 68) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/error.rs
  type MetadataError (line 5) | pub enum MetadataError {

FILE: metadata/src/external_id.rs
  type ExternalId (line 12) | pub struct ExternalId {
    method from (line 23) | fn from(external_id: &ExternalIdMessage) -> Self {
  type ExternalIds (line 18) | pub struct ExternalIds(pub Vec<ExternalId>);

FILE: metadata/src/image.rs
  type Image (line 18) | pub struct Image {
    method from (line 59) | fn from(image: &ImageMessage) -> Self {
  type Images (line 26) | pub struct Images(pub Vec<Image>);
    method from (line 29) | fn from(image_group: &ImageGroup) -> Self {
  type PictureSize (line 37) | pub struct PictureSize {
    method from (line 72) | fn from(size: &PictureSizeMessage) -> Self {
  type PictureSizes (line 43) | pub struct PictureSizes(pub Vec<PictureSize>);
  type TranscodedPicture (line 48) | pub struct TranscodedPicture {
    type Error (line 83) | type Error = librespot_core::Error;
    method try_from (line 84) | fn try_from(picture: &TranscodedPictureMessage) -> Result<Self, Self::...
  type TranscodedPictures (line 54) | pub struct TranscodedPictures(pub Vec<TranscodedPicture>);

FILE: metadata/src/lib.rs
  type Metadata (line 43) | pub trait Metadata: Send + Sized + 'static {
    method request (line 47) | async fn request(session: &Session, id: &SpotifyUri) -> RequestResult;
    method get (line 50) | async fn get(session: &Session, id: &SpotifyUri) -> Result<Self, Error> {
    method parse (line 57) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error>;

FILE: metadata/src/lyrics.rs
  type Lyrics (line 33) | pub struct Lyrics {
    method get (line 6) | pub async fn get(session: &Session, id: &SpotifyId) -> Result<Self, Er...
    method get_for_image (line 12) | pub async fn get_for_image(
    type Error (line 24) | type Error = Error;
    method try_from (line 26) | fn try_from(lyrics: &Bytes) -> Result<Self, Self::Error> {
  type Colors (line 41) | pub struct Colors {
  type LyricsInner (line 49) | pub struct LyricsInner {
  type SyncType (line 64) | pub enum SyncType {
  type Line (line 71) | pub struct Line {

FILE: metadata/src/playlist/annotation.rs
  type PlaylistAnnotation (line 16) | pub struct PlaylistAnnotation {
    method request_for_user (line 53) | async fn request_for_user(
    method get_for_user (line 67) | async fn get_for_user(
    type Error (line 88) | type Error = librespot_core::Error;
    method try_from (line 89) | fn try_from(
  type Message (line 26) | type Message = protocol::playlist_annotate3::PlaylistAnnotation;
  method request (line 28) | async fn request(session: &Session, playlist_uri: &SpotifyUri) -> Reques...
  method parse (line 41) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/playlist/attribute.rs
  type PlaylistAttributes (line 26) | pub struct PlaylistAttributes {
    type Error (line 98) | type Error = librespot_core::Error;
    method try_from (line 99) | fn try_from(attributes: &PlaylistAttributesMessage) -> Result<Self, Se...
  type PlaylistAttributeKinds (line 40) | pub struct PlaylistAttributeKinds(pub Vec<PlaylistAttributeKind>);
  type PlaylistFormatAttribute (line 47) | pub struct PlaylistFormatAttribute(pub HashMap<String, String>);
    method from (line 116) | fn from(attributes: &[PlaylistFormatAttributeMessage]) -> Self {
  type PlaylistItemAttributes (line 52) | pub struct PlaylistItemAttributes {
    type Error (line 127) | type Error = librespot_core::Error;
    method try_from (line 128) | fn try_from(attributes: &PlaylistItemAttributesMessage) -> Result<Self...
  type PlaylistItemAttributeKinds (line 62) | pub struct PlaylistItemAttributeKinds(pub Vec<PlaylistItemAttributeKind>);
  type PlaylistPartialAttributes (line 69) | pub struct PlaylistPartialAttributes {
    type Error (line 140) | type Error = librespot_core::Error;
    method try_from (line 141) | fn try_from(attributes: &PlaylistPartialAttributesMessage) -> Result<S...
  type PlaylistPartialItemAttributes (line 77) | pub struct PlaylistPartialItemAttributes {
    type Error (line 156) | type Error = librespot_core::Error;
    method try_from (line 157) | fn try_from(attributes: &PlaylistPartialItemAttributesMessage) -> Resu...
  type PlaylistUpdateAttributes (line 85) | pub struct PlaylistUpdateAttributes {
    type Error (line 172) | type Error = librespot_core::Error;
    method try_from (line 173) | fn try_from(update: &PlaylistUpdateAttributesMessage) -> Result<Self, ...
  type PlaylistUpdateItemAttributes (line 91) | pub struct PlaylistUpdateItemAttributes {
    type Error (line 182) | type Error = librespot_core::Error;
    method try_from (line 183) | fn try_from(update: &PlaylistUpdateItemAttributesMessage) -> Result<Se...

FILE: metadata/src/playlist/diff.rs
  type PlaylistDiff (line 11) | pub struct PlaylistDiff {
    type Error (line 18) | type Error = librespot_core::Error;
    method try_from (line 19) | fn try_from(diff: &DiffMessage) -> Result<Self, Self::Error> {

FILE: metadata/src/playlist/item.rs
  type PlaylistItem (line 21) | pub struct PlaylistItem {
    type Error (line 56) | type Error = librespot_core::Error;
    method try_from (line 57) | fn try_from(item: &PlaylistItemMessage) -> Result<Self, Self::Error> {
  type PlaylistItems (line 27) | pub struct PlaylistItems(pub Vec<PlaylistItem>);
  type PlaylistItemList (line 32) | pub struct PlaylistItemList {
    type Error (line 68) | type Error = librespot_core::Error;
    method try_from (line 69) | fn try_from(list_items: &PlaylistItemsMessage) -> Result<Self, Self::E...
  type PlaylistMetaItem (line 40) | pub struct PlaylistMetaItem {
    type Error (line 80) | type Error = librespot_core::Error;
    method try_from (line 81) | fn try_from(item: &PlaylistMetaItemMessage) -> Result<Self, Self::Erro...
  type PlaylistMetaItems (line 51) | pub struct PlaylistMetaItems(pub Vec<PlaylistMetaItem>);

FILE: metadata/src/playlist/list.rs
  type Geoblocks (line 22) | pub struct Geoblocks(Vec<Geoblock>);
  type Playlist (line 27) | pub struct Playlist {
    method tracks (line 70) | pub fn tracks(&self) -> impl ExactSizeIterator<Item = &SpotifyUri> {
    method name (line 82) | pub fn name(&self) -> &str {
  type Playlists (line 46) | pub struct Playlists(pub Vec<SpotifyId>);
  type SelectedListContent (line 51) | pub struct SelectedListContent {
    type Error (line 139) | type Error = librespot_core::Error;
    method try_from (line 140) | fn try_from(playlist: &<Playlist as Metadata>::Message) -> Result<Self...
  type Message (line 89) | type Message = protocol::playlist4_external::SelectedListContent;
  method request (line 91) | async fn request(session: &Session, playlist_uri: &SpotifyUri) -> Reques...
  method parse (line 102) | fn parse(msg: &Self::Message, uri: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/playlist/operation.rs
  type PlaylistOperation (line 22) | pub struct PlaylistOperation {
    type Error (line 60) | type Error = librespot_core::Error;
    method try_from (line 61) | fn try_from(operation: &PlaylistOperationMessage) -> Result<Self, Self...
  type PlaylistOperations (line 32) | pub struct PlaylistOperations(pub Vec<PlaylistOperation>);
  type PlaylistOperationAdd (line 37) | pub struct PlaylistOperationAdd {
    type Error (line 82) | type Error = librespot_core::Error;
    method try_from (line 83) | fn try_from(add: &PlaylistAddMessage) -> Result<Self, Self::Error> {
  type PlaylistOperationMove (line 45) | pub struct PlaylistOperationMove {
    method from (line 94) | fn from(mov: &PlaylistMoveMessage) -> Self {
  type PlaylistOperationRemove (line 52) | pub struct PlaylistOperationRemove {
    type Error (line 104) | type Error = librespot_core::Error;
    method try_from (line 105) | fn try_from(remove: &PlaylistRemoveMessage) -> Result<Self, Self::Erro...

FILE: metadata/src/playlist/permission.rs
  type Capabilities (line 13) | pub struct Capabilities {
    method from (line 28) | fn from(playlist: &CapabilitiesMessage) -> Self {
  type PermissionLevels (line 23) | pub struct PermissionLevels(pub Vec<PermissionLevel>);

FILE: metadata/src/request.rs
  type RequestResult (line 7) | pub type RequestResult = Result<bytes::Bytes, Error>;
  type MercuryRequest (line 10) | pub trait MercuryRequest {
    method request (line 11) | async fn request(session: &Session, uri: &str) -> RequestResult {

FILE: metadata/src/restriction.rs
  type Restriction (line 16) | pub struct Restriction {
    method parse_country_codes (line 35) | fn parse_country_codes(country_codes: &str) -> Vec<String> {
    method from (line 41) | fn from(restriction: &RestrictionMessage) -> Self {
  type Restrictions (line 25) | pub struct Restrictions(pub Vec<Restriction>);
  type RestrictionCatalogues (line 30) | pub struct RestrictionCatalogues(pub Vec<RestrictionCatalogue>);
  type StrChunks (line 76) | struct StrChunks<'s>(&'s str, usize);
  type StrChunksExt (line 78) | trait StrChunksExt {
    method chunks (line 79) | fn chunks(&self, size: usize) -> StrChunks<'_>;
    method chunks (line 83) | fn chunks(&self, size: usize) -> StrChunks<'_> {
  type Item (line 89) | type Item = &'s str;
  method next (line 90) | fn next(&mut self) -> Option<&'s str> {

FILE: metadata/src/sale_period.rs
  type SalePeriod (line 17) | pub struct SalePeriod {
    type Error (line 29) | type Error = librespot_core::Error;
    method try_from (line 30) | fn try_from(sale_period: &SalePeriodMessage) -> Result<Self, Self::Err...
  type SalePeriods (line 24) | pub struct SalePeriods(pub Vec<SalePeriod>);

FILE: metadata/src/show.rs
  type Show (line 15) | pub struct Show {
    type Error (line 53) | type Error = librespot_core::Error;
    method try_from (line 54) | fn try_from(show: &<Self as Metadata>::Message) -> Result<Self, Self::...
  type Message (line 37) | type Message = protocol::metadata::Show;
  method request (line 39) | async fn request(session: &Session, show_uri: &SpotifyUri) -> RequestRes...
  method parse (line 47) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/track.rs
  type Track (line 24) | pub struct Track {
    type Error (line 75) | type Error = librespot_core::Error;
    method try_from (line 76) | fn try_from(track: &<Self as Metadata>::Message) -> Result<Self, Self:...
  type Tracks (line 53) | pub struct Tracks(pub Vec<SpotifyUri>);
  type Message (line 59) | type Message = protocol::metadata::Track;
  method request (line 61) | async fn request(session: &Session, track_uri: &SpotifyUri) -> RequestRe...
  method parse (line 69) | fn parse(msg: &Self::Message, _: &SpotifyUri) -> Result<Self, Error> {

FILE: metadata/src/video.rs
  type VideoFiles (line 14) | pub struct VideoFiles(pub Vec<FileId>);

FILE: oauth/examples/oauth_async.rs
  constant SPOTIFY_CLIENT_ID (line 5) | const SPOTIFY_CLIENT_ID: &str = "65b708073fc0480ea92a077233ca87bd";
  constant SPOTIFY_REDIRECT_URI (line 6) | const SPOTIFY_REDIRECT_URI: &str = "http://127.0.0.1:8898/login";
  constant RESPONSE (line 8) | const RESPONSE: &str = r#"
  function main (line 18) | async fn main() {

FILE: oauth/examples/oauth_sync.rs
  constant SPOTIFY_CLIENT_ID (line 5) | const SPOTIFY_CLIENT_ID: &str = "65b708073fc0480ea92a077233ca87bd";
  constant SPOTIFY_REDIRECT_URI (line 6) | const SPOTIFY_REDIRECT_URI: &str = "http://127.0.0.1:8898/login";
  constant RESPONSE (line 8) | const RESPONSE: &str = r#"
  function main (line 17) | fn main() {

FILE: oauth/src/lib.rs
  type OAuthError (line 54) | pub enum OAuthError {
  type OAuthToken (line 127) | pub struct OAuthToken {
  function get_code (line 141) | fn get_code(redirect_url: &str) -> Result<AuthorizationCode, OAuthError> {
  function get_authcode_stdin (line 158) | fn get_authcode_stdin() -> Result<AuthorizationCode, OAuthError> {
  function get_authcode_listener (line 170) | fn get_authcode_listener(
  function get_socket_address (line 213) | fn get_socket_address(redirect_uri: &str) -> Option<SocketAddr> {
  type OAuthClient (line 225) | pub struct OAuthClient {
    method set_auth_url (line 237) | fn set_auth_url(&self) -> PkceCodeVerifier {
    method build_token (line 258) | fn build_token(
    method get_access_token (line 285) | pub fn get_access_token(&self) -> Result<OAuthToken, OAuthError> {
    method refresh_token (line 314) | pub fn refresh_token(&self, refresh_token: &str) -> Result<OAuthToken,...
    method get_access_token_async (line 327) | pub async fn get_access_token_async(&self) -> Result<OAuthToken, OAuth...
    method refresh_token_async (line 349) | pub async fn refresh_token_async(&self, refresh_token: &str) -> Result...
  type OAuthClientBuilder (line 364) | pub struct OAuthClientBuilder {
    method new (line 376) | pub fn new(client_id: &str, redirect_uri: &str, scopes: Vec<&str>) -> ...
    method open_in_browser (line 388) | pub fn open_in_browser(mut self) -> Self {
    method with_custom_message (line 395) | pub fn with_custom_message(mut self, message: &str) -> Self {
    method build (line 401) | pub fn build(self) -> Result<OAuthClient, OAuthError> {
  function get_access_token (line 436) | pub fn get_access_token(
  function get_socket_address_none (line 521) | fn get_socket_address_none() {
  function get_socket_address_some (line 531) | fn get_socket_address_some() {

FILE: playback/src/audio_backend/alsa.rs
  constant MAX_BUFFER (line 12) | const MAX_BUFFER: Frames = (SAMPLE_RATE / 2) as Frames;
  constant MIN_BUFFER (line 13) | const MIN_BUFFER: Frames = (SAMPLE_RATE / 10) as Frames;
  constant ZERO_FRAMES (line 14) | const ZERO_FRAMES: Frames = 0;
  constant MAX_PERIOD_DIVISOR (line 16) | const MAX_PERIOD_DIVISOR: Frames = 4;
  constant MIN_PERIOD_DIVISOR (line 17) | const MIN_PERIOD_DIVISOR: Frames = 10;
  type AlsaError (line 20) | enum AlsaError {
  method from (line 72) | fn from(e: AlsaError) -> SinkError {
  method from (line 85) | fn from(f: AudioFormat) -> Format {
  type AlsaSink (line 98) | pub struct AlsaSink {
    constant NAME (line 484) | pub const NAME: &'static str = "alsa";
    method write_buf (line 486) | fn write_buf(&mut self) -> SinkResult<()> {
  function list_compatible_devices (line 105) | fn list_compatible_devices() -> SinkResult<()> {
  function open_device (line 165) | fn open_device(dev_name: &str, format: AudioFormat) -> SinkResult<(PCM, ...
  method open (line 389) | fn open(device: Option<String>, format: AudioFormat) -> Self {
  method start (line 417) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 436) | fn stop(&mut self) -> SinkResult<()> {
  method write_bytes (line 456) | fn write_bytes(&mut self, data: &[u8]) -> SinkResult<()> {

FILE: playback/src/audio_backend/gstreamer.rs
  constant GSTREAMER_ASYNC_ERROR_POISON_MSG (line 13) | const GSTREAMER_ASYNC_ERROR_POISON_MSG: &str = "gstreamer async error mu...
  type GstreamerSink (line 21) | pub struct GstreamerSink {
    constant NAME (line 215) | pub const NAME: &'static str = "gstreamer";
  method open (line 30) | fn open(device: Option<String>, format: AudioFormat) -> Self {
  method start (line 145) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 160) | fn stop(&mut self) -> SinkResult<()> {
  method drop (line 179) | fn drop(&mut self) {
  method write_bytes (line 186) | fn write_bytes(&mut self, data: &[u8]) -> SinkResult<()> {

FILE: playback/src/audio_backend/jackaudio.rs
  type JackSink (line 11) | pub struct JackSink {
    constant NAME (line 86) | pub const NAME: &'static str = "jackaudio";
  type JackData (line 18) | pub struct JackData {
  method process (line 25) | fn process(&mut self, _: &Client, ps: &ProcessScope) -> Control {
  method open (line 41) | fn open(client_name: Option<String>, format: AudioFormat) -> Self {
  method write (line 69) | fn write(&mut self, packet: AudioPacket, converter: &mut Converter) -> S...

FILE: playback/src/audio_backend/mod.rs
  type SinkError (line 7) | pub enum SinkError {
  type SinkResult (line 20) | pub type SinkResult<T> = Result<T, SinkError>;
  type Open (line 22) | pub trait Open {
    method open (line 23) | fn open(_: Option<String>, format: AudioFormat) -> Self;
  type Sink (line 26) | pub trait Sink {
    method start (line 27) | fn start(&mut self) -> SinkResult<()> {
    method stop (line 30) | fn stop(&mut self) -> SinkResult<()> {
    method write (line 33) | fn write(&mut self, packet: AudioPacket, converter: &mut Converter) ->...
  type SinkBuilder (line 36) | pub type SinkBuilder = fn(Option<String>, AudioFormat) -> Box<dyn Sink>;
  type SinkAsBytes (line 38) | pub trait SinkAsBytes {
    method write_bytes (line 39) | fn write_bytes(&mut self, data: &[u8]) -> SinkResult<()>;
  function mk_sink (line 42) | fn mk_sink<S: Sink + Open + 'static>(device: Option<String>, format: Aud...
  constant BACKENDS (line 124) | pub const BACKENDS: &[(&str, SinkBuilder)] = &[
  function find (line 145) | pub fn find(name: Option<String>) -> Option<SinkBuilder> {

FILE: playback/src/audio_backend/pipe.rs
  type StdoutError (line 12) | enum StdoutError {
  method from (line 27) | fn from(e: StdoutError) -> SinkError {
  type StdoutSink (line 38) | pub struct StdoutSink {
    constant NAME (line 112) | pub const NAME: &'static str = "pipe";
  method open (line 45) | fn open(file: Option<String>, format: AudioFormat) -> Self {
  method start (line 64) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 85) | fn stop(&mut self) -> SinkResult<()> {
  method write_bytes (line 100) | fn write_bytes(&mut self, data: &[u8]) -> SinkResult<()> {

FILE: playback/src/audio_backend/portaudio.rs
  type PortAudioSink (line 11) | pub enum PortAudioSink<'a> {
  function output_devices (line 26) | fn output_devices() -> Box<dyn Iterator<Item = (DeviceIndex, DeviceInfo)...
  function list_outputs (line 35) | fn list_outputs() {
  function find_output (line 47) | fn find_output(device: &str) -> Option<DeviceIndex> {
  method open (line 54) | fn open(device: Option<String>, format: AudioFormat) -> PortAudioSink<'a> {
  method start (line 98) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 127) | fn stop(&mut self) -> SinkResult<()> {
  method write (line 143) | fn write(&mut self, packet: AudioPacket, converter: &mut Converter) -> S...
  method drop (line 179) | fn drop(&mut self) {
  constant NAME (line 185) | pub const NAME: &'static str = "portaudio";

FILE: playback/src/audio_backend/pulseaudio.rs
  type PulseError (line 12) | enum PulseError {
  method from (line 37) | fn from(e: PulseError) -> SinkError {
  type PulseAudioSink (line 49) | pub struct PulseAudioSink {
    constant NAME (line 151) | pub const NAME: &'static str = "pulseaudio";
  method open (line 58) | fn open(device: Option<String>, format: AudioFormat) -> Self {
  method start (line 82) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 129) | fn stop(&mut self) -> SinkResult<()> {
  method write_bytes (line 141) | fn write_bytes(&mut self, data: &[u8]) -> SinkResult<()> {

FILE: playback/src/audio_backend/rodio.rs
  function mk_rodio (line 21) | pub fn mk_rodio(device: Option<String>, format: AudioFormat) -> Box<dyn ...
  function mk_rodiojack (line 26) | pub fn mk_rodiojack(device: Option<String>, format: AudioFormat) -> Box<...
  type RodioError (line 35) | pub enum RodioError {
    method from (line 63) | fn from(_: cpal::DefaultStreamConfigError) -> RodioError {
    method from (line 69) | fn from(_: cpal::SupportedStreamConfigsError) -> RodioError {
  method from (line 51) | fn from(e: RodioError) -> SinkError {
  type RodioSink (line 74) | pub struct RodioSink {
    constant NAME (line 268) | pub const NAME: &'static str = "rodio";
  function list_formats (line 79) | fn list_formats(device: &cpal::Device) {
  function list_outputs (line 110) | fn list_outputs(host: &cpal::Host) -> Result<(), cpal::DevicesError> {
  function create_sink (line 145) | fn create_sink(
  function open (line 216) | pub fn open(host: cpal::Host, device: Option<String>, format: AudioForma...
  method start (line 232) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 237) | fn stop(&mut self) -> SinkResult<()> {
  method write (line 243) | fn write(&mut self, packet: AudioPacket, converter: &mut Converter) -> S...

FILE: playback/src/audio_backend/sdl.rs
  type SdlSink (line 10) | pub enum SdlSink {
    constant NAME (line 120) | pub const NAME: &'static str = "sdl";
  method open (line 17) | fn open(device: Option<String>, format: AudioFormat) -> Self {
  method start (line 55) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 70) | fn stop(&mut self) -> SinkResult<()> {
  method write (line 85) | fn write(&mut self, packet: AudioPacket, converter: &mut Converter) -> S...

FILE: playback/src/audio_backend/subprocess.rs
  type SubprocessError (line 12) | enum SubprocessError {
  method from (line 48) | fn from(e: SubprocessError) -> SinkError {
  type SubprocessSink (line 62) | pub struct SubprocessSink {
    constant NAME (line 195) | pub const NAME: &'static str = "subprocess";
    method try_restart (line 197) | fn try_restart(&mut self, e: SubprocessError, restarted: &mut bool) ->...
  method open (line 69) | fn open(shell_command: Option<String>, format: AudioFormat) -> Self {
  method start (line 88) | fn start(&mut self) -> SinkResult<()> {
  method stop (line 113) | fn stop(&mut self) -> SinkResult<()> {
  method write_bytes (line 143) | fn write_bytes(&mut self, data: &[u8]) -> SinkResult<()> {

FILE: playback/src/config.rs
  type Bitrate (line 7) | pub enum Bitrate {
  type Err (line 15) | type Err = ();
  method from_str (line 16) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type AudioFormat (line 27) | pub enum AudioFormat {
    method size (line 55) | pub fn size(&self) -> usize {
  type Err (line 38) | type Err = ();
  method from_str (line 39) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type NormalisationType (line 67) | pub enum NormalisationType {
  type Err (line 75) | type Err = ();
  method from_str (line 76) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type NormalisationMethod (line 87) | pub enum NormalisationMethod {
  type Err (line 94) | type Err = ();
  method from_str (line 95) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type PlayerConfig (line 105) | pub struct PlayerConfig {
  method default (line 130) | fn default() -> Self {
  type VolumeCtrl (line 152) | pub enum VolumeCtrl {
    constant MAX_VOLUME (line 173) | pub const MAX_VOLUME: u16 = u16::MAX;
    constant DEFAULT_DB_RANGE (line 176) | pub const DEFAULT_DB_RANGE: f64 = 60.0;
    method from_str_with_range (line 178) | pub fn from_str_with_range(s: &str, db_range: f64) -> Result<Self, <Se...
  type Err (line 160) | type Err = ();
  method from_str (line 161) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method default (line 167) | fn default() -> VolumeCtrl {

FILE: playback/src/convert.rs
  type i24 (line 7) | pub struct i24([u8; 3]);
    method from_s24 (line 9) | fn from_s24(sample: i32) -> Self {
  type Converter (line 20) | pub struct Converter {
    method new (line 25) | pub fn new(dither_config: Option<DithererBuilder>) -> Self {
    constant SHIFT_S16 (line 41) | const SHIFT_S16: u8 = 15;
    constant SHIFT_S24 (line 42) | const SHIFT_S24: u8 = 23;
    constant SHIFT_S32 (line 43) | const SHIFT_S32: u8 = 31;
    constant SHIFT_16_TO_24 (line 47) | const SHIFT_16_TO_24: u8 = Self::SHIFT_S24 - Self::SHIFT_S16;
    constant SHIFT_16_TO_32 (line 48) | const SHIFT_16_TO_32: u8 = Self::SHIFT_S32 - Self::SHIFT_S16;
    constant SCALE_S24 (line 51) | const SCALE_S24: f64 = (1_u64 << Self::SHIFT_S24) as f64;
    method scale (line 63) | pub fn scale(&mut self, sample: f64, shift: u8) -> f64 {
    method clamping_scale_s24 (line 85) | pub fn clamping_scale_s24(&mut self, sample: f64) -> f64 {
    method f64_to_f32 (line 96) | pub fn f64_to_f32(&mut self, samples: &[f64]) -> Vec<f32> {
    method f64_to_s32 (line 101) | pub fn f64_to_s32(&mut self, samples: &[f64]) -> Vec<i32> {
    method f64_to_s24 (line 110) | pub fn f64_to_s24(&mut self, samples: &[f64]) -> Vec<i32> {
    method f64_to_s24_3 (line 119) | pub fn f64_to_s24_3(&mut self, samples: &[f64]) -> Vec<i24> {
    method f64_to_s16 (line 127) | pub fn f64_to_s16(&mut self, samples: &[f64]) -> Vec<i16> {

FILE: playback/src/decoder/mod.rs
  type DecoderError (line 14) | pub enum DecoderError {
    method from (line 89) | fn from(err: symphonia::core::errors::Error) -> Self {
  type DecoderResult (line 21) | pub type DecoderResult<T> = Result<T, DecoderError>;
  type AudioPacketError (line 24) | pub enum AudioPacketError {
  type AudioPacketResult (line 31) | pub type AudioPacketResult<T> = Result<T, AudioPacketError>;
  type AudioPacket (line 33) | pub enum AudioPacket {
    method samples (line 40) | pub fn samples(&self) -> AudioPacketResult<&[f64]> {
    method raw (line 48) | pub fn raw(&self) -> AudioPacketResult<&[u8]> {
    method is_empty (line 56) | pub fn is_empty(&self) -> bool {
  type AudioPacketPosition (line 65) | pub struct AudioPacketPosition {
  type Target (line 71) | type Target = u32;
  method deref (line 72) | fn deref(&self) -> &Self::Target {
  type AudioDecoder (line 77) | pub trait AudioDecoder {
    method seek (line 78) | fn seek(&mut self, position_ms: u32) -> Result<u32, DecoderError>;
    method next_packet (line 79) | fn next_packet(&mut self) -> DecoderResult<Option<(AudioPacketPosition...
  function from (line 83) | fn from(err: DecoderError) -> Self {

FILE: playback/src/decoder/passthrough_decoder.rs
  function get_header (line 17) | fn get_header<T>(code: u8, rdr: &mut PacketReader<T>) -> DecoderResult<V...
  type PassthroughDecoder (line 35) | pub struct PassthroughDecoder<R: Read + Seek> {
  function new (line 49) | pub fn new(rdr: R, format: AudioFileFormat) -> DecoderResult<Self> {
  function position_pcm_to_ms (line 85) | fn position_pcm_to_ms(position_pcm: u64) -> u32 {
  method seek (line 91) | fn seek(&mut self, position_ms: u32) -> Result<u32, DecoderError> {
  method next_packet (line 139) | fn next_packet(&mut self) -> DecoderResult<Option<(AudioPacketPosition, ...

FILE: playback/src/decoder/symphonia_decoder.rs
  type SymphoniaDecoder (line 17) | pub struct SymphoniaDecoder {
    method new (line 35) | pub fn new<R>(input: R, hint: Hint) -> DecoderResult<Self>
    method normalisation_data (line 95) | pub fn normalisation_data(&mut self) -> Option<NormalisationData> {
    method local_file_metadata (line 120) | pub(crate) fn local_file_metadata(&mut self) -> Option<LocalFileMetada...
    method ts_to_ms (line 180) | fn ts_to_ms(&self, ts: u64) -> u32 {
  type LocalFileMetadata (line 24) | pub(crate) struct LocalFileMetadata {
  method seek (line 193) | fn seek(&mut self, position_ms: u32) -> Result<u32, DecoderError> {
  method next_packet (line 220) | fn next_packet(&mut self) -> DecoderResult<Option<(AudioPacketPosition, ...

FILE: playback/src/dither.rs
  type Ditherer (line 31) | pub trait Ditherer {
    method new (line 32) | fn new() -> Self
    method name (line 35) | fn name(&self) -> &'static str;
    method noise (line 36) | fn noise(&mut self) -> f64;
    method new (line 55) | fn new() -> Self {
    method name (line 63) | fn name(&self) -> &'static str {
    method noise (line 68) | fn noise(&mut self) -> f64 {
    method new (line 83) | fn new() -> Self {
    method name (line 98) | fn name(&self) -> &'static str {
    method noise (line 103) | fn noise(&mut self) -> f64 {
    method new (line 120) | fn new() -> Self {
    method name (line 131) | fn name(&self) -> &'static str {
    method noise (line 136) | fn noise(&mut self) -> f64 {
  function fmt (line 40) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function create_rng (line 45) | fn create_rng() -> SmallRng {
  type TriangularDitherer (line 49) | pub struct TriangularDitherer {
    constant NAME (line 74) | pub const NAME: &'static str = "tpdf";
  type GaussianDitherer (line 77) | pub struct GaussianDitherer {
    constant NAME (line 109) | pub const NAME: &'static str = "gpdf";
  type HighPassDitherer (line 112) | pub struct HighPassDitherer {
    constant NAME (line 146) | pub const NAME: &'static str = "tpdf_hp";
  function mk_ditherer (line 149) | pub fn mk_ditherer<D: Ditherer + 'static>() -> Box<dyn Ditherer> {
  type DithererBuilder (line 153) | pub type DithererBuilder = fn() -> Box<dyn Ditherer>;
  function find_ditherer (line 155) | pub fn find_ditherer(name: Option<String>) -> Option<DithererBuilder> {

FILE: playback/src/lib.rs
  constant SAMPLE_RATE (line 18) | pub const SAMPLE_RATE: u32 = 44100;
  constant NUM_CHANNELS (line 19) | pub const NUM_CHANNELS: u8 = 2;
  constant SAMPLES_PER_SECOND (line 20) | pub const SAMPLES_PER_SECOND: u32 = SAMPLE_RATE * NUM_CHANNELS as u32;
  constant PAGES_PER_MS (line 21) | pub const PAGES_PER_MS: f64 = SAMPLE_RATE as f64 / 1000.0;
  constant MS_PER_PAGE (line 22) | pub const MS_PER_PAGE: f64 = 1000.0 / SAMPLE_RATE as f64;

FILE: playback/src/local_file.rs
  constant SUPPORTED_FILE_EXTENSIONS (line 23) | const SUPPORTED_FILE_EXTENSIONS: &[&str; 4] = &["mp3", "mp4", "m4p", "fl...
  type LocalFileLookup (line 26) | pub struct LocalFileLookup(HashMap<SpotifyUri, PathBuf>);
    method get (line 29) | pub fn get(&self, uri: &SpotifyUri) -> Option<&Path> {
  function create_local_file_lookup (line 34) | pub fn create_local_file_lookup(directories: &[PathBuf]) -> LocalFileLoo...
  function visit_dir (line 58) | fn visit_dir(dir: &Path, accumulator: &mut LocalFileLookup) -> io::Resul...
  function get_uri_from_file (line 91) | fn get_uri_from_file(audio_path: &Path, file_extension: &str) -> Result<...

FILE: playback/src/mixer/alsamixer.rs
  type AlsaMixer (line 17) | pub struct AlsaMixer {
    constant NAME (line 295) | pub const NAME: &'static str = "alsa";
    method switched_off (line 297) | fn switched_off(&self) -> bool {
    method is_some_linear (line 314) | fn is_some_linear(&self) -> bool {
  constant SND_CTL_TLV_DB_GAIN_MUTE (line 32) | const SND_CTL_TLV_DB_GAIN_MUTE: MilliBel = MilliBel(-9999999);
  constant ZERO_DB (line 33) | const ZERO_DB: MilliBel = MilliBel(0);
  type AlsaMixerError (line 36) | enum AlsaMixerError {
  method from (line 52) | fn from(value: AlsaMixerError) -> Self {
  method open (line 58) | fn open(config: MixerConfig) -> Result<Self, Error> {
  method volume (line 196) | fn volume(&self) -> u16 {
  method set_volume (line 236) | fn set_volume(&self, volume: u16) {

FILE: playback/src/mixer/mappings.rs
  type MappedCtrl (line 4) | pub trait MappedCtrl {
    method to_mapped (line 5) | fn to_mapped(&self, volume: u16) -> f64;
    method as_unmapped (line 6) | fn as_unmapped(&self, mapped_volume: f64) -> u16;
    method db_range (line 8) | fn db_range(&self) -> f64;
    method set_db_range (line 9) | fn set_db_range(&mut self, new_db_range: f64);
    method range_ok (line 10) | fn range_ok(&self) -> bool;
    method to_mapped (line 14) | fn to_mapped(&self, volume: u16) -> f64 {
    method as_unmapped (line 49) | fn as_unmapped(&self, mapped_volume: f64) -> u16 {
    method db_range (line 74) | fn db_range(&self) -> f64 {
    method set_db_range (line 82) | fn set_db_range(&mut self, new_db_range: f64) {
    method range_ok (line 91) | fn range_ok(&self) -> bool {
  type VolumeMapping (line 96) | pub trait VolumeMapping {
    method linear_to_mapped (line 97) | fn linear_to_mapped(unmapped_volume: f64, db_range: f64) -> f64;
    method mapped_to_linear (line 98) | fn mapped_to_linear(mapped_volume: f64, db_range: f64) -> f64;
    method linear_to_mapped (line 107) | fn linear_to_mapped(normalized_volume: f64, db_range: f64) -> f64 {
    method mapped_to_linear (line 112) | fn mapped_to_linear(mapped_volume: f64, db_range: f64) -> f64 {
    method linear_to_mapped (line 140) | fn linear_to_mapped(normalized_volume: f64, db_range: f64) -> f64 {
    method mapped_to_linear (line 145) | fn mapped_to_linear(mapped_volume: f64, db_range: f64) -> f64 {
  type LogMapping (line 105) | pub struct LogMapping {}
    method coefficients (line 119) | fn coefficients(db_range: f64) -> (f64, f64) {
  type CubicMapping (line 138) | pub struct CubicMapping {}
    method min_norm (line 152) | fn min_norm(db_range: f64) -> f64 {

FILE: playback/src/mixer/mod.rs
  type NoOpVolume (line 8) | pub struct NoOpVolume;
  type Mixer (line 10) | pub trait Mixer: Send + Sync {
    method open (line 11) | fn open(config: MixerConfig) -> Result<Self, Error>
    method volume (line 15) | fn volume(&self) -> u16;
    method set_volume (line 16) | fn set_volume(&self, volume: u16);
    method get_soft_volume (line 18) | fn get_soft_volume(&self) -> Box<dyn VolumeGetter + Send> {
  type VolumeGetter (line 23) | pub trait VolumeGetter {
    method attenuation_factor (line 24) | fn attenuation_factor(&self) -> f64;
    method attenuation_factor (line 29) | fn attenuation_factor(&self) -> f64 {
  type MixerConfig (line 43) | pub struct MixerConfig {
  method default (line 51) | fn default() -> MixerConfig {
  type MixerFn (line 61) | pub type MixerFn = fn(MixerConfig) -> Result<Arc<dyn Mixer>, Error>;
  function mk_sink (line 63) | fn mk_sink<M: Mixer + 'static>(config: MixerConfig) -> Result<Arc<dyn Mi...
  constant MIXERS (line 67) | pub const MIXERS: &[(&str, MixerFn)] = &[
  function find (line 73) | pub fn find(name: Option<&str>) -> Option<MixerFn> {

FILE: playback/src/mixer/softmixer.rs
  type SoftMixer (line 10) | pub struct SoftMixer {
    constant NAME (line 45) | pub const NAME: &'static str = "softvol";
  method open (line 18) | fn open(config: MixerConfig) -> Result<Self, Error> {
  method volume (line 28) | fn volume(&self) -> u16 {
  method set_volume (line 33) | fn set_volume(&self, volume: u16) {
  method get_soft_volume (line 39) | fn get_soft_volume(&self) -> Box<dyn VolumeGetter + Send> {
  type SoftVolume (line 48) | struct SoftVolume(Arc<AtomicU64>);
  method attenuation_factor (line 52) | fn attenuation_factor(&self) -> f64 {

FILE: playback/src/player.rs
  constant PRELOAD_NEXT_TRACK_BEFORE_END_DURATION_MS (line 45) | const PRELOAD_NEXT_TRACK_BEFORE_END_DURATION_MS: u32 = 30000;
  constant DB_VOLTAGE_RATIO (line 46) | pub const DB_VOLTAGE_RATIO: f64 = 20.0;
  constant PCM_AT_0DBFS (line 47) | pub const PCM_AT_0DBFS: f64 = 1.0;
  constant SPOTIFY_OGG_HEADER_END (line 51) | const SPOTIFY_OGG_HEADER_END: u64 = 0xa7;
  constant LOAD_HANDLES_POISON_MSG (line 53) | const LOAD_HANDLES_POISON_MSG: &str = "load handles mutex should not be ...
  type PlayerResult (line 55) | pub type PlayerResult = Result<(), Error>;
  type Player (line 57) | pub struct Player {
    method new (line 456) | pub fn new<F>(
    method is_invalid (line 549) | pub fn is_invalid(&self) -> bool {
    method command (line 556) | fn command(&self, cmd: PlayerCommand) {
    method load (line 564) | pub fn load(&self, track_id: SpotifyUri, start_playing: bool, position...
    method preload (line 572) | pub fn preload(&self, track_id: SpotifyUri) {
    method play (line 576) | pub fn play(&self) {
    method pause (line 580) | pub fn pause(&self) {
    method stop (line 584) | pub fn stop(&self) {
    method seek (line 588) | pub fn seek(&self, position_ms: u32) {
    method set_session (line 592) | pub fn set_session(&self, session: Session) {
    method get_player_event_channel (line 596) | pub fn get_player_event_channel(&self) -> PlayerEventChannel {
    method await_end_of_track (line 602) | pub async fn await_end_of_track(&self) {
    method set_sink_event_callback (line 614) | pub fn set_sink_event_callback(&self, callback: Option<SinkEventCallba...
    method emit_volume_changed_event (line 618) | pub fn emit_volume_changed_event(&self, volume: u16) {
    method set_auto_normalise_as_album (line 622) | pub fn set_auto_normalise_as_album(&self, setting: bool) {
    method emit_filter_explicit_content_changed_event (line 626) | pub fn emit_filter_explicit_content_changed_event(&self, filter: bool) {
    method emit_session_connected_event (line 630) | pub fn emit_session_connected_event(&self, connection_id: String, user...
    method emit_session_disconnected_event (line 637) | pub fn emit_session_disconnected_event(&self, connection_id: String, u...
    method emit_session_client_changed_event (line 644) | pub fn emit_session_client_changed_event(
    method emit_shuffle_changed_event (line 659) | pub fn emit_shuffle_changed_event(&self, shuffle: bool) {
    method emit_repeat_changed_event (line 663) | pub fn emit_repeat_changed_event(&self, context: bool, track: bool) {
    method emit_auto_play_changed_event (line 667) | pub fn emit_auto_play_changed_event(&self, auto_play: bool) {
    method emit_set_queue_event (line 671) | pub fn emit_set_queue_event(
  type SinkStatus (line 63) | pub enum SinkStatus {
  type SinkEventCallback (line 69) | pub type SinkEventCallback = Box<dyn Fn(SinkStatus) + Send>;
  type PlayerInternal (line 71) | struct PlayerInternal {
    method ensure_sink_running (line 1624) | fn ensure_sink_running(&mut self) {
    method ensure_sink_stopped (line 1640) | fn ensure_sink_stopped(&mut self, temporarily: bool) {
    method handle_player_stop (line 1673) | fn handle_player_stop(&mut self) {
    method handle_play (line 1712) | fn handle_play(&mut self) {
    method handle_pause (line 1740) | fn handle_pause(&mut self) {
    method handle_packet (line 1770) | fn handle_packet(
    method start_playback (line 1898) | fn start_playback(
    method handle_command_load (line 1972) | fn handle_command_load(
    method handle_command_preload (line 2183) | fn handle_command_preload(&mut self, track_id: SpotifyUri) {
    method handle_command_seek (line 2234) | fn handle_command_seek(&mut self, position_ms: u32) -> PlayerResult {
    method handle_command (line 2300) | fn handle_command(&mut self, cmd: PlayerCommand) -> PlayerResult {
    method send_event (line 2421) | fn send_event(&mut self, event: PlayerEvent) {
    method load_track (line 2426) | fn load_track(
    method preload_data_before_playback (line 2464) | fn preload_data_before_playback(&mut self) -> PlayerResult {
  type PlayerCommand (line 102) | enum PlayerCommand {
    method fmt (line 2508) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type QueueTrack (line 151) | pub struct QueueTrack {
  type PlayerEvent (line 157) | pub enum PlayerEvent {
    method get_play_request_id (line 274) | pub fn get_play_request_id(&self) -> Option<u64> {
  type PlayerEventChannel (line 309) | pub type PlayerEventChannel = mpsc::UnboundedReceiver<PlayerEvent>;
  function db_to_ratio (line 312) | pub fn db_to_ratio(db: f64) -> f64 {
  function ratio_to_db (line 317) | pub fn ratio_to_db(ratio: f64) -> f64 {
  function duration_to_coefficient (line 321) | pub fn duration_to_coefficient(duration: Duration) -> f64 {
  function coefficient_to_duration (line 325) | pub fn coefficient_to_duration(coefficient: f64) -> Duration {
  type NormalisationData (line 330) | pub struct NormalisationData {
    method parse_from_ogg (line 351) | fn parse_from_ogg<T: Read + Seek>(mut file: T) -> io::Result<Normalisa...
    method get_factor (line 383) | fn get_factor(config: &PlayerConfig, data: NormalisationData) -> f64 {
  method default (line 340) | fn default() -> Self {
  method drop (line 688) | fn drop(&mut self) {
  type PlayerLoadedTrackData (line 699) | struct PlayerLoadedTrackData {
  type PlayerPreload (line 710) | enum PlayerPreload {
  type Decoder (line 722) | type Decoder = Box<dyn AudioDecoder + Send>;
  type PlayerState (line 724) | enum PlayerState {
    method is_playing (line 770) | fn is_playing(&self) -> bool {
    method is_stopped (line 783) | fn is_stopped(&self) -> bool {
    method is_loading (line 789) | fn is_loading(&self) -> bool {
    method decoder (line 794) | fn decoder(&mut self) -> Option<&mut Decoder> {
    method playing_to_end_of_track (line 811) | fn playing_to_end_of_track(&mut self) {
    method paused_to_playing (line 850) | fn paused_to_playing(&mut self) {
    method playing_to_paused (line 892) | fn playing_to_paused(&mut self) {
    method fmt (line 2602) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PlayerTrackLoader (line 934) | struct PlayerTrackLoader {
    method find_available_alternative (line 941) | async fn find_available_alternative(&self, audio_item: AudioItem) -> O...
    method stream_data_rate (line 966) | fn stream_data_rate(&self, format: AudioFileFormat) -> Option<usize> {
    method load_track (line 992) | async fn load_track(
    method load_remote_track (line 1009) | async fn load_remote_track(
    method load_local_track (line 1248) | async fn load_local_track(
  type Output (line 1352) | type Output = ();
  method poll (line 1354) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  method drop (line 2488) | fn drop(&mut self) {
  type Subfile (line 2647) | struct Subfile<T: Read + Seek> {
  function new (line 2654) | pub fn new(mut stream: T, offset: u64, length: u64) -> Result<Subfile<T>...
  method read (line 2667) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method seek (line 2673) | fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
  method is_seekable (line 2697) | fn is_seekable(&self) -> bool {
  method byte_len (line 2701) | fn byte_len(&self) -> Option<u64> {

FILE: playback/src/symphonia_util.rs
  function get_latest_metadata (line 4) | pub fn get_latest_metadata(probe_result: &mut ProbeResult) -> Option<Met...

FILE: protocol/build.rs
  function out_dir (line 7) | fn out_dir() -> PathBuf {
  function cleanup (line 11) | fn cleanup() {
  function compile (line 15) | fn compile() {
  function main (line 82) | fn main() {

FILE: protocol/src/impl_trait/context.rs
  method hash (line 6) | fn hash<H: Hasher>(&self, state: &mut H) {
  method from (line 16) | fn from(value: Vec<String>) -> Self {
  method from (line 31) | fn from(tracks: Vec<ContextTrack>) -> Self {

FILE: protocol/src/impl_trait/player.rs
  function hashmap_into (line 15) | fn hashmap_into<T: Into<V>, V>(map: HashMap<String, T>) -> HashMap<Strin...
  method from (line 20) | fn from(value: ContextPlayerOptions) -> Self {
  method from (line 33) | fn from(value: PlayerRestrictions) -> Self {
  method from (line 73) | fn from(value: Restrictions) -> Self {
  method from (line 115) | fn from(value: PlayerModeRestrictions) -> Self {
  method from (line 124) | fn from(value: ModeRestrictions) -> Self {
  method from (line 133) | fn from(value: PlayerRestrictionReasons) -> Self {
  method from (line 142) | fn from(value: RestrictionReasons) -> Self {
  method from (line 151) | fn from(value: PlayOrigin) -> Self {
  method from (line 167) | fn from(value: Suppressions) -> Self {

FILE: src/main.rs
  function device_id (line 44) | fn device_id(name: &str) -> String {
  function usage (line 48) | fn usage(program: &str, opts: &getopts::Options) -> String {
  function setup_logging (line 56) | fn setup_logging(quiet: bool, verbose: bool) {
  function list_backends (line 88) | fn list_backends() {
  type ParseFileSizeError (line 100) | pub enum ParseFileSizeError {
  function parse_file_size (line 111) | pub fn parse_file_size(input: &str) -> Result<u64, ParseFileSizeError> {
  function get_version_string (line 159) | fn get_version_string() -> String {
  type Setup (line 206) | struct Setup {
  function get_setup (line 226) | async fn get_setup() -> Setup {
  function set_env_var (line 1868) | async fn set_env_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(key: K, value: V) {
  function main (line 1883) | async fn main() {

FILE: src/player_event_handler.rs
  type EventHandler (line 10) | pub struct EventHandler {
    method new (line 15) | pub fn new(mut player_events: PlayerEventChannel, onevent: &str) -> Se...
  method drop (line 281) | fn drop(&mut self) {
  function run_program_on_sink_events (line 291) | pub fn run_program_on_sink_events(sink_status: SinkStatus, onevent: &str) {
  function run_program (line 307) | fn run_program(env_vars: HashMap<&str, String>, onevent: &str) {