pub fn actor_get_actor_albums(
  client: xrpc.Client,
  params: models.GetActorAlbumsParams,
) -> Result(models.GetActorAlbumsOutput, xrpc.Error)

pub fn actor_get_actor_artists(
  client: xrpc.Client,
  params: models.GetActorArtistsParams,
) -> Result(models.GetActorArtistsOutput, xrpc.Error)

pub fn actor_get_actor_compatibility(
  client: xrpc.Client,
  params: models.GetActorCompatibilityParams,
) -> Result(models.GetActorCompatibilityOutput, xrpc.Error)

pub fn actor_get_actor_loved_songs(
  client: xrpc.Client,
  params: models.GetActorLovedSongsParams,
) -> Result(models.GetActorLovedSongsOutput, xrpc.Error)

pub fn actor_get_actor_neighbours(
  client: xrpc.Client,
  params: models.GetActorNeighboursParams,
) -> Result(models.GetActorNeighboursOutput, xrpc.Error)

pub fn actor_get_actor_playlists(
  client: xrpc.Client,
  params: models.GetActorPlaylistsParams,
) -> Result(models.GetActorPlaylistsOutput, xrpc.Error)

pub fn actor_get_actor_scrobbles(
  client: xrpc.Client,
  params: models.GetActorScrobblesParams,
) -> Result(models.GetActorScrobblesOutput, xrpc.Error)

pub fn actor_get_actor_songs(
  client: xrpc.Client,
  params: models.GetActorSongsParams,
) -> Result(models.GetActorSongsOutput, xrpc.Error)

pub fn actor_get_profile(
  client: xrpc.Client,
  params: models.GetProfileParams,
) -> Result(models.ActorProfileViewDetailed, xrpc.Error)

pub fn album_get_album(
  client: xrpc.Client,
  params: models.AlbumGetAlbumParams,
) -> Result(models.AlbumViewDetailed, xrpc.Error)

pub fn album_get_album_tracks(
  client: xrpc.Client,
  params: models.GetAlbumTracksParams,
) -> Result(models.GetAlbumTracksOutput, xrpc.Error)

pub fn album_get_albums(
  client: xrpc.Client,
  params: models.GetAlbumsParams,
) -> Result(models.GetAlbumsOutput, xrpc.Error)

pub fn apikey_create_apikey(
  client: xrpc.Client,
  input: models.CreateApikeyInput,
) -> Result(models.ApiKeyView, xrpc.Error)

pub fn apikey_get_apikeys(
  client: xrpc.Client,
  params: models.GetApikeysParams,
) -> Result(models.GetApikeysOutput, xrpc.Error)

pub fn apikey_remove_apikey(
  client: xrpc.Client,
  params: models.RemoveApikeyParams,
) -> Result(models.ApiKeyView, xrpc.Error)

pub fn apikey_update_apikey(
  client: xrpc.Client,
  input: models.UpdateApikeyInput,
) -> Result(models.ApiKeyView, xrpc.Error)

pub fn artist_get_artist(
  client: xrpc.Client,
  params: models.ArtistGetArtistParams,
) -> Result(models.ArtistViewDetailed, xrpc.Error)

pub fn artist_get_artist_albums(
  client: xrpc.Client,
  params: models.GetArtistAlbumsParams,
) -> Result(models.GetArtistAlbumsOutput, xrpc.Error)

pub fn artist_get_artist_listeners(
  client: xrpc.Client,
  params: models.GetArtistListenersParams,
) -> Result(models.GetArtistListenersOutput, xrpc.Error)

pub fn artist_get_artist_recent_listeners(
  client: xrpc.Client,
  params: models.GetArtistRecentListenersParams,
) -> Result(models.GetArtistRecentListenersOutput, xrpc.Error)

pub fn artist_get_artist_tracks(
  client: xrpc.Client,
  params: models.GetArtistTracksParams,
) -> Result(models.GetArtistTracksOutput, xrpc.Error)

pub fn artist_get_artists(
  client: xrpc.Client,
  params: models.ArtistGetArtistsParams,
) -> Result(models.ArtistGetArtistsOutput, xrpc.Error)

pub fn charts_get_decades(
  client: xrpc.Client,
  params: models.GetDecadesParams,
) -> Result(models.GetDecadesOutput, xrpc.Error)

pub fn charts_get_scrobbles_chart(
  client: xrpc.Client,
  params: models.GetScrobblesChartParams,
) -> Result(models.ChartsView, xrpc.Error)

