Struct MusicRequestBuilder

pub struct MusicRequestBuilder<'a, BuilderType, Data = ()> { /* private fields */ }

A request builder

Implementations

impl<'a, BuilderType, Data> MusicRequestBuilder<'a, BuilderType, Data>

pub fn override_storefront(self, storefront: Country) -> Self

Override storefront for this request

pub fn override_localization(self, localization: &'a str) -> Self

Override localization for this request

pub fn extend(self, extension: impl ExtensionTrait) -> Self

Extend resource attributes

pub fn include(self, relationship: impl RelationshipTrait) -> Self

Include a relationship

This will fetch the full object for the relationship data

pub fn include_lazy(self, relationship: impl RelationshipTrait) -> Self

Lazily include a relationship

This will only fetch the identifiers for the relationship data

pub fn view(self, view: impl ViewTrait) -> Self

Add a relationship view

impl<'a> MusicRequestBuilder<'a, ActivityRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Activity>, Error>

Fetch one catalog activity by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<Activity>, Error>

Fetch multiple activities by id

impl<'a> MusicRequestBuilder<'a, AlbumRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Album>, Error>

Fetch one album by id

pub async fn many( self, client: &ApiClient, ids: &[&str], upc: bool, ) -> Result<Vec<Album>, Error>

Fetch multiple albums by id

Params

• upc - if the ids are UPCs or album ids, false means album ids, true means UPCs

impl<'a> MusicRequestBuilder<'a, ArtistRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Artist>, Error>

Fetch one artist by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<Artist>, Error>

Fetch multiple artists by id

impl<'a> MusicRequestBuilder<'a, AppleCuratorRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<AppleCurator>, Error>

Fetch one apple curator by id

pub async fn main( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<AppleCurator>, Error>

Fetch multiple apple curators by id

impl<'a> MusicRequestBuilder<'a, CuratorRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Curator>, Error>

Fetch one curator by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<Curator>, Error>

Fetch multiple curators by id

impl<'a> MusicRequestBuilder<'a, MusicVideoRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<MusicVideo>, Error>

Fetch one music video by id

pub async fn many( self, client: &ApiClient, ids: &[&str], isrc: bool, ) -> Result<Vec<MusicVideo>, Error>

Fetch multiple music videos by id

Params

• isrc - if the ids are ISRCs or music video ids, false means music video ids, true means ISRCs

impl<'a> MusicRequestBuilder<'a, PlaylistRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Playlist>, Error>

Fetch one playlist by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<Playlist>, Error>

Fetch many playlists by id

pub async fn chart( self, client: &ApiClient, storefront: &str, ) -> Result<Vec<Playlist>, Error>

Fetch chart playlists by storefront value

impl<'a> MusicRequestBuilder<'a, RecordLabelRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<RecordLabel>, Error>

Fetch one record label by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<RecordLabel>, Error>

Fetch many record labels by id

impl<'a> MusicRequestBuilder<'a, SongRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Song>, Error>

Fetch one song by id

pub async fn many( self, client: &ApiClient, ids: &[&str], isrc: bool, ) -> Result<Vec<Song>, Error>

Fetch multiple songs by id

Params

• isrc - if the ids are ISRCs or song ids, false means song ids, true means ISRCs

impl<'a> MusicRequestBuilder<'a, StationRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Station>, Error>

Fetch one station by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<Station>, Error>

Fetch multiple stations by id

pub async fn live(self, client: &ApiClient) -> Result<Vec<Station>, Error>

Fetch live radio stations

pub async fn personal( self, client: &ApiClient, ) -> Result<Option<Station>, Error>

Fetch user’s current personal station

impl<'a> MusicRequestBuilder<'a, StationGenreRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<StationGenre>, Error>

Fetch one station genre by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<StationGenre>, Error>

Fetch multiple station genres by id

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<StationGenre, Error>>

Fetch all station genres

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, GenreRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<Genre>, Error>

Fetch one genre by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<Genre>, Error>

Fetch multiple genres by id

pub async fn top_charts( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<Genre, Error>>

Fetch all genres for the current top charts

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, HistoryRequestBuilder>

pub async fn heavy_rotation( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<Resource, Error>>

Fetch heavy rotation content

Params

• limit - limit of entries per query

• offset - query offset

Possible resources: any

pub async fn recently_played( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<Resource, Error>>

Fetch recently played resources

Params

• limit - limit of entries per query

• offset - query offset

Possible resources: any

pub async fn recently_played_tracks( self, client: &ApiClient, tracks: &[TrackType], limit: usize, offset: usize, ) -> impl Stream<Item = Result<Resource, Error>>

Fetch recently played tracks

Params

• limit - limit of entries per query

• offset - query offset

Possible resources: [LibraryMusicVideo], [LibrarySong], [MusicVideo], [Song]

pub async fn recently_played_stations( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<Resource, Error>>

Fetch recently played radio stations

Params

• limit - limit of entries per query

• offset - query offset

Possible resources: [Station]

pub async fn recently_added_to_library( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<Resource, Error>>

Fetch resources recently added to the library

Params

• limit - limit of entries per query

• offset - query offset

Possible resources: [LibraryAlbum], [LibraryArtist], [LibraryPlaylist], [LibrarySong]

impl<'a> MusicRequestBuilder<'a, LibraryAlbumRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<LibraryAlbum>, Error>

Fetch one library album by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<LibraryAlbum>, Error>

Fetch multiple library albums by id

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<LibraryAlbum, Error>>

Fetch all library albums

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, LibraryArtistRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<LibraryArtist>, Error>

Fetch one library artist by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<LibraryArtist>, Error>

Fetch multiple library artists by id

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<LibraryArtist, Error>>

Fetch all library artists

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, LibraryMusicVideoRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<LibraryMusicVideo>, Error>

Fetch one library music video by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<LibraryMusicVideo>, Error>

Fetch multiple library music videos by id

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<LibraryMusicVideo, Error>>

Fetch all library music videos

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, LibraryPlaylistRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<LibraryPlaylist>, Error>

Fetch one library playlist by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<LibraryPlaylist>, Error>

Fetch multiple library playlists by id

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<LibraryPlaylist, Error>>

Fetch all library playlists

Params

• limit - limit of entries per query

• offset - query offset

impl<'localization, 'name> MusicRequestBuilder<'localization, LibraryPlaylistRequestBuilder, LibraryPlaylistCreateRequest<'name>>

pub fn new(name: &'name str) -> Self

Create a new LibraryPlaylistCreateBuilder instance

pub fn description(self, desc: &str) -> Self

Set description for this request

pub fn public(self, p: bool) -> Self

Set if the playlist is public for this request

pub fn tracks(self, resources: &[&Resource]) -> Result<Self, Error>

Add tracks to this request

pub fn parent_folder(self, parent_folder_id: &str) -> Self

Set parent playlist folder

pub async fn create( self, client: &ApiClient, ) -> Result<Option<LibraryPlaylist>, Error>

Create the playlist

Return type

Resource of type LibraryPlaylist

impl<'a> MusicRequestBuilder<'a, LibraryPlaylistFolderRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<LibraryPlaylistFolder>, Error>

Fetch one library playlist folder by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<LibraryPlaylistFolder>, Error>

Fetch multiple library playlist folders by id

impl<'a> MusicRequestBuilder<'a, LibrarySongRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<LibrarySong>, Error>

Fetch one library song by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<LibrarySong>, Error>

Fetch multiple library songs by id

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<LibrarySong, Error>>

Fetch all library songs

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, LibraryBuilder, HashMap<&'static str, HashSet<String>>>

pub fn new() -> LibraryAddResourceBuilder<'a>

Create a new LibraryAddResourceBuilder instance

pub fn add_resource(self, resource: &Resource) -> Result<Self, Error>

Add a resource to the library

pub fn add_resources(self, resources: &[Resource]) -> Result<Self, Error>

Add multiple resources to the library

pub async fn send(self, client: &ApiClient) -> Result<Vec<Resource>, Error>

Send the request

impl<'a> MusicRequestBuilder<'a, PersonalRecommendationRequestBuilder>

pub async fn one( self, client: &ApiClient, id: &str, ) -> Result<Option<PersonalRecommendation>, Error>

Fetch one recommendation by id

pub async fn many( self, client: &ApiClient, ids: &[&str], ) -> Result<Vec<PersonalRecommendation>, Error>

Fetch multiple recommendations by id

pub async fn default_recommendations( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<PersonalRecommendation, Error>>

Fetch default recommendations

Params

• limit - limit of entries per query

• offset - query offset

impl<'a> MusicRequestBuilder<'a, RatingGetRequestBuilderMarker>

pub async fn one( self, client: &ApiClient, rating_type: RatingType, id: &str, ) -> Result<Option<Rating>, Error>

Fetch one rating for a resource

pub async fn many( self, client: &ApiClient, rating_type: RatingType, ids: &[&str], ) -> Result<Vec<Rating>, Error>

Fetch multiple ratings by ids

impl<'a> MusicRequestBuilder<'a, RatingPostRequestBuilderMarker>

pub async fn add_rating( self, client: &ApiClient, resource: &Resource, rating: i32, ) -> Result<Option<Rating>, Error>

Add a rating to a resource

Return value

Resource of type Rating

pub async fn remove_rating( self, client: &ApiClient, resource: &Resource, ) -> Result<(), Error>

Remove a rating from a resource

impl<'a> MusicRequestBuilder<'a, CatalogSearchRequestBuilderMarker>

pub async fn search( self, client: &ApiClient, types: &[CatalogSearchType], term: &str, ) -> Result<CatalogSearchResults, Error>

Search the catalog using a query

Params

• types - types to include in the search results

• term - The entered text for the search

pub async fn search_hints( self, client: &ApiClient, term: &str, limit: usize, ) -> Result<Vec<String>, Error>

Get catalog search hints

Params

• term - The entered text for the search

• limit - returned hints count limit

pub async fn suggestions( self, client: &ApiClient, kinds: &[SuggestionKind], types: &[CatalogSearchType], term: &str, limit: usize, ) -> Result<Vec<CatalogSearchSuggestion>, Error>

Get catalog search suggestions

Params

• term - The entered text for the search

• types - types to include in the search results

• limit - returned hints count limit (Default value: 5, maximum: 10)

impl<'a> MusicRequestBuilder<'a, LibrarySearchRequestBuilderMarker>

pub async fn search( self, client: &ApiClient, types: &[LibrarySearchType], term: &str, ) -> Result<LibrarySearchResults, Error>

Search the library using a query

Params

• types - types to search

• term - The entered text for the search, spaces will automatically get replaced with ‘+’

impl<'a> MusicRequestBuilder<'a, StorefrontGetRequestBuilderMarker>

pub async fn one( self, client: &ApiClient, country: Country, ) -> Result<Option<Storefront>, Error>

Fetch one storefront using a country

pub async fn many( self, client: &ApiClient, countries: &[Country], ) -> Result<Vec<Storefront>, Error>

Fetch multiple storefronts using countries

Params

• limit - limit of entries per query

• offset - query offset

pub fn all( self, client: &ApiClient, limit: usize, offset: usize, ) -> impl Stream<Item = Result<Storefront, Error>>

Fetch all storefronts

Trait Implementations

impl<'a, T, Data> Default for MusicRequestBuilder<'a, T, Data>

where Data: Default,

fn default() -> Self

Returns the “default value” for a type.