pub fn charts_get_top_artists(
  client: xrpc.Client,
  params: models.GetTopArtistsParams,
) -> Result(models.GetTopArtistsOutput, xrpc.Error)

pub fn charts_get_top_scrobblers(
  client: xrpc.Client,
  params: models.GetTopScrobblersParams,
) -> Result(models.GetTopScrobblersOutput, xrpc.Error)

pub fn charts_get_top_tracks(
  client: xrpc.Client,
  params: models.GetTopTracksParams,
) -> Result(models.GetTopTracksOutput, xrpc.Error)

pub fn dropbox_download_file(
  client: xrpc.Client,
  params: models.DropboxDownloadFileParams,
) -> Result(BitArray, xrpc.Error)

pub fn dropbox_get_files(
  client: xrpc.Client,
  params: models.DropboxGetFilesParams,
) -> Result(models.DropboxFileListView, xrpc.Error)

pub fn dropbox_get_metadata(
  client: xrpc.Client,
  params: models.GetMetadataParams,
) -> Result(models.GetMetadataOutput, xrpc.Error)

pub fn dropbox_get_temporary_link(
  client: xrpc.Client,
  params: models.GetTemporaryLinkParams,
) -> Result(models.DropboxTemporaryLinkView, xrpc.Error)

pub fn equalizer_delete_preset(
  client: xrpc.Client,
  params: models.DeletePresetParams,
) -> Result(Nil, xrpc.Error)

pub fn equalizer_list_presets(
  client: xrpc.Client,
  params: models.ListPresetsParams,
) -> Result(models.ListPresetsOutput, xrpc.Error)

pub fn equalizer_put_preset(
  client: xrpc.Client,
  input: models.PutPresetInput,
) -> Result(models.EqualizerPresetView, xrpc.Error)

pub fn feed_describe_feed_generator(
  client: xrpc.Client,
) -> Result(models.DescribeFeedGeneratorOutput, xrpc.Error)

pub fn feed_get_album_recommendations(
  client: xrpc.Client,
  params: models.GetAlbumRecommendationsParams,
) -> Result(models.FeedRecommendedAlbumsView, xrpc.Error)

pub fn feed_get_artist_recommendations(
  client: xrpc.Client,
  params: models.GetArtistRecommendationsParams,
) -> Result(models.FeedRecommendedArtistsView, xrpc.Error)

pub fn feed_get_feed(
  client: xrpc.Client,
  params: models.GetFeedParams,
) -> Result(models.FeedView, xrpc.Error)

pub fn feed_get_feed_generator(
  client: xrpc.Client,
  params: models.GetFeedGeneratorParams,
) -> Result(models.GetFeedGeneratorOutput, xrpc.Error)

pub fn feed_get_feed_generators(
  client: xrpc.Client,
  params: models.GetFeedGeneratorsParams,
) -> Result(models.FeedGeneratorsView, xrpc.Error)

pub fn feed_get_feed_skeleton(
  client: xrpc.Client,
  params: models.GetFeedSkeletonParams,
) -> Result(models.GetFeedSkeletonOutput, xrpc.Error)

pub fn feed_get_recommendations(
  client: xrpc.Client,
  params: models.GetRecommendationsParams,
) -> Result(models.FeedRecommendationsView, xrpc.Error)

pub fn feed_get_stories(
  client: xrpc.Client,
  params: models.GetStoriesParams,
) -> Result(models.FeedStoriesView, xrpc.Error)

pub fn feed_search(
  client: xrpc.Client,
  params: models.FeedSearchParams,
) -> Result(models.FeedSearchResultsView, xrpc.Error)

pub fn googledrive_download_file(
  client: xrpc.Client,
  params: models.GoogledriveDownloadFileParams,
) -> Result(BitArray, xrpc.Error)

pub fn googledrive_get_file(
  client: xrpc.Client,
  params: models.GetFileParams,
) -> Result(models.GoogledriveFileView, xrpc.Error)

pub fn googledrive_get_files(
  client: xrpc.Client,
  params: models.GoogledriveGetFilesParams,
) -> Result(models.GoogledriveFileListView, xrpc.Error)

pub fn graph_follow_account(
  client: xrpc.Client,
  params: models.FollowAccountParams,
) -> Result(models.FollowAccountOutput, xrpc.Error)

pub fn graph_get_followers(
  client: xrpc.Client,
  params: models.GetFollowersParams,
) -> Result(models.GetFollowersOutput, xrpc.Error)

pub fn graph_get_follows(
  client: xrpc.Client,
  params: models.GetFollowsParams,
) -> Result(models.GetFollowsOutput, xrpc.Error)

pub fn graph_get_known_followers(
  client: xrpc.Client,
  params: models.GetKnownFollowersParams,
) -> Result(models.GetKnownFollowersOutput, xrpc.Error)

pub fn graph_unfollow_account(
  client: xrpc.Client,
  params: models.UnfollowAccountParams,
) -> Result(models.UnfollowAccountOutput, xrpc.Error)

pub fn library_create_playlist(
  client: xrpc.Client,
  input: models.LibraryCreatePlaylistInput,
) -> Result(models.LibraryCreatePlaylistOutput, xrpc.Error)

pub fn library_delete_album(
  client: xrpc.Client,
  input: models.DeleteAlbumInput,
) -> Result(models.DeleteAlbumOutput, xrpc.Error)

pub fn library_delete_playlist(
  client: xrpc.Client,
  input: models.DeletePlaylistInput,
) -> Result(models.DeletePlaylistOutput, xrpc.Error)

pub fn library_delete_song(
  client: xrpc.Client,
  input: models.DeleteSongInput,
) -> Result(models.DeleteSongOutput, xrpc.Error)

pub fn library_get_album(
  client: xrpc.Client,
  params: models.LibraryGetAlbumParams,
) -> Result(models.LibraryGetAlbumOutput, xrpc.Error)

pub fn library_get_album_info(
  client: xrpc.Client,
  params: models.GetAlbumInfoParams,
) -> Result(models.GetAlbumInfoOutput, xrpc.Error)

pub fn library_get_album_list(
  client: xrpc.Client,
  params: models.GetAlbumListParams,
) -> Result(models.GetAlbumListOutput, xrpc.Error)

pub fn library_get_artist(
  client: xrpc.Client,
  params: models.LibraryGetArtistParams,
) -> Result(models.LibraryGetArtistOutput, xrpc.Error)

pub fn library_get_artist_info(
  client: xrpc.Client,
  params: models.GetArtistInfoParams,
) -> Result(models.GetArtistInfoOutput, xrpc.Error)

pub fn library_get_artists(
  client: xrpc.Client,
  params: models.LibraryGetArtistsParams,
) -> Result(models.LibraryGetArtistsOutput, xrpc.Error)

pub fn library_get_cover_art_url(
  client: xrpc.Client,
  params: models.GetCoverArtUrlParams,
) -> Result(models.GetCoverArtUrlOutput, xrpc.Error)

pub fn library_get_download_url(
  client: xrpc.Client,
  params: models.GetDownloadUrlParams,
) -> Result(models.GetDownloadUrlOutput, xrpc.Error)

pub fn library_get_genres(
  client: xrpc.Client,
  params: models.GetGenresParams,
) -> Result(models.GetGenresOutput, xrpc.Error)

pub fn library_get_indexes(
  client: xrpc.Client,
  params: models.GetIndexesParams,
) -> Result(models.GetIndexesOutput, xrpc.Error)

pub fn library_get_internet_radio_stations(
  client: xrpc.Client,
  params: models.GetInternetRadioStationsParams,
) -> Result(models.GetInternetRadioStationsOutput, xrpc.Error)

pub fn library_get_license(
  client: xrpc.Client,
  params: models.GetLicenseParams,
) -> Result(models.GetLicenseOutput, xrpc.Error)

pub fn library_get_lyrics(
  client: xrpc.Client,
  params: models.GetLyricsParams,
) -> Result(models.GetLyricsOutput, xrpc.Error)

pub fn library_get_music_directory(
  client: xrpc.Client,
  params: models.GetMusicDirectoryParams,
) -> Result(models.GetMusicDirectoryOutput, xrpc.Error)

pub fn library_get_music_folders(
  client: xrpc.Client,
  params: models.GetMusicFoldersParams,
) -> Result(models.GetMusicFoldersOutput, xrpc.Error)

pub fn library_get_now_playing(
  client: xrpc.Client,
  params: models.GetNowPlayingParams,
) -> Result(models.GetNowPlayingOutput, xrpc.Error)

pub fn library_get_play_queue(
  client: xrpc.Client,
  params: models.GetPlayQueueParams,
) -> Result(models.GetPlayQueueOutput, xrpc.Error)

pub fn library_get_playlist(
  client: xrpc.Client,
  params: models.LibraryGetPlaylistParams,
) -> Result(models.LibraryGetPlaylistOutput, xrpc.Error)

pub fn library_get_playlists(
  client: xrpc.Client,
  params: models.LibraryGetPlaylistsParams,
) -> Result(models.LibraryGetPlaylistsOutput, xrpc.Error)

pub fn library_get_random_songs(
  client: xrpc.Client,
  params: models.GetRandomSongsParams,
) -> Result(models.GetRandomSongsOutput, xrpc.Error)

pub fn library_get_scan_status(
  client: xrpc.Client,
  params: models.GetScanStatusParams,
) -> Result(models.GetScanStatusOutput, xrpc.Error)

pub fn library_get_similar_songs(
  client: xrpc.Client,
  params: models.GetSimilarSongsParams,
) -> Result(models.GetSimilarSongsOutput, xrpc.Error)

pub fn library_get_song(
  client: xrpc.Client,
  params: models.LibraryGetSongParams,
) -> Result(models.LibraryGetSongOutput, xrpc.Error)

pub fn library_get_songs_by_genre(
  client: xrpc.Client,
  params: models.GetSongsByGenreParams,
) -> Result(models.GetSongsByGenreOutput, xrpc.Error)

pub fn library_get_starred(
  client: xrpc.Client,
  params: models.GetStarredParams,
) -> Result(models.GetStarredOutput, xrpc.Error)

pub fn library_get_stream_url(
  client: xrpc.Client,
  params: models.GetStreamUrlParams,
) -> Result(models.GetStreamUrlOutput, xrpc.Error)

pub fn library_get_top_songs(
  client: xrpc.Client,
  params: models.GetTopSongsParams,
) -> Result(models.GetTopSongsOutput, xrpc.Error)

pub fn library_get_user(
  client: xrpc.Client,
  params: models.GetUserParams,
) -> Result(models.GetUserOutput, xrpc.Error)

pub fn library_ping(
  client: xrpc.Client,
  params: models.PingParams,
) -> Result(models.PingOutput, xrpc.Error)

pub fn library_save_play_queue(
  client: xrpc.Client,
  input: models.SavePlayQueueInput,
) -> Result(models.SavePlayQueueOutput, xrpc.Error)

pub fn library_scrobble(
  client: xrpc.Client,
  input: models.ScrobbleInput,
) -> Result(models.ScrobbleOutput, xrpc.Error)

pub fn library_search(
  client: xrpc.Client,
  params: models.LibrarySearchParams,
) -> Result(models.LibrarySearchOutput, xrpc.Error)

pub fn library_star(
  client: xrpc.Client,
  input: models.StarInput,
) -> Result(models.StarOutput, xrpc.Error)

pub fn library_start_scan(
  client: xrpc.Client,
  params: models.StartScanParams,
) -> Result(models.StartScanOutput, xrpc.Error)

pub fn library_unstar(
  client: xrpc.Client,
  input: models.UnstarInput,
) -> Result(models.UnstarOutput, xrpc.Error)

pub fn library_update_now_playing(
  client: xrpc.Client,
  input: models.UpdateNowPlayingInput,
) -> Result(models.UpdateNowPlayingOutput, xrpc.Error)

pub fn library_update_playlist(
  client: xrpc.Client,
  input: models.LibraryUpdatePlaylistInput,
) -> Result(models.LibraryUpdatePlaylistOutput, xrpc.Error)

pub fn like_dislike_shout(
  client: xrpc.Client,
  input: models.DislikeShoutInput,
) -> Result(models.ShoutView, xrpc.Error)

pub fn like_dislike_song(
  client: xrpc.Client,
  input: models.DislikeSongInput,
) -> Result(models.SongViewDetailed, xrpc.Error)

pub fn like_like_shout(
  client: xrpc.Client,
  input: models.LikeShoutInput,
) -> Result(models.ShoutView, xrpc.Error)

pub fn like_like_song(
  client: xrpc.Client,
  input: models.LikeSongInput,
) -> Result(models.SongViewDetailed, xrpc.Error)

pub fn mirror_get_mirror_sources(
  client: xrpc.Client,
  params: models.GetMirrorSourcesParams,
) -> Result(models.GetMirrorSourcesOutput, xrpc.Error)

pub fn mirror_put_mirror_source(
  client: xrpc.Client,
  input: models.PutMirrorSourceInput,
) -> Result(models.MirrorSourceView, xrpc.Error)

pub fn notification_get_unread_count(
  client: xrpc.Client,
) -> Result(models.GetUnreadCountOutput, xrpc.Error)

pub fn notification_list_notifications(
  client: xrpc.Client,
  params: models.ListNotificationsParams,
) -> Result(models.ListNotificationsOutput, xrpc.Error)

pub fn notification_update_seen(
  client: xrpc.Client,
  input: models.UpdateSeenInput,
) -> Result(models.UpdateSeenOutput, xrpc.Error)

pub fn player_add_directory_to_queue(
  client: xrpc.Client,
  params: models.AddDirectoryToQueueParams,
) -> Result(Nil, xrpc.Error)

pub fn player_add_items_to_queue(
  client: xrpc.Client,
  params: models.AddItemsToQueueParams,
) -> Result(Nil, xrpc.Error)

pub fn player_get_currently_playing(
  client: xrpc.Client,
  params: models.PlayerGetCurrentlyPlayingParams,
) -> Result(models.PlayerCurrentlyPlayingViewDetailed, xrpc.Error)

pub fn player_get_playback_queue(
  client: xrpc.Client,
  params: models.GetPlaybackQueueParams,
) -> Result(models.PlayerPlaybackQueueViewDetailed, xrpc.Error)

pub fn player_next(
  client: xrpc.Client,
  params: models.PlayerNextParams,
) -> Result(Nil, xrpc.Error)

pub fn player_pause(
  client: xrpc.Client,
  params: models.PlayerPauseParams,
) -> Result(Nil, xrpc.Error)

pub fn player_play(
  client: xrpc.Client,
  params: models.PlayerPlayParams,
) -> Result(Nil, xrpc.Error)

pub fn player_play_directory(
  client: xrpc.Client,
  params: models.PlayDirectoryParams,
) -> Result(Nil, xrpc.Error)

pub fn player_play_file(
  client: xrpc.Client,
  params: models.PlayFileParams,
) -> Result(Nil, xrpc.Error)

pub fn player_previous(
  client: xrpc.Client,
  params: models.PlayerPreviousParams,
) -> Result(Nil, xrpc.Error)

pub fn player_seek(
  client: xrpc.Client,
  params: models.PlayerSeekParams,
) -> Result(Nil, xrpc.Error)

pub fn playlist_add_songs(
  client: xrpc.Client,
  params: models.AddSongsParams,
) -> Result(models.AddSongsOutput, xrpc.Error)

pub fn playlist_create_playlist(
  client: xrpc.Client,
  params: models.PlaylistCreatePlaylistParams,
) -> Result(models.PlaylistCreatePlaylistOutput, xrpc.Error)

pub fn playlist_get_playlist(
  client: xrpc.Client,
  params: models.PlaylistGetPlaylistParams,
) -> Result(models.PlaylistViewDetailed, xrpc.Error)

pub fn playlist_get_playlists(
  client: xrpc.Client,
  params: models.PlaylistGetPlaylistsParams,
) -> Result(models.PlaylistGetPlaylistsOutput, xrpc.Error)

pub fn playlist_insert_directory(
  client: xrpc.Client,
  params: models.InsertDirectoryParams,
) -> Result(Nil, xrpc.Error)

pub fn playlist_insert_files(
  client: xrpc.Client,
  params: models.InsertFilesParams,
) -> Result(Nil, xrpc.Error)

pub fn playlist_remove_playlist(
  client: xrpc.Client,
  params: models.RemovePlaylistParams,
) -> Result(Nil, xrpc.Error)

pub fn playlist_remove_track(
  client: xrpc.Client,
  params: models.RemoveTrackParams,
) -> Result(Nil, xrpc.Error)

pub fn playlist_start_playlist(
  client: xrpc.Client,
  params: models.StartPlaylistParams,
) -> Result(Nil, xrpc.Error)

pub fn playlist_update_playlist(
  client: xrpc.Client,
  params: models.PlaylistUpdatePlaylistParams,
) -> Result(models.PlaylistUpdatePlaylistOutput, xrpc.Error)

pub fn rockbox_get_audio_settings(
  client: xrpc.Client,
  params: models.GetAudioSettingsParams,
) -> Result(models.RockboxSettingsView, xrpc.Error)

pub fn rockbox_put_audio_settings(
  client: xrpc.Client,
  input: models.PutAudioSettingsInput,
) -> Result(models.RockboxSettingsView, xrpc.Error)

pub fn scrobble_create_scrobble(
  client: xrpc.Client,
  input: models.CreateScrobbleInput,
) -> Result(models.ScrobbleViewBasic, xrpc.Error)

pub fn scrobble_get_scrobble(
  client: xrpc.Client,
  params: models.GetScrobbleParams,
) -> Result(models.ScrobbleViewDetailed, xrpc.Error)

pub fn scrobble_get_scrobbles(
  client: xrpc.Client,
  params: models.GetScrobblesParams,
) -> Result(models.GetScrobblesOutput, xrpc.Error)

pub fn shout_create_shout(
  client: xrpc.Client,
  input: models.CreateShoutInput,
) -> Result(models.ShoutView, xrpc.Error)

pub fn shout_get_album_shouts(
  client: xrpc.Client,
  params: models.GetAlbumShoutsParams,
) -> Result(models.GetAlbumShoutsOutput, xrpc.Error)

pub fn shout_get_artist_shouts(
  client: xrpc.Client,
  params: models.GetArtistShoutsParams,
) -> Result(models.GetArtistShoutsOutput, xrpc.Error)

pub fn shout_get_profile_shouts(
  client: xrpc.Client,
  params: models.GetProfileShoutsParams,
) -> Result(models.GetProfileShoutsOutput, xrpc.Error)

pub fn shout_get_shout_replies(
  client: xrpc.Client,
  params: models.GetShoutRepliesParams,
) -> Result(models.GetShoutRepliesOutput, xrpc.Error)

pub fn shout_get_track_shouts(
  client: xrpc.Client,
  params: models.GetTrackShoutsParams,
) -> Result(models.GetTrackShoutsOutput, xrpc.Error)

pub fn shout_remove_shout(
  client: xrpc.Client,
  params: models.RemoveShoutParams,
) -> Result(models.ShoutView, xrpc.Error)

pub fn shout_reply_shout(
  client: xrpc.Client,
  input: models.ReplyShoutInput,
) -> Result(models.ShoutView, xrpc.Error)

pub fn shout_report_shout(
  client: xrpc.Client,
  input: models.ReportShoutInput,
) -> Result(models.ShoutView, xrpc.Error)

pub fn song_create_song(
  client: xrpc.Client,
  input: models.CreateSongInput,
) -> Result(models.SongViewDetailed, xrpc.Error)

pub fn song_get_song(
  client: xrpc.Client,
  params: models.SongGetSongParams,
) -> Result(models.SongViewDetailed, xrpc.Error)

pub fn song_get_song_recent_listeners(
  client: xrpc.Client,
  params: models.GetSongRecentListenersParams,
) -> Result(models.GetSongRecentListenersOutput, xrpc.Error)

pub fn song_get_songs(
  client: xrpc.Client,
  params: models.GetSongsParams,
) -> Result(models.GetSongsOutput, xrpc.Error)

pub fn song_match_song(
  client: xrpc.Client,
  params: models.MatchSongParams,
) -> Result(models.SongViewDetailed, xrpc.Error)

pub fn spotify_get_currently_playing(
  client: xrpc.Client,
  params: models.SpotifyGetCurrentlyPlayingParams,
) -> Result(models.PlayerCurrentlyPlayingViewDetailed, xrpc.Error)

pub fn spotify_next(
  client: xrpc.Client,
) -> Result(Nil, xrpc.Error)

pub fn spotify_pause(
  client: xrpc.Client,
) -> Result(Nil, xrpc.Error)

pub fn spotify_play(
  client: xrpc.Client,
) -> Result(Nil, xrpc.Error)

pub fn spotify_previous(
  client: xrpc.Client,
) -> Result(Nil, xrpc.Error)

pub fn spotify_seek(
  client: xrpc.Client,
  params: models.SpotifySeekParams,
) -> Result(Nil, xrpc.Error)

pub fn stats_get_global_stats(
  client: xrpc.Client,
  params: models.GetGlobalStatsParams,
) -> Result(models.StatsGlobalStatsView, xrpc.Error)

pub fn stats_get_stats(
  client: xrpc.Client,
  params: models.GetStatsParams,
) -> Result(models.StatsView, xrpc.Error)

pub fn stats_get_wrapped(
  client: xrpc.Client,
  params: models.GetWrappedParams,
) -> Result(models.StatsWrappedView, xrpc.Error